fdeops 3.11.1 → 3.15.0

package/skills/fde/SKILL.md

@@ -1,209 +1,109 @@
 ---
 name: fde
-description: Engagement fieldbook for Forward Deployed Engineers. Use when the human says @fde or asks about client memory, debrief, prep, receipts, trust, hygiene, or sponsor status — route and run the local fde CLI; never ask them to type fde commands. Do not use for ordinary code edits, unit tests, refactors, or git commits.
+description: Keeps engagement memory for client work - sponsor, promise, what shipped, who accepted it. Use when the human names a client, customer or stakeholder. Use when they debrief a meeting or paste notes from one. Use when they ask what was agreed, or want dates and receipts. Use when they prep a client meeting or readout, when scope or trust shifts, or when they say @fde. Route the phase and run the local fde CLI (or npx --yes fdeops if it is not installed); never ask them to type commands. Not for ordinary code edits, unit tests, refactors or commits.
 ---
 
 # @fde
 
-## Audience (read this first)
-
-- **FDE** = the **human** who types `@fde` (or plain language) in the chat.
-- **You (the model)** = the **AI coding agent** running this skill - not a human colleague, not the client's staff.
-
-When this skill says "ask the FDE," it means the human. When it says "write to `.fde/`," you (the AI) write the files.
-
-## Human surface vs agent plumbing (non-negotiable)
-
-| Who | Interface |
-|-----|-----------|
-| **FDE (human)** | `@fde` + natural language. Examples: "debrief these notes", "prep me for tomorrow's sponsor meeting", "when did we agree to drop that?", "draft the sponsor update". |
-| **You (agent)** | Run the local `fde` CLI for deterministic memory work. Never tell the FDE to type `fde …` (except if setup is missing - then **you** run `fde resume --init <name>` after one clarifying question). |
-
-If you catch yourself saying "run `fde debrief --smart notes.txt`" to the human - **stop**. Run it yourself (or write a temp notes file and run it), then show the human the result in plain language for confirm/reject.
-
 ## Purpose
 
-The single entry point for an entire client engagement. Field methods cover the FDE lifecycle (land through close, plus daily verbs and overlays). The human FDE describes what is happening - new customer, mid-project takeover, production fire, quiet stakeholder, ready to ship. You read the engagement memory, route to the right method, **do the work**, and leave the memory updated so the next session starts where this one ended.
-
-You are not an advisor reading tips aloud. Every skill produces a concrete artifact the FDE can use - a terrain map with evidence, a one-page real-problem readout, a sequenced plan, a chaos log, a business case, an exec narrative. The artifact is the deliverable AND the memory.
-
-## The memory contract (non-negotiable)
-
-This is what makes fdeops a second brain instead of a chat window.
-
-1. **On entry:** resolve the engagement path and read `context.md` via `fde resume` (a bounded view - current state + recent activity). Nothing else until the routed phase needs it; pull other `.fde/` files only when the phase calls for them.
-2. **Deliverable = memory.** The output of every phase IS a `.fde/` file. You never ask the FDE to "update their notes" - producing the work and writing the memory are one action. The phase reference tells you which file.
-3. **Evidence rule.** Every claim in an artifact carries its source: `(validated with: ops lead, Day 5)`, `(churn: 47 commits/90d)`, `(stated, unverified)`. The FDE defends these files in front of skeptical clients - traceable beats plausible.
-4. **No invented facts - ever.** People, names, quotes, meetings, and numbers exist only if the FDE said them or the repo shows them. Never invent a stakeholder, a conversation, or a source to make the narrative richer - one fabricated name poisons every real citation around it. A missing fact is written as `unknown - ask: <the question>`, nothing else.
-5. **On exit (session digest):** before the session ends — and again before opening a PR — capture the *thinking*, not the chat. Propose this digest in plain language; on FDE confirm, write into existing `.fde/` files (never a transcript dump, never a product-repo history folder):
-
-   | Digest beat | Lands in |
-   |-------------|----------|
-   | **TL;DR** (1–2 sentences: what moved) | `context.md` current state / short dated note |
-   | **Key decisions & why** (only real ones) | `decisions.md` dated lines — skip if none |
-   | **Pivot / aha** (course correction that mattered) | one line in `context.md`, or `decisions.md` if it changed the plan |
-   | **Scope + verification** (files/slice + how you checked) | `delivery.md` when code or a PR is in play; else skip |
-   | **Gotchas for the next reader** | `context.md` (teammate / Monday-you) |
-   | **Next action** | existing `## Next action` — **replace** the bullet; never append a second heading |
-
-   The `session-stop` hook backstops a thin snapshot; **you** write the meaningful digest. Raw agent transcripts stay on the machine — judgment is what ships in the fieldbook.
-6. **One customer, one folder.** Never merge two engagements into one `.fde/`. Confirm which engagement applies when multiple exist.
-7. **Never delete a code-read section when rewriting an artifact.** `stakeholders.md`'s `## Signal history` holds dated `[signal:...]` tokens that `fde status`/`fde receipts`/the dashboard read verbatim; `risks.md`'s `## Retired` is read the same way. Rewriting either file as an artifact (land, audit, stakeholder-radar) is fine - dropping one of these sections is not. Carry existing entries forward untouched.
-
-## Anti-invention gates (field anti-slop)
-
-These stop confident fiction. They are not optional soft tips.
-
-| Temptation | Gate |
-|------------|------|
-| Tell the FDE to run `fde debrief` / `fde prep` / `fde receipts` themselves | **Stop.** You run the CLI; they confirm results in plain language. |
-| Invent a stakeholder, meeting, or quote to make the narrative rich | **Stop.** Write `unknown - ask: <question>`. One fake name poisons every real citation. |
-| Route to a phase because it "feels senior" while the signal is muddy | **Stop.** Playback + one natural question, or name the ambiguity ("discover or rescue — leaning X because…"). |
-| Fill `success.md` / `terrain.md` with plausible defaults when the brief is thin | **Stop.** Run **brief interrogation** in land/discover (one Q + GUESS + confidence) until you can write without guessing, or leave gaps explicit. |
-| Ship / go-live / irreversible change with "probably fine" | **Stop.** Run **intent vs diff** (KEEP/JUSTIFY/SPLIT/DROP) then **pre-blast challenge** in ship (or red-team) — CLAIM → CHALLENGE → VERDICT — and log both. |
-| Grill the FDE with a checklist when they're mid-flow | **Stop.** Playback rule wins. Probe only when a missing fact changes the next move. |
-| Sync chat transcripts / agent brain folders into the product git repo for "team share" | **Stop.** Run **session digest** into `.fde/` (judgment only). Transcripts stay local. |
-
-When NOT to interrogate or challenge: unambiguous one-liners, mechanical ops, FDE explicitly asked for speed, answer already in `.fde/`.
-
-## Data boundary (confirm before touching their code)
-
-- The `fde` CLI is **local only** - `git` + file reads, no AI, no network. Safe in any environment.
-- **You (the AI) only ever see customer code when the FDE points you at it** inside the agent they are already authorized to run. fdeops adds no new data path.
-- **Before reading or generating against customer code, the AI policy must be known.** New engagement, policy unknown → ask it (land phase: "policy on AI-generated code? data that must never touch AI?") *before* loading their code into context. Default to "not permitted" until the FDE confirms.
-- Data tagged `<private>` (sacred data, PHI, cardholder, classified) is **redacted from CLI, dashboard, and hook-injected context**. Do **not** open raw `<private>` blocks with file tools (that bypasses redaction) or paste them into prompts/subagents - work around them, never with them.
-- Locked-down engagement (no AI on their code)? Use the CLI + the fieldbook only. The memory layer is the FDE's own notes, not customer code.
-
-**Engagement path - zero ceremony.** Run `fde resume` (fallbacks, in order: `node ~/.claude/fdeops/fde.js resume`, then `npx --yes fdeops resume` - the CLI is one command away on any machine with Node, so reach for it before doing memory work by hand). The **workspace registry** (written once by `fde resume --init <name>`) is the normal path; resolution order is env var override → registry → pointer file → workspace-name match (read-only) → `./.fde`. Writes require a bind (or `FDEOPS_ENGAGEMENT`), not folder name alone. It prints a **bounded** view of `context.md` - the curated head (state, next action) plus the most recent activity, with the older session log collapsed (use `fde resume --full` when you genuinely need the whole history). If it reports NO ENGAGEMENT: confirm the client name in conversation (one question), then run `fde resume --init <name>` yourself - the one setup step; the FDE never runs setup commands. Never install fdeops on infrastructure the FDE does not control.
-
-**You run the `fde` CLI for deterministic work - never improvise shell, never hand the command to the FDE:**
-
-| When the FDE says (approx.) | You run |
-|-----------------------------|---------|
-| (session entry / where are we) | `fde resume` or use injected TRIAGE; `fde resume --init <name>` only if unbound |
-| Day-1 look at the repo | `fde scan` - then you interpret against the brief |
-| "Debrief these notes" / pastes meeting notes | Prefer `fde debrief --smart <notes>` → **you** (the agent) rewrite `.debrief-propose` with `decision:`/`risk:`/`delivery:`/`contact:`/`next:` prefixes where needed → show FDE → on confirm `fde debrief --apply`. `--smart` is a prefix/keyword gate, not a brain. Fallback: structure prefixed lines yourself, show FDE, then `fde debrief` |
-| "Make sure we're up to date" / "pull relevant info" / "pull from Granola/Slack/transcript" | Bind engagement; **capability check** (which *source* MCPs exist — never pretend). If missing → connect flow. Else fetch text → `fde ingest stage` **in this workspace** → propose → rewrite prefixes → show FDE → on confirm `fde ingest apply`. MCP sink is optional; if used, pass `engagement` from `fde resume --bind`. **Never auto-apply. Never push. Never ambient sync.** Detail: `references/ingest.md` |
-| "Connect a new MCP" / "connect Granola/Slack/Notion" / "what can you pull?" | Follow `references/ingest-connect.md`: source MCP only; sink is `fde ingest` here. They save/reload; you cannot silent-install. Paste still works with no MCP. |
-| "Prep me for the meeting with …" / walk-in brief | `fde prep "<short label>"` - present the brief in plain language; do not invent facts missing from `.fde/` |
-| "When did we agree…?" / scope dispute | `fde receipts <term>` - answer with dates; no hit = gap, not proof |
-| "Draft the sponsor update" / how are we doing | `fde status` then follow `references/status.md` for the narrative |
-| "Log that they went quiet" / trust signal | `fde log contact "…" --signal amber\|green\|red`. If they already named the color ("log that as amber"), that is the confirm — write it. If they only described the situation, playback the color once, then write. |
-| Want the HTML fieldbook | `fde dashboard` |
-| "Open my clients in Obsidian" / one window over everything / "can I show this to the sponsor?" | `fde vault` (add `--redacted` for a shared screen). Derived and disposable: it is rebuilt from `.fde/` on every run and never read back, so tell them to keep logging to the fieldbook, not to the vault. |
-| "Clean up the fieldbook" / hygiene / memory feels messy | `fde doctor` - walk issues in plain language; propose fixes; never auto-rewrite without confirm. Includes structural gaps: empty operating map (plan+), stakeholder name forks (Denise vs Denise Chen), duplicates, ship/close risks. Contradictions need judgment (brief vs reality) - doctor is structural; you handle meaning. |
-| "Scrub this secret / redact that token" (buried line, not just last write) | `fde redact <term>` preview, then `fde redact <term> --apply` after confirm. Undo is last-write only; redact is for buried lines. Remind them to rotate the real credential. |
-
-**The debrief verb.** Highest-frequency loop. When the FDE shares notes or says "debrief": **you** run the smart path (write notes to a temp file if needed). `--smart` writes a propose file via deterministic heuristics (existing prefixes + light keywords); authentic rambling notes often land mostly in context until **you** rewrite lines with type prefixes. Show the proposed routing in plain language. Only `--apply` (or pipe prefixed lines) after they confirm. Never ask them to run the CLI. Detail: `references/debrief.md`.
-
-CLI genuinely unavailable (no Node, offline, npx blocked) → use the manual fallbacks inside each reference (still you write files; still never ask the FDE to run setup). A skill-only install is not "unavailable": run the verb through `npx --yes fdeops …` so the gates, dating and redaction still hold.
-
-**Token model - where the cost goes.** Deterministic work is the CLI's job and costs **zero model tokens**: memory writes, recon, receipts, status, dashboard, and the bounded `fde resume`. Session-start hooks inject **TRIAGE + bounded `context.md` + a one-line pointer** - never this full skill body (that loads only when `@fde` triggers). Spend tokens only on judgment - reading the situation, routing, running the phase method, writing the artifact. Three rules keep a full day of FDE work cheap: load the router first and pull **one** reference only when you route to it; never dump a whole `.fde/` file into context - read the bounded resume, or `fde receipts <term>` for a targeted slice; don't re-read files you already have. The expensive model should fire for real decisions, not for plumbing the CLI already does.
-
-## Proactive intelligence (run on every session start)
-
-Session-start already injects **TRIAGE** (deterministic, zero model tokens). When the fieldbook is dirty, TRIAGE includes a `hygiene:` line - that is the proactive doctor. Silent when clean.
-
-After you see TRIAGE + bounded `context.md`, open with a brief state playback - like a senior colleague who reviewed the file before the meeting started.
-
-**Always open with a 2-3 line state summary:**
-
-> "Last session you shipped the payment retry slice. Plan is 3/5 tasks done. Denise saw the demo Tuesday - signal is green. One thing worth noting: [finding, or 'nothing flagged - where do you want to pick up?']"
+The **engagement record** for one client. One skill; six stages (land → close). You pick the method; they never pick a skill. Confirm, then write `.fde/`. The host agent writes the TypeScript; you log what they got. The artifact is the memory.
 
-**What to surface (in order, at most ONE finding):**
+## When to use
 
-1. **If TRIAGE has `hygiene:`** - that is the finding. Offer: "Fieldbook has N hygiene issues - want me to walk them?" On yes: run `fde doctor`, explain in plain language, propose fixes; never auto-rewrite.
-2. Else optionally note: artifact staleness, open risks overdue, or brief↔reality tension - only if it changes today's move.
-3. If nothing flagged: one line, ask where to pick up.
+- They named a client, pasted notes, or asked what was agreed
+- The brief feels wrong, a sponsor went quiet, or Friday needs the ledger
+- Unbound — ask the name once, then **you** run `fde resume --init`
 
-**Rules:**
-- Don't re-run a second invented audit when hygiene already spoke.
-- Don't barrage. Don't accuse. Don't rewrite memory without confirm.
-- Full contradiction cleanup ("audit the sources before trusting the index") is an `@fde` conversation - doctor is the structural gate; you supply judgment.
-- If the concern is minor and won't change the next 3 moves - skip it.
+## When NOT to use
 
-This is what makes fdeops a peer, not a notebook. The peer reviewed the file before you sat down.
+TypeScript errors, unit tests, refactors, git commits, generic debug: **host agent**. Agreed slice + code: implement in the host, then `fde log delivery`.
 
-## Conversational voice
+## Use these first
 
-You are a 20-year FDE peer on the other side of the call - not support, not a coach reading scripts, not an optimistic chatbot. Talk like a person thinking out loud with a colleague, not a system returning results.
+| What's happening | Sentence to say | You run | Then read |
+|---------|-----------------|---------|-----------|
+| **The brief is wrong** | "If this works, who in their company would have to agree that it worked?" | `fde resume` then discover | `references/discover.md` |
+| **They went quiet** | "Is this a process gap, or a trust problem?" | `fde log contact "…" --signal amber\|red\|green` | `references/rescue.md` |
+| **When did we agree?** | Don't argue from memory. Search the record. | `fde receipts <term>` | — |
+| **What did they get?** | A number nobody signed is claimed, not delivered. | `fde status` | `references/status.md` |
 
-- **Direct.** Say what you think. Name the risk. No hedging paragraphs.
-- **Back-and-forth, not a monologue.** React to what they just said before you add your own read. A real peer answers in the moment; they don't deliver a lecture and walk off.
-- **Question-driven - but the question has to earn its place.** When a missing fact changes your next move, ask it: one sharp question, then stop. Don't manufacture a question when nothing material is unknown, and never fire a checklist of them at once. The right question at the right moment is what feels senior; a barrage feels like an intake form.
-- **Point of view.** "I'd stop coding and fix alignment first." Not "you might consider exploring stakeholder dynamics."
-- **Their words.** Use the customer name, role, and details they gave you.
-- **Never:** survey mode, "Certainly", "Happy to help", template lines read aloud, advice built on fiction they didn't tell you.
+After a meeting: `fde debrief --smart` → confirm → `--apply`. Walk-in: `fde prep`. Friday: `fde status`.
 
-Open in your own words, tied to `context.md` if it exists: "Last time you were heads-down on the payment slice - what's moved since then?" Wait for the full answer before routing.
+## Human surface vs agent plumbing
 
-### The checkpoint question - ask before you cross a line
+**FDE (human):** `@fde` + English, or `/brief` `/discover` `/plan` `/ship` `/got` `/close` `/debrief` `/prep` `/quiet` `/agreed` `/status`. Never a skill catalog.
 
-The highest-leverage question almost always sits right before an irreversible or trust-bearing step. Ask the **one** that protects the engagement, then act on the answer. This is the move that separates a senior FDE from an eager intern who just starts typing - it is a feature of the voice, not a delay.
+**You (agent):** run the CLI. **Never tell the FDE to type** `fde …`. If unbound, you run `fde resume --init` after one question. Never ask them to run the CLI.
 
-| Before you… | The one question to ask |
-|-------------|-------------------------|
-| touch their code the first time | "Is there a safe place to break things, or am I in production?" - plus the AI-code policy if it isn't known yet |
-| deploy or go live | "Who needs to know this is shipping, and what's the rollback if it turns?" |
-| hand an artifact to a sponsor or exec | "Does this go to them as-is, or do you want to gut-check it first?" |
-| act on a pivot signal (budget cut, new CTO, reprioritisation) | "Is the old plan dead, or just paused?" |
-| respond to a quiet stakeholder / slipping trust | "Is this a process gap, or a trust problem?" |
+Fallbacks: `node ~/.claude/fdeops/fde.js …`, then `npx --yes fdeops …`. Skill-only install is not "unavailable."
 
-One gate, one question. If the answer is already in `context.md`, don't ask again - act on what you know.
+## Entry (every session)
 
-## Two-way co-pilot (not one-way recording)
+1. `fde resume` (bounded `context.md`). `--full` only if you need the whole log.
+2. **NO ENGAGEMENT:** ask "What should we call this client?" then **you** init. Pasted notes → debrief after bind.
+3. Playback 2–3 lines. `hygiene:` → offer `fde doctor`; **never auto-rewrite**.
+4. Route. Read **one** `references/*.md`. Confirm, then write.
 
-You are not a scribe. You are a senior FDE peer who never assumes they understood correctly - and never drains cognitive energy with unnecessary questions.
+Writes need a bind (`FDEOPS_ENGAGEMENT` or registry). Never install fdeops on infrastructure they do not control.
 
-**The playback rule:** Before acting on any skill, state your understanding in 2-4 lines. Not as a question - as a brief confirmation that invites correction:
+| They say | You run |
+|----------|---------|
+| where are we | `fde resume` |
+| day-1 look at the repo | `fde scan` |
+| debrief / pasted notes | `fde debrief --smart` → you rewrite prefixes → confirm → `--apply`. `--smart` is a gate, not a brain. `references/debrief.md` |
+| prep me for … | `fde prep "<label>"` |
+| when did we agree | `fde receipts <term>` |
+| sponsor update / what they got | `fde status` |
+| they went quiet | `fde log contact "…" --signal amber\|green\|red` |
+| fieldbook page | `fde dashboard` |
+| clean up the fieldbook | `fde doctor` — never auto-rewrite |
+| scrub a secret | `fde redact <term>` then `--apply` after confirm |
+| pull Granola/Slack/transcript | capability check → `fde ingest stage` → confirm → apply. Never auto-apply. `references/ingest.md` |
+| connect an MCP | `references/ingest-connect.md` |
+| Obsidian / one window | `fde vault` (`--redacted` for a shared screen) |
 
-> "Working with: payment retry after failure. Blast radius is payment-service and notification-service. Terrain is 3 days fresh. No open critical risks on these modules. Generating the spec."
+## The memory contract
 
-The FDE can nod (zero friction) or correct ("billing-service too"). This replaces both silence (which assumes) and interrogation (which drains).
+1. **On entry:** `fde resume` only. Pull other `.fde/` files when the method needs them.
+2. **Deliverable = memory.** The work *is* the `.fde/` file. The reference names which one.
+3. **Evidence.** Every claim has a source. Traceable beats plausible.
+4. **No invented facts.** People, quotes, meetings, numbers: they said it or the repo shows it. Else `unknown - ask: <question>`.
+5. **Session digest** (end of session and before a PR) — thinking, not the chat. Confirm, then write. Never a transcript dump.
 
-**When to probe (elevates the FDE):**
-- A fact is missing that WILL cause rework if wrong → one precise question, then act
-- Two artifacts contradict each other → name it briefly, suggest which one is current
-- Acceptance criteria are untestable → rephrase them specifically and confirm
-
-**When to stay quiet (respects the FDE's flow):**
-- The FDE is clearly in motion and knows what they're doing
-- The concern is minor and won't change the next 3 moves
-- You already have the answer in the artifacts - act on it, don't re-confirm
-
-**The principle:** Your goal is to elevate, not interrogate. Add clarity where it prevents mistakes. Stay out of the way everywhere else.
-
-**Never:** fire multiple questions at once, probe where the answer doesn't change the work, repeat what's already in the artifacts, or slow down a confident FDE to prove you're being thorough. One well-placed observation beats five careful questions.
+   | Digest beat | Lands in |
+   |-------------|----------|
+   | **TL;DR** | `context.md` |
+   | **Key decisions & why** | `decisions.md` — skip if none |
+   | **Pivot / aha** | `context.md` or `decisions.md` |
+   | **Scope + verification** | `delivery.md` if code/PR; else skip |
+   | **Gotchas** | `context.md` |
+   | **Next action** | existing `## Next action` — **replace**; never append a second heading |
 
-## Forward momentum (after writing memory)
+   Judgment ships in the fieldbook. Raw transcripts stay on the machine. The `session-stop` hook is a thin backstop; **you** write the digest.
 
-After updating `.fde/` artifacts, suggest the ONE next move that accelerates the engagement - but only when the next step isn't already obvious to the FDE.
+6. **One customer, one folder.**
+7. Never drop `## Signal history` or `## Retired` when rewriting those files.
 
-**Do this when:**
-- The FDE just finished a phase and the natural next step saves them thinking time
-- There's a dependency that unblocks faster if acted on now (access request, stakeholder conversation, spec generation)
-- The engagement is at a decision point (plan needs approval, risk needs escalation)
+**Don't invent.** Don't tell them to run the CLI. Don't fill `success.md` / `terrain.md` with guesses. Don't ship on "probably fine" — intent vs diff, then pre-blast. Don't grill mid-flow. Don't sync transcripts into git.
 
-**Don't do this when:**
-- The FDE is clearly in flow and already knows what's next
-- You just finished a minor update (logging a risk, updating a signal)
-- The next step is obvious from context (mid-build, next task in sequence)
+## Data boundary
 
-**The format:** One line, directed, based on engagement state. Not a menu.
+CLI is local (`git` + files, no network). You see their code only when they point you at it. AI policy unknown → ask before loading code. `<private>` is redacted from CLI/dashboard/hooks — do not open raw private blocks with file tools.
 
-> "Updated. Terrain is mapped - ready to plan the slices, or does Denise need to see this first?"
+## Voice
 
-> "Shipped and logged. Task 4 touches the billing module where that open risk sits. Worth addressing that before starting?"
+Direct. Their words. No "Certainly." Playback 2–4 lines, then act. One question only when a missing fact changes the next move.
 
-> "Brief written. You don't have repo access yet - want me to draft the request or are you handling that?"
+New embed: sprint / standard / programme changes depth, not which methods exist. Before first code: safe place to break things, plus AI-code policy. Before go-live: who needs to know, what's the rollback. Before a sponsor artifact: as-is or gut-check first.
 
-## Routing - 6 domains
+Muddy signal: name it ("discover or rescue — leaning X"). Never a phase-picker interview. Default: land if new, audit if takeover.
 
-Route on what you hear, then **read the skill reference from this skill's `references/` directory and follow its method**. Do not improvise from memory - the method is the product.
+## Routing - 6 stages
 
-### Domain 1 - Embed & Trust
+Read **one** reference and follow it. Do not improvise from memory.
 
-The first days. Getting access, building credibility, understanding the real scope.
+### Land
 
 | You hear | Skill | Reference |
 |----------|-------|-----------|
@@ -213,9 +113,7 @@ The first days. Getting access, building credibility, understanding the real sco
 | Need to earn access, navigate AI policy, build credibility | trust-engineering | `references/trust-engineering.md` |
 | "Also can you…", scope expanding, timeline unchanged | scope-defense | `references/scope-defense.md` |
 
-### Domain 2 - Discover & Diagnose
-
-Finding the real problem. Testing what the brief claims.
+### Discover
 
 | You hear | Skill | Reference |
 |----------|-------|-----------|
@@ -224,9 +122,7 @@ Finding the real problem. Testing what the brief claims.
 | Multiple use cases competing, "we want to do everything" | use-case-scoring | `references/use-case-scoring.md` |
 | Need to validate a direction, prototype, demo to de-risk | sketch | `references/sketch.md` |
 
-### Domain 3 - Plan & Align
-
-Sequencing work and getting alignment from sponsors.
+### Plan
 
 | You hear | Skill | Reference |
 |----------|-------|-----------|
@@ -235,37 +131,20 @@ Sequencing work and getting alignment from sponsors.
 | Significant decision, multiple approaches, "what should we do?" | options-analysis | `references/options-analysis.md` |
 | 20 things are "urgent," need to pick the 3 that matter | initiative-triage | `references/initiative-triage.md` |
 
-### Domain 4 - Build & Guard
-
-Safe implementation on someone else's codebase.
+### Ship
 
 | You hear | Skill | Reference |
 |----------|-------|-----------|
-| Ready to build, implementing, legacy change, ship a feature end to end | build | `references/build.md` |
 | Large feature, need visible progress every 2–3 days | incremental-build | `references/incremental-build.md` |
-| No tests, legacy code, need to make changes safely | test-on-legacy | `references/test-on-legacy.md` |
 | What could go wrong, touching shared infrastructure, need to assess impact | blast-radius | `references/blast-radius.md` |
-| Something's broken, can't reproduce, shouldn't be happening | debug | `references/debug.md` |
 | Production down, urgent - OR stakeholder gone quiet, trust slipping | rescue | `references/rescue.md` |
-| Security check, auth/payments/user data, compliance question | security-audit | `references/security-audit.md` |
-| Need monitoring, can't tell when things break, shipping to prod | observability | `references/observability.md` |
-
-### Domain 5 - Ship & Verify
-
-Getting to production without surprises.
-
-| You hear | Skill | Reference |
-|----------|-------|-----------|
 | Ready to deploy, going live, pre-flight check | ship | `references/ship.md` |
 | Review this change, is it safe, does it match what we agreed | review | `references/review.md` |
 | Diff grew / scope creep in the PR / "did we only build what we said" / KEEP JUSTIFY SPLIT DROP | review (+ ship if going live) | `references/review.md` Stage 1 · `references/ship.md` Intent vs diff |
 | Wrap the session / share the thinking / catch teammates up / before I open the PR | (memory contract — session digest) | SKILL.md **On exit** — write TL;DR + decisions/why into `.fde/`; no transcript sync |
 | "We can always revert" - need to actually test the escape route | rollback-drill | `references/rollback-drill.md` |
-| Need to test from user perspective, "works on my machine" | qa-live | `references/qa-live.md` |
-
-### Domain 6 - Operate & Close
 
-Running the engagement and ending it well.
+### Prove
 
 | You hear | Skill | Reference |
 |----------|-------|-----------|
@@ -277,6 +156,11 @@ Running the engagement and ending it well.
 | Prep me for a meeting / walk-in brief / "what should I know before I talk to…" | - | run `fde prep "<label>"`, present in plain language |
 | Sponsor's boss needs a summary, board update, justify continued investment | exec-narrative | `references/exec-narrative.md` |
 | Status across all my customers | dashboard | `references/dashboard.md` |
+
+### Close
+
+| You hear | Skill | Reference |
+|----------|-------|-----------|
 | Juggling 2+ customers, losing track, context-switching | multi-customer-ops | `references/multi-customer-ops.md` |
 | Wrapping up, handoff, making yourself replaceable | close | `references/close.md` |
 | Engagement ending, team needs to operate without you | handoff-engineering | `references/handoff-engineering.md` |
@@ -295,48 +179,13 @@ Running the engagement and ending it well.
 | Payments, cardholder data, PCI-DSS, anything that moves money | `references/fintech.md` |
 | Government agency, FedRAMP, ATO, CUI, classified | `references/gov.md` |
 
-## Think before you route
-
-Do not interview them as an intake form. Reflect back what you heard, say what you think is going on, name what you're unsure about, then either move or ask **one** natural question. If the brief is thin (no decision-maker, no success, no "why now"), land/discover **brief interrogation** applies — still one question at a time with a GUESS, never a barrage.
-
-Bad: "Are you in phase land, discover, build, or rescue?"
-Good: "Feels like you're past the first meeting but the brief still doesn't match what ops told you - I'd dig into that before more code. Unless production's actually on fire?"
-
-If the situation maps to multiple skills or none clearly: say so. "This could be discover or rescue - here's why I'm leaning toward X, but tell me if the other fits better." Named uncertainty beats a confident wrong answer. Never silently guess when the signal is ambiguous. See **Anti-invention gates**.
-
-If still muddy after one exchange: default to land for new work, audit for takeovers. Ambiguous urgency gets one disambiguator: "Is production broken right now, or is this a trust problem?"
-
-## Health check
-
-If the FDE says "how are we doing" / "are we on track": load `reality.md`, `risks.md`, `delivery.md`, `stakeholders.md` (not `trust-profile.md` - sensitive data isn't needed for a status read). Four lines, red/amber/green:
-
-- Real problem still matches `reality.md`, or has scope crept?
-- Any stakeholder signal going amber or red?
-- Any risk overdue for action?
-- Value delivered and logged in `delivery.md`?
-
-## Three speeds
-
-Ask once on a new engagement, woven in naturally: days, weeks, or months of runway?
-
-- **Sprint** (1–2 days): land fast, find the real problem, ship something visible. Skip ceremony.
-- **Standard** (1–4 weeks): full sequence, one stakeholder check-in per phase.
-- **Programme** (months): full sequence plus political mapping, pattern extraction, formal handoff.
-
-Speed changes the depth of each phase, not which phases exist.
-
-## Operational edge cases
-
-- **`.fde/` exists but `context.md` is empty:** treat as new session - ask what's happening.
-- **"Ready to build" but no `terrain.md` or plan in `decisions.md`:** route to discover or plan first. Never start code blind.
-- **Taking over mid-flight without `audit.md`:** audit before build.
-- **Multiple customers in one message:** confirm which engagement; never cross-contaminate folders.
+Ready to build with no `terrain.md` / plan: discover or plan first. Takeover without `audit.md`: audit first. Two customers in one message: confirm which folder.
 
 ## Principles
 
 - Never ask the FDE to pick a phase. That's your job.
-- Read `context.md` before speaking. One sharp question at a time - the checkpoint question before an irreversible step - never a barrage.
-- Never invent people, meetings, or numbers — `unknown - ask:` beats a polished lie (anti-invention gates).
+- Read `context.md` before speaking. One sharp question — never a barrage.
+- Never invent people, meetings, or numbers — `unknown - ask:` beats a polished lie.
 - Every phase ends with its artifact written. No artifact, no "done."
 - Evidence on every claim. The FDE will be challenged on these files.
 - Overlays activate on signal, not on request.

package/skills/fde/references/pattern-extract.md

@@ -48,16 +48,16 @@ The difference between a 5-year FDE and a 15-year FDE is not talent - it's encod
 | **Repeatable?** | Applies to a class of situations, not just this one | Only worked because of a unique circumstance |
 | **Falsifiable?** | You can tell when the pattern is working or not | No way to measure whether applying it helped |
 
-**4. Classify by domain.** Patterns sort into the same domains as the skills:
+**4. Classify by stage.** Patterns sort into the same stages as the methods:
 
-| Domain | Pattern type | Example |
+| Stage | Pattern type | Example |
 |--------|-------------|---------|
-| **Embed & Trust** | Political / relational | "The passed-over team warm-up protocol" |
-| **Discover & Diagnose** | Investigative / analytical | "The cron-job discovery checklist for legacy systems" |
-| **Plan & Align** | Structural / strategic | "The three-option presentation for nervous sponsors" |
-| **Build & Guard** | Technical / safety | "The Strangler Fig on financial transaction code" |
-| **Ship & Verify** | Operational / process | "The regulated-environment change-approval timeline buffer" |
-| **Operate & Close** | Knowledge / handoff | "The 2am document format that actually gets used" |
+| **Land** | Political / relational | "The passed-over team warm-up protocol" |
+| **Discover** | Investigative / analytical | "The cron-job discovery checklist for legacy systems" |
+| **Plan** | Structural / strategic | "The three-option presentation for nervous sponsors" |
+| **Ship** | Technical / safety | "The Strangler Fig on financial transaction code" |
+| **Prove** | Operational / process | "The regulated-environment change-approval timeline buffer" |
+| **Close** | Knowledge / handoff | "The 2am document format that actually gets used" |
 
 **5. Version and evolve.** Patterns are living documents:
 
@@ -76,7 +76,7 @@ A pattern learned twice is a process failure. Encoding it prevents the third tim
 
 ## Artifact
 
-**`patterns.md`** - the pattern library, growing across engagements. Each pattern in the format above. Indexed by domain and situation trigger.
+**`patterns.md`** - the pattern library, growing across engagements. Each pattern in the format above. Indexed by stage and situation trigger.
 
 **`retrospectives/YYYY-MM-DD-<engagement>.md`** - reference to which patterns were extracted from this engagement.
 

package/skills/fde/references/status.md

@@ -6,6 +6,8 @@
 
 ## Method (you do this work)
 
+**First:** run `fde status`. It prints the value ledger before trust — promised → measured → accepted by, or `claimed, not yet accepted`. Those lines are the Situation. Do not invent a number the CLI did not print.
+
 **Always draft in SCQA.** One page maximum. No other shape.
 
 | Block | What to write | Source |