fdeops 3.9.5 → 3.9.6

package/README.md

@@ -7,7 +7,7 @@
 [![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)
 
-CLI + one `@fde` skill + hooks over a local `.fde/` fieldbook - one folder per client. The **second brain for Forward Deployed Engineers** - engineers embedded at a client, from first meeting to final handoff. Works the same for consultants, agency developers, solutions architects, and fractional CTOs.
+One `@fde` skill over a local client notebook (the **fieldbook** under `.fde/`) - one folder per client. The **second brain for Forward Deployed Engineers** - engineers embedded at a client, from first meeting to final handoff. Works the same for consultants, agency developers, solutions architects, and fractional CTOs.
 
 ```
   land      discover      plan      build      ship      close
@@ -17,25 +17,23 @@ CLI + one `@fde` skill + hooks over a local `.fde/` fieldbook - one folder per c
              written as a side effect of the work
 ```
 
-**Glossary:** **fieldbook** = the `.fde/` folder · **TRIAGE** = trust + phase + next from memory · **receipts** = dated search of what you logged · **hooks** = auto load/capture at session start/end.
-
-Describe your situation - `@fde` routes to the right method and writes the matching `.fde/` artifact. Phase methods (land → close) live in the skill; the CLI owns scan, memory, and receipts. You still confirm judgment - the fieldbook does not maintain itself without you.
+**You talk in plain language with `@fde`.** The agent (and an optional CLI) handles the boring memory work. You still confirm anything that goes into the record.
 
 ---
 
 ## The week
 
-What you actually run most days - the habit that compounds the fieldbook:
+Day to day you only need `@fde` and normal English. No command cheat sheet.
 
-| When | What you do | Why it matters |
-|------|-------------|----------------|
-| **Monday** | Open your AI coding agent → TRIAGE loads (trust, phase, next) | Start where last week left off - no re-paste |
-| **After a meeting** | `fde debrief --smart notes.txt` → review → `--apply` | Messy notes become dated decisions, risks, contacts |
-| **Before a walk-in** | `fde prep "Denise sync"` | Walk in with memory, not a blank chat |
-| **Scope fight** | `fde receipts descope` (+ memory git hash) | Answer "when did we agree?" from the record |
-| **Friday** | `fde status` → sponsor update from the real record | Status from evidence, not memory theater |
+| When | What you say | What you get |
+|------|--------------|--------------|
+| **Start of week** | Open your AI coding agent (nothing to paste) | It already knows where you left off - trust, phase, what's next |
+| **After a meeting** | `@fde` debrief these notes *(paste or attach them)* | Proposed updates to the record - you review, then confirm |
+| **Before a stakeholder meeting** | `@fde` prep me for tomorrow's meeting with the sponsor | A short brief from what you already logged - not a blank chat |
+| **Someone disputes scope** | `@fde` when did we agree to drop that feature? | Dated answers from the record (or a clear gap if nothing was logged) |
+| **End of week** | `@fde` draft the sponsor update from the record | Status grounded in what actually happened |
 
-Same engagement folder every time (`~/fde-engagements/<client>/.fde/`). Git versions it. Your AI coding agent reads it on every session.
+Same client folder every time (`~/fde-engagements/<client>/.fde/`). Your AI coding agent reads it on every session. Optional terminal tools live under [Under the hood](#under-the-hood-optional).
 
 ---
 
@@ -52,25 +50,25 @@ npx skills add suboss87/fdeops          # Cursor, Codex, and skills-compatible a
 /plugin install fdeops@fdeops
 ```
 
-**2. Bind** - once, inside the client workspace:
+**2. Bind once** - inside the client workspace (setup only; not a daily habit):
 
 ```bash
 npx fdeops resume --init garvey   # creates ~/fde-engagements/garvey engagement + binds workspace
 ```
 
-**Verify:**
+**Check it worked:**
 
 ```bash
-npx fdeops resume                 # should print TRIAGE (trust, phase, next) for garvey
+npx fdeops resume                 # prints a short "where we are" for this client
 ```
 
-**3. Work**
+**3. Work** - talk normally:
 
 ```text
 @fde I just got the brief. New client, payments platform, they want it live before their Q3 audit.
 ```
 
-`@fde` routes and writes `.fde/` artifacts - you confirm judgment. Use `npx fdeops …` until you want a short command: `npm i -g fdeops` (optional). Full workflow: [docs/USAGE.md](docs/USAGE.md).
+`@fde` routes and updates the fieldbook - you confirm judgment. Full workflow: [docs/USAGE.md](docs/USAGE.md).
 
 <details>
 <summary><strong>Other install paths</strong> · scan · env</summary>
@@ -88,14 +86,11 @@ npx fdeops resume                 # should print TRIAGE (trust, phase, next) for
 
 ## How it works
 
-Three pieces on top of the fieldbook:
-
-- **Session start** - a hook loads where you left off into your AI coding agent's context
-- **Session end** - a hook captures what happened back into the fieldbook
-- **`@fde`** - routes your situation to a field method; you confirm before memory sticks
-- **CLI** - deterministic, offline (`scan`, `debrief`, `prep`, `receipts`, `status`)
+- **You** describe the situation with `@fde` (or plain language once the skill is loaded)
+- **Session start / end** - small hooks load where you left off and capture what changed (no re-paste)
+- **Under the hood** - a local CLI does memory writes, search, and status with no model tokens; you do not need to learn it for daily use
 
-fdeops complements repo memory: CLAUDE.md holds how the *code* works; the fieldbook holds how the *engagement* works.
+fdeops complements repo memory: CLAUDE.md holds how the *code* works; the fieldbook holds how the *client engagement* works.
 
 Works with **Claude Code** · **Cursor** · **Copilot** · **Gemini CLI** · **Ollama** · **LM Studio** - any model that reads markdown.
 
@@ -134,41 +129,50 @@ Every entry is dated and sourced, so you can defend it in front of skeptical sta
 
 ---
 
-## The CLI
+## Under the hood (optional)
+
+**You do not need to learn these for daily work.** Chat with `@fde`; the agent runs the local tools. The list below is for setup, air-gap, or if you prefer the terminal.
 
-Commands that match **The week** (skill adds judgment on top):
+**Humans only need (once / occasional):**
 
 ```bash
-fde resume                        # TRIAGE + load this workspace's engagement
-fde resume --init <client>        # create + bind + git-version .fde/
-fde debrief --smart notes.md      # propose routing → --apply to confirm
-fde prep "Denise sync"            # walk-in brief from existing memory
-fde receipts <term>               # dated search (gap ≠ proof of absence)
-fde status                        # sponsor-ready triage (--all for portfolio)
-fde scan                          # day-1 recon + ASK ON DAY 1 (works via npx)
+npx fdeops resume --init <client>   # one-time: create + bind this workspace
+npx fdeops resume                   # check "where we are"
+npx fdeops scan                     # try day-1 recon with no install
+npx fdeops dashboard                # optional local HTML view of the fieldbook
 ```
 
+**What you say → what the agent runs** (you never have to type the right-hand side):
+
+| You say | Agent runs |
+|---------|------------|
+| Debrief these notes | `fde debrief --smart …` → you confirm → `--apply` |
+| Prep me for the sponsor meeting | `fde prep "…"` |
+| When did we agree to drop that? | `fde receipts …` |
+| Draft the sponsor update | `fde status` (+ judgment in chat) |
+| Log that the sponsor went quiet | `fde log contact "…" --signal amber` |
+
 <details>
-<summary><strong>More commands</strong></summary>
+<summary><strong>Full command list</strong> (power users / scripts)</summary>
 
 ```bash
-fde triage                        # TRIAGE only (hooks / Cursor entry)
-fde debrief notes.md              # prefix router: decision: / risk: / delivery: / contact:
-fde doctor                        # lint: stale signals, unset phase, gaps
+fde triage                        # short status (also injected by session hooks)
+fde debrief notes.md              # if notes already use decision: / risk: / … prefixes
+fde doctor                        # check the fieldbook for gaps
 fde log decision "…"
 fde log contact "…" --signal amber
-fde dashboard                     # FieldBook HTML (--all for every client)
+fde dashboard --all               # every client, sorted by trust
 ```
 
 Optional: `export FDEOPS_ENGAGEMENTS_ROOT=~/path/to/engagements` to isolate from `~/fde-engagements`.
 
-Each `.fde/` is a local git repo (no remote, no telemetry) - dated entries carry an author tag; every write commits so receipts are tamper-evident. Worst-of `[signal:...]` per stakeholder drives trust; signals older than 21 days show as stale.
+Each `.fde/` is a local git repo (no remote, no telemetry). More detail: [docs/USAGE.md](docs/USAGE.md).
 
 </details>
 
 <p align="center"><img src="media/terminal-demo.svg" alt="fde CLI - status, scan, dashboard" width="720"/></p>
 
-`fde dashboard` (FieldBook) renders the **current** engagement by default. Pass `--all` for every client sorted by trust:
+Optional FieldBook view (`fde dashboard`) - current engagement by default:
 
 <p align="center"><img width="1336" height="624" alt="fde dashboard FieldBook" src="https://github.com/user-attachments/assets/5683614c-7730-4a3a-860d-185053a377eb" /></p>
 

package/adapters/cursor.fde.mdc

@@ -9,10 +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 (new customer, mid-project takeover, production fire, quiet stakeholder, ready to ship), load the skill and route.
+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.
 
 - 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
 
@@ -20,7 +21,7 @@ Read and write engagement files under the workspace's bound engagement: run `fde
 
 **On every session entry (before other work):** run `fde triage` (fallback `node ~/.claude/fdeops/fde.js triage`, then `fde resume`). Lead with that TRIAGE block — trust, phase, open risks, next action, record owner/hash. Do not invent stakeholders or status.
 
-Use the CLI for deterministic work - `fde scan | log | debrief | prep | doctor | receipts | status | dashboard` - instead of improvising shell.
+You run the CLI for deterministic work - `fde scan | log | debrief | prep | doctor | receipts | status | dashboard` - instead of improvising shell or handing commands to the human.
 
 ### Meeting → memory loop
 - Messy notes: `fde debrief --smart notes.md` → review `.debrief-propose` → `fde debrief --apply`

package/bin/check.js

@@ -214,8 +214,21 @@ if (/\$\(cat\s+"\$BOOTSTRAP"\)|cat\s+"\$BOOTSTRAP"|cat\s+[^\n]*SKILL\.md/.test(h
 if (hookCode.includes('BOOTSTRAP=')) {
   fail('session-start must not resolve BOOTSTRAP skill path for inject')
 }
-if (!hook.includes('invoke @fde')) {
-  fail('session-start must include a lean @fde pointer (not full skill)')
+if (!/plain language with @fde|invoke @fde/.test(hook)) {
+  fail('session-start must include a lean @fde / plain-language pointer (not full skill)')
+}
+const skillBody = read('skills/fde/SKILL.md')
+if (!skillBody.includes('Human surface vs agent plumbing')) {
+  fail('SKILL.md must define human NL surface vs agent CLI plumbing')
+}
+if (!/never tell the FDE to type|Never tell the FDE to type|never ask the human to type fde/i.test(skillBody)) {
+  fail('SKILL.md must forbid asking the human to type fde commands')
+}
+if (!skillBody.includes('fde prep')) {
+  fail('SKILL.md must route walk-in prep to fde prep')
+}
+if (!skillBody.includes('debrief --smart')) {
+  fail('SKILL.md must prefer fde debrief --smart for messy notes')
 }
 if (!/\btriage\b/.test(hook)) {
   fail('session-start must still inject TRIAGE')

package/hooks/session-start

@@ -136,7 +136,7 @@ bounded_context() {
 CONTENT=""
 
 # Lean pointer only - never cat SKILL.md. Methods load on @fde / skill trigger.
-CONTENT="${CONTENT}fdeops: engagement fieldbook active. For field methods, invoke @fde (loads skills/fde/SKILL.md + one references/*.md). Plumbing is zero-token CLI: fde triage | resume | debrief | prep | receipts | status.\n\n"
+CONTENT="${CONTENT}fdeops: engagement fieldbook active. Human speaks plain language with @fde - you (the agent) run the local fde CLI for memory plumbing; never ask the human to type fde commands. Load skills/fde/SKILL.md when @fde triggers.\n\n"
 
 # Same TRIAGE block as `fde resume` / `fde triage` - Monday morning must not
 # depend on the model remembering to run a CLI command. Prefer the installed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fdeops",
-  "version": "3.9.5",
+  "version": "3.9.6",
   "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.",
   "bin": {
     "fdeops": "bin/install.js",

package/skills/fde/SKILL.md

@@ -1,17 +1,26 @@
 ---
 name: fde
-description: Second brain for Forward Deployed Engineers. One @fde router over field methods plus a local CLI for scan, memory, and receipts. Tell it your situation — it routes, does the work, and writes the engagement fieldbook.
+description: Second brain for Forward Deployed Engineers. The human describes the situation in plain language with @fde - you route, run the local fde CLI for memory plumbing, and write the fieldbook. Never ask the human to type fde commands.
 ---
 
 # @fde
 
 ## Audience (read this first)
 
-- **FDE** = the **human** who types `@fde` in the chat.
+- **FDE** = the **human** who types `@fde` (or plain language) in the chat.
 - **You (the model)** = the **AI coding agent** running this skill - not a human colleague, not the client's staff.
 
 When this skill says "ask the FDE," it means the human. When it says "write to `.fde/`," you (the AI) write the files.
 
+## Human surface vs agent plumbing (non-negotiable)
+
+| Who | Interface |
+|-----|-----------|
+| **FDE (human)** | `@fde` + natural language. Examples: "debrief these notes", "prep me for tomorrow's sponsor meeting", "when did we agree to drop that?", "draft the sponsor update". |
+| **You (agent)** | Run the local `fde` CLI for deterministic memory work. Never tell the FDE to type `fde …` (except if setup is missing - then **you** run `fde resume --init <name>` after one clarifying question). |
+
+If you catch yourself saying "run `fde debrief --smart notes.txt`" to the human - **stop**. Run it yourself (or write a temp notes file and run it), then show the human the result in plain language for confirm/reject.
+
 ## Purpose
 
 The single entry point for an entire client engagement. Field methods cover the FDE lifecycle (land through close, plus daily verbs and overlays). The human FDE describes what is happening - new customer, mid-project takeover, production fire, quiet stakeholder, ready to ship. You read the engagement memory, route to the right method, **do the work**, and leave the memory updated so the next session starts where this one ended.
@@ -36,6 +45,7 @@ These stop confident fiction. They are not optional soft tips.
 
 | Temptation | Gate |
 |------------|------|
+| Tell the FDE to run `fde debrief` / `fde prep` / `fde receipts` themselves | **Stop.** You run the CLI; they confirm results in plain language. |
 | Invent a stakeholder, meeting, or quote to make the narrative rich | **Stop.** Write `unknown - ask: <question>`. One fake name poisons every real citation. |
 | Route to a phase because it "feels senior" while the signal is muddy | **Stop.** Playback + one natural question, or name the ambiguity ("discover or rescue — leaning X because…"). |
 | Fill `success.md` / `terrain.md` with plausible defaults when the brief is thin | **Stop.** Run **brief interrogation** in land/discover (one Q + GUESS + confidence) until you can write without guessing, or leave gaps explicit. |
@@ -54,21 +64,22 @@ When NOT to interrogate or challenge: unambiguous one-liners, mechanical ops, FD
 
 **Engagement path - zero ceremony.** Run `fde resume` (fallback: `node ~/.claude/fdeops/fde.js resume`). 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.
 
-**The `fde` CLI does the deterministic work - use it instead of improvising shell:**
+**You run the `fde` CLI for deterministic work - never improvise shell, never hand the command to the FDE:**
 
-| Mechanics | Command |
-|-----------|---------|
-| Load/create engagement memory | `fde resume` (bounded) / `fde resume --full` / `fde resume --init <name>` |
-| Day-1 repo recon (facts + ASK ON DAY 1) | `fde scan` - then YOU interpret against the brief |
-| Structured memory appends | `fde log decision\|risk\|delivery\|contact "<text>"` - on `contact`, add `--signal green\|amber\|red` to write a `[signal:…]` token |
-| Meeting notes → memory | `fde debrief <file>` (or stdin) - `decision:`/`risk:`/`delivery:`/`contact:` prefixed lines route to their `.fde` file with dates; the rest lands as a dated block in `context.md` |
-| "What did we agree?" with dates | `fde receipts <term>` |
-| Portfolio across customers | `fde status` - trust from the latest dated `[signal:…]` token (stale after 21 days; keyword heuristic only as fallback); verify before acting |
-| Visual portfolio (one local page) | `fde dashboard` - renders `.fde/` → `fieldbook.html`, deterministic, 0 tokens |
+| When the FDE says (approx.) | You run |
+|-----------------------------|---------|
+| (session entry / where are we) | `fde resume` or use injected TRIAGE; `fde resume --init <name>` only if unbound |
+| Day-1 look at the repo | `fde scan` - then you interpret against the brief |
+| "Debrief these notes" / pastes meeting notes | Prefer `fde debrief --smart <notes>` → show propose → on confirm `fde debrief --apply`. Fallback: structure `decision:`/`risk:`/`delivery:`/`contact:` lines yourself, show FDE, then `fde debrief` |
+| "Prep me for the meeting with …" / walk-in brief | `fde prep "<short label>"` - present the brief in plain language; do not invent facts missing from `.fde/` |
+| "When did we agree…?" / scope dispute | `fde receipts <term>` - answer with dates; no hit = gap, not proof |
+| "Draft the sponsor update" / how are we doing | `fde status` then follow `references/status.md` for the narrative |
+| "Log that they went quiet" / trust signal | `fde log contact "…" --signal amber\|green\|red` (after FDE confirms the read) |
+| Want the HTML fieldbook | `fde dashboard` |
 
-**The debrief verb.** When the FDE shares meeting notes or a transcript, or says "debrief": structure the notes into lines prefixed `decision:` / `risk:` / `delivery:` / `contact:` (append `[signal:green|amber|red]` to a `contact:` line when the notes carry trust information), leave everything else unprefixed, **show the structured version to the FDE for confirmation**, then pipe it to `fde debrief`. Routing and dating are deterministic and cost zero tokens - your judgment is the structuring. Signal-reading guidance: `references/debrief.md`.
+**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). 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 missing → use the manual fallback commands inside each reference.
+CLI missing → use the manual fallbacks inside each reference (still you write files; still never ask the FDE to run setup).
 
 **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.
 
@@ -241,6 +252,7 @@ Running the engagement and ending it well.
 | Weekly update due, "need to send the sponsor something" | status | `references/status.md` |
 | Demo coming up, show-and-tell, exec walkthrough | demo-prep | `references/demo-prep.md` |
 | Just out of a meeting, raw notes, "they said…", "debrief" | debrief | the debrief verb (above) + `references/debrief.md` |
+| Prep me for a meeting / walk-in brief / "what should I know before I talk to…" | - | run `fde prep "<label>"`, present in plain language |
 | Sponsor's boss needs a summary, board update, justify continued investment | exec-narrative | `references/exec-narrative.md` |
 | Status across all my customers | dashboard | `references/dashboard.md` |
 | Juggling 2+ customers, losing track, context-switching | multi-customer-ops | `references/multi-customer-ops.md` |

package/skills/fde/references/debrief.md

@@ -1,36 +1,51 @@
 # debrief - capture the meeting before it evaporates
 
-**Enter when:** the FDE just left a meeting/call and dumps raw notes, a transcript, or "they said…". The highest-frequency moment in FDE life (3–5×/day). Capture within the hour - memory decays fast.
+**Enter when:** the FDE just left a meeting/call and dumps raw notes, a transcript, or "they said…". Highest-frequency moment in FDE life. Capture within the hour.
 
-**Read first:** `context.md`, `stakeholders.md` (to update signals against what's known).
+**Read first:** `context.md`, `stakeholders.md` (signals against what's known).
+
+**Who runs the CLI:** you (the agent). Never tell the FDE to type `fde debrief …`.
 
 ## Method (you do this work)
 
-Take the raw dump exactly as given. Extract into five buckets - **only what was actually said**; rule 4 applies with full force here (no invented names, no embellished quotes):
+### Preferred path - smart debrief (messy notes)
+
+1. Save the FDE's notes to a temp `.md` file in the workspace (or pipe stdin).
+2. Run `fde debrief --smart <notes.md>` (or `npx fdeops debrief --smart …`).
+3. Show the **proposed** routing in plain language (what would become decisions, risks, contacts, etc.).
+4. On FDE confirm → run `fde debrief --apply`.
+5. On reject → stop; ask what to change; do not apply.
+
+No invented names or quotes. If the propose looks wrong, fix with judgment then re-propose or use the fallback path.
+
+### Fallback - you structure, then route
+
+If `--smart` is unavailable or the notes are already cleanly prefixed:
 
-1. **Decisions** - what was agreed, by whom, in their words where possible.
-2. **Action items** - owner + due date. Unowned actions get `owner: unknown - ask`.
-3. **Stakeholder signals** - tone shifts, hesitations, who went quiet, who pushed back, verbatim quotes that matter. Map each to green/amber/red movement *with the evidence*.
-4. **Risks** - new ones surfaced, old ones confirmed or retired.
-5. **Open questions** - what the FDE must chase before the next session.
+1. Extract into buckets - **only what was actually said**:
+   - **Decisions** - agreed, by whom, in their words where possible
+   - **Action items** - owner + due; unowned → `owner: unknown - ask`
+   - **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:` (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).
 
-Ambiguity in the dump → ask **one** clarifying question, then write. Never stall the capture on completeness.
+One clarifying question max if the dump is ambiguous - then write. Never stall capture on completeness.
 
-## Artifact (this IS the memory - write immediately)
+## Artifact
 
-- Decisions → `decisions.md` via `fde log decision "<text> (meeting: <who>, <date>)"` or direct append, dated and attributed.
-- Signal changes → `stakeholders.md`: update the signal column with evidence + date. A quote moves a signal; a vibe does not.
-- Risks → `risks.md`, dated.
-- Action items + open questions → `context.md` under "Next actions".
-- Sacred/sensitive things mentioned (data, systems, politics) → `trust-profile.md` if new.
+- Smart apply / debrief CLI writes the dated routes into the right `.fde/` files.
+- If you must write directly: decisions → `decisions.md`; signals → `stakeholders.md` Signal history; risks → `risks.md`; next actions → `context.md`. Prefer the CLI.
 
 ## Checkpoint
 
-Read back the 2–3 most consequential captures in one breath - "Logged: descope agreed with Dana; ops lead went amber (quote attached); CISO ticket now blocking" - so the FDE can correct on the spot. Then stop. No summary theatre.
+Read back the 2-3 most consequential captures in one breath - so the FDE can correct on the spot. Then stop. No summary theatre.
 
 ## Principles
 
-- Capture within the hour or lose the nuance forever.
-- The verbatim quote outranks the paraphrase. The hesitation outranks the quote.
-- Signals move on evidence, never on inference.
-- A meeting that produced no decisions and no actions - say so; that's a finding about the meeting.
+- Capture within the hour or lose the nuance.
+- Verbatim quote outranks paraphrase; hesitation outranks quote.
+- Signals move on evidence, never on vibe alone.
+- A meeting with no decisions and no actions - say so; that is a finding.