fdeops 3.20.0 → 3.22.0

package/AGENTS.md

@@ -4,7 +4,7 @@ This repository **is** fdeops - the engagement record for Forward Deployed Engin
 
 ## If you are helping use fdeops in an engagement
 
-Route via **`@fde`** - read `skills/fde/SKILL.md` (the single source of truth), pick the phase, do the work, and write `.fde/` memory. Never ask the human to pick a skill. Other tools get the same behavior through thin pointer files in [`adapters/`](adapters/README.md).
+Route via **`@fde`** - read `skills/fde/SKILL.md` (the single source of truth), route to one `references/*.md`, do the work, and write `.fde/` memory. Never ask the human to pick a skill. Other tools get the same behavior through thin pointer files in [`adapters/`](adapters/README.md).
 
 ## If you are contributing to this repository
 

package/README.md

@@ -2,91 +2,78 @@
 
 **Forward deployed engineering skills for AI coding agents.**
 
-Skills encode the workflows, quality gates, and judgment Forward Deployed Engineers use on someone else's site. Packaged so an AI coding agent can run the embed end-to-end: discovery, POC, their codebase (greenfield or brownfield), go-live, eval, signed outcome. The workspace still compiles and commits. `@fde` does not leave.
+You're on a customer site. The AI coding agent writes code in their repo. This kit is the work around that code: the brief, who can say yes, proof on their staging then live, whether they signed off, whether they can run it after you leave.
 
-<img width="1774" height="887" alt="FDEops-githubposter" src="https://github.com/user-attachments/assets/9eb842d2-a356-4995-9057-841f1b2d15d6" />
+Notes stay on your laptop. Their repo stays theirs. You confirm before anything is written down.
 
----
-
-## Commands
+Keep the coding pack you already use. Install this next to it. FDEOps is the client work. The other pack writes the code.
 
-One command per stage. Skills load automatically.
+<img width="1536" height="1024" alt="fdeops" src="https://github.com/user-attachments/assets/2bcb8739-55ee-445d-8a1a-8b38433b7b58" />
 
-Six commands map to the embed. Each one loads `@fde`, which opens the skill for that moment: a thin brief pulls land, a wrong brief pulls discover, a Friday number pulls readout. Sprint or programme. Greenfield or brownfield. Any industry. You never pick from 30 names.
-
-| Work | Command | Stage | Principle |
-|------|---------|-------|-----------|
-| Engage | `/brief` | Land | Name who signs done |
-| Diagnose | `/discover` | Discover | Treat the brief as a hypothesis |
-| Align | `/plan` | Plan | Work backwards from done |
-| Deliver | `/ship` | Ship | One visible change, then go live |
-| Realize | `/outcome` | Outcome | Promised, measured, accepted |
-| Transfer | `/close` | Close | They operate it without you |
+---
 
-Also:
+## Quick Start
 
-| Work | Command | Principle |
-|------|---------|-----------|
-| Diagnose trust | `/trust` | Process gap, or they stopped trusting you |
-| Find the receipt | `/receipts` | A dated line, or it did not happen |
-| Capture the meeting | `/debrief` | Notes into the record |
-| Prepare the meeting | `/prep` | One page from the record |
-| Report the outcome | `/readout` | Promised, measured, accepted |
+**Try it first, nothing installed.** In any repo:
 
-Skills also activate on English: naming a client, running a POC, changing their checkout, going live, asking what was agreed. A throwaway one-liner in an unbound repo can skip `@fde`. Bound client work cannot.
+```bash
+npx fdeops scan
+```
 
----
+Two minutes. It prints what to look at on day one and the questions to ask. Local only, nothing written.
 
-## Quick Start
+**Then install the skill:**
 
 ```bash
 npx skills add suboss87/fdeops --skill fde
 ```
 
-Then one chat. Name the client. The AI coding agent binds.
+One chat. Name the client:
 
 ```text
-@fde this is Acme
+@fde this is client01
 ```
 
-Paste kickoff notes in the same thread. `@fde` routes; you confirm judgment. Same folder every time: `~/fde-engagements/<client>/.fde/`. Workflow: [docs/USAGE.md](docs/USAGE.md).
+That creates `~/fde-engagements/client01/.fde/` on your laptop. Paste kickoff notes in the same thread. `@fde` picks what to check. You still decide.
+
+Day to day: [docs/USAGE.md](docs/USAGE.md).
 
 <details>
-<summary><b>Claude Code (recommended)</b></summary>
+<summary><b>Claude Code</b></summary>
 
 ```text
 /plugin marketplace add suboss87/fdeops
 /plugin install fdeops@fdeops
 ```
 
-Hooks load where you left off. Slash commands match the map above.
+Hooks resume where you left off. Slash commands match the table below.
 
 </details>
 
 <details>
 <summary><b>Cursor</b></summary>
 
+After the skill install, in the **client repo** you have open (pointer, not a second pack):
+
 ```bash
-npx skills add suboss87/fdeops --skill fde
+npx fdeops adapters .
 ```
 
-Or `npx fdeops adapters .`. See [adapters/](adapters/README.md).
+See [adapters/](adapters/README.md).
 
 </details>
 
 <details>
-<summary><b>Other agents</b></summary>
+<summary><b>Air-gap, PATH, override</b></summary>
 
 ```bash
-npx skills add suboss87/fdeops --skill fde
+git clone https://github.com/suboss87/fdeops.git && node bin/install.js
 ```
 
-Gemini, Copilot, Codex, local LLMs: [adapters/](adapters/README.md). Air-gapped: `git clone https://github.com/suboss87/fdeops.git && node bin/install.js`.
-
-Fallback if the agent cannot bind:
+If the agent cannot create the folder:
 
 ```bash
-npx fdeops resume --init acme   # ~/fde-engagements/acme + bind this checkout
+npx fdeops resume --init client01   # ~/fde-engagements/client01
 ```
 
 Requires Node.js >= 18. Override: `FDEOPS_ENGAGEMENT`. See [docs/install.md](docs/install.md). Try the loop: `npx fdeops demo`.
@@ -95,13 +82,34 @@ Requires Node.js >= 18. Override: `FDEOPS_ENGAGEMENT`. See [docs/install.md](doc
 
 ---
 
+## Commands
+
+One command per stage. Skills load automatically.
+
+Six stages, same order every job: Land, Discover, Plan, Ship, Outcome, Close.
+
+| What you're doing | Command | Stage |
+|-------------------|---------|-------|
+| First days. Get the brief. Name who signs. | `/brief` | Land |
+| Check the brief is the real job. | `/discover` | Discover |
+| Sequence from done, not from the ticket. | `/plan` | Plan |
+| Prove it on their staging, then go live. | `/ship` | Ship |
+| What you promised, measured, and who accepted. | `/outcome` | Outcome |
+| Hand it over. They run it without you. | `/close` | Close |
+
+Same `@fde`, when you need them: `/debrief` (notes into the record), `/prep` (one page before you walk in), `/trust` (process gap, or they stopped trusting you), `/receipts` (a dated line, or it did not happen), `/readout` (Friday page for the sponsor; not a seventh stage).
+
+You can also just say it: naming a client, a POC, changing their checkout, going live, asking what was agreed. A typo in a repo that is not a client job can skip this. A named client, a POC, or go-live cannot.
+
+---
+
 ## All 30 Skills
 
-The catalog. 30 skills spanning the embed. Not prompts - structured workflows with steps, an artifact, and a checkpoint. Type English or a slash command. `@fde` activates the right skill. You never pick one by name.
+Thirty situations, grouped by stage. Not prompts - each one has steps, a file it writes, and a checkpoint with you. Type English or a slash command. `@fde` opens the matching skill. You never pick one by name.
 
 Full detail: [docs/skills-reference.md](docs/skills-reference.md).
 
-### Land - Engage
+### Land
 
 | Skill | What it does | Use when |
 |--------|--------------|----------|
@@ -111,7 +119,7 @@ Full detail: [docs/skills-reference.md](docs/skills-reference.md).
 | [earn-trust](skills/fde/references/earn-trust.md) | Earn access | Need access or credibility |
 | [hold-scope](skills/fde/references/hold-scope.md) | Hold scope | "Also can you…", timeline unchanged |
 
-### Discover - Diagnose
+### Discover
 
 | Skill | What it does | Use when |
 |--------|--------------|----------|
@@ -120,7 +128,7 @@ Full detail: [docs/skills-reference.md](docs/skills-reference.md).
 | [score-use-cases](skills/fde/references/score-use-cases.md) | Score use cases | Everything is P0 |
 | [poc](skills/fde/references/poc.md) | Validate the solution | POC, spike, need to de-risk |
 
-### Plan - Align
+### Plan
 
 | Skill | What it does | Use when |
 |--------|--------------|----------|
@@ -129,7 +137,7 @@ Full detail: [docs/skills-reference.md](docs/skills-reference.md).
 | [three-options](skills/fde/references/three-options.md) | Generate options | "What should we do?" |
 | [pick-three](skills/fde/references/pick-three.md) | Prioritize three | Everything is urgent |
 
-### Ship - Deliver
+### Ship
 
 | Skill | What it does | Use when |
 |--------|--------------|----------|
@@ -139,7 +147,7 @@ Full detail: [docs/skills-reference.md](docs/skills-reference.md).
 | [review](skills/fde/references/review.md) | Review the change | Before merge, scope creep |
 | [rollback](skills/fde/references/rollback.md) | Rehearse rollback | "We can always revert" |
 
-### Outcome - Realize
+### Outcome
 
 | Skill | What it does | Use when |
 |--------|--------------|----------|
@@ -151,7 +159,7 @@ Full detail: [docs/skills-reference.md](docs/skills-reference.md).
 | [ingest](skills/fde/references/ingest.md) | Ingest sources | Transcript, Notion, Slack |
 | [connect](skills/fde/references/connect.md) | Connect a source | Connect Granola |
 
-### Close - Transfer
+### Close
 
 | Skill | What it does | Use when |
 |--------|--------------|----------|
@@ -161,7 +169,7 @@ Full detail: [docs/skills-reference.md](docs/skills-reference.md).
 | [encode-pattern](skills/fde/references/encode-pattern.md) | Encode the pattern | It will apply again |
 | [red-team](skills/fde/references/red-team.md) | Challenge the plan | "Poke holes in this" |
 
-Overlays (on signal, not on request): [ai](skills/fde/references/ai.md) · [artifacts](skills/fde/references/artifacts.md) · [fintech](skills/fde/references/fintech.md) · [healthcare](skills/fde/references/healthcare.md) · [gov](skills/fde/references/gov.md) · [eval-pack](skills/fde/references/eval-pack.md)
+Overlays (on signal, not on request): [ai](skills/fde/references/ai.md) · [artifacts](skills/fde/references/artifacts.md) · [fintech](skills/fde/references/fintech.md) · [healthcare](skills/fde/references/healthcare.md) · [gov](skills/fde/references/gov.md). AI companion (not a sixth overlay): [eval-pack](skills/fde/references/eval-pack.md).
 
 Optional pull: you add the source MCP; we **pull** on request. [mcp/recipes/](mcp/recipes/)
 
@@ -169,33 +177,84 @@ Optional pull: you add the source MCP; we **pull** on request. [mcp/recipes/](mc
 
 ## How Skills Work
 
-One skill. One reference file per situation. One folder per client.
+One `@fde`. One file per situation. One folder per client.
 
 ```
-  /brief   or   "@fde this is Acme"
-           │
-           ▼
-  skills/fde/SKILL.md          hosts load this one file
+  "@fde this is client01"      creates ~/fde-engagements/client01/.fde/
+  /brief  or  English          the AI coding agent loads skills/fde/SKILL.md
            │  routes. you never pick a skill by name
            ▼
-  references/land.md           one skill, then stop
+  references/<one>.md          one skill, then stop
            │
            ▼
   fde CLI (local)              dates, gates, redacts. no network
            │  after you confirm
            ▼
-  ~/fde-engagements/<client>/.fde/
+  ~/fde-engagements/client01/.fde/
 ```
 
-**One skill routes.** Hosts load `@fde`. It reads the situation and opens one `references/*.md`. Slash commands and English both land here. You never pick a skill by name.
+**A dated line, or it did not happen.** Promised → measured → accepted. If it is not in `.fde/`, it is not on the record.
 
-**Evidence, not memory.** Promised → measured → accepted. A dated line in `.fde/`, or it did not happen. Nothing is done on vibes.
+**Confirm, then it is written.** The CLI stays on your laptop: git and files, no network. The AI coding agent runs the command. You say yes. Then it is in the folder.
 
-**Confirm before write.** Local CLI: git and files, no network. `.fde/` on your laptop. The AI coding agent runs the command. You confirm. Then it is on the record.
+**The record is on your laptop.** Change hosts, install `@fde` on the new one, keep talking. The notes are not inside any vendor.
 
-**Progressive disclosure.** `SKILL.md` is the entry. One skill file loads when routed. Writes and status cost zero model tokens.
+One skill hosts load: `skills/fde/SKILL.md`. It opens one file in `skills/fde/references/` and stops. Slash commands live in `.claude/commands/`. The local CLI is `bin/fde.js` (git + files, no network). Layout: [docs/REPO_LAYOUT.md](docs/REPO_LAYOUT.md).
 
-Change hosts, install `@fde` on the new one, bind if needed, keep talking. The record is not inside any vendor.
+---
+
+## Engagement memory (`.fde/`)
+
+One folder per client. Plain markdown. Grep it, copy it, take it into a meeting.
+
+| File | Holds |
+|------|-------|
+| `context.md` | Where you are |
+| `brief.md` / `success.md` | What they asked; what “done” is and who signs |
+| `reality.md` / `terrain.md` | The real problem; the map |
+| `stakeholders.md` | `[signal:green\|amber\|red]` |
+| `trust-profile.md` | Sacred data, AI policy, approval chain |
+| `decisions.md` / `risks.md` / `delivery.md` | Dated choices; live risks; what shipped and how it rolls back |
+
+Schema: [docs/schema.md](docs/schema.md). Local HTML: `npx fdeops dashboard`.
+
+---
+
+## Who this is for
+
+You sit with a customer's team. An AI coding agent writes in their repo. You need a record of the brief, who can say yes, what went live, and whether they signed off.
+
+If you ship your own company's product from HQ, with no customer team that has to run it after you leave, you do not need this kit.
+
+---
+
+## Your data stays yours
+
+The **CLI** is local: git + files, no network, no telemetry. The **host model** sees `.fde/` the agent loads (usually a bounded `context.md`) and any client code you open. It must not see `<private>` blocks - redacted from CLI, dashboard, and hooks; do not paste them or open them with file tools. Nothing is written until you confirm. `~/fde-engagements` is in `$HOME`; iCloud/Dropbox is an NDA incident waiting.
+
+[PRIVACY.md](PRIVACY.md) · [SECURITY.md](SECURITY.md)
+
+---
+
+## Why FDEOps?
+
+AI coding agents are built for a repo, not for a client. Left alone they skip who signs, whether the brief is true, and whether anyone accepted the number. Monday they start from the ticket again.
+
+This is the kit you take on site. `@fde` runs the client work around the code. A local command dates every decision. The notes are markdown on your laptop. You confirm; then it is on the record.
+
+---
+
+## Principles
+
+- **Who signs** - name them in the first days
+- **Brief vs real job** - check the floor, not only the slide
+- **Back from done** - sequence from signed-off, not from the ticket
+- **Their staging then live** - prove it where they operate, then go live
+- **Promised, measured, accepted** - a number nobody signed is claimed, not delivered
+- **They run it** - if they cannot operate it without you, you are not done
+- **A dated line, or it did not happen** - these files get defended in the room
+- **One customer, one folder** - context never bleeds
+- **The kit says what to check. You still decide.**
 
 ---
 
@@ -258,7 +317,7 @@ fdeops/
 ├── bin/                                   # local CLI: git + files, no network
 ├── hooks/                                 # session-start / session-stop / pre-compact
 ├── adapters/                              # Cursor, Gemini, Copilot, Codex pointers
-├── templates/.fde/                        # memory files created on bind
+├── templates/.fde/                        # memory files created on first client
 ├── examples/                              # fictional walkthroughs
 ├── mcp/                                   # optional ingest + source recipes
 ├── evals/                                 # routing checks
@@ -267,59 +326,6 @@ fdeops/
 
 ---
 
-## Why FDEOps?
-
-AI coding agents are built for a repo, not for a client. Left alone they skip who signs done, whether the brief is true, and whether anyone accepted the number. Monday morning they start from the ticket again.
-
-FDEOps is the catalog you take on site. One `@fde` skill runs the embed from discovery to signed outcome: POC, their codebase, go-live, eval when a model judges, promised → measured → accepted. A local CLI dates every decision. `.fde/` is markdown on your laptop. You confirm; then it is on the record.
-
----
-
-## Engagement memory (`.fde/`)
-
-One folder per client. Plain markdown. Grep it, copy it, defend it.
-
-| File | Holds |
-|------|-------|
-| `context.md` | Where you are |
-| `brief.md` / `success.md` | What they asked; what “done” is and who signs |
-| `reality.md` / `terrain.md` | The real problem; the map |
-| `stakeholders.md` | `[signal:green\|amber\|red]` |
-| `trust-profile.md` | Sacred data, AI policy, approval chain |
-| `decisions.md` / `risks.md` / `delivery.md` | Dated choices; live risks; what shipped and how it rolls back |
-
-Schema: [docs/schema.md](docs/schema.md). Local HTML: `npx fdeops dashboard`.
-
----
-
-## Who this is for
-
-You embed with a customer and an AI coding agent. Take this on the ground. Discovery through signed outcome lives in `@fde`. One `.fde/` per client so they do not blur.
-
-If you only write code in your own repo with no client record to defend, you do not need this kit.
-
----
-
-## Your data stays yours
-
-Local only - `git` + files, no network, no telemetry. Plain markdown. The model sees client code only when you point the AI coding agent at it. `<private>` is redacted from CLI, dashboard, and hooks. Nothing is written until you confirm. `~/fde-engagements` is in `$HOME`; iCloud/Dropbox is an NDA incident waiting.
-
-[PRIVACY.md](PRIVACY.md) · [SECURITY.md](SECURITY.md)
-
----
-
-## Principles
-
-- **One map** - any scale, greenfield or brownfield, any industry. Overlays carry the vertical
-- **The artifact is the memory** - producing the work and recording it are one action
-- **Ground loop** - name the change, characterise their code, prove it on their staging, go live, log the outcome
-- **Skills, not autonomy** - the kit says what to check; judgment stays yours
-- **Brief is a hypothesis** - discover before building the wrong thing
-- **Evidence on every claim** - these files get defended in the room
-- **One customer, one folder** - context never bleeds
-
----
-
 ## Contributing
 
 **[Subash Natarajan](https://www.linkedin.com/in/subashn/)**. [Issues](https://github.com/suboss87/fdeops/issues) · [Discussions](https://github.com/suboss87/fdeops/discussions) · [CONTRIBUTING.md](CONTRIBUTING.md) · [Code of Conduct](CODE_OF_CONDUCT.md)

package/bin/check.js

@@ -153,8 +153,8 @@ ok(`router dispatch (${mentioned.length} reference targets verified) + memory co
   }
   if (!routed.size) fail('check.js could not parse the SKILL.md routing table')
 
-  // docs/skills-reference.md is the canonical per-method list: one row per
-  // method inside the six domain tables, ending at the Overlays section.
+  // docs/skills-reference.md is the canonical per-skill list: one row per
+  // skill inside the six stage tables, ending at the Overlays section.
   const reference = read('docs/skills-reference.md')
   const documented = new Set()
   let documentedRows = 0
@@ -409,6 +409,28 @@ for (const f of exampleFiles) {
 }
 ok('examples walkthrough files')
 
+// The examples are the first .fde/ a newcomer reads. They must pass the kit's
+// own doctor, or the kit is telling people to do what its showcase does not.
+// Tolerated: things a frozen reference copy cannot have (an owner, a memory
+// git, a fresh trust signal).
+{
+  const { spawnSync } = require('child_process')
+  const tolerated = /no \.owner|not git-versioned|trust signal is STALE/
+  for (const ex of fs.readdirSync(path.join(root, 'examples'))) {
+    const eng = path.join(root, 'examples', ex, '.fde')
+    if (!fs.existsSync(eng)) continue
+    const r = spawnSync(process.execPath, [path.join(root, 'bin', 'fde.js'), 'doctor'], {
+      encoding: 'utf8',
+      env: { ...process.env, FDEOPS_ENGAGEMENT: eng, HOME: fs.mkdtempSync(path.join(require('os').tmpdir(), 'fdeops-check-')) },
+    })
+    const issues = (r.stdout || '').split('\n')
+      .map(l => l.match(/^\s+\d+\.\s+(.*)$/)).filter(Boolean).map(m => m[1])
+      .filter(i => !tolerated.test(i))
+    if (issues.length) fail(`examples/${ex} fails its own doctor:\n    - ${issues.join('\n    - ')}`)
+    else ok(`examples/${ex} passes fde doctor`)
+  }
+}
+
 if (fs.existsSync(path.join(root, 'tasks', 'plan.md'))) {
   fail('tasks/plan.md should not be in public tree (move to docs/internal)')
 }

package/bin/fde.js

@@ -1515,8 +1515,8 @@ function smartProposeText(input) {
       out.push(`decision: ${bare.replace(/^decided:\s+/i, '')}`)
       continue
     }
-    if (/^(decision|risk|delivery|contact|next):\s*/i.test(bare)) {
-      let routed = bare.replace(/^(decision|risk|delivery|contact|next):\s*/i, (m, t) => `${t.toLowerCase()}: `)
+    if (/^(decision|risk|delivery|contact|next|signer):\s*/i.test(bare)) {
+      let routed = bare.replace(/^(decision|risk|delivery|contact|next|signer):\s*/i, (m, t) => `${t.toLowerCase()}: `)
       if (/^contact:/i.test(routed) && !/\[signal:(red|amber|green)\]/i.test(routed)) {
         const sig = inferContactSignal(routed)
         if (sig) routed = routed.replace(/\s*$/, ` [signal:${sig}]`)
@@ -1524,6 +1524,12 @@ function smartProposeText(input) {
       out.push(routed)
       continue
     }
+    // Sentence-level: a signer named mid-paragraph gets its own routed line and
+    // the original stays as context, so nothing is invented or lost.
+    for (const sentence of bare.split(/(?<=[.!?])\s+/)) {
+      const who = signerFromLine(sentence)
+      if (who) { out.push(`signer: ${who}`); break }
+    }
     if (/^(next action|follow-?ups?|action items?|todo):\s*/i.test(bare) ||
         /\b(next action|walk in with|follow up with)\b/i.test(bare)) {
       const next = bare.replace(/^(next action|follow-?ups?|action items?|todo):\s*/i, '').trim()
@@ -1549,6 +1555,56 @@ function smartProposeText(input) {
   return out.join('\n') + (out.length ? '\n' : '')
 }
 
+// "Priya signs off" is the most expensive sentence in a kickoff and used to land
+// in context.md as a note. signer: fills the success.md line the whole kit
+// keys on, and logs the person as a contact so prep/status can see them.
+const SIGNER_RX = /^(?<who>[A-Z][\w.'-]+(?:\s+[A-Z][\w.'-]+){0,3}(?:\s*\([^)]{1,40}\))?)\s+(?:signs?(?:\s+off)?|approves|has (?:the )?final say|can say yes|owns the decision|is the (?:sponsor|signer|decision[- ]maker))\b/
+
+function signerFromLine(text) {
+  const t = String(text || '').trim()
+  const m = t.match(SIGNER_RX)
+  if (!m) return ''
+  const who = m.groups.who.trim()
+  // "Staging exists" / "The API is slow" also match "Capital Word + verb"; a
+  // sentence-initial common noun is not a person.
+  if (/^(The|This|That|It|We|They|Staging|Budget|Prod|Production|Nobody|Someone|Everyone)\b/.test(who)) return ''
+  return who
+}
+
+function setSigner(eng, who) {
+  ensureMemoryGit(eng)
+  const p = path.join(eng, 'success.md')
+  let md = readEng(eng, 'success.md')
+  if (!md) md = '# Success definition\n\n'
+  const norm = (s) => String(s).replace(/\s+/g, ' ').trim().toLowerCase()
+  const line = /^\*\*Stakeholder who signs off:\*\*\s*(.*)$/m
+  const m = md.match(line)
+  if (m && !m[1].trim()) {
+    md = md.replace(line, `**Stakeholder who signs off:** ${who}`)
+  } else if (m) {
+    // Whole-name compare against the primary and every "also named" line under
+    // it: "Sam" must not vanish inside "Samantha", and re-applying must not
+    // stack duplicates.
+    const start = md.indexOf(m[0]) + m[0].length
+    const alsoNamed = []
+    for (const l of md.slice(start).split('\n').slice(1)) {
+      const a = l.match(/^- also named:\s*(.+)$/)
+      if (!a) break
+      alsoNamed.push(a[1])
+    }
+    const known = [m[1], ...alsoNamed].map(norm)
+    if (known.includes(norm(who))) return false
+    // A second, different name is a fact worth keeping next to the first, not
+    // a silent overwrite - who signs is exactly the thing people argue about.
+    const block = [m[0], ...alsoNamed.map(a => `- also named: ${a}`)].join('\n')
+    md = md.replace(block, `${block}\n- also named: ${who}`)
+  } else {
+    md = md.replace(/\n*$/, `\n\n**Stakeholder who signs off:** ${who}\n`)
+  }
+  withFileLock(p, () => { atomicWriteFile(p, md.endsWith('\n') ? md : md + '\n') })
+  return true
+}
+
 function setNextAction(eng, text) {
   ensureMemoryGit(eng)
   const bullet = `- ${stripControlChars(String(text).replace(/^[-*]\s+/, '').trim())}`
@@ -1665,7 +1721,7 @@ function readSealedProposal(eng) {
 function routeDebriefInput(eng, input, { dry, force, sealed = [] }) {
   const d = new Date()
   const date = d.toISOString().slice(0, 10)
-  const counts = { decision: 0, risk: 0, delivery: 0, contact: 0, next: 0 }
+  const counts = { decision: 0, risk: 0, delivery: 0, contact: 0, next: 0, signer: 0 }
   const ctxLines = []
   let nextAction = ''
   ensureMemoryGit(eng)
@@ -1678,8 +1734,8 @@ function routeDebriefInput(eng, input, { dry, force, sealed = [] }) {
   for (const raw of routable.split('\n')) {
     let line = raw.trim()
     if (!line) continue
-    const bare = line.replace(/^[-*+]\s+/, '').replace(/^\*\*(decision|risk|delivery|contact|next):?\*\*:?\s*/i, '$1: ')
-    const m = bare.match(/^(decision|risk|delivery|contact|next):\s*(.+)$/i)
+    const bare = line.replace(/^[-*+]\s+/, '').replace(/^\*\*(decision|risk|delivery|contact|next|signer):?\*\*:?\s*/i, '$1: ')
+    const m = bare.match(/^(decision|risk|delivery|contact|next|signer):\s*(.+)$/i)
     if (m) {
       const type = m[1].toLowerCase()
       let body = m[2]
@@ -1688,6 +1744,18 @@ function routeDebriefInput(eng, input, { dry, force, sealed = [] }) {
         console.error(`skipped ${type} line - looks like a ${hit}. Redact it, or re-run with --force.`)
         continue
       }
+      if (type === 'signer') {
+        const who = body.replace(/\s+signs?(?:\s+off)?\b.*$/i, '').trim() || body.trim()
+        if (dry) {
+          console.log(`→ success.md  **Stakeholder who signs off:** ${previewLine(who)}`)
+          console.log(`→ stakeholders.md  ${previewLine(datedEntry(eng, date, `${who} signs off`))}`)
+        } else {
+          setSigner(eng, who)
+          appendLogEntry(eng, 'contact', datedEntry(eng, date, `${who} signs off`), { skipCommit: true })
+        }
+        counts.signer++
+        continue
+      }
       if (type === 'next') {
         if (dry) console.log(`→ context.md ## Next action  - ${previewLine(body)}`)
         else nextAction = body
@@ -1760,7 +1828,7 @@ function cmdDebrief(args) {
     if (smart) {
     const { proposePath, clean, blocks } = writeProposal(eng, smartProposeText(input))
     console.log('SMART PROPOSE (heuristic - review before apply; no new facts invented beyond line rewrites)\n')
-    console.log('Prefix vocabulary (lines that route): decision:  risk:  delivery:  contact:  next:')
+    console.log('Prefix vocabulary (lines that route): decision:  risk:  delivery:  contact:  next:  signer:')
     console.log('Everything else → context.md. Keep the prefixes; the preview gate stays.\n')
     routeDebriefInput(eng, clean, { dry: true, force, sealed: blocks })
     if (!apply) {
@@ -1776,7 +1844,7 @@ function cmdDebrief(args) {
   const { counts, ctxLines, privateBlocks } = routeDebriefInput(eng, input, { dry, force, sealed })
   if (!dry) {
     const hash = commitMemory(eng, 'debrief', {
-      files: ['decisions.md', 'risks.md', 'delivery.md', 'stakeholders.md', 'context.md', SIGNAL_LEDGER],
+      files: ['decisions.md', 'risks.md', 'delivery.md', 'stakeholders.md', 'success.md', 'context.md', SIGNAL_LEDGER],
     })
     try { fs.unlinkSync(path.join(eng, DEBRIEF_PROPOSE)) } catch (_) {}
     try { fs.unlinkSync(path.join(eng, DEBRIEF_PRIVATE)) } catch (_) {}
@@ -1784,7 +1852,7 @@ function cmdDebrief(args) {
     if (hash) console.log(`memory @${hash}`)
   }
   const plural = {
-    decision: 'decisions', risk: 'risks', delivery: 'deliveries', contact: 'contacts', next: 'next actions',
+    decision: 'decisions', risk: 'risks', delivery: 'deliveries', contact: 'contacts', next: 'next actions', signer: 'signers',
   }
   const parts = Object.keys(counts).filter(t => counts[t])
     .map(t => `${counts[t]} ${counts[t] === 1 ? (t === 'next' ? 'next action' : t) : plural[t]}`)
@@ -2176,6 +2244,66 @@ function findDuplicateOpenRisks(eng) {
   return [...byKey.values()].filter(g => g.length >= 2)
 }
 
+// The bound client repo moved and delivery.md did not. This is the one place
+// the CLI can catch "we shipped code and told the record nothing" without AI:
+// registry gives the workspace(s) bound to this engagement, git gives commits
+// newer than the last dated delivery line. Local reads only.
+// Only dates that stamp an entry count: a ledger row's Date cell, a dated
+// bullet, a dated heading. "trial night 2026-06-02" inside a Measured cell is a
+// promise, not a receipt - and a future promise must not hide today's commits.
+function latestDeliveryEntry(md) {
+  const today = new Date().toISOString().slice(0, 10)
+  let latest = { date: '', line: '' }
+  for (const raw of stripTemplateNoise(md).split('\n')) {
+    const t = raw.trim()
+    const m = t.match(/^[-*]\s*\[(\d{4}-\d{2}-\d{2})\]/) ||
+      t.match(/^#{1,6}\s+\[?(\d{4}-\d{2}-\d{2})(?:\]|\b)/) ||
+      t.match(/^\|\s*(\d{4}-\d{2}-\d{2})\s*\|/)
+    if (!m || m[1] > today) continue
+    if (m[1] >= latest.date) latest = { date: m[1], line: t }
+  }
+  return latest
+}
+
+function silentCommitIssues(eng) {
+  const slug = path.basename(path.dirname(eng))
+  const workspaces = readRegistry().filter(r => r.slug === slug).map(r => r.workspace)
+  if (!workspaces.length) return []
+  const entry = latestDeliveryEntry(readClean(eng, 'delivery.md'))
+  const lastDelivery = entry.date
+  const out = []
+  for (const ws of workspaces) {
+    let st
+    try { st = fs.statSync(ws) } catch (_) { continue }
+    if (!st.isDirectory()) continue
+    // The memory folder is itself a git repo; never lint it as the client repo.
+    if (path.resolve(ws) === path.resolve(eng) || path.resolve(ws) === path.dirname(path.resolve(eng))) continue
+    if (sh('git rev-parse --is-inside-work-tree', ws) !== 'true') continue
+    // Memory git knows the exact moment that entry was written; dates in the
+    // file are day-grained and would miss a commit made later the same day.
+    // Pickaxe on the entry text, not the file: a later status edit to
+    // delivery.md must not become the cutoff and hide commits before it.
+    const raw = entry.line
+      ? sh(`git log -1 --format=%cI -S${JSON.stringify(entry.line)} -- delivery.md`, eng)
+      : ''
+    // git --since is inclusive at second grain; a commit in the same second as
+    // the receipt is the receipt's own work, not a silent one.
+    const stamp = raw && !Number.isNaN(Date.parse(raw)) ? new Date(Date.parse(raw) + 1000).toISOString() : ''
+    const since = stamp ? `--since="${stamp}"`
+      : lastDelivery ? `--since="${lastDelivery} 23:59:59"`
+        : "--since='30 days ago'"
+    const commits = sh(`git log ${since} --format=%h -- .`, ws).split('\n').filter(Boolean).length
+    if (!commits) continue
+    const where = path.basename(ws)
+    out.push(
+      lastDelivery
+        ? `${commits} commit(s) in ${where} since the last delivery line (${lastDelivery}) - code moved, ledger did not; log the receipt or say why nothing shipped`
+        : `${commits} commit(s) in ${where} in 30d and delivery.md has no dated line - code moved, ledger did not; fde log delivery "slice | bucket | promised | measured | accepted | evidence | rollback"`
+    )
+  }
+  return out
+}
+
 // Deterministic fieldbook hygiene - shared by doctor + session TRIAGE.
 // Silent when clean OR brand-new (no dated work yet). Never auto-rewrites.
 // High-value moments: week-start (via triage), ship/close, after real work accrues.
@@ -2246,9 +2374,11 @@ function collectDoctorIssues(eng) {
       'duplicate ## Next action headings in context.md - fill the first (template) section and remove extras; triage reads the last non-empty'
     )
   }
-  if ((s.phase === 'close' || s.phase === 'ship') && s.openRisks > 0) {
+  // Open, owned risks are normal mid-ship (triage already shows the count every
+  // session). The gate is close: nothing still live when you call the embed done.
+  if (s.phase === 'close' && s.openRisks > 0) {
     issues.push(
-      `phase is ${s.phase} with ${s.openRisks} open risk(s) - retire, hand off, or move still-live ones before calling the embed done`
+      `phase is close with ${s.openRisks} open risk(s) - retire, hand off, or move still-live ones before calling the embed done`
     )
   }
   if (s.phase === 'close' || s.phase === 'ship') {
@@ -2268,6 +2398,7 @@ function collectDoctorIssues(eng) {
         `phase is ${s.phase} with AI in scope but no eval receipt (evals.md Verdict or delivery Eval / Ship receipts) - required before green ship/close`
       )
     }
+    issues.push(...silentCommitIssues(eng))
   }
   const dupes = findDuplicateOpenRisks(eng)
   if (dupes.length) {

package/bin/lib/trust.js

@@ -194,6 +194,9 @@ function createTrustApi(deps) {
     }) || '').replace(/\|/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 80)
     // Prefer trust trigger / memory warn over a random risk line; always keep mem.warn available
     const reason = (trustReason || mem.warn) ? (trustReason || mem.warn) : topRisk
+    // What the triage line is actually quoting. A risk bullet printed under
+    // "trust:" read as a stakeholder problem that did not exist.
+    const reasonKind = mem.warn && trustReason === mem.warn ? 'memory' : trustReason ? 'trust' : mem.warn ? 'memory' : topRisk ? 'risk' : ''
     const openRisks = countOpenRisks(eng)
     const nextAction = nextActionLine(ctx)
     let updated = 'never', ageDays = Infinity
@@ -203,7 +206,7 @@ function createTrustApi(deps) {
     } catch (_) {}
     const dirty = memoryDirtyManual(eng)
     return {
-      phase, trust, signalAge, stale, topRisk, reason, memoryWarn: mem.warn,
+      phase, trust, signalAge, stale, topRisk, reason, reasonKind, memoryWarn: mem.warn,
       dirtyFiles: dirty, openRisks, nextAction, updated, ageDays,
     }
   }
@@ -215,9 +218,9 @@ function createTrustApi(deps) {
     const lines = [
       `TRIAGE  [${label.padEnd(6)}]  phase:${phase}  updated:${s.updated}  open risks:${s.openRisks}`,
     ]
-    if (s.reason) {
-      const age = s.signalAge != null ? ` (${s.signalAge}d old${s.stale ? ', STALE - reconfirm' : ''})` : ''
-      lines.push(`  trust: ${s.reason}${age}`)
+    if (s.reason && s.reasonKind !== 'memory') {
+      const age = s.reasonKind === 'trust' && s.signalAge != null ? ` (${s.signalAge}d old${s.stale ? ', STALE - reconfirm' : ''})` : ''
+      lines.push(`  ${s.reasonKind === 'risk' ? 'top risk' : 'trust'}: ${s.reason}${age}`)
     }
     // Always surface corruption / unreadable memory - even when trust still reads green
     if (s.memoryWarn) lines.push(`  memory: ${s.memoryWarn}`)

package/mcp/fdeops-ingest/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fdeops-ingest-mcp",
-  "version": "3.20.0",
+  "version": "3.22.0",
   "private": true,
   "description": "Thin stdio MCP sink for FDEOps ingest (stage → propose → apply). Zero runtime dependencies.",
   "bin": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fdeops",
-  "version": "3.20.0",
-  "description": "Forward deployed engineering skills for AI coding agents. Your agent forgets the client every morning - the sponsor, the promise, who signed off. FDEOps keeps that as dated markdown on your laptop: one @fde skill, a deterministic local CLI, and hooks that make it automatic. Claude Code plugin and any agent that loads skills.",
+  "version": "3.22.0",
+  "description": "Forward deployed engineering skills for AI coding agents. One @fde skill for the client work around the code: who can say yes, what went live, whether they signed off. Dated markdown on your laptop. You confirm each write.",
   "bin": {
     "fdeops": "bin/install.js",
     "fde": "bin/fde.js"

package/plugin.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "fdeops",
-  "version": "3.20.0",
-  "description": "Forward deployed engineering skills for AI coding agents: per-client memory in local .fde/ files, one @fde skill. Local-only, no network.",
+  "version": "3.22.0",
+  "description": "Forward deployed engineering skills for AI coding agents. One @fde skill for the client work around the code. You confirm; then it lands in .fde/ on your laptop.",
   "author": {
     "name": "Subash Natarajan",
     "url": "https://github.com/suboss87"

package/skills/fde/SKILL.md

@@ -42,6 +42,8 @@ On someone else's site the work is not "write code, remember later." Every chang
 
 A throwaway file can skip the loop. Bound client work cannot.
 
+**Skip is loud.** Bound + a change that will ship + no this-turn line in `delivery.md` = not done. Say that. Do not call it shipped. A coding pack may write the function; `@fde` still owns done.
+
 ## Human surface vs agent plumbing
 
 **FDE (human):** `@fde` + English, or `/brief` `/discover` `/plan` `/ship` `/outcome` `/close` `/debrief` `/prep` `/trust` `/receipts` `/readout`. Never a skill catalog.
@@ -129,8 +131,8 @@ Work names (engage, diagnose, align, deliver, realize, transfer) are the same ma
 
 | You hear | Skill | Reference |
 |----------|-------|-----------|
-| Diagnose, don't know the real problem, brief feels wrong, shadow processes, frame discovery, understand the problem space, data not ready, data estate, catalog the data | discover | `references/discover.md` |
-| The brief feels too neat, assumptions untested, "we just need…", test assumptions | test-assumptions | `references/test-assumptions.md` |
+| Diagnose, don't know the real problem, brief feels wrong, shadow processes, frame discovery, understand the problem space, data not ready, data estate, catalog the data, parts of the problem, decompose | discover | `references/discover.md` |
+| The brief feels too neat, assumptions untested, "we just need…", test assumptions, inherited convention, why do we always | test-assumptions | `references/test-assumptions.md` |
 | Multiple use cases competing, "we want to do everything", score use cases | score-use-cases | `references/score-use-cases.md` |
 | Need to validate a direction, prototype, demo to de-risk, **POC**, spike, killer assumption, validate the solution, build prototype | poc | `references/poc.md` |
 
@@ -140,7 +142,7 @@ Work names (engage, diagnose, align, deliver, realize, transfer) are the same ma
 |----------|-------|-----------|
 | Align, break this down, what order, sequence the build, plan the roadmap, create user stories, write the tasks | plan | `references/plan.md` |
 | Sponsor needs justification, need to defend budget or timeline, build the business case | business-case | `references/business-case.md` |
-| Significant decision, multiple approaches, "what should we do?", generate solutions, generate options | three-options | `references/three-options.md` |
+| Significant decision, multiple approaches, "what should we do?", generate solutions, generate options, not the playbook, from the surviving facts | three-options | `references/three-options.md` |
 | 20 things are "urgent," need to pick the 3 that matter, prioritize three | pick-three | `references/pick-three.md` |
 
 ### Ship
@@ -196,8 +198,8 @@ Ready to build with no `terrain.md` / plan: discover or plan first. Takeover wit
 
 - Never ask the FDE to pick a phase. That's your job.
 - Same six stages at any scale. Overlays carry the industry. Greenfield and brownfield change the first move inside ship, not the map.
-- Ground loop on a bound client: name → characterise → prove on their staging → go live → log. Do not hand their repo to a generic coding pack.
-- Do not call a change done until the signer in `success.md` can reject it on staging they operate.
+- Ground loop on a bound client: name → characterise → prove on their staging → go live → log. A coding pack may write the function. `@fde` still owns done. When they disagree, their repo and the signer win.
+- Do not call a change done until the signer in `success.md` can reject it on staging they operate. No this-turn receipt in `delivery.md` is a failed test, not a note to write later.
 - 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."

package/skills/fde/references/debrief.md

@@ -11,7 +11,8 @@
 ## Honest contract (read once)
 
 - The `fde` CLI is **local, deterministic, no AI**. `--smart` is a **gate + writer**, not a brain.
-- It keeps lines that already have `decision:` / `risk:` / `delivery:` / `contact:` / `next:` prefixes, plus a thin keyword pass (e.g. "we agreed", person+verb lines, "open question").
+- It keeps lines that already have `decision:` / `risk:` / `delivery:` / `contact:` / `next:` / `signer:` prefixes, plus a thin keyword pass (e.g. "we agreed", person+verb lines, "open question", "X signs off").
+- `signer: Priya` fills **Stakeholder who signs off** in `success.md` and logs Priya as a contact. The CLI proposes it when a sentence says someone signs off / approves / has final say. If the notes name who can say yes and the proposal does not carry a `signer:` line, add one - that is the most expensive sentence in the meeting.
 - Real messy notes without prefixes often route **0 useful lines** - everything else lands as a context dump. That is expected. **You are the router:** rewrite `.debrief-propose` with type prefixes, then `--apply`.
 - `.debrief-propose` is raw lines only (no routing annotations). "Edit if mis-routed" means **rewrite the line with the right prefix**, not leave a comment in the file.
 
@@ -25,6 +26,7 @@
    - `decision: agreed chargebacks stay phase 2 - Priya`
    - `risk: legal may reopen scope if we slip the SOW date`
    - `contact: Priya pushed hard on Friday deck [signal:amber]`
+   - `signer: Priya` (she can say yes; lands in `success.md`)
    - `next: send one-pager before Thursday 9am`
    - unprefixed lines stay context color only
 4. Show the **proposed** routing in plain language (what would become decisions, risks, contacts, next).
@@ -43,7 +45,7 @@ If `--smart` is unavailable or you already have clean prefixes:
    - **Stakeholder signals** - tone shifts with evidence → green/amber/red
    - **Risks** - new / confirmed / retired
    - **Open questions** - what to chase next
-2. Format lines as `decision:` / `risk:` / `delivery:` / `contact:` / `next:` (contacts may end with `[signal:green|amber|red]`).
+2. Format lines as `decision:` / `risk:` / `delivery:` / `contact:` / `next:` / `signer:` (contacts may end with `[signal:green|amber|red]`).
 3. Show that structured version to the FDE for confirmation.
 4. Pipe to `fde debrief` (or write a file and run it).
 

package/skills/fde/references/discover.md

@@ -54,6 +54,16 @@ Tests on **Question** - rewrite until all five hold:
 
 Cannot write the Question → keep interrogating. Do not `fde scan`. Every later output of this phase aims at that Question. Sub-questions go to the operating map or `assumptions.md`, not into the Question.
 
+## Parts of the problem (decompose only)
+
+After the Question is locked, and **before** `fde scan` or any option: write what the problem is made of. No advice, no playbook, no solution.
+
+If the stated brief hides a deeper job, name that deeper job in one sentence and **wait**. Do not silently replace their problem with yours.
+
+In `terrain.md` under `## Parts`, list the smallest useful pieces that still change what you examine next. Typical cuts: people, process step, system, data, time, cost. For each piece: what it contains, and how it connects to the Question. Stop when a further split would not change where you dig.
+
+Do not mark pieces as facts or assumptions here. That is `test-assumptions`. Do not assemble options here. That is `three-options`.
+
 ## Method - part 1: the codebase (you do this work)
 
 **First move: `fde scan`** - it runs everything below deterministically in seconds (churn×tests, "temporary" archaeology, AI components, secrets redacted, previous attempts). Your job is then **interpretation**: read its output against the brief, follow the hotspots into the code, and connect the technical findings to the human signals in part 2.
@@ -127,9 +137,11 @@ When discovery requires a structured session with multiple stakeholders (alignme
 
 **After the room:** Summary in `decisions.md` within 2 hours. Decisions decay - what felt clear at 3pm is debatable by 5pm if unwritten.
 
-## Method - part 4: data estate assessment
+## Method - part 4: data estate and the pipe
+
+Always map the estate before you score a use case - not only when someone said "AI." A path they cannot feed is a discover miss, not a ship surprise.
 
-When the engagement involves AI, analytics, or data-heavy automation, assess the data estate before scoring use cases:
+**Their words first.** In `terrain.md`, write the names the floor uses for the workaround, the sheet, the exception path, and the person who left. Later plan/ship/review sentences use those names. Do not translate their floor into generic product language.
 
 **The 5 questions (ask the data owner, not the sponsor):**
 1. **Where does data live?** - List every source: databases, warehouses, SaaS exports, spreadsheets, S3 buckets, vendor APIs. Map it.
@@ -138,13 +150,15 @@ When the engagement involves AI, analytics, or data-heavy automation, assess the
 4. **What's the quality?** - Sample 100 rows from each critical source. Check: nulls, duplicates, format consistency, semantic correctness. A 60% null rate in a key field = that source is fiction.
 5. **What are the governance constraints?** - PII classification, retention policies, cross-border rules, consent basis. One missed constraint = a compliance stop later.
 
+**The pipe (what talks to what).** For each source that a use case depends on, write: the system it flows from and to, the contract (object, table, file, API), whose credentials, what happens when the vendor 500s or the Monday file does not land, and whether the join the sponsor described actually exists. Their IdP, CRM, and warehouse are delivery work when the path needs them - policy questions in `trust-profile.md` are not a substitute.
+
 **The data readiness matrix:**
 
-| Source | Location | Freshness | Owner | Quality (sample) | Governance | Verdict |
-|--------|----------|-----------|-------|-----------------|------------|---------|
-| _fill per source_ | | | | | | Ready / Needs work / Blocker |
+| Source | Location | Freshness | Owner | Quality (sample) | Governance | Pipe | Verdict |
+|--------|----------|-----------|-------|-----------------|------------|------|---------|
+| _fill per source_ | | | | | | | Ready / Needs work / Blocker |
 
-A use case that depends on a "Blocker" source doesn't get scored - it gets a data remediation conversation first. Write this to `terrain.md` under a `## Data estate` section.
+A use case that depends on a "Blocker" source **or a Blocker pipe** doesn't get scored - it gets a remediation conversation first. `what-breaks` finding an invisible integration at ship is already too late. Write this to `terrain.md` under a `## Data estate` section.
 
 ## When scope is a transformation, not a single problem
 

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

@@ -47,6 +47,7 @@ The difference between a 5-year FDE and a 15-year FDE is not talent - it's encod
 | **Specific enough?** | Contains concrete steps, not just principles | "Build trust" / "Communicate well" - too vague to act on |
 | **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 |
+| **Monday bag?** | You would refuse the next similar embed without this in your bag - a named move plus an artifact you can drop on day one (pipe questions, CAB dance, eval golden shape, floor-drill script) | "We learned to communicate." Patterns that only live in this client's `.fde/` do not compound |
 
 **4. Classify by stage.** Patterns sort into the same stages as the skills:
 

package/skills/fde/references/eval-pack.md

@@ -22,9 +22,9 @@ Intelligence without evidence is token-maxing with a nicer name. An FDE earns tr
 
 **3. Score pass/fail, not vibes.** Run the suite. Record count pass / fail. Failures get a failure-mode tag (missing data, wrong record, format drift, hallucination, retrieval miss, unsafe action, other).
 
-**4. Human-in-the-loop gate.** Name which outcomes require human approve before side effects. If none, write why that is allowed under `trust-profile.md` AI policy - do not invent permission.
+**4. Human-in-the-loop gate.** Name which outcomes require human approve before side effects. Judgement that has a side effect (write, send, transfer, ticket, deploy, pay, page) is **NO-SHIP** without a named human on their side in the loop. Do not write "none - allowed under policy" to bless lights-out write-access. Staging may run a supervised loop with a kill switch, a cost cap, and a golden set from **their** failures. Production stays gated until they have a written policy, a named owner, and dated eval receipts on real traffic.
 
-**5. Ship rule.** Until `evals.md` shows Verdict **SHIP** with a dated run (critical fails = 0) and HITL filled when policy requires it, AI-touching ship stays **fix-first**. Log a one-line eval receipt in `delivery.md` → `## Ship receipts`.
+**5. Ship rule.** Until `evals.md` shows Verdict **SHIP** with a dated run (critical fails = 0) and HITL filled, AI-touching ship stays **fix-first**. Eval fails do not sit in a backlog - they reopen plan (descope, move the judgement, or kill the path). Log a one-line eval receipt in `delivery.md` → `## Ship receipts`. No "probably fine."
 
 ## Artifact - `evals.md`
 
@@ -39,5 +39,5 @@ Present to the FDE: suite size, pass rate, top failure mode, HITL gate, Verdict
 - No golden set, no AI ship.
 - Pass/fail beats “looks good.”
 - Failure modes are the product - the happy path is table stakes.
-- HITL is a gate, not a slide.
+- HITL is a gate, not a slide. Side effects without a named human on their side are NO-SHIP.
 - Non-AI work does not need this file.

package/skills/fde/references/ingest.md

@@ -31,7 +31,7 @@ List what you can actually call **this session**:
 3. **Stage** - `fde ingest stage [--source NAME] [--title TEXT] [file|-]` writes raw text into `<engagement>/.inbox/` (outside the memory git ledger).
 4. **List** (optional) - `fde ingest list` shows staged items when you need an id or filename.
 5. **Propose** - `fde ingest propose <id-or-filename>` runs the debrief `--smart` path on the staged body (+ provenance line). Opens `.debrief-propose`.
-6. **Rewrite prefixes** - same as debrief: lines without `decision:` / `risk:` / `delivery:` / `contact:` / `next:` need **you** to rewrite before showing the FDE. `--smart` is a gate, not a brain.
+6. **Rewrite prefixes** - same as debrief: lines without `decision:` / `risk:` / `delivery:` / `contact:` / `next:` / `signer:` need **you** to rewrite before showing the FDE. `--smart` is a gate, not a brain.
 7. **Show** the proposed routing in plain language. Wait for confirm.
 8. **Apply** - on FDE confirm only → `fde ingest apply` (= `fde debrief --apply`). On reject → stop; ask what to change.
 

package/skills/fde/references/land.md

@@ -99,12 +99,12 @@ If `stakeholders.md` already has a `## Signal history` section (it does from the
 
 **`trust-profile.md`** - sacred data (`<private>` tagged), fears heard, AI policy, approval chain. Sensitive: skip for status reads; use CLI/redacted surfaces; never paste raw `<private>` into prompts or subagents.
 
-**`assumptions.md`** - seed every unverified claim from the brief (and the day-1 hypothesis) as rows with blast radius CRITICAL / LOAD-BEARING / CONVENIENCE and status `OPEN`. Do not wait for test-assumptions - land makes the register exist. Example:
+**`assumptions.md`** - seed every unverified claim from the brief (and the day-1 hypothesis) as rows with Kind `UNKNOWN` (or `CONVENTION` if they said "we always"), blast radius CRITICAL / LOAD-BEARING / CONVENIENCE, and status `OPEN`. Do not wait for test-assumptions - land makes the register exist. Example:
 
 ```markdown
-| # | Assumption | Blast radius | How we test | Status | Evidence |
-|---|------------|--------------|-------------|--------|----------|
-| 1 | <claim from brief> | CRITICAL | <cheapest falsifying test> | OPEN | (stated, unverified) |
+| # | Assumption | Kind | Blast radius | How we test | Status | Evidence |
+|---|------------|------|--------------|-------------|--------|----------|
+| 1 | <claim from brief> | UNKNOWN | CRITICAL | <cheapest falsifying test> | OPEN | (stated, unverified) |
 ```
 
 One falsifiable hypothesis about the real problem also goes at the bottom of `brief.md` - discover / test-assumptions will test it.

package/skills/fde/references/poc.md

@@ -8,7 +8,9 @@ A green check on synthetic data is not a validated solution. The person who can
 
 ## Method (you do this work)
 
-**0. Name the killer assumption.** With the FDE: "What's the belief that kills the project if it's wrong?" Prototype **that** - not the pretty demo.
+**0. Name the killer assumption.** With the FDE: "What's the belief that kills the project if it's wrong?" Prototype **that** - not the pretty demo. If `three-options` just ran: the cheapest test is for the recommended option first, unless they pick another.
+
+**0b. Pass / fail before you build.** For the test you will run, write three lines in `prototype-log.md` first: what you will actually do (who you talk to, what you show, on whose screen); the result that **kills** this option; the result that keeps it alive. What you would learn either way. If every option's test would fail, name which `assumptions.md` block to reopen - do not invent a fourth playbook.
 
 **1. Pick by score when several use cases compete.** Use the scoring model from `discover.md` - (Value × Data readiness) / Complexity. If discover already scored, reuse; never re-score independently.
 
@@ -37,6 +39,7 @@ Tell the FDE: did the riskiest assumption hold · what the customer's reaction a
 ## Principles
 
 - Speed of learning beats code quality. Never more than a day.
+- Write pass/fail before you build. A demo with no kill line is a show.
 - Show it rough. Polish misleads.
 - Prototype the killer assumption, not the demo.
 - Kill fast; log the learning.

package/skills/fde/references/readout.md

@@ -12,15 +12,16 @@
 
 | Block | What to write | Source |
 |-------|---------------|--------|
-| **S - Situation** | Where we are against `success.md`, in their words | success.md, delivery value ledger |
+| **S - Situation** | Where we are against `success.md`, in their words - including whether the floor still uses the old path | success.md, delivery value ledger, reality.md workaround |
 | **C - Complication** | What changed, what is at risk, or what we learned (bad news first) | risks.md, assumptions DISPROVED/OPEN, stakeholders signal |
 | **Q - Question / Ask** | The one decision or help you need from them | decisions.md, access/sign-off needs |
 | **A - Answer** | What you recommend / what happens next week (≤3 bullets) | plan Now lane, delivery promised→measured |
 
 Then add, still on the same page:
 1. **Value this week** - from the value ledger: promised → measured (or "pending") → **accepted by whom**, with evidence citation. A measured number nobody on the customer side has agreed to is written as `claimed`, and the Ask never rests on it - if the whole case for the next phase is a claimed number, the real ask this week is "who signs off that this is real?".
-2. **Kill / defer reminder** - one line from the plan kill list so scope fights stay visible.
-3. **Hostile Q prep** - three questions a skeptical sponsor will ask, with one-line answers from memory.
+2. **Are they using it?** - Situation must say whether the workaround is still open: spreadsheet still running, shadow paste still happening, named operator completed Tuesday's job on the new path without you at the keyboard. A measured metric with the old path still live is `claimed`. That week's Ask is not "fund phase 2." It is "who on their side stops the old way, by when."
+3. **Kill / defer reminder** - one line from the plan kill list so scope fights stay visible.
+4. **Hostile Q prep** - three questions a skeptical sponsor will ask, with one-line answers from memory.
 
 Exec voice: no jargon, no hedging, every claim traceable (`(shipped Tue, delivery.md)`). Draft in the **FDE's voice, for the FDE to send** - never send anything yourself.
 

package/skills/fde/references/review.md

@@ -1,6 +1,6 @@
 # review - Review the change
 
-**Enter when:** a change needs review before merge - "is this safe," "does it match what we agreed."
+**Enter when:** a change needs review before merge - "is this safe," "does it match what we agreed." Their team commented on the PR: same skill. Comments are to check, not to obey.
 
 **Read first:** `context.md`, `decisions.md`, `trust-profile.md`, `terrain.md`. Not `reality.md`/`stakeholders.md` - irrelevant to reviewing code against agreed scope.
 
@@ -52,7 +52,7 @@ Five dimensions, line-specific ("line 47 fails under concurrent writes - no lock
 
 1. Read the full diff before commenting.
 2. Verdicts: **Stage 1: Pass / Blocked (reason)** · **Stage 2: Pass / Concerns (line-specific)**.
-3. Fix only **real** findings tied to this change - no drive-by refactors. Reject false positives with one sentence why.
+3. Fix only **real** findings tied to this change - no drive-by refactors. Reject false positives with one sentence why. Their comments are to check, not to obey. Restate each against the one-line intent and `trust-profile.md`. One item unclear → ask before changing any of them. If it breaks a signed constraint, a sacred system, or nothing calls it: one-sentence pushback, then wait.
 4. Add or update a test per bug found where possible.
 5. Re-run tests/typechecks - state what ran.
 6. Re-review. Repeat until Pass/Pass or a human must decide scope/product.

package/skills/fde/references/runbook.md

@@ -60,6 +60,7 @@ Rollback: <exact command and expected time>
 |---------|-------|-----------|----------|--------|
 | **Architecture walkthrough** | Why, not what. The decisions, the trade-offs, the things that almost went wrong. | Full team | 60-90 min | Recording + Q&A log |
 | **Operational drill** | Deploy, rollback, incident response. They do it, you watch. | On-call team | 60 min | Drill report with confidence level |
+| **Floor drill** | They run the real job (the exception on the operating map) while you watch, hands off. Then they teach the next person. If they cannot, the runbook is a PDF. | Named operator on the floor | 45-60 min | They used the 2am doc during the drill, or the embed is not closed |
 | **Edge-case handover** | The things that aren't in any document. The workarounds, the fragile spots, the "ask Sarah because she's the only one who knows." | Team lead + 1 | 30 min | Additions to `handoff.md` |
 
 **4. The confidence check.** After the knowledge transfer, score the team's readiness:
@@ -68,11 +69,12 @@ Rollback: <exact command and expected time>
 |------|------------------|----------|
 | Daily operations | | Can they deploy and rollback without help? |
 | Incident response | | Did they complete the drill within acceptable time? |
+| Floor job | | Did the named operator complete Tuesday's real exception without you at the keyboard? |
 | Architecture decisions | | Can they explain why the system is built this way? |
 | AI components (if any) | | Do they know how to monitor, retrain, and disable? |
 | Stakeholder management | | Do they know who to update and how? |
 
-**Average below 3.5 → the handoff is not complete.** Extend if possible; if not, document the gaps and name the risk.
+**Average below 3.5 → the handoff is not complete.** Extend, or tell the sponsor the embed is not closed. Do not document the gap and leave.
 
 **5. The successor brief.** If a new FDE is taking over, write a brief that gets them operational in one hour:
 
@@ -132,7 +134,7 @@ If you see 2+: accelerate the handoff immediately. The longer you stay past usef
 
 - The goal of every engagement is to make yourself replaceable.
 - The 2am document is the real handoff - everything else supports it.
-- Knowledge transfer is three sessions, not a doc dump.
+- Knowledge transfer is four sessions, not a doc dump. The floor drill is the named operator completing Tuesday's real job from the 2am doc, hands off. If they cannot, do not close.
 - A confidence score below 3.5 means the handoff isn't done.
 - The successor brief gets the next FDE operational in one hour or it's too long.
 - Clean exit: no personal credentials left behind, ever.

package/skills/fde/references/ship.md

@@ -27,7 +27,7 @@ Skip POC only when the killer assumption already lives in the repo (typical brow
 
 **Done means:** the signer in `success.md` can reject this on staging they operate. A green check on your laptop is not delivery. Do not start the next change until this one is rejectable.
 
-If `terrain.md` **Data estate** lists a **Blocker** this change depends on: stop. That is discover, not ship. Do not build a path they cannot feed.
+If `terrain.md` **Data estate** lists a **Blocker** this change depends on (source or pipe): stop. That is discover, not ship. Do not build a path they cannot feed.
 
 ## Method - one change they can see
 
@@ -56,6 +56,10 @@ Each change is independently revertible.
 - [ ] Rollback named: revert this change, or something more specific
 - [ ] No dependency on an unmerged change (if dependent, state it and land in order)
 - [ ] `Kill if` is written - the observation that stops this change
+- [ ] Before-receipt captured: the failing output, number, or screen as it is today, dated in `delivery.md`, before you change anything
+- [ ] Open PRs and uncommitted work in the area checked (`gh pr list`, `gh pr diff <n> --name-only`); overlap goes to `decisions.md` before you start
+
+Your coding pack writes the function. This skill owns done. When they disagree with this repo, the repo wins.
 
 **The loop.** In this order:
 
@@ -72,10 +76,12 @@ Read existing code in the area (search before creating)
 
 **Prove it on their staging.** A green check on your laptop is not delivery.
 
-- Run **their** test command, typecheck, or smallest proving path. Write the command and the result in `delivery.md`.
+- Run **their** test command, on **their** CI, with **their** fixtures. Write the command and the result in `delivery.md` in this turn. You do not add a runner they will not keep. If you have not run their command in this turn, you cannot write that it passed. Last session's green, "should pass," and "looks correct" are not a receipt. Missing this-turn line = not proven. Same as a failing test.
 - If the signer in `success.md` cannot reject this on a screen they already use, it is not proven.
 - Staging they operate beats a local demo. If you have no staging: `unknown - ask:` who owns an environment, then stop pretending it shipped.
+- **Monday-shaped data.** Staging that is empty, synthetic, or last quarter is not next Tuesday. Before go-live, write what staging is missing (volume, PII, the batch that only runs in prod, the account that only exists in the warehouse) and what that means for the kill test. If the signer cannot reject it on a screen they already operate, with data that looks like next Tuesday, it is not proven.
 - Model in the path: `eval-pack` until `evals.md` says SHIP. Do not skip because "it looked right in chat."
+- A model drafts. A named human on their side ships. No unsupervised loop on their production. If the brief demands lights-out write-access, that is `who-decides` / `hold-scope`, not ship.
 
 The proof is whatever this client already believes, plus one new receipt they can replay.
 
@@ -214,6 +220,8 @@ grep -rnE "(api[_-]?key|secret|password|token)\s*[:=]\s*['\"][^'\"]{8,}" \
 
 **Canary:** 1-5% of traffic, ≥10 minutes. Watch error rate, latency, and **the business metric this change affects**. Anything looks wrong → roll back immediately; investigate safely; redeploy when confident. Never investigate during the canary. Then stage up: 5% → 25% → 100%, each confirmed stable.
 
+**Canary receipt** (write it, or the canary did not happen): what was watched, on whose dashboard, for how long, and that the next change did not start in the window. If prod is a CAB console, vendor button, or their pipeline, write the owner and the click path - the host agent does not get to pretend it shipped.
+
 **Programme-scale rollout (transformations)** - different problem from one service:
 1. **Pilot** - one team, one use case; success metrics defined *before* it starts (after = fitting metrics to results).
 2. **Limited release** - 3-5 teams, real load; this is where the failure modes the pilot hid show up.

package/skills/fde/references/test-assumptions.md

@@ -8,7 +8,7 @@ Every engagement is built on assumptions. Most are invisible until they're wrong
 
 ## Method (you do this work)
 
-**1. Extract the assumptions.** Read `brief.md` and `reality.md` line by line. Every statement that isn't backed by evidence is an assumption. Common hiding places:
+**1. Extract the assumptions.** Read `brief.md`, `reality.md`, and `terrain.md` `## Parts` line by line. Every statement that isn't backed by evidence is an assumption. Treat every "obvious" block as a convention until a receipt proves it. Common hiding places:
 
 | Where assumptions hide | Example | The real question |
 |----------------------|---------|-------------------|
@@ -19,7 +19,17 @@ Every engagement is built on assumptions. Most are invisible until they're wrong
 | **The data claim** | "We have good data for this" | Defined how? Validated when? By whom? Sample checked? |
 | **The "just"** | "We just need to add a feature" | On what system? With what dependencies? What breaks? |
 
-**2. Classify each assumption by blast radius:**
+**2. Kind first, then blast radius.** For each row, classify:
+
+| Kind | Meaning |
+|------|---------|
+| **FACT** | A dated receipt, a measurement, or the repo. You can point at it. |
+| **CONVENTION** | How they have always done it. The playbook. "We just…" |
+| **UNKNOWN** | No evidence either way. |
+
+Order the list load-bearing first. For each CONVENTION or UNKNOWN, one line: what breaks if it is wrong, and what opens if you **invert** it (stop obeying it). A FACT with no receipt is UNKNOWN - do not promote it to protect the brief.
+
+Then classify blast radius:
 
 ```
 CRITICAL - if wrong, the engagement fails or the approach changes fundamentally
@@ -55,11 +65,11 @@ Evidence first, then the question. Let them reach the conclusion.
 **`assumptions.md`** - this IS the register (create if land did not). Keep one live table; do not only bury results in `reality.md`:
 
 ```markdown
-| # | Assumption | Blast radius | How we test | Status | Evidence |
-|---|------------|--------------|-------------|--------|----------|
-| 1 | API is the bottleneck | CRITICAL | p95 instrumentation 24h | DISPROVED | 80% wait in DB layer (Day N) |
-| 2 | Team will adopt new tool | LOAD-BEARING | 3 individual interviews | CONFIRMED | 2/3 describe a use case unprompted |
-| 3 | Data clean enough for ML | CRITICAL | 200-record sample | PARTIAL → OPEN follow-up | 12% nulls on key field; cleaning task added |
+| # | Assumption | Kind | Blast radius | How we test | Status | Evidence |
+|---|------------|------|--------------|-------------|--------|----------|
+| 1 | API is the bottleneck | CONVENTION | CRITICAL | p95 instrumentation 24h | DISPROVED | 80% wait in DB layer (Day N) |
+| 2 | Team will adopt new tool | UNKNOWN | LOAD-BEARING | 3 individual interviews | CONFIRMED | 2/3 describe a use case unprompted |
+| 3 | Data clean enough for ML | UNKNOWN | CRITICAL | 200-record sample | PARTIAL → OPEN follow-up | 12% nulls on key field; cleaning task added |
 ```
 
 Status values: `OPEN` · `TESTING` · `CONFIRMED` · `DISPROVED` · `PARKED`. A CRITICAL row still `OPEN` blocks plan.
@@ -85,6 +95,7 @@ Result: acked in 40 minutes, by Marco, not finance. Assumption DISPROVED, and th
 ## Principles
 
 - Every "just" is an assumption. Every "should" is an assumption.
+- Kind before blast radius. A FACT with no receipt is UNKNOWN.
 - Kill the riskiest, cheapest-to-test assumption first.
 - Evidence first, then the question. Let the customer reach the conclusion.
 - A brief with zero disproved assumptions wasn't audited - it was accepted.

package/skills/fde/references/three-options.md

@@ -2,7 +2,7 @@
 
 **Enter when:** a significant technical or strategic decision needs to be made, the FDE is asked "what should we do?", the team is stuck between approaches, or a fork in the engagement requires the sponsor's input.
 
-**Read first:** `reality.md`, `terrain.md`, `success.md`, `context.md`. Load `business-case.md` if the decision has cost implications.
+**Read first:** `reality.md`, `terrain.md`, `assumptions.md`, `success.md`, `context.md`. Load `business-case.md` if the decision has cost implications.
 
 One option is a request for trust. Two options is a false choice. Three options is a conversation between professionals. The FDE who presents three genuine options earns the decision-maker's respect - and their protection when things get hard.
 
@@ -12,24 +12,30 @@ One option is a request for trust. Two options is a false choice. Three options
 
 > "Decision: approach for the payment migration. Decided by: CTO. Needed by: Friday. Deferral cost: blocks the next sprint and delays the pilot by two weeks."
 
-**2. Generate three genuine options.** Not "good / medium / bad" - three approaches with real trade-offs:
+**2. Generate three genuine options from what survived.** Read `assumptions.md` (CONFIRMED / DISPROVED) and `terrain.md` `## Parts`. The playbook is unavailable. Assemble from those blocks only.
 
-| Option archetype | Description | When it fits |
-|-----------------|-------------|-------------|
-| **Conservative** | Lowest risk, smallest change, longest timeline | When trust is thin or the system is fragile |
-| **Pragmatic** | Balanced risk/reward, proven patterns, moderate timeline | When the team is competent and the deadline is real |
-| **Ambitious** | Highest reward, most change, highest risk | When the sponsor has appetite and the team has capacity |
+Not "good / medium / bad." Not three speeds of the same plan (Conservative / Pragmatic / Ambitious of one architecture). Three approaches that differ in **structure** - rearrange the same surviving parts.
 
-Each option must be one the FDE would genuinely recommend under different circumstances. If you can't defend an option, replace it - padding is visible.
+Each option must be one the FDE would genuinely recommend under different circumstances. If you cannot defend an option, replace it - padding is visible.
+
+For each option, name:
+- which surviving blocks it is built from
+- which CONVENTION it refuses to obey
+- its single biggest point of failure
+- any new building block, labelled as a new assumption (`UNKNOWN` in `assumptions.md`) - do not smuggle one in as a fact
+
+If all three are the same system at different risk levels, you wrote the playbook. Start over.
 
 **3. Structure each option identically.** Same dimensions, same format - so comparison is instant:
 
 ```markdown
-### Option A: <name> (Conservative)
+### Option A: <name>
+- **Blocks:** <which surviving assumptions / parts it is built from>
+- **Convention refused:** <the "we just…" it will not obey>
 - **What:** <the approach in one paragraph>
 - **Timeline:** <estimate with basis>
 - **Cost:** <effort, infrastructure, external>
-- **Risk:** <what could go wrong and the mitigation>
+- **Biggest failure:** <the single point that kills this option>
 - **Trade-off:** <what you give up by choosing this>
 - **Best when:** <the condition that makes this the right choice>
 ```
@@ -85,6 +91,7 @@ Recommendation: pragmatic, conditional - *if* Raj is on the design, otherwise sa
 ## Principles
 
 - Three options, never one. One option is a request for trust; three is a real decision.
+- Assemble from surviving blocks. Three speeds of the same plan is the playbook - start over.
 - Each option must be genuinely defensible - no straw men.
 - Same structure for each option. Comparison should take 30 seconds.
 - Recommend one. State why. Accept the override gracefully.

package/templates/.fde/README.md

@@ -5,7 +5,7 @@
 Create with:
 
 ```bash
-node bin/install.js init <engagement-name>   # from fdeops repo; or npx fdeops@latest init when npm ≥ 3.0.0
+fde resume --init <engagement-name>   # or: npx fdeops resume --init <engagement-name>
 ```
 
 Stays on **your machine** - not in shared git by default.

package/templates/.fde/assumptions.md

@@ -2,9 +2,10 @@
 
 <!-- Brief claims that are not yet evidence. Land seeds; test-assumptions / discover update. -->
 
-| # | Assumption | Blast radius | How we test | Status | Evidence |
-|---|------------|--------------|-------------|--------|----------|
+| # | Assumption | Kind | Blast radius | How we test | Status | Evidence |
+|---|------------|------|--------------|-------------|--------|----------|
 
+**Kind:** `FACT` · `CONVENTION` · `UNKNOWN`  
 **Blast radius:** `CRITICAL` · `LOAD-BEARING` · `CONVENIENCE`  
 **Status:** `OPEN` · `TESTING` · `CONFIRMED` · `DISPROVED` · `PARKED`