insight-wave

This skill should be used when the user wants to produce a deliverable of a cogni-consult engagement by running its design-thinking loop — empathize→define→ideate→prototype→test on one deliverable inside an action field. Trigger on: "work the deliverable", "run design thinking on <deliverable>", "produce the <deliverable> deliverable", "start the DT loop", "draft the deliverable", "continue the deliverable", or when a WBS dashboard recommendation hands off the next unstarted deliverable. Starting a fresh (not-yet-in-progress) deliverable requires a satisfied personas gate: when it is unsatisfied the loop routes to consult-personas first before opening, so a fresh start may bounce to persona seeding or a waiver. Global phase phrasing ("discover phase", "develop phase", "diamond") refers to a legacy engagement model no longer in the ecosystem — do not run this loop against legacy engagement directories; cogni-consult has no engagement-level phases; design thinking runs per deliverable.

This skill should be used when the user wants to resume, continue, or check the status of a cogni-consult engagement across sessions. Trigger on: "continue the engagement", "resume the engagement", "engagement status", "where was I with the engagement", "what's next for the engagement", "show engagement progress", "consult resume", or ANY session start that references an existing cogni-consult engagement — even if the user doesn't say "resume" explicitly. Double Diamond phrasing ("resume diamond", "diamond status", phase talk like "continue discover") refers to a legacy engagement model no longer in the ecosystem; cogni-consult engagements have no phases; progress lives in the action-fields WBS.

This skill should be used when the user wants to start a new consulting engagement — cogni-consult is the action-fields-WBS engagement model, so new structured consulting work starts here. Trigger on: "start a consult engagement", "new consulting engagement", "set up a consult project", "begin an action-fields engagement", or any request to start structured consulting work. Legacy Double Diamond engagements are not handled here — that earlier engagement model is no longer part of the ecosystem and its engagements live in git history. Scaffolds the engagement directory, binds one cogni-knowledge base, and registers it globally.

Generate a self-contained HTML dashboard showing the full insight-wave workspace configuration — installed plugins (with maturity stages and env vars), themes gallery with color swatches, MCP server status, market coverage matrix, cross-plugin hooks, and a health snapshot. Use whenever the user mentions workspace dashboard, workspace overview, "show me what's installed", "show me the themes", "MCP overview", plugin registry, market coverage, ecosystem map, or wants a *visual* view of the cogni-workspace configuration — even if they don't say "dashboard". This is the visual sibling of `workspace-status` (which is a text-based health diagnostic): pick this skill when the user wants to *see* the configuration, not diagnose it.

This skill should be used when a partner or consultant wants a readable snapshot of a cogni-projects portfolio for a partner meeting — staffing coverage per project, at-risk projects, and portfolio value by strategic impact — rather than reading raw entity files. Trigger on: "projects dashboard", "portfolio dashboard", "partner-meeting dashboard", "show me the project portfolio", "portfolio health", "staffing coverage", "which projects are at risk", or any request to review the project portfolio at a glance — even if the user does not say "dashboard" explicitly.

This skill should be used when the user wants a ranked shortlist of consultants for the open roles on a cogni-projects portfolio — the staffing match engine (whether the ask comes from a partner, a delivery lead, or consulting ops). Trigger on: "staff this project", "who should I put on", "recommend consultants for", "staffing recommendations", "match consultants to roles", "rank candidates for the open roles", "who is available for", "build a staffing shortlist", or any request to turn a cogni-projects portfolio's consultants and projects into a ranked candidate list per open role — even if the user does not name the portfolio.

This skill should be used when the user wants to author or register a consultant, project, or assignment record in a cogni-projects portfolio — the entities the staffing engine scores over. Trigger on: "add a consultant", "add a project", "create an assignment", "author a projects entity", "register a consultant/project", "record a staffing assignment", "populate the projects portfolio", or any request to write consultant/project/assignment data into a cogni-projects portfolio — even if the user does not name the entity type.

This skill should be used when the user wants to start a new project-portfolio for partner project-portfolio steering — cogni-projects models consultants, projects, and staffing, so new portfolio work starts here. Trigger on: "set up a projects portfolio", "start a project portfolio", "new cogni-projects portfolio", "initialize project-portfolio steering", "create a staffing portfolio", or any request to begin structured consultant/project/staffing work — even if the user does not say "setup" explicitly.

Generate an interactive HTML dashboard showing a cogni-consult engagement's status — action fields, deliverables, design-thinking stage, and persona-review progress. Use whenever the user mentions dashboard, engagement dashboard, engagement status, "show me the engagement", "visualize the engagement", WBS view, status overview, or wants to see the engagement in a browser — even if they don't say "dashboard".

Polish, rewrite, or create business documents (memos, briefs, reports, proposals, one-pagers, executive summaries, emails, blog posts, business letters) using professional messaging frameworks (BLUF, McKinsey Pyramid, SCQA, STAR, PSB, FAB) and persuasion techniques (number plays, power words, rhetorical devices). Use this skill when the user asks to polish a document, improve writing, make something more readable, restructure a brief, apply BLUF or Pyramid Principle, rewrite for executives, strengthen messaging, create a proposal, write a one-pager, clean up a report, compress a document to minimum length without losing facts, shorten a synthesis for circulation, tighten a document while keeping every citation and number, or apply any named messaging framework. Also handles German documents (Wolf Schneider style), arc-aware narrative polishing (cogni-narrative arcs with arc_id), and IS/DOES/MEANS sales messaging. Even simple requests like "make this better" about a markdown file should trigger this skill.

Cross-plugin data model for claim verification — defines ClaimRecord, DeviationRecord, and ResolutionRecord schemas, status transitions, deviation types, severity levels, and workspace layout. Use this skill whenever you need to understand claim data structures, create or validate claim records, check what fields a ClaimRecord has, understand deviation types or severity levels, or work with the cogni-claims directory layout. Any plugin that submits or consumes claims should consult this skill for the contract.

This skill should be used when the user wants a phased roadmap or timeline of a cogni-consult engagement's own WBS deliverables — sequenced from the dependency graph and durations and written as an Obsidian-browsable markdown artifact. Trigger on: "project plan", "engagement timeline", "roadmap", "show the roadmap", "gantt", "gantt chart", "schedule the engagement", "when does the engagement finish", "plan the timeline", "render the project plan", or when a WBS/dashboard view hands off a request for the sequenced plan — even if the user doesn't say "project plan" explicitly. This is an INTERNAL engagement-management view (a read-mostly sibling of consult-dashboard and consult-resume), not a client-facing content producer. Double Diamond phase phrasing ("discover phase", "deliver phase timeline") refers to a legacy engagement model no longer in the ecosystem; cogni-consult engagements have no phases — the roadmap phases here are the derived topological layers of the deliverable graph, not engagement stages.

This skill should be used when the user wants to manage the WBS of a cogni-consult engagement — listing each action field's deliverables and their status, planning a field's deliverable set, picking the next deliverable to work, adding/splitting/merging action fields after scoping, or setting a deliverable's schedule (due date, effort, owner, milestone). Trigger on: "show the WBS", "action fields dashboard", "what deliverables are open", "plan the deliverables", "next deliverable", "add an action field", "split this field", "merge two action fields", "set a deliverable's due date", "set the start date/effort/owner", "mark a deliverable as a milestone", "schedule the deliverables", or when consult-scope hands off a freshly scoped engagement. Double Diamond phase phrasing ("discover phase", "deliver phase status") refers to a legacy engagement model no longer in the ecosystem; new consulting work lives in cogni-consult (this skill owns its WBS and deliverable management).

This skill should be used when a consultant elects to turn a completed cogni-consult deliverable into presentation-ready documentation — a brief the consultant hands to Claude Design to render. Trigger on: "publish this deliverable", "turn <deliverable> into slides", "make a poster/web page from <deliverable>", "build a report from <deliverable>", "make an infographic from <deliverable>", "present this deliverable", "render-ready brief", or "hand this to Claude Design". Runs only when the named deliverable's `state` is `complete`. It is consultant-elected: invoke it explicitly — it is never auto-fired from the design-thinking loop.

This skill should be used when the user wants to manage or invoke the acting stakeholder personas of a cogni-consult engagement — defining personas from the scope's Stakeholder dimension, enriching one with evidence, or having a persona challenge a deliverable in its own voice. Trigger on: "set up the personas", "add a stakeholder persona", "enrich the persona", "challenge this deliverable as the partner", "act as the project manager", "persona review", "what would the partner say", or when a design-thinking test stage requests a persona challenge. Design-for persona phrasing tied to Double Diamond phases ("discover personas", "persona for the define phase") belongs to a legacy engagement model no longer in the ecosystem — cogni-consult personas act and challenge, they are not phase artifacts.

This skill should be used when the user wants to scope a cogni-consult engagement — framing the SMART key question, working the five scoping dimensions, and deriving the 3-6 action fields that become the engagement's work-breakdown structure. Trigger on: "scope the engagement", "consult scope", "frame the key question", "define action fields", "add or waive the diagnostic field", "run scoping for the consult engagement", or when consult-setup hands off a freshly scaffolded engagement for scoping. Double Diamond phrasing ("0-scope phase", "diamond scoping") refers to a legacy engagement model no longer in the ecosystem; all new scoping runs here.

Show status of a cogni-knowledge base — knowledge slug, bound wiki path, deposited research projects, wiki health verdict, and the recommended next action; or, when no clear target is given, present the bound bases alongside an offer to start a new one. Use this skill whenever the user says 'resume the knowledge base', 'knowledge resume', 'knowledge status', 'where was I with the eu-ai-act base', 'what's in my knowledge base', 'show me the knowledge base overview', 'what knowledge bases do I have', 'list my knowledge bases', 'resume but I don't know the slug', or 'start a new knowledge base' (resume is the orientation front door — it surfaces the existing bases and the start-a-new affordance as peers). Proactively after a long gap between sessions, or right after knowledge-setup or a knowledge-finalize run.

Phase 2 of the inverted pipeline. Reads plan.json, dispatches one source-curator agent per sub-question to WebSearch + score candidate sources AND fetch each survivor's body via WebFetch into the shared fetch-cache, then merges the per-sub-question batches into candidates.json via candidate-store.py. Each candidate carries a fetch sub-object. Use this skill whenever the user says 'curate sources for the eu-ai-act plan', 'discover candidates for project X', 'run the curators on plan.json', 'knowledge curate', 'phase 2 of the knowledge pipeline'. After curate, run knowledge-fetch (cobrowse reconcile; a near no-op unless --cobrowse).

Standalone single-source ingest for cogni-knowledge — deposit ONE source directly into the bound wiki with no research run: a web page or PDF URL, a local file (.docx/.html/.txt), pasted text, a local PDF, or a local interview note. Lands one wiki/sources/<slug>.md page (or wiki/interviews/<slug>.md with type: interview for an interview note) carrying pre_extracted_claims: and the same diff-before-write + citation discipline as the research path; local inputs deposit honestly via fetch_method: direct. Use whenever the user says 'ingest this URL into my wiki', 'add this file/source to the knowledge base', 'ingest this interview note', 'paste this into my wiki', or 'single-source ingest'. For batch research-fetched sources use knowledge-ingest instead.

Phase 5 of the inverted pipeline. Reads <project>/.metadata/plan.json + <project>/.metadata/ingest-manifest.json + the populated cogni-wiki, dispatches a wiki-composer pass (plus ONE bounded fail-soft zero-network coverage-gated re-dispatch when a sub-question has ingested evidence the draft left uncited), and lands <project>/output/draft-vN.md + <project>/.metadata/citation-manifest.json. Supports --source wiki to compose a report grounded only in the bound wiki + fetch-cache with no web crawl (default web unchanged; local/hybrid staged). Use this skill whenever the user says 'compose the draft', 'write the report from the wiki', 'wiki-only report', 'compose from the wiki only', 'no web crawl report', 'phase 5 of the knowledge pipeline', 'knowledge compose', 'draft v1', or 'run the writer'. After compose, knowledge-verify will run the zero-network claim alignment.

Drive the cogni-knowledge inverted pipeline end-to-end for ONE fresh topic in a single invocation — the ordered-phase driver. Runs the seven-phase chain knowledge-plan → curate → fetch → ingest → distill (optional, fail-soft) → compose → verify → finalize via Skill(...), threading one resolved project path between phases, depositing a freshly-composed, claim-verified synthesis into the bound wiki with no per-phase manual dispatch. Distinct from its two siblings: knowledge-refresh push-mode lints the wiki and re-researches stale pages (this takes one explicit --topic instead), and knowledge-refresh-synthesis extends ONE existing synthesis from a freshly-landed source (this researches a brand-new topic from scratch). Use this skill whenever the user says 'run the knowledge pipeline on X', 'research X end-to-end into my <slug> base', 'one-shot research X into the eu-ai-act base', or 'run plan to finalize on X'.

Phase 4.5 of the inverted pipeline (between ingest and compose). Distills the run's source claims into recurring type:concept / type:entity / type:person pages, creating-or-merging them under a lock with claim-level dedup so the bound wiki compounds across runs (distilled pages get enriched, not duplicated). Also synthesizes a citable answer_claims: surface onto each type:question node from its findings' claims (Step 6.1). An optional cross-lingual pass merges DE↔EN twin claims on mixed-language bases (auto-skips otherwise). Fail-soft and optional: a distill failure never blocks compose. Use this skill whenever the user says 'distill the concepts', 'build the concept web', 'phase 4.5', 'knowledge distill', 'extract entities and concepts', 'answer the question nodes', or 'dedupe claims'. After distill, knowledge-compose reads the distilled pages as framing context.

Phase 4 of the inverted pipeline. Reads fetch-manifest.json, dispatches source-ingester per fetched source to write wiki/sources/<slug>.md pages with pre_extracted_claims:, merges per-source results into ingest-manifest.json, then consolidates the wiki integration (backlinks, thematic index, question nodes, sub-indexes) into one first-party post-processing call. The wiki becomes populated before any draft runs. Use this skill whenever the user says 'ingest the fetched sources', 'deposit fetched pages into the wiki', 'phase 4 of the knowledge pipeline', 'run the ingesters', 'knowledge ingest'. After ingest, knowledge-compose drafts the report.

Run a read-only structural health check on a cogni-knowledge base — page/link/schema integrity plus entries-count and claim drift for the bound wiki. Use this skill whenever the user says 'check knowledge health', 'knowledge health', 'is my knowledge base healthy', 'audit the knowledge base structure', 'knowledge integrity check', 'health-check the wiki', or wants a structural verdict on a bound base without running the research pipeline.

Phase 7 of the inverted pipeline — deposits the verified draft as a wiki synthesis page, closing the compounding loop. Reads the latest verified draft + its verify manifest + citation manifest, runs cycle-guard.py to refuse self-citing loops, atomically writes the draft to <wiki>/syntheses/<slug>.md with type: synthesis frontmatter (incl. derived_from_research), updates wiki/index.md, bumps entries_count, rebuilds context_brief.md, appends a research_projects[] entry to binding.json and a finalize line to wiki/log.md, and runs a conformance gate (wiki-lint --fix=all + wiki-health) with bare [[slug]] backlinks that de-orphan the cited sources. Then dispatches the wiki-contradictor agent for a zero-network contradiction tripwire and the wiki-reviewer agent for an advisory structural-quality score — both fail-soft, non-blocking observability. The deposited synthesis becomes visible to future knowledge-compose runs as cross-source framing. Use this skill whenever the user says 'finalize the draft', 'deposit the s

Rebuild the curated root index + per-type sub-indexes of a cogni-knowledge base on demand, migrate an EXISTING pre-0.0.8 wiki to the curated layout (control files into wiki/meta/, overview folded into the index intro, flat root split into root-map + sub-indexes, schema 0.0.7→0.0.8), or repair drifted machine-owned regions (theme-scoped ROOT-LINKS, schema lag) on a base already >= 0.0.8. Use this skill whenever the user says 'rebuild the index', 'rebuild the knowledge index', 'regenerate the wiki indexes', 'refresh the sub-indexes', 'migrate my wiki to the curated layout', 'upgrade the wiki layout', 'migrate the knowledge base structure', 'repair the knowledge index', 'regenerate the curated front door', 'fix the structural drift', or knowledge-resume / knowledge-health surfaces a schema_version < 0.0.8 migration nudge or a structural-drift verdict.

Phase 6 of the inverted pipeline. Reads the draft and citation manifest, shards the citations, and dispatches wiki-verifier in parallel to score every citation against each cited page's pre_extracted_claims (zero network), then loops with the revisor on unsupported deviations — capped at 2 iterations. Writes verify-vN.json per round and, when the revisor fires, draft-v{N+1}.md plus a citation-records file the orchestrator serializes into the manifest. Use this skill whenever the user says 'verify the draft', 'phase 6 of the knowledge pipeline', 'knowledge verify', 'check the citations', or 'run the claim alignment'. After verify, knowledge-finalize deposits the verified draft as a synthesis page.

Ask a question against a bound cogni-knowledge base — resolve its wiki path from binding.json, rank and read the covering pages, and synthesize a cited answer natively. The shallow rung of the query↔research ladder: one question, index-first read of ≤12 pages, no web, no verify; read-only by default, opt-in `--file-back` deposits an un-verified synthesis page. Use when the user says 'query my <slug> knowledge base', 'ask the <slug> base about X', or 'knowledge-query <slug> [--file-back]'.

Render an HTML dashboard for a bound cogni-knowledge base — runs the vendored wiki-dashboard scripts (render_dashboard.py + build_graph.py) natively against the bound wiki and writes a knowledge-overlay.md sidecar that lists deposited research projects and the latest lint-audit claim_drift count. Use this skill whenever the user says 'show the dashboard for my <slug> base', 'knowledge dashboard', 'visualize my eu-ai-act knowledge base', 'render the knowledge base as HTML', 'knowledge-dashboard <slug>'. The sidecar makes the binding's contribution visible alongside the wiki's own dashboard.

Phase 3 of the inverted pipeline. Builds fetch-manifest.json from the fetch results the curators already produced in Phase 2 (bodies are already fetched during curate). Cobrowse is OPT-IN (--cobrowse): the skill walks the user through enabling the Claude-in-Chrome extension, then dispatches source-fetcher sequentially to recover WebFetch misses AND to additively top up thin primary-tier sources (reading the fuller browser body beyond WebFetch's cap, superseding only if strictly longer). Use this skill whenever the user says 'fetch candidates for project X', 'build the fetch manifest', 'phase 3 of the knowledge pipeline', 'recover the failed sources', 'deepen the primary sources', 'knowledge fetch'. After fetch, run knowledge-ingest to deposit per-URL wiki pages.

Manage claim verification lifecycle — submit, verify, review dashboard, inspect, resolve, and cobrowse claims. Use this skill whenever the user mentions claims, fact-checking, source verification, checking whether statements match their cited sources, reviewing deviations, or anything related to tracking the accuracy of sourced statements. Also use it when another plugin submits claims for verification (e.g., after a research or portfolio workflow produces sourced assertions). Even if the user doesn't say "claims" explicitly — if they're asking about verifying facts against sources, checking citations, finding outdated or mismatched data in cited references, reviewing what's been flagged, checking for stale sources, outdated data in references, or asking "which claims need attention" or "what did verification find", this skill handles it. Also trigger when the user wants to cobrowse unreachable sources together, recover unavailable claims interactively, open sources in their browser to help check them, or say

Phase 1 of the inverted pipeline. Decomposes a research topic into 3-7 sub-questions with per-sub-question candidate-domain hints, writes plan.json into a fresh project directory under the bound knowledge base. Pure decomposition by default (no web); an optional, fail-soft preliminary scoping search engages only inside topic-framing (vague topics or --frame) to ground sub-questions in what's actually searchable. Use this skill whenever the user says 'plan a new research topic', 'decompose topic X into sub-questions', 'start a knowledge-pipeline run on X', 'knowledge plan for X', 'create sub-questions for X under the eu-ai-act base'. After plan, the user runs knowledge-curate to discover candidate sources.

This skill refreshes one existing synthesis in a bound cogni-knowledge base from a newly-landed source — union-not-rederive. Given a synthesis flagged in binding.json::refresh_candidates[] (populated by synthesis-impact.py at ingest-source time), it unions the new source into that synthesis's existing project ingest-manifest rather than re-deriving the manifest via wiki-grounding (which under-maps and thins the synthesis), then runs knowledge-compose -> knowledge-verify -> knowledge-finalize --overwrite as one orchestrated flow. A pure orchestrator over existing phase skills. Pass --all to refresh every open refresh candidate in one fail-soft batch run instead of one synthesis per invocation. Use this skill whenever the user says 'refresh this synthesis from the new source', 'update the <topic> synthesis with the source I just ingested', 'extend an existing synthesis instead of re-running it', 'a new source supersedes my synthesis — fold it in', 'resolve a refresh candidate without thinning the synthesis', or

Transform structured content into compelling executive narratives using story arc frameworks. Use this skill whenever the user asks to create a narrative, write a narrative, transform content into a story arc, apply a specific arc framework (corporate visions, technology futures, competitive intelligence, strategic foresight, industry transformation, trend panorama), generate an insight summary, or summarize research findings as a narrative. Also trigger when other plugins need arc-driven narrative generation, when the user mentions TIPS trend narratives, or when they have research output they want turned into an executive-readable story. Even if the user just says 'make this readable for executives' or 'turn these findings into something presentable,' this skill is the right choice.

Use this skill whenever the user has an existing markdown report and wants it transformed into a polished visual deliverable. This is the go-to skill for turning any completed .md report into themed HTML with interactive Chart.js charts, an infographic header, sidebar navigation, and inline SVG concept diagrams — or exporting it to PDF or DOCX. Trigger for any request that involves an already-written report needing visual enrichment, format conversion, or presentable output: adding charts or diagrams to a report, making a report look good or presentable, generating an HTML version of a report, exporting a report as PDF or Word, enriching a report with visualizations, or converting a text-only report into a themed deliverable. Also trigger for German equivalents (Bericht visualisieren, als PDF exportieren, Diagramme hinzufuegen). The key signal is that the user already has a finished report file and wants to make it visual or export it — this skill post-processes existing content, it never creates new reports

Compose the canonical TIPS trend report from research artefacts produced by `/trend-research`. The report is always organized around the four Smarter Service dimensions (Forces → Impact → Horizons → Foundations) as H2 sections, with investment themes nested as anchored H3 cases written in a slim 3-beat structure (Stake / Move / Cost-of-Inaction). Closes on a "Capability Imperative" synthesis. The four dimensions form a single CxO story arc — see the Storytelling Spine — and the writer agents thread protagonist-shaped micro-stories under the structural beats. Produces `tips-trend-report.md` plus `tips-trend-report-claims.json` — the same canonical filenames the legacy `trend-report` skill produced, so `/verify-trend-report` keeps working unchanged. Required pipeline: trend-scout → value-modeler → trend-research → trend-synthesis → verify-trend-report. Use when: (1) `/trend-research` has completed and written `.metadata/trend-research-output.json`, (2) the user wants a written trend report, (3) the user mention

Run the extended quality pipeline on a generated cogni-trends report — verify claims against their cited sources via cogni-claims, run cross-theme structural review, apply corrections through the revisor, and surface downstream polish and visualization options to the user. Use whenever the user says "verify trend report", "verify claims", "fact-check the trend report", "improve the trend report", "enrich the trend report", "review the trend report", "extend the trend report", "trend report verification", or runs `/trends-resume` after trend-synthesis finished and picks the verify path. Also trigger when a trend-synthesis Phase 3 summary recommends it. Scoped to the cogni-trends data model (`tips-trend-report.md` and `tips-trend-report-claims.json`).

Bootstrap a cogni-knowledge knowledge base — a wiki base + a binding manifest that records every research project deposited into it. Scaffolds the wiki skeleton natively (the wiki engine is vendored; no separate plugin required) if it does not exist, then writes .cogni-knowledge/binding.json. Use this skill whenever the user says 'set up a knowledge base', 'start a knowledge base on X', 'bootstrap a wiki-first research base', 'new knowledge base for X', 'create a knowledge base', or 'wiki-first research setup'. After setup, run the inverted pipeline (knowledge-plan → knowledge-curate → knowledge-fetch → knowledge-ingest → knowledge-compose → knowledge-verify → knowledge-finalize) to deposit research syntheses into the base.

This skill plans the site structure for a cogni-website project interactively — discovering available content, proposing pages, mapping content to page sections, and generating website-plan.json. It should be triggered when the user mentions "plan the website", "site structure", "which pages", "website plan", "plan pages", "Seitenstruktur", "Website planen", "Seiten festlegen", "map content to pages", "which pages do I need", "welche Seiten brauche ich", or wants to decide what pages their website should have — even without saying "plan" explicitly. Requires website-project.json.

This skill resumes, continues, or checks status of a cogni-website project. It is the primary re-entry point for returning to website work across sessions. It should be triggered when the user mentions "continue website", "resume website", "website status", "where was I", "Website fortsetzen", "Website-Status", "weiter mit der Website", "was fehlt noch", "pick up where I left off", "website status check", or opens a session involving an existing website project — even without saying "resume" explicitly.