fdeops 3.11.1 → 3.13.0

package/README.md

@@ -1,130 +1,128 @@
 # FDEOps
 
-**Your AI coding agent forgets your client every morning. FDEOps remembers.**
+**The AI coding agent forgets the client. fdeops is the countersigned record — promised, measured, accepted.**
 
 [![npm version](https://img.shields.io/npm/v/fdeops.svg)](https://www.npmjs.com/package/fdeops)
 [![CI](https://github.com/suboss87/fdeops/actions/workflows/validate.yml/badge.svg)](https://github.com/suboss87/fdeops/actions)
+[![skills.sh](https://skills.sh/b/suboss87/fdeops)](https://skills.sh/suboss87/fdeops)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
 
-Skill packs teach your AI coding agent how to *build*. None of them remember who the client is, what you promised, or who agreed it was delivered. FDEOps adds that layer: a private fieldbook per engagement (`.fde/`), a field methodology from land to close, and one `@fde` skill that routes it.
+One `@fde` skill. Four days on an embed:
 
-Built for Forward Deployed Engineers and anyone embedded in client work - consultants, agency developers, solutions architects, fractional CTOs. Feels like a second brain; behaves like a defensible record: dated, sourced, on your laptop.
+**the brief is wrong · they went quiet · when did we agree · what did they get**
 
-```
-  land      discover      plan      build      ship      close
-    |           |           |         |          |         |
-    +-----------+-----------+---------+----------+---------+
-          the fieldbook (.fde/) - one per engagement
-             written as a side effect of the work
-```
+The host agent still writes the TypeScript, runs the tests, and makes the commits. This skill is the engagement record. Do not ask `@fde` to review a unit test.
+
+Talk in plain language. The AI coding agent runs the plumbing. You confirm anything that enters the record.
 
 ---
 
-## A real session
+## The week
 
-Kickoff notes go in messy. You confirm what enters the record. A cold session the next morning already knows the client, the sponsor brief is grounded in dated facts, and the receipts survive the argument. Real CLI output - only the typing pace is staged, and you can [re-record it yourself](media/record-session.sh).
+`@fde` plus English. No cheat sheet.
 
-<p align="center"><img alt="A real fdeops session: messy kickoff notes routed into dated memory after you confirm, then a cold session that already knows the client, a grounded sponsor-meeting brief, and dated receipts" src="media/session.gif" width="900" /></p>
+| When | What you say | What you get |
+|------|--------------|--------------|
+| **The brief is wrong** | `@fde this is Acme. Brief says they want a portal.` | Real problem, or a gap. First chat: you name the client; the AI coding agent binds. |
+| **They went quiet** | `@fde the sponsor went quiet` | Trust signal in the record — process gap vs trust problem. |
+| **When did we agree?** | `@fde when did we agree to drop that?` | Dated receipts, or a clear gap. |
+| **What did they get?** | `@fde what did they get this week` | Friday ledger: promised → measured → accepted. |
+| **After a meeting** | `@fde` debrief these notes *(paste or attach)* | Proposed updates. You review, then confirm. |
+| **Optional: pull** | `@fde` connect Granola *(once)* · `@fde` pull today's Acme transcript | You add that source MCP. We **pull** on request — no push, no sync. [mcp/recipes/](mcp/recipes/) |
 
-Nothing to install to see it on a fake client: `npx fdeops demo`.
+Same folder every time: `~/fde-engagements/<client>/.fde/`.
+
+**Words used here, once:** *engagement* - one client's body of work, one folder. *Fieldbook* - that folder (`.fde/`), the record itself. *Brief vs reality* - what they said the problem was, and what it turned out to be. *Terrain* - their systems and org as you actually found them. *Trust signal* - green / amber / red on one relationship. *Receipts* - the dated line proving something was agreed. *Vault* - the Obsidian copy `fde vault` generates to read it all in one window.
 
 ---
 
 ## Quickstart
 
-**1. Install** on your machine - never in the customer's repo.
+**1. Install** (30 seconds). Pick one — both copies `@fde` twice.
+
+Claude Code (hooks before you type):
 
 ```text
 /plugin marketplace add suboss87/fdeops
 /plugin install fdeops@fdeops
 ```
 
-```bash
-npx skills add suboss87/fdeops --skill fde   # Cursor, Codex, skills-compatible hosts
-```
-
-That is one skill, not a catalogue - `@fde` routes the whole method. The CLI needs no install either: the skill reaches for `npx fdeops` when `fde` is not on the PATH. (Drop `--skill fde` and you also get `testing-fieldbook`, which is for people contributing to this repo, not for field work.)
-
-Claude Code additionally gets session hooks, so context arrives before you type. Everywhere else it is the same fieldbook, loaded when you ask.
-
-**2. Bind once** in the client workspace:
+Cursor, Codex, and any host that speaks the skills CLI:
 
 ```bash
-npx fdeops resume --init garvey   # ~/fde-engagements/garvey + bind this checkout
-npx fdeops resume                 # where we are
+npx skills add suboss87/fdeops --skill fde
 ```
 
-**3. Work** in plain language:
+**2. One chat.** Name the client. The AI coding agent binds the engagement; you never type the CLI.
 
 ```text
-@fde New client. Payments platform. They want it live before the Q3 audit.
+@fde this is Acme
 ```
 
-**It is working if** `npx fdeops resume` prints this client's phase, trust signal, and next action - and prints the same thing tomorrow, from a new session, with no explaining. Full workflow: [docs/USAGE.md](docs/USAGE.md).
+Paste kickoff notes in the same thread. `@fde` routes; you confirm judgment. Workflow: [docs/USAGE.md](docs/USAGE.md).
+
+Claude Code auto-loads the fieldbook at session start. Elsewhere, say `@fde`. Tomorrow the file is still there.
 
 <details>
-<summary>Other install paths · scan · env</summary>
+<summary>Terminal bind · other hosts · env</summary>
 
-- **Adapters:** `npx fdeops adapters .` - [adapters/](adapters/README.md)
-- **Local LLMs:** load `skills/fde/SKILL.md` - [guide](adapters/LOCAL-LLM.md)
+Fallback if the agent cannot bind — creates the engagement under `~/fde-engagements` and points this checkout at it:
+
+```bash
+npx fdeops resume --init acme   # ~/fde-engagements/acme + bind this checkout
+npx fdeops resume               # where we are
+```
+
+- **Adapters** (Cursor rules, Gemini, Copilot): `npx fdeops adapters .` — [adapters/](adapters/README.md)
+- **Local LLMs:** load `skills/fde/SKILL.md` — [guide](adapters/LOCAL-LLM.md)
 - **Air-gapped:** `git clone https://github.com/suboss87/fdeops.git && cd fdeops && node bin/install.js`
 - **No install:** `npx fdeops demo` · `npx fdeops scan` (heuristic recon, not findings)
 - **Requires:** Node.js >= 18
-- **Override:** `FDEOPS_ENGAGEMENT` - [docs/install.md](docs/install.md)
+- **Override:** `FDEOPS_ENGAGEMENT` — [docs/install.md](docs/install.md)
 
 </details>
 
 ---
 
-## The week
+## See it
 
-`@fde` plus English. No cheat sheet.
+```bash
+npx fdeops demo
+```
 
-| When | What you say | What you get |
-|------|--------------|--------------|
-| **Start of week** | `@fde` - or just open Claude Code | Fieldbook on disk either way. **Claude Code** injects trust, phase, next before you type. **Cursor / Codex / others:** say `@fde` or `resume` - nothing auto-loads. |
-| **After a meeting** | `@fde` debrief these notes *(paste or attach)* | Proposed updates. You review, then confirm. |
-| **Optional: pull** | `@fde` connect Granola *(once)* · `@fde` pull today's Acme transcript | You add that source MCP. We **pull** on request - no push, no sync. [mcp/recipes/](mcp/recipes/) |
-| **Before a stakeholder meeting** | `@fde` prep me for tomorrow with the sponsor | Brief from what you already logged. |
-| **Scope dispute** | `@fde` when did we agree to drop that? | Dated answers, or a clear gap. |
-| **End of week** | `@fde` draft the sponsor update from the record | Status grounded in what happened. |
+Real commands on a fake client: messy notes → you confirm → cold reload → prep → receipts → fieldbook page. Nothing of yours is read. Lives in `~/fde-engagements/.demo/`. Remove with `npx fdeops demo --clean`.
 
-Same folder every time: `~/fde-engagements/<client>/.fde/`.
+One recorded session — kickoff notes, next morning, “when did we agree?” weeks later. CLI output; typing pace is staged. Re-record: [`media/record-session.sh`](media/record-session.sh).
 
----
+<p align="center"><img alt="A real fdeops session: messy kickoff notes routed into dated memory after you confirm, then a cold session that already knows the client, a grounded sponsor-meeting brief, and dated receipts" src="media/session.gif" width="900" /></p>
 
-## How it works
+Two things a chat window cannot do: **nothing is written until you confirm**, and `<private>` lands sealed as `(private - redacted)` — never in `resume`, `prep`, `receipts`, or the dashboard.
 
-- **You** describe the situation with `@fde`, in plain language.
-- **The AI coding agent** routes to a method, does the work, and drafts the memory.
-- **The CLI** (`bin/fde.js`) does every write, receipt, and status check - git and file reads only, no network, no model tokens. You do not live in the CLI; your agent runs it. [docs/USAGE.md](docs/USAGE.md)
-- **You confirm.** Nothing enters the record unreviewed; `fde debrief --dry-run` shows the routing first.
+---
 
-`CLAUDE.md` is how the *code* works. The fieldbook is how the *engagement* works. It lives at `~/fde-engagements/<client>/.fde/`, not inside any vendor - change hosts, install `@fde` on the new one, keep talking.
+## How it works
 
-### What works where
+- **You** describe the situation with `@fde` (or plain language once the skill is loaded). First chat: you name the client; the AI coding agent runs the bind.
+- **Hooks (Claude Code)** load where you left off and snapshot on the way out. Other hosts: same CLI and files; you call `@fde`.
+- **Local CLI** — writes, receipts, status. Zero model tokens. The AI coding agent runs it; you do not live in the CLI. Friday, `fde status` prints promised → measured → accepted. [docs/USAGE.md](docs/USAGE.md)
+- **Pull (optional)** — FDEOps is the sink. Paste is the daily path. A source MCP you add (Granola, Slack, Notion, …) can fetch text; `@fde connect …` walks config. No push, no sync, no tokens in `.fde/`. [mcp/recipes/](mcp/recipes/)
 
-Honest boundaries, so nothing here needs a footnote:
+`CLAUDE.md` is how the *code* works. The fieldbook is how the *engagement* works. The record lives at `~/fde-engagements/<client>/.fde/` — not inside any vendor.
 
-| | Claude Code | Cursor · Codex · Copilot · Gemini · local LLMs |
-|---|---|---|
-| Fieldbook, methods, CLI, dashboard | yes | yes |
-| Context loaded before you type | session hooks | you say `@fde` / `resume` |
-| Snapshot on session end | session hooks | `@fde` capture, or `fde capture` |
-| Pull from Granola / Slack / Notion | you add that source MCP; FDEOps only ingests | same |
+### Switch coding agents anytime
 
-FDEOps is the sink, never the source: no push, no sync, no third-party tokens in `.fde/`. [mcp/recipes/](mcp/recipes/)
+Change hosts, install `@fde` on the new one, bind if needed, keep talking. The client record does not move.
 
 <details>
-<summary>Phase verbs (land → close)</summary>
+<summary>Engagement verbs</summary>
 
 | Verb | When |
 |------|------|
-| **land** | First days - brief, stakeholders, success |
-| **discover** | The brief is wrong - evidence from the repo |
+| **land** | First days — brief, stakeholders, success |
+| **discover** | The brief is wrong — evidence from the repo |
 | **plan** | Sequence backwards from done, PR-sized |
-| **build** | Blast radius, log what shipped |
+| log delivery | After the host agent codes — what shipped, how it rolls back |
 | **ship** | Pre-flight, canary, rollback |
 | **close** | Handoff, retro, receipts that survive you |
 
@@ -136,48 +134,26 @@ Overlays (AI, fintech, healthcare, gov) fire on signal. [docs/skills.md](docs/sk
 
 ## Engagement memory (`.fde/`)
 
-One folder per client. Plain markdown, so you can grep it, diff it, copy it into a readout, and defend it in a room.
+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 |
+| `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 |
 
-A day-one fieldbook ships **empty** - headings and allowed values, no invented rows - so anything you read in it is something that actually happened. Schema: [docs/schema.md](docs/schema.md).
-
----
-
-## The field methods
-
-You never pick one. You describe the situation and `@fde` routes. **37 methods** across six domains, each a method - thinking, artifact, checkpoint - not a tip sheet. [docs/skills.md](docs/skills.md) · [docs/skills-reference.md](docs/skills-reference.md)
-
-<details>
-<summary>All 37 methods</summary>
-
-| Domain | Methods |
-|--------|---------|
-| **1. Embed & Trust** | [land](skills/fde/references/land.md) · [audit](skills/fde/references/audit.md) · [stakeholder-radar](skills/fde/references/stakeholder-radar.md) · [trust-engineering](skills/fde/references/trust-engineering.md) · [scope-defense](skills/fde/references/scope-defense.md) |
-| **2. Discover & Diagnose** | [discover](skills/fde/references/discover.md) · [assumption-audit](skills/fde/references/assumption-audit.md) · [use-case-scoring](skills/fde/references/use-case-scoring.md) · [sketch](skills/fde/references/sketch.md) |
-| **3. Plan & Align** | [plan](skills/fde/references/plan.md) · [business-case](skills/fde/references/business-case.md) · [options-analysis](skills/fde/references/options-analysis.md) · [initiative-triage](skills/fde/references/initiative-triage.md) |
-| **4. Build & Guard** | [build](skills/fde/references/build.md) · [incremental-build](skills/fde/references/incremental-build.md) · [test-on-legacy](skills/fde/references/test-on-legacy.md) · [blast-radius](skills/fde/references/blast-radius.md) · [debug](skills/fde/references/debug.md) · [rescue](skills/fde/references/rescue.md) · [security-audit](skills/fde/references/security-audit.md) · [observability](skills/fde/references/observability.md) |
-| **5. Ship & Verify** | [ship](skills/fde/references/ship.md) · [review](skills/fde/references/review.md) · [rollback-drill](skills/fde/references/rollback-drill.md) · [qa-live](skills/fde/references/qa-live.md) |
-| **6. Operate & Close** | [status](skills/fde/references/status.md) · [demo-prep](skills/fde/references/demo-prep.md) · [debrief](skills/fde/references/debrief.md) · [exec-narrative](skills/fde/references/exec-narrative.md) · [dashboard](skills/fde/references/dashboard.md) · [multi-customer-ops](skills/fde/references/multi-customer-ops.md) · [close](skills/fde/references/close.md) · [handoff-engineering](skills/fde/references/handoff-engineering.md) · [pattern-extract](skills/fde/references/pattern-extract.md) · [red-team](skills/fde/references/red-team.md) · [ingest](skills/fde/references/ingest.md) · [ingest-connect](skills/fde/references/ingest-connect.md) |
-
-Overlays: [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)
-
-</details>
+Schema: [docs/schema.md](docs/schema.md).
 
 ---
 
 ## Fieldbook UI
 
-`@fde` dashboard, or `npx fdeops dashboard` (`--all` for the portfolio): one local HTML file - trust, phase, next action, and the record behind them. Generated on demand, no server.
+Local HTML: trust, phase, next, the record. `@fde` dashboard, or `npx fdeops dashboard` (`--all` for the portfolio).
 
-<p align="center"><img width="1336" height="624" alt="The fdeops Fieldbook dashboard: engagements with trust signal, phase and next action" src="https://github.com/user-attachments/assets/5683614c-7730-4a3a-860d-185053a377eb" /></p>
+<p align="center"><img width="1336" height="624" alt="fdeops Fieldbook in the browser" src="https://github.com/user-attachments/assets/5683614c-7730-4a3a-860d-185053a377eb" /></p>
 
 ---
 
@@ -185,32 +161,35 @@ Overlays: [ai](skills/fde/references/ai.md) · [artifacts](skills/fde/references
 
 | You are | What this is |
 |---------|----------------|
-| **Forward Deployed Engineer** | The job this was built for - first meeting through handoff |
+| **Forward Deployed Engineer** | The job this was built for — first meeting through handoff |
 | **Consultant / contractor on site** | The engagement stops resetting every morning |
 | **Solutions architect** | Politics and architecture in the same record |
-| **Agency, 3-5 clients** | One `.fde/` each - they stop blurring |
+| **Agency, 3–5 clients** | One `.fde/` each — they stop blurring |
 | **Fractional CTO on client work** | System of record for the embed, and the billable trail |
 
+Ordinary TypeScript, unit tests, and git commits stay in the host agent.
+
 ---
 
 ## Your data stays yours
 
 - **Local only.** `git` + files. No network, no telemetry, no account. Air-gapped is fine.
-- **Plain markdown.** No database, no lock-in, nothing to export.
-- **No new data path.** The model sees client code only when you point the AI coding agent at it. `<private>` blocks are redacted from CLI, dashboard, and hook output - do not open raw private blocks with file tools.
-- **Know the sync surface.** `~/fde-engagements` lives in `$HOME`. iCloud or Dropbox is an NDA incident waiting; `resume --init` warns you.
+- **Plain markdown.** No database.
+- **No new data path.** The model sees client code only when you point the AI coding agent at it. `<private>` is redacted from CLI, dashboard, and hooks — do not open raw private blocks with file tools.
+- **Nothing unreviewed.** Draft → you confirm. `fde debrief --dry-run` shows routing first.
+- **Know the sync surface.** `~/fde-engagements` is in `$HOME`. iCloud/Dropbox is an NDA incident waiting. `resume --init` warns. [PRIVACY.md](PRIVACY.md) before the first NDA.
 
-[PRIVACY.md](PRIVACY.md) before the first NDA · [SECURITY.md](SECURITY.md)
+[PRIVACY.md](PRIVACY.md) · [SECURITY.md](SECURITY.md)
 
 ---
 
 ## Principles
 
-- **The artifact is the memory** - producing the work and recording it are one action
-- **Methods, 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
+- **The artifact is the memory** — producing the work and recording it are one action
+- **Methods, 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
 
 ---
 
@@ -224,8 +203,26 @@ Re-run the Quickstart install, or from a clone: `git pull && node bin/install.js
 
 **[Subash Natarajan](https://www.linkedin.com/in/subashn/)**. [Issues](https://github.com/suboss87/fdeops/issues) · [CONTRIBUTING.md](CONTRIBUTING.md)
 
-Thanks to builders whose craft sharpened the thinking, among them [Andrej Karpathy](https://karpathy.ai/)'s engineering guidelines and the [agentic engineering workflow](https://github.com/pawel-cell/micky-podcast-agentic-engineering) notes from David Ondrej / Michael Shimeles.
-
-**What we won't build:** SaaS sync; Slack/Notion/Granola connectors or **push** inside the CLI; CRM as core; hardware capture; generic code-craft packs (TDD and review live elsewhere). You may **pull** via *your* MCP. The `fde` CLI stays local-only.
+**What we won't build:** SaaS sync; Slack/Notion/Granola connectors or **push** inside the CLI; CRM as core; hardware capture; generic code-craft packs. You may **pull** via *your* MCP. The `fde` CLI stays local-only.
 
 [FDE Methodology](FDE-METHODOLOGY.md) · [SECURITY.md](SECURITY.md) · [PRIVACY.md](PRIVACY.md) · [Repo layout](docs/REPO_LAYOUT.md) · [Skills matrix](docs/skills.md) · MIT
+
+---
+
+<details>
+<summary>31 field methods (you never pick one)</summary>
+
+You describe the situation; `@fde` routes. **31 methods**, six domains — each a method (thinking, artifact, checkpoint), not a tip sheet. [docs/skills.md](docs/skills.md) · [docs/skills-reference.md](docs/skills-reference.md)
+
+| Domain | Methods |
+|--------|---------|
+| **1. Embed & Trust** | [land](skills/fde/references/land.md) · [audit](skills/fde/references/audit.md) · [stakeholder-radar](skills/fde/references/stakeholder-radar.md) · [trust-engineering](skills/fde/references/trust-engineering.md) · [scope-defense](skills/fde/references/scope-defense.md) |
+| **2. Discover & Diagnose** | [discover](skills/fde/references/discover.md) · [assumption-audit](skills/fde/references/assumption-audit.md) · [use-case-scoring](skills/fde/references/use-case-scoring.md) · [sketch](skills/fde/references/sketch.md) |
+| **3. Plan & Align** | [plan](skills/fde/references/plan.md) · [business-case](skills/fde/references/business-case.md) · [options-analysis](skills/fde/references/options-analysis.md) · [initiative-triage](skills/fde/references/initiative-triage.md) |
+| **4. Build & Guard** | [incremental-build](skills/fde/references/incremental-build.md) · [blast-radius](skills/fde/references/blast-radius.md) · [rescue](skills/fde/references/rescue.md) |
+| **5. Ship & Verify** | [ship](skills/fde/references/ship.md) · [review](skills/fde/references/review.md) · [rollback-drill](skills/fde/references/rollback-drill.md) |
+| **6. Operate & Close** | [status](skills/fde/references/status.md) · [demo-prep](skills/fde/references/demo-prep.md) · [debrief](skills/fde/references/debrief.md) · [exec-narrative](skills/fde/references/exec-narrative.md) · [dashboard](skills/fde/references/dashboard.md) · [multi-customer-ops](skills/fde/references/multi-customer-ops.md) · [close](skills/fde/references/close.md) · [handoff-engineering](skills/fde/references/handoff-engineering.md) · [pattern-extract](skills/fde/references/pattern-extract.md) · [red-team](skills/fde/references/red-team.md) · [ingest](skills/fde/references/ingest.md) · [ingest-connect](skills/fde/references/ingest-connect.md) |
+
+Overlays: [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)
+
+</details>

package/adapters/AGENTS.md

@@ -4,10 +4,13 @@ You are the AI coding agent for a **Forward Deployed Engineer (FDE)** - the huma
 
 ## Entry
 
-When the FDE types **`@fde`** (or describes an engagement situation - new customer, mid-project takeover, production fire, quiet stakeholder, ready to ship), load the skill and route.
+When the FDE types **`@fde`**, names a client, pastes meeting notes, asks what was agreed, or describes embed work (quiet sponsor, brief feels wrong, Friday update) — load the skill. If `fde resume` says NO ENGAGEMENT: ask the client name once, then **you** run `fde resume --init <slug>`. Never tell them to type it.
+
+Do **not** load `@fde` for ordinary code edits, TypeScript, unit tests, refactors, or git commits.
 
 - Skill (single source of truth): `~/.claude/skills/fde/SKILL.md`
 - **Never ask the FDE to pick a skill.** Read the situation, route silently, do the work.
+- **Never ask the FDE to type `fde …` commands.** You run the local CLI; they confirm judgment in chat.
 
 ## Engagement memory
 

package/adapters/GEMINI.md

@@ -4,10 +4,13 @@ Context for Gemini CLI when assisting a **Forward Deployed Engineer (FDE)** - th
 
 ## Entry
 
-When the FDE types **`@fde`** or describes an engagement situation (new customer, mid-project takeover, production fire, quiet stakeholder, ready to ship), load the skill and route.
+When the FDE types **`@fde`**, names a client, pastes meeting notes, asks what was agreed, or describes embed work (quiet sponsor, brief feels wrong, Friday update) — load the skill. If `fde resume` says NO ENGAGEMENT: ask the client name once, then **you** run `fde resume --init <slug>`. Never tell them to type it.
+
+Do **not** load `@fde` for ordinary code edits, TypeScript, unit tests, refactors, or git commits.
 
 - Skill (single source of truth): `~/.claude/skills/fde/SKILL.md`
 - **Never ask the FDE to pick a skill.** Read the situation, route silently, do the work.
+- **Never ask the FDE to type `fde …` commands.** You run the local CLI; they confirm judgment in chat.
 
 ## Engagement memory
 

package/adapters/LOCAL-LLM.md

@@ -62,7 +62,7 @@ The model reads SKILL.md, routes to the right skill, and produces artifacts in y
 
 ## Model size recommendations
 
-The methodology is detailed (37 methods, routing logic, evidence format, memory contract). Larger models handle it better:
+The methodology is detailed (31 methods, routing logic, evidence format, memory contract). Larger models handle it better:
 
 | Model class | Experience |
 |-------------|-----------|

package/adapters/README.md

@@ -2,7 +2,7 @@
 
 **One brain, thin adapters.** fdeops has a single source of truth - the `@fde` skill at `skills/fde/SKILL.md` and the `fde` CLI. Each AI coding tool discovers it through a small pointer file in the place that tool already looks. No forked logic, no five copies to maintain - every adapter says the same thing: *route via `@fde`, read/write `.fde/` memory, talk like a peer, never touch what isn't yours.*
 
-**Switching tools:** the fieldbook does not live in the agent. It lives at `~/fde-engagements/<client>/.fde/`. Point a new tool at a bound workspace, drop adapters (or install the skill/plugin for that tool), and the same client record opens. Auto session hooks are Claude Code–first; elsewhere load via `@fde` / `fde resume`. See [README § What works where](../README.md#what-works-where).
+**Switching tools:** the fieldbook does not live in the agent. It lives at `~/fde-engagements/<client>/.fde/`. Point a new tool at a bound workspace, drop adapters (or install the skill/plugin for that tool), and the same client record opens. Auto session hooks are Claude Code–first; elsewhere load via `@fde` / `fde resume`. See [README § Switch coding agents](../README.md#switch-coding-agents-anytime).
 
 ## What goes where
 
@@ -31,4 +31,4 @@ Defaults to the current directory if no path is given. Existing files are never
 
 ## The principle
 
-The adapter only tells the tool **where the brain is and how to behave**. All the method - the 37 methods, the overlays, the memory contract - lives once in `skills/fde/SKILL.md`. Update the brain, every platform gets it. That's why fdeops feels native in whatever the FDE already uses, without five things to keep in sync.
+The adapter only tells the tool **where the brain is and how to behave**. All the method - the 31 methods, the overlays, the memory contract - lives once in `skills/fde/SKILL.md`. Update the brain, every platform gets it. That's why fdeops feels native in whatever the FDE already uses, without five things to keep in sync.

package/adapters/copilot-instructions.md

@@ -4,10 +4,13 @@ You are the AI coding agent for a **Forward Deployed Engineer (FDE)** - the huma
 
 ## Entry
 
-When the FDE types **`@fde`** or describes an engagement situation (new customer, mid-project takeover, production fire, quiet stakeholder, ready to ship), load the skill and route.
+When the FDE types **`@fde`**, names a client, pastes meeting notes, asks what was agreed, or describes embed work (quiet sponsor, brief feels wrong, Friday update) — load the skill. If `fde resume` says NO ENGAGEMENT: ask the client name once, then **you** run `fde resume --init <slug>`. Never tell them to type it.
+
+Do **not** load `@fde` for ordinary code edits, TypeScript, unit tests, refactors, or git commits.
 
 - Skill (single source of truth): `~/.claude/skills/fde/SKILL.md`
 - **Never ask the FDE to pick a skill.** Read the situation, route silently, do the work.
+- **Never ask the FDE to type `fde …` commands.** You run the local CLI; they confirm judgment in chat.
 
 ## Engagement memory
 

package/adapters/cursor.fde.mdc

@@ -9,9 +9,11 @@ You are the AI coding agent for a **Forward Deployed Engineer (FDE)** - the huma
 
 ## Entry
 
-When the FDE types **`@fde`** or describes an engagement situation in plain language (new customer, meeting notes, prep for a stakeholder meeting, scope dispute, ready to ship), load the skill and route.
+When the FDE types **`@fde`**, names a client, pastes meeting notes, asks what was agreed, or describes embed work (quiet sponsor, brief feels wrong, Friday update) — load `@fde`. If `fde resume` says NO ENGAGEMENT: ask the client name once, then **you** run `fde resume --init <slug>`. Never tell them to type it.
 
-- Skill (single source of truth): `~/.claude/skills/fde/SKILL.md`
+Do **not** load `@fde` for ordinary code edits, unit tests, refactors, or git commits.
+
+- Skill (single source of truth): `~/.claude/skills/fde/SKILL.md` (or the copy this install placed)
 - **Never ask the FDE to pick a skill.** Read the situation, route silently, do the work.
 - **Never ask the FDE to type `fde …` commands.** You run the local CLI; they confirm judgment in chat.
 

package/bin/check.js

@@ -59,8 +59,8 @@ ok('skills structure')
 
 // v3: one skill + phase references (progressive disclosure)
 const requiredReferences = [
-  'land.md', 'discover.md', 'audit.md', 'plan.md', 'build.md', 'review.md',
-  'debug.md', 'rescue.md', 'ship.md', 'sketch.md', 'close.md', 'dashboard.md',
+  'land.md', 'discover.md', 'audit.md', 'plan.md', 'review.md',
+  'rescue.md', 'ship.md', 'sketch.md', 'close.md', 'dashboard.md',
   'debrief.md', 'status.md', 'demo-prep.md',
   'healthcare.md', 'fintech.md', 'gov.md',
   'ai.md', 'eval-pack.md',
@@ -80,7 +80,7 @@ ok('phase references')
 // every judgment-heavy reference carries a worked example that names the memory
 // file the work lands in. Prose-only guidance drifts into advice nobody can apply.
 const exampleReferences = [
-  'land.md', 'discover.md', 'plan.md', 'build.md', 'ship.md', 'close.md',
+  'land.md', 'discover.md', 'plan.md', 'ship.md', 'close.md',
   'status.md', 'stakeholder-radar.md', 'options-analysis.md', 'business-case.md',
   'assumption-audit.md', 'scope-defense.md',
 ]
@@ -286,6 +286,33 @@ if (!read('skills/fde/SKILL.md').includes('npx --yes fdeops')) {
   fail('skills/fde/SKILL.md must fall back to npx --yes fdeops when the CLI is not installed')
 } else ok('SKILL.md npx CLI fallback')
 
+// The frontmatter description is the only text every host reads before deciding
+// to load the skill. If it triggers on "@fde" alone, an FDE who just talks about
+// their client gets no memory - so it must carry natural-intent triggers in the
+// "Use when …" convention, and @fde must be one of several, never the gate.
+{
+  const fm = /^---\n([\s\S]*?)\n---/.exec(read('skills/fde/SKILL.md'))
+  const desc = fm ? (/^description:[^\S\n]*(.*)$/m.exec(fm[1]) || [])[1] || '' : ''
+  const triggers = desc.match(/Use when/g) || []
+  if (triggers.length < 4) {
+    fail(`SKILL.md description needs several "Use when …" triggers so it fires on intent (found ${triggers.length})`)
+  } else if (/Use when the human says @fde or/.test(desc)) {
+    fail('SKILL.md description must not gate on @fde - name the client-work intents first')
+  } else ok('SKILL.md description triggers on intent')
+}
+
+// Six invented words (fieldbook, terrain, reality, trust signal, receipts,
+// vault) carry the method. They were never defined in one place, so a stranger
+// met them scattered through the docs and guessed.
+{
+  const gloss = /Words used here[\s\S]{0,1200}/.exec(readme)
+  const missing = ['fieldbook', 'reality', 'terrain', 'trust signal', 'receipts', 'vault']
+    .filter(w => !gloss || !new RegExp(w, 'i').test(gloss[0]))
+  if (!gloss) fail('README must define its invented words once (a "Words used here" line)')
+  else if (missing.length) fail(`README glossary is missing: ${missing.join(', ')}`)
+  else ok('README defines its own vocabulary')
+}
+
 if (!fs.existsSync(path.join(root, 'docs', 'USAGE.md'))) {
   fail('docs/USAGE.md missing')
 } else ok('docs/USAGE.md')

package/bin/fde.js

@@ -18,13 +18,13 @@
  *   fde debrief --smart     propose routing from messy notes; --apply commits it
  *   fde prep [label]        grounded walk-in brief from existing .fde/ only
  *   fde doctor              deterministic memory lint (stale signals, gaps)
- *   fde garden [--apply]    propose safe consolidations; apply only with --apply
+ *   fde tidy [--apply]      propose safe consolidations; apply only with --apply (was: garden)
  *   fde ingest …            stage → propose → apply pull sink (.inbox/; never auto-writes .fde/)
  *   fde owner [set …]       who keeps this engagement record
  *   fde receipts <term>     "what did we agree?" - search memory with dates
  *   fde capture             session-end snapshot → context.md (hooks use this)
  *   fde preserve            pre-compaction context snapshot (hook-internal; hooks use this)
- *   fde status [--all]      current engagement (default) or full portfolio (--all)
+ *   fde status [--all]      value ledger first, then trust (pass --all for portfolio)
  *   fde dashboard [--all]   current engagement fieldbook (default) or all (--all)
  *   fde vault               derived Obsidian vault of the fieldbook (disposable; --redacted)
  */
@@ -1223,7 +1223,7 @@ function cmdResume(args) {
         .filter(d => !d.startsWith('.') && fs.existsSync(path.join(ENGAGEMENTS_ROOT, d, '.fde')))
         .join(', ') || '(none yet)'
       : '(none yet)'
-    console.log(`NO ENGAGEMENT for this workspace.\nexisting: ${list}\ncreate + bind one:  fde resume --init <client-name>`)
+    console.log(`NO ENGAGEMENT for this workspace.\nexisting: ${list}\nAsk the human the client name (one question), then run: fde resume --init <client-name>\nDo not tell them to type that command.`)
     process.exit(2)
   }
   // Monday-morning: triage + proactive hygiene (silent when clean), then memory.
@@ -2295,21 +2295,59 @@ function hasValueBucket(eng) {
 const PENDING_CELL_RE =
   /^(?:pending|tbd|to ?be ?(?:measured|confirmed|determined)|n\s*\/\s*a|na|none|unknown|not measured|\?+|\.{2,}|…|-+|—+|–+)(?:[^\w].*)?$/i
 
-function claimedValueRows(eng) {
+function parseValueLedger(eng) {
   const ledger = stripTemplateNoise(sectionBody(readClean(eng, 'delivery.md'), 'Value ledger') || '')
   const table = parseMdTable(ledger)
-  if (!table) return { claimed: 0, columnMissing: false }
-  const mIdx = colIndex(table.headers, /measured/i)
-  if (mIdx === -1) return { claimed: 0, columnMissing: false }
-  const aIdx = colIndex(table.headers, /accept/i)
-  let claimed = 0
+  if (!table) return { rows: [], columnMissing: false }
+  const idx = {
+    slice: colIndex(table.headers, /slice/i),
+    promised: colIndex(table.headers, /promised/i),
+    measured: colIndex(table.headers, /measured/i),
+    accepted: colIndex(table.headers, /accept/i),
+  }
+  const cell = (row, i) => (i === -1 ? '' : String(row[i] || '').trim())
+  const rows = []
   for (const row of table.rows) {
-    const measured = String(row[mIdx] || '').trim()
-    if (!measured || PENDING_CELL_RE.test(measured)) continue
-    const accepted = aIdx === -1 ? '' : String(row[aIdx] || '').trim()
-    if (!accepted || PENDING_CELL_RE.test(accepted)) claimed++
+    const slice = cell(row, idx.slice)
+    const promised = cell(row, idx.promised)
+    const measured = cell(row, idx.measured)
+    const accepted = cell(row, idx.accepted)
+    if (!slice && !promised && !measured) continue
+    const measuredPending = !measured || PENDING_CELL_RE.test(measured)
+    const acceptedPending = idx.accepted === -1 || !accepted || PENDING_CELL_RE.test(accepted)
+    let state = 'unmeasured'
+    if (!measuredPending && acceptedPending) state = 'claimed'
+    else if (!measuredPending) state = 'accepted'
+    rows.push({ slice, promised, measured, accepted, state })
   }
-  return { claimed, columnMissing: aIdx === -1 }
+  return { rows, columnMissing: idx.accepted === -1 }
+}
+
+function claimedValueRows(eng) {
+  const { rows, columnMissing } = parseValueLedger(eng)
+  return { claimed: rows.filter(r => r.state === 'claimed').length, columnMissing }
+}
+
+function formatValueLedgerLine(r) {
+  const name = r.slice || 'value'
+  let body = r.promised || ''
+  if (r.state !== 'unmeasured' && r.measured) {
+    if (!body) body = r.measured
+    else if (!body.includes(r.measured)) body = `${body} → ${r.measured}`
+  }
+  const head = body ? `${name}: ${body}` : name
+  if (r.state === 'accepted') return `${head} · accepted by ${r.accepted}`
+  if (r.state === 'claimed') return `${head} · claimed, not yet accepted`
+  return `${head} · not yet measured`
+}
+
+function valueLedgerStatusLines(eng, opts = {}) {
+  const { rows } = parseValueLedger(eng)
+  if (!rows.length) return ['    value: none yet']
+  const cap = opts.compact ? 1 : 8
+  const lines = rows.slice(0, cap).map(r => `    ${formatValueLedgerLine(r)}`)
+  if (rows.length > cap) lines.push(`    … ${rows.length - cap} more in delivery.md`)
+  return lines
 }
 
 // AI in scope for ship/close hygiene — delivery/decisions/trust evidence only.
@@ -2488,18 +2526,18 @@ function cmdGarden(args) {
   // Gardener contract (from Rowboat note_curation): no new facts, no deleted substance,
   // reversible via git when healthy, confirm before apply. Mechanical only - no LLM rewrite.
   if (gitHealth.ok) {
-    console.log('GARDEN (contract: no new facts · no deleted substance · reversible via memory git)')
+    console.log('TIDY (contract: no new facts · no deleted substance · reversible via memory git)')
   } else if (gitHealth.reason === 'broken') {
-    console.log('GARDEN (contract: no new facts · no deleted substance · ⚠ memory git BROKEN — NOT reversible until ledger is repaired)')
+    console.log('TIDY (contract: no new facts · no deleted substance · ⚠ memory git BROKEN — NOT reversible until ledger is repaired)')
   } else {
-    console.log('GARDEN (contract: no new facts · no deleted substance · ⚠ memory not git-versioned — NOT reversible)')
+    console.log('TIDY (contract: no new facts · no deleted substance · ⚠ memory not git-versioned — NOT reversible)')
   }
   console.log(resumeTriage(eng))
   if (!gitHealth.ok) {
     console.log(
       gitHealth.reason === 'broken'
-        ? '\n⚠ ledger is UNVERSIONED (corrupt .git). Repair before trusting garden apply: mv .fde/.git .fde/.git.broken && run any fde write to re-init.'
-        : '\n⚠ no memory git — garden apply cannot create a reversible commit until the ledger exists.'
+        ? '\n⚠ ledger is UNVERSIONED (corrupt .git). Repair before trusting tidy apply: mv .fde/.git .fde/.git.broken && run any fde write to re-init.'
+        : '\n⚠ no memory git — tidy apply cannot create a reversible commit until the ledger exists.'
     )
   }
   const proposals = []
@@ -2539,18 +2577,18 @@ function cmdGarden(args) {
     })
   }
   if (!proposals.length) {
-    console.log('\nNothing to garden.')
+    console.log('\nNothing to tidy.')
     return
   }
   console.log(`\n${proposals.length} proposal(s):`)
   proposals.forEach((p, i) => console.log(`  ${i + 1}. [${p.kind}] ${p.text}`))
   if (!apply) {
-    console.log('\nApply mechanical items only:  fde garden --apply')
+    console.log('\nApply mechanical items only:  fde tidy --apply')
     console.log('Manual items stay yours. Every apply commits to memory git when the ledger is healthy.')
     return
   }
   if (!gitHealth.ok && gitHealth.reason === 'broken') {
-    console.error('refusing garden --apply while memory git is broken - repair the ledger first')
+    console.error('refusing tidy --apply while memory git is broken - repair the ledger first')
     process.exit(1)
   }
   ensureMemoryGit(eng)
@@ -2603,9 +2641,9 @@ function cmdGarden(args) {
     touched.add('context-archive.md')
     console.log(`applied: archived ${p.sessionBlocks.length} old session-end blocks → context-archive.md`)
   }
-  const hash = commitMemory(eng, 'garden', { files: [...touched] })
+  const hash = commitMemory(eng, 'tidy', { files: [...touched] })
   if (!applied) console.log('no mechanical proposals applied (manual items remain)')
-  else console.log(`garden done${hash ? ` @${hash}` : ''}`)
+  else console.log(`tidy done${hash ? ` @${hash}` : ''}`)
 }
 
 // Keep the first open-risk bullet per fingerprint; move later echoes under ## Retired.
@@ -2647,7 +2685,7 @@ function applyRiskDedupe(eng, clusters) {
   const stamp = new Date().toISOString().slice(0, 10)
   const block = retiredLines.map(l => {
     const body = l.trim().replace(/^-\s*/, '')
-    return `- [${stamp}] (garden dedupe) ${body}`
+    return `- [${stamp}] (tidy dedupe) ${body}`
   }).join('\n')
   out = appendUnderSection(out, 'Retired', block)
   withFileLock(p, () => { atomicWriteFile(p, out.endsWith('\n') ? out : out + '\n') })
@@ -2669,7 +2707,7 @@ function cmdStatus(args) {
       if (!fs.existsSync(eng)) continue
       const s = computeSignals(eng)
       const note = [s.memoryWarn, (s.dirtyFiles && s.dirtyFiles.length) ? `dirty:${s.dirtyFiles.length}` : '', s.reason || s.topRisk].filter(Boolean).join(' · ').slice(0, 70)
-      rows.push({ name: d, phase: s.phase, trust: s.trust, signalAge: s.signalAge, stale: s.stale, updated: s.updated, reason: note, memoryWarn: s.memoryWarn, dirtyFiles: s.dirtyFiles })
+      rows.push({ name: d, phase: s.phase, trust: s.trust, signalAge: s.signalAge, stale: s.stale, updated: s.updated, reason: note, memoryWarn: s.memoryWarn, dirtyFiles: s.dirtyFiles, valueLines: valueLedgerStatusLines(eng, { compact: true }) })
     }
   } else {
     const eng = resolveEngagement()
@@ -2679,13 +2717,14 @@ function cmdStatus(args) {
     }
     const s = computeSignals(eng)
     const note = [s.memoryWarn, (s.dirtyFiles && s.dirtyFiles.length) ? `dirty:${s.dirtyFiles.length}` : '', s.reason || s.topRisk].filter(Boolean).join(' · ').slice(0, 70)
-    rows.push({ name: engagementSlugFromPath(eng), phase: s.phase, trust: s.trust, signalAge: s.signalAge, stale: s.stale, updated: s.updated, reason: note, memoryWarn: s.memoryWarn, dirtyFiles: s.dirtyFiles })
+    rows.push({ name: engagementSlugFromPath(eng), phase: s.phase, trust: s.trust, signalAge: s.signalAge, stale: s.stale, updated: s.updated, reason: note, memoryWarn: s.memoryWarn, dirtyFiles: s.dirtyFiles, valueLines: valueLedgerStatusLines(eng) })
   }
   if (!rows.length) { console.log('no engagements yet'); return }
   const order = { RED: 0, amber: 1, green: 2 }
   rows.sort((a, b) => order[a.trust] - order[b.trust])
-  console.log((all ? 'FDE PORTFOLIO' : 'FDE STATUS') + ' - trust-first triage (heuristic: red > amber > green)\n')
+  console.log((all ? 'FDE PORTFOLIO' : 'FDE STATUS') + ' - value first, then trust\n')
   for (const r of rows) {
+    for (const line of r.valueLines) console.log(line)
     // "amber?" = structured signal went stale (>21d) - reconfirm before trusting it
     const label = r.trust + (r.stale ? '?' : '')
     const sig = r.signalAge != null ? `signal ${r.signalAge}d old${r.stale ? ' (STALE - reconfirm)' : ''}  ` : ''
@@ -3150,14 +3189,13 @@ function printUsage() {
   fde prep [label]         grounded walk-in brief from existing .fde/ only
   fde doctor               lint engagement memory (stale signals, gaps)
   fde redact <term>        preview/remove lines containing a buried term (pass --apply to commit)
-  fde garden [--apply]     propose safe consolidations (contract: no new facts; git-reversible)
+  fde tidy [--apply]       propose safe consolidations (contract: no new facts; git-reversible)
   fde owner [set email]    who keeps this engagement record
   fde receipts <term>      "what did we agree?" with dates
-  fde capture              session-end memory snapshot (hooks use this)
-  fde preserve             pre-compaction context snapshot (hook-internal; hooks use this)
-  fde status [--all]       current engagement status (pass --all for full portfolio)
+  fde status [--all]       value ledger, then trust (pass --all for full portfolio)
   fde dashboard [--all]    current engagement fieldbook (pass --all for every client)
   fde vault                derived Obsidian vault of every engagement (--current for one, --redacted for a shared screen, --out <dir>)
+  hooks call these; you do not: capture (session-end snapshot), preserve (pre-compaction snapshot)
   env FDEOPS_ENGAGEMENTS_ROOT  override ~/fde-engagements (init/status/dashboard/registry)
   writes require a workspace bind (or FDEOPS_ENGAGEMENT) - folder-name match is read-only
   .fde/ is git-versioned locally for tamper-evident receipts (no remote, no telemetry)
@@ -3176,6 +3214,8 @@ switch (cmd) {
   case 'prep': cmdPrep(args); break
   case 'doctor': cmdDoctor(); break
   case 'redact': cmdRedact(args); break
+  // `garden` was the name through 3.11.x; it keeps working.
+  case 'tidy':
   case 'garden': cmdGarden(args); break
   case 'owner': cmdOwner(args); break
   case 'receipts': cmdReceipts(args); break

package/bin/install.js

@@ -355,7 +355,7 @@ function cmdInstall(opts = {}) {
 // through to the CLI (fde.js reads process.argv itself, so require() is enough).
 const FDE_SUBCOMMANDS = [
   'demo', 'scan', 'resume', 'triage', 'log', 'debrief', 'ingest', 'prep', 'doctor', 'redact',
-  'garden', 'owner', 'receipts', 'capture', 'preserve', 'status', 'dashboard', 'vault', 'help',
+  'tidy', 'garden', 'owner', 'receipts', 'capture', 'preserve', 'status', 'dashboard', 'vault', 'help',
 ]
 
 const INSTALL_SUBCOMMANDS = ['init', 'adapters', 'install']

package/mcp/fdeops-ingest/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fdeops-ingest-mcp",
-  "version": "3.11.1",
+  "version": "3.13.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.11.1",
-  "description": "Field kit for engineers embedded in client work - a real CLI (recon, memory, portfolio), one @fde skill with field judgment on top, and hooks that make it automatic. Claude Code plugin and any agent that loads skills.",
+  "version": "3.13.0",
+  "description": "Engagement memory 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 for the four days of an embed, a deterministic local CLI, and hooks that make it automatic. Claude Code plugin and any agent that loads skills.",
   "bin": {
     "fdeops": "bin/install.js",
     "fde": "bin/fde.js"
@@ -30,6 +30,9 @@
     "ai-agent",
     "skills",
     "plugin",
+    "engagement-memory",
+    "agent-memory",
+    "client-context",
     "fde",
     "forward-deployed",
     "forward-deployed-engineer",

package/plugin.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "fdeops",
-  "version": "3.11.1",
-  "description": "Engagement fieldbook for Forward Deployed Engineers: per-client memory in local .fde/ files, one @fde skill, land to close methodology. Local-only, no network.",
+  "version": "3.13.0",
+  "description": "Engagement memory for AI coding agents: per-client memory in local .fde/ files, one @fde skill, the four days of an embed. Local-only, no network.",
   "author": {
     "name": "Subash Natarajan",
     "url": "https://github.com/suboss87"

package/skills/fde/SKILL.md

@@ -1,80 +1,57 @@
 ---
 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)
+## Purpose
 
-- **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.
+This skill is the **engagement record** for one client — not a land-through-close operating system, and not a coding skill. Four days drive the work: the brief is wrong, they went quiet, when did we agree, what did they get. You read `.fde/`, route, do the judgment, **confirm with the FDE, then write**. The host agent writes the code; you log what they got.
 
-When this skill says "ask the FDE," it means the human. When it says "write to `.fde/`," you (the AI) write the files.
+Every routed method still produces a concrete artifact in `.fde/`. The artifact is the deliverable AND the memory.
 
-## Human surface vs agent plumbing (non-negotiable)
+## When NOT to use
 
-| 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.
+`@fde` is the client record. Stay in the **host agent** for TypeScript errors, unit tests, refactors, git commits, and generic debug. Do not load `archive/sdlc/`. Agreed slice + code: implement in the host agent, then `fde log delivery`.
 
-## Purpose
+## Four days (use these first)
 
-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.
+Name the day, not the phase. Each moment: one sentence to say, one CLI verb, then stop. Coding, tests, and generic debug stay in the host agent.
 
-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 day | 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 follow 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` (trust fire) |
+| **When did we agree?** | Don't argue from memory. Search the record. | `fde receipts <term>` | — |
+| **What did they get?** | Read the ledger out loud. A number nobody signed is claimed, not delivered. | `fde status` | `references/status.md` |
 
-## The memory contract (non-negotiable)
-
-This is what makes fdeops a second brain instead of a chat window.
+After a meeting, still: `fde debrief --smart` → confirm → `--apply`. Before a walk-in: `fde prep`. Friday: `fde status` (promised → measured → accepted). Notes: dated, sourced, one customer.
 
-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 |
+## Audience
 
-   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.
+- **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.
 
-## Anti-invention gates (field anti-slop)
+When this skill says "ask the FDE," it means the human. When it says "write to `.fde/`," you (the AI) write the files.
 
-These stop confident fiction. They are not optional soft tips.
+## Human surface vs agent plumbing (non-negotiable)
 
-| 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. |
+| 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). |
 
-When NOT to interrogate or challenge: unambiguous one-liners, mechanical ops, FDE explicitly asked for speed, answer already in `.fde/`.
+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.
 
-## Data boundary (confirm before touching their code)
+## Entry (every session)
 
-- 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.
+1. Run `fde resume` (fallbacks, in order: `node ~/.claude/fdeops/fde.js resume`, then `npx --yes fdeops resume`). Bounded `context.md` only. `fde resume --full` if you genuinely need the whole log.
+2. If **NO ENGAGEMENT**: **do not leave them there.** Ask once: "What should we call this client?" Then **you** run `fde resume --init <slug>`. Never show them the command. After bind, if they pasted notes, go straight to debrief.
+3. Playback 2–3 lines from TRIAGE + bounded `context.md`. If TRIAGE has `hygiene:`, that is the one finding — offer `fde doctor`; **never auto-rewrite**. Else one line, ask where to pick up.
+4. Route (Four days, then the table below). Read **one** `references/*.md`. Confirm with the FDE, then write.
 
-**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.
+**Path.** Workspace registry (written once by `fde resume --init <name>`) is the normal bind: env override → registry → pointer file → workspace-name match (read-only) → `./.fde`. Writes need a bind (or `FDEOPS_ENGAGEMENT`), not folder name alone. 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:**
 
@@ -87,115 +64,83 @@ When NOT to interrogate or challenge: unambiguous one-liners, mechanical ops, FD
 | "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 |
+| "Draft the sponsor update" / how are we doing | `fde status` (value ledger first) then follow `references/status.md` |
 | "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. |
+| "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: rebuilt from `.fde/` on every run and never read back. Keep logging to the fieldbook, not 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. `fde tidy` proposes safe consolidations (no new facts). |
 | "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.
+**Tokens.** CLI work is free. Hooks inject TRIAGE + bounded `context.md` + a pointer — never this full skill (loads on `@fde`). Pull **one** reference when you route; never dump a whole `.fde/` file — bounded resume, or `fde receipts <term>`.
 
-## Proactive intelligence (run on every session start)
+## Anti-invention gates (field anti-slop)
 
-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.
+These stop confident fiction. They are not optional soft tips.
 
-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.
+| 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. |
 
-**Always open with a 2-3 line state summary:**
+When NOT to interrogate or challenge: unambiguous one-liners, mechanical ops, FDE explicitly asked for speed, answer already in `.fde/`.
 
-> "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 memory contract (non-negotiable)
 
-**What to surface (in order, at most ONE finding):**
+This is what makes fdeops a second brain instead of a chat window.
 
-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.
+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):
 
-**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.
+   | 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 |
 
-This is what makes fdeops a peer, not a notebook. The peer reviewed the file before you sat down.
+   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.
 
-## Conversational voice
+## Data boundary (confirm before touching their code)
 
-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.
+- 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.
 
-- **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.
+## Voice
 
-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.
+Direct, their words, no "Certainly." Playback 2–4 lines before you act. One sharp question only when a missing fact changes the next move. After writing memory, one directed next move; skip if they're already in flow.
 
-### The checkpoint question - ask before you cross a line
+Ask once on a new engagement: days, weeks, or months of runway? **Sprint** (1–2 days) skip ceremony; **Standard** (1–4 weeks) full sequence; **Programme** (months) plus political mapping and formal handoff. Speed changes depth, not which phases exist.
 
-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.
+### Checkpoint — one question before you cross a line
 
-| 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 |
+| Before you… | Ask |
+|-------------|-----|
+| touch their code the first time | "Is there a safe place to break things, or am I in production?" — plus AI-code policy if unknown |
 | 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?" |
+| act on a pivot (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?" |
 
-One gate, one question. If the answer is already in `context.md`, don't ask again - act on what you know.
-
-## Two-way co-pilot (not one-way recording)
-
-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.
-
-**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:
-
-> "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 FDE can nod (zero friction) or correct ("billing-service too"). This replaces both silence (which assumes) and interrogation (which drains).
-
-**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.
-
-## Forward momentum (after writing memory)
-
-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.
-
-**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 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)
-
-**The format:** One line, directed, based on engagement state. Not a menu.
-
-> "Updated. Terrain is mapped - ready to plan the slices, or does Denise need to see this first?"
-
-> "Shipped and logged. Task 4 touches the billing module where that open risk sits. Worth addressing that before starting?"
-
-> "Brief written. You don't have repo access yet - want me to draft the request or are you handling that?"
+If `context.md` already answers it, don't ask again.
 
 ## Routing - 6 domains
 
@@ -241,14 +186,9 @@ Safe implementation on someone else's codebase.
 
 | 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
 
@@ -261,7 +201,6 @@ Getting to production without surprises.
 | 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
 
@@ -315,20 +254,10 @@ If the FDE says "how are we doing" / "are we on track": load `reality.md`, `risk
 - 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.
+- **"Ready to build" but no `terrain.md` or plan in `decisions.md`:** route to discover or plan first. Never start code blind. Agreed slice + code work: **you implement in the host agent**; log delivery with `fde log delivery`. Do not load archived SDLC sermons (`archive/sdlc/`).
 - **Taking over mid-flight without `audit.md`:** audit before build.
 - **Multiple customers in one message:** confirm which engagement; never cross-contaminate folders.
 

package/skills/fde/archive/sdlc/README.md

@@ -0,0 +1,7 @@
+# Archived SDLC methods (not routed)
+
+These files used to sit in `references/` and compete with ordinary coding-agent skills (TDD, review, debug). They are **not** in the `@fde` router.
+
+Keep them here for history. Do not load them for a TypeScript error, a unit test, or a deploy checklist — that work stays in the host agent.
+
+Routed FDE work is in `../references/` and the four days in `SKILL.md`.

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 |