fdeops 3.5.6 → 3.7.0

package/bin/install.js

@@ -199,7 +199,7 @@ function cmdInstall() {
   console.log('    node bin/install.js init <engagement-name>')
   console.log('')
   console.log('  Example:')
-  console.log('    node bin/install.js init acme-payments')
+  console.log('    node bin/install.js init garvey-payments')
   console.log('  (npm 3.0.0+: npx fdeops@latest init <engagement-name>)')
   console.log('')
   console.log('  Use another AI tool (Cursor, Codex, Gemini CLI, Copilot)? Wire it up:')
@@ -210,11 +210,17 @@ function cmdInstall() {
   console.log('')
 }
 
+// `npx fdeops scan` must recon, not install - any fde subcommand passes straight
+// through to the CLI (fde.js reads process.argv itself, so require() is enough).
+const FDE_SUBCOMMANDS = ['scan', 'resume', 'log', 'debrief', 'receipts', 'capture', 'status', 'dashboard']
+
 const arg = process.argv[2]
 if (arg === 'init') {
   cmdInit(process.argv[3])
 } else if (arg === 'adapters') {
   cmdAdapters(process.argv[3])
+} else if (FDE_SUBCOMMANDS.includes(arg)) {
+  require(path.join(__dirname, 'fde.js'))
 } else {
   cmdInstall()
 }

package/hooks/pre-compact

@@ -11,8 +11,27 @@ resolve_engagement_dir() {
   return 1
 }
 
+# Workspace registry written by `fde resume --init` - mirrors resolveEngagement()
+# step 2 in bin/fde.js; keep the resolution order identical in bash and JS.
+# Lines are "<workspace-path> <slug>": the path may contain spaces, the slug
+# never does, so split on the LAST space (same as the JS lastIndexOf parse).
+registry_engagement_dir() {
+  local reg="$HOME/fde-engagements/.registry" slug
+  [ -f "$reg" ] || return 1
+  slug=$(awk 'BEGIN{ws=ENVIRON["PWD"]}
+    { i = match($0, / [^ ]*$/)
+      if (i > 0 && substr($0, 1, i - 1) == ws) { print substr($0, i + 1); exit } }' "$reg" 2>/dev/null)
+  [ -z "$slug" ] && return 1
+  [ -d "$HOME/fde-engagements/$slug/.fde" ] && printf '%s\n' "$HOME/fde-engagements/$slug/.fde" && return 0
+  return 1
+}
+
 ENG_DIR=$(resolve_engagement_dir "${FDEOPS_ENGAGEMENT:-${FDEOS_ENGAGEMENT:-}}")
 
+if [ -z "$ENG_DIR" ]; then
+  ENG_DIR=$(registry_engagement_dir)
+fi
+
 if [ -z "$ENG_DIR" ] && [ -f "CLAUDE.md" ]; then
   ENG=$(grep -m1 '^FDEOPS_ENGAGEMENT=\|^FDEOS_ENGAGEMENT=' CLAUDE.md 2>/dev/null | cut -d= -f2-)
   ENG_DIR=$(resolve_engagement_dir "$ENG")

package/hooks/session-start

@@ -23,27 +23,48 @@ resolve_engagement_dir() {
   return 1
 }
 
+# Workspace registry written by `fde resume --init` - mirrors resolveEngagement()
+# step 2 in bin/fde.js; keep the resolution order identical in bash and JS.
+# Lines are "<workspace-path> <slug>": the path may contain spaces, the slug
+# never does, so split on the LAST space (same as the JS lastIndexOf parse).
+registry_engagement_dir() {
+  local reg="$HOME/fde-engagements/.registry" slug
+  [ -f "$reg" ] || return 1
+  slug=$(awk 'BEGIN{ws=ENVIRON["PWD"]}
+    { i = match($0, / [^ ]*$/)
+      if (i > 0 && substr($0, 1, i - 1) == ws) { print substr($0, i + 1); exit } }' "$reg" 2>/dev/null)
+  [ -z "$slug" ] && return 1
+  [ -d "$HOME/fde-engagements/$slug/.fde" ] && printf '%s\n' "$HOME/fde-engagements/$slug/.fde" && return 0
+  return 1
+}
+
 # 1) Environment variable (any agent)
 if [ -z "$CONTEXT_FILE" ]; then
   ENG_DIR=$(resolve_engagement_dir "${FDEOPS_ENGAGEMENT:-${FDEOS_ENGAGEMENT:-}}")
   [ -n "$ENG_DIR" ] && CONTEXT_FILE="$ENG_DIR/context.md"
 fi
 
-# 2) Project CLAUDE.md
+# 2) Workspace registry binding (written by fde resume --init)
+if [ -z "$CONTEXT_FILE" ]; then
+  ENG_DIR=$(registry_engagement_dir)
+  [ -n "$ENG_DIR" ] && CONTEXT_FILE="$ENG_DIR/context.md"
+fi
+
+# 3) Project CLAUDE.md
 if [ -z "$CONTEXT_FILE" ] && [ -f "CLAUDE.md" ]; then
   ENG=$(grep -m1 '^FDEOPS_ENGAGEMENT=\|^FDEOS_ENGAGEMENT=' CLAUDE.md 2>/dev/null | cut -d= -f2-)
   ENG_DIR=$(resolve_engagement_dir "$ENG")
   [ -n "$ENG_DIR" ] && CONTEXT_FILE="$ENG_DIR/context.md"
 fi
 
-# 3) Global fdeops pointer file
+# 4) Global fdeops pointer file
 if [ -z "$CONTEXT_FILE" ] && [ -f "$HOME/.claude/FDEOPS-CLAUDE.md" ]; then
   ENG=$(grep -m1 '^FDEOPS_ENGAGEMENT=\|^FDEOS_ENGAGEMENT=' "$HOME/.claude/FDEOPS-CLAUDE.md" 2>/dev/null | cut -d= -f2-)
   ENG_DIR=$(resolve_engagement_dir "$ENG")
   [ -n "$ENG_DIR" ] && CONTEXT_FILE="$ENG_DIR/context.md"
 fi
 
-# 4) Optional in-repo .fde (customer-approved only)
+# 5) Optional in-repo .fde (customer-approved only)
 if [ -z "$CONTEXT_FILE" ] && [ -f ".fde/context.md" ]; then
   CONTEXT_FILE=".fde/context.md"
 fi

package/hooks/session-stop

@@ -19,24 +19,44 @@ resolve_engagement_dir() {
   return 1
 }
 
+# Workspace registry written by `fde resume --init` - mirrors resolveEngagement()
+# step 2 in bin/fde.js; keep the resolution order identical in bash and JS.
+# Lines are "<workspace-path> <slug>": the path may contain spaces, the slug
+# never does, so split on the LAST space (same as the JS lastIndexOf parse).
+registry_engagement_dir() {
+  local reg="$HOME/fde-engagements/.registry" slug
+  [ -f "$reg" ] || return 1
+  slug=$(awk 'BEGIN{ws=ENVIRON["PWD"]}
+    { i = match($0, / [^ ]*$/)
+      if (i > 0 && substr($0, 1, i - 1) == ws) { print substr($0, i + 1); exit } }' "$reg" 2>/dev/null)
+  [ -z "$slug" ] && return 1
+  [ -d "$HOME/fde-engagements/$slug/.fde" ] && printf '%s\n' "$HOME/fde-engagements/$slug/.fde" && return 0
+  return 1
+}
+
 ENG_DIR=""
 
 # 1) Environment variable (any agent)
 ENG_DIR=$(resolve_engagement_dir "${FDEOPS_ENGAGEMENT:-${FDEOS_ENGAGEMENT:-}}")
 
-# 2) Project CLAUDE.md
+# 2) Workspace registry binding (written by fde resume --init)
+if [ -z "$ENG_DIR" ]; then
+  ENG_DIR=$(registry_engagement_dir)
+fi
+
+# 3) Project CLAUDE.md
 if [ -z "$ENG_DIR" ] && [ -f "CLAUDE.md" ]; then
   ENG=$(grep -m1 '^FDEOPS_ENGAGEMENT=\|^FDEOS_ENGAGEMENT=' CLAUDE.md 2>/dev/null | cut -d= -f2-)
   ENG_DIR=$(resolve_engagement_dir "$ENG")
 fi
 
-# 3) Global fdeops pointer file
+# 4) Global fdeops pointer file
 if [ -z "$ENG_DIR" ] && [ -f "$HOME/.claude/FDEOPS-CLAUDE.md" ]; then
   ENG=$(grep -m1 '^FDEOPS_ENGAGEMENT=\|^FDEOS_ENGAGEMENT=' "$HOME/.claude/FDEOPS-CLAUDE.md" 2>/dev/null | cut -d= -f2-)
   ENG_DIR=$(resolve_engagement_dir "$ENG")
 fi
 
-# 4) Optional in-repo .fde (customer-approved only)
+# 5) Optional in-repo .fde (customer-approved only)
 if [ -z "$ENG_DIR" ] && [ -d ".fde" ]; then
   ENG_DIR=".fde"
 fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fdeops",
-  "version": "3.5.6",
+  "version": "3.7.0",
   "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

@@ -26,7 +26,7 @@ This is what makes fdeops a second brain instead of a chat window.
 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:** before the session ends, append three lines to `context.md`: where we are, what changed today, the next step. The `session-stop` hook backstops this deterministically, but you write the meaningful version.
+5. **On exit:** before the session ends, append three lines to `context.md`: where we are, what changed today, the next step. The `session-stop` hook backstops this deterministically (hooks resolve the engagement through the workspace registry - no env var needed), but you write the meaningful version.
 6. **One customer, one folder.** Never merge two engagements into one `.fde/`. Confirm which engagement applies when multiple exist.
 
 ## Data boundary (confirm before touching their code)
@@ -37,19 +37,22 @@ This is what makes fdeops a second brain instead of a chat window.
 - Data tagged `<private>` in `trust-profile.md` (sacred data, PHI, cardholder, classified) **never enters your context or any subagent prompt** - work around it, never with it.
 - Locked-down engagement (no AI on their code)? Use the CLI + the fieldbook only. The memory layer is the FDE's own notes, not customer code.
 
-**Engagement path - zero ceremony.** Run `fde resume` (fallback: `node ~/.claude/fdeops/fde.js resume`). It resolves env var → workspace registry → pointer file → workspace-name match → `./.fde`, and 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 FDE never runs setup commands. Never install fdeops on infrastructure the FDE does not control.
+**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 → `./.fde`. 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:**
 
 | Mechanics | Command |
 |-----------|---------|
 | Load/create engagement memory | `fde resume` (bounded) / `fde resume --full` / `fde resume --init <name>` |
-| Day-1 repo recon (facts) | `fde scan` - then YOU interpret against the brief |
-| Structured memory appends | `fde log decision\|risk\|delivery\|contact "<text>"` |
+| 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` - heuristic triage; verify before acting |
+| 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 |
 
+**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`.
+
 CLI missing → use the manual fallback commands inside each reference.
 
 **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`. 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.
@@ -60,7 +63,7 @@ After loading `context.md` via `fde resume`, run a quick integrity scan and open
 
 **Always open with a 2-3 line state summary:**
 
-> "Last session you shipped the payment retry slice. Plan is 3/5 tasks done. Diana saw the demo Tuesday - signal is green. One thing worth noting: [finding, or 'nothing flagged - where do you want to pick up?']"
+> "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?']"
 
 **What to scan (in order, surface only what matters):**
 
@@ -124,7 +127,7 @@ The FDE can nod (zero friction) or correct ("billing-service too"). This replace
 - 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. A 20-year FDE peer doesn't ask "are you sure?" - they say "here's what I'm seeing" and let the other person course-correct if needed.
+**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.
 
@@ -144,14 +147,12 @@ After updating `.fde/` artifacts, suggest the ONE next move that accelerates the
 
 **The format:** One line, directed, based on engagement state. Not a menu.
 
-> "Updated. Terrain is mapped - ready to plan the slices, or does Diana need to see this first?"
+> "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?"
 
-The suggestion should feel like a colleague who sees the board and says "hey, this would be faster if..." - not a system prompting for the next input.
-
 ## Routing - 6 domains, 35 skills
 
 Route on what you hear, then **read the skill reference from this skill's `references/` directory and follow its method**. Do not improvise from memory - the method is the product.
@@ -224,7 +225,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 | `references/debrief.md` |
+| Just out of a meeting, raw notes, "they said…", "debrief" | debrief | the debrief verb (above) + `references/debrief.md` |
 | 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/multi-customer-ops.md

@@ -12,9 +12,9 @@ The solo FDE running three customers simultaneously is the norm, not the excepti
 
 ```
 ~/fde-engagements/
-  acme-corp/.fde/         ← Acme's engagement memory
-  globex/.fde/            ← Globex's engagement memory
-  initech/.fde/           ← Initech's engagement memory
+  garvey-payments/.fde/    ← Garvey's engagement memory
+  kesterman-freight/.fde/  ← Kesterman's engagement memory
+  rennick-health/.fde/     ← Rennick's engagement memory
 ```
 
 **Never:**
@@ -32,11 +32,11 @@ Cross-contamination is the fastest way to lose two engagements at once.
 
 | Customer | Trust signal | Top risk | Today's action | Time budget |
 |----------|-------------|----------|---------------|-------------|
-| Acme | green | Migration deadline Fri | Finish data mapping, send status | 4h |
-| Globex | AMBER | Sponsor went quiet Tue | Proactive conversation TODAY | 2h |
-| Initech | green | None active | Build slice 3, push PR | 2h |
+| Garvey | green | Canary blocked on their security ticket | Chase ticket, prep ship checklist | 4h |
+| Kesterman | AMBER | Sponsor went quiet Tue | Proactive conversation TODAY | 2h |
+| Rennick | green | None active | Build slice 3, push PR | 2h |
 
-Priority order: Globex (amber trust), Acme (deadline), Initech (steady)
+Priority order: Kesterman (amber trust), Garvey (deadline), Rennick (steady)
 ```
 
 **3. The triage rules.** In order of priority:
@@ -60,7 +60,7 @@ BEFORE STARTING CUSTOMER B:
   1. Run: fde resume (loads Customer B's engagement)
   2. Read context.md - where did we leave off?
   3. Confirm: what's the one thing to accomplish in this block?
-  4. Set a time boundary (e.g., "2 hours on Globex, then back to Acme")
+  4. Set a time boundary (e.g., "2 hours on Kesterman, then back to Garvey")
 ```
 
 The 3-line context update is the bridge. Without it, the next session starts with "what was I doing?" - that's 20 minutes of re-discovery each time.

package/skills/fde/references/red-team.md

@@ -34,7 +34,7 @@ You are not a helpful peer right now. You are the skeptical senior who has seen
 | **Second-order** | If this succeeds, what new problem does it create? Who notices? |
 
 **4. Deliver the hits.** Three rules:
-- **Specific, not generic.** Not "have you considered stakeholder alignment?" but "Robert Tanaka hasn't signed off on the compliance scope change and he reports to Diana's boss - what happens when he raises it in the Thursday meeting?"
+- **Specific, not generic.** Not "have you considered stakeholder alignment?" but "Robert Tanaka hasn't signed off on the compliance scope change and he reports to Denise's boss - what happens when he raises it in the Thursday meeting?"
 - **Grounded in their data.** Use names, dates, and facts from the `.fde/` files. If `risks.md` says something is CRITICAL and `delivery.md` shows no mitigation logged, say so.
 - **One at a time.** Deliver a challenge. Wait for the response. Then the next. A barrage overwhelms; a sequence sharpens.
 
@@ -57,13 +57,13 @@ EXPOSED  - no answer, no plan, this will hurt them in the room
 The red-team adapts to what's being tested:
 
 ### Pre-meeting red-team
-The FDE is about to walk into a sponsor meeting, accumulation conversation, or exec presentation. Attack their talking points, their data, their ask. "If Diana says 'why should I keep paying for this when nothing shipped last week,' what are your first three words?"
+The FDE is about to walk into a sponsor meeting, accumulation conversation, or exec presentation. Attack their talking points, their data, their ask. "If Denise says 'why should I keep paying for this when nothing shipped last week,' what are your first three words?"
 
 ### Pre-ship red-team
 About to deploy, hand off, or mark complete. Attack the readiness. "It's 2am, the batch job fails, you're on a flight. Who fixes it? Show me the runbook they'll actually open. What's the first command?"
 
 ### Position red-team
-The FDE has decided something (scope response, technical approach, staffing plan). Attack the decision. "You're saying no to the reporting module. Diana asked for it personally. What happens to trust when you say no? What's your alternative offer?"
+The FDE has decided something (scope response, technical approach, staffing plan). Attack the decision. "You're saying no to the reporting module. Denise asked for it personally. What happens to trust when you say no? What's your alternative offer?"
 
 ### Brief red-team
 Day 1 or early discovery. Attack the brief itself. "This brief says 'migrate COBOL to Java.' That's a solution, not a problem. What's the actual problem? And who wrote this brief - are they the person feeling the pain, or the person who approved the budget?"

package/README.md.bak

@@ -1,227 +0,0 @@
-# fdeops
-
-[![npm version](https://img.shields.io/npm/v/fdeops)](https://www.npmjs.com/package/fdeops)
-[![CI](https://github.com/suboss87/fdeops/actions/workflows/validate.yml/badge.svg)](https://github.com/suboss87/fdeops/actions)
-[![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)
-
-You embed at a client site. You bridge strategy and code. You ship on their systems, not yours.
-
-Every morning you open your AI coding agent, and it has no idea what happened yesterday. You re-paste the same context. You explain the stakeholders again. You remind it about the scope change from Tuesday. Meanwhile, the real problem - the one the brief didn't mention - sits undiscovered because nobody asked the right questions on day one.
-
-**fdeops fixes this.** It gives your AI agent a complete engagement methodology and a private memory that writes itself. You type `@fde`, describe your situation, and the right method runs - from first stakeholder meeting to final handoff. Tomorrow's session starts exactly where today ended.
-
-```mermaid
-flowchart LR
-    A["@fde"] --> B{"Describe\nyour situation"}
-    B --> C["Embed & Trust"]
-    B --> D["Discover & Diagnose"]
-    B --> E["Plan & Align"]
-    B --> F["Build & Guard"]
-    B --> G["Ship & Verify"]
-    B --> H["Operate & Close"]
-    C --> I[".fde/ memory\n(written as you work)"]
-    D --> I
-    E --> I
-    F --> I
-    G --> I
-    H --> I
-    I --> J["Next session\nloads automatically"]
-```
-
-Works with **Claude Code** · **Cursor** · **Copilot** · **Devin** · **Gemini CLI** · **Ollama** · **LM Studio** · any model that reads SKILL.md
-
-<p align="center"><strong>The CLI</strong></p>
-<p align="center"><img src="media/terminal-demo.svg" alt="fde CLI - status, scan, dashboard" width="720"/></p>
-
-<p align="center"><strong>The Fieldbook Dashboard</strong></p>
-<p align="center"><img src="media/fieldbook-dashboard.png" alt="FDE Fieldbook - portfolio view" width="720"/></p>
-
----
-
-## Who this is for
-
-| You are... | fdeops helps when... |
-|----------|-------------------|
-| **Consultant or contractor at a client site** | Every session, you re-explain context. fdeops remembers for you. |
-| **Solutions architect bridging strategy and code** | You navigate politics AND architecture. fdeops has methods for both. |
-| **Agency engineer running 3-5 clients** | Client details blur together. One `.fde/` per customer, never cross-contaminated. |
-| **Forward Deployed Engineer** | The role this was built for. 35 skills across the full engagement lifecycle. |
-| **Technical founder doing client work solo** | You ARE the team. The agent becomes your second brain. |
-| **Enterprise programme lead** | Leading AI transformations? Built-in methods for model selection, agent safety, governance, and cost management. |
-
----
-
-## Without fdeops vs with fdeops
-
-| | **Without fdeops** | **With fdeops** |
-|---|-------------------|----------------|
-| **Monday morning** | Re-paste last week's context, explain the stakeholders again | Agent opens with "last session you were on the ingest retry - CTO demo is Friday" |
-| **Scope creep** | Five "small" additions absorbed silently, timeline slips | Receipts timestamped - you walk into the sponsor meeting with evidence |
-| **Multiple customers** | Wrong client name in a status update, details blur | One folder per customer, context-switch protocol, cross-contamination checklist |
-| **The sponsor meeting** | "We completed the API endpoint" | "Manual reconciliation dropped from 3 FTEs to 0.5 - here's the rollback if it turns" |
-
----
-
-## Quickstart
-
-**Requires:** [Node.js](https://nodejs.org) >= 18
-
-### 1. Create your first engagement
-
-```bash
-npx fdeops init my-client   # creates engagement memory
-```
-
-This creates `~/fde-engagements/my-client/.fde/` with 12 memory files - your private engagement brain.
-
-### 2. Try the CLI (no AI needed)
-
-```bash
-cd ~/fde-engagements/my-client
-fde scan                              # instant repo recon (run from any git repo)
-fde log decision "Chose React over Vue for the dashboard"
-fde log risk "No staging environment for integration tests"
-fde receipts "React"                  # find what you logged, with dates
-fde status                            # portfolio view across all clients
-fde dashboard                         # offline HTML fieldbook - open in browser
-```
-
-These commands work without any AI model. Zero network. Zero tokens.
-
-### 3. Connect your AI agent
-
-```bash
-export FDEOPS_ENGAGEMENT=~/fde-engagements/my-client/.fde
-```
-
-Then in Claude Code, Cursor, Copilot, Gemini, or any agent:
-
-```
-@fde I'm on site. First stakeholder meeting tomorrow. Brief says fix the payments API.
-```
-
-The agent loads your engagement memory, routes to the right skill, and starts working with you - not from scratch. The memory compounds. You maintain nothing.
-
-> **Other install methods:** `npx skills add suboss87/fdeops` or `git clone && node bin/install.js`
-
----
-
-## Works with any AI coding tool
-
-One skill file powers every tool. Install adapters for your setup:
-
-```bash
-npx fdeops adapters ~/fde-engagements/my-client
-```
-
-| Tool | What it reads |
-|------|--------------|
-| Claude Code | Plugin + `~/.claude/FDEOPS-CLAUDE.md` |
-| Codex / OpenAI / generic | `AGENTS.md` |
-| Gemini CLI | `GEMINI.md` |
-| Cursor | `.cursor/rules/fde.mdc` |
-| GitHub Copilot | `.github/copilot-instructions.md` |
-| **Local LLMs** (Ollama, LM Studio, llama.cpp, vLLM) | Load `SKILL.md` as system prompt |
-
-Each adapter points at the same `@fde` skill, so the methodology and memory stay consistent across tools. Details: [`adapters/`](adapters/README.md).
-
-> **No cloud dependency.** fdeops calls no external API. The AI skill is a markdown file your model reads. The CLI is local Node.js. Works fully offline, fully air-gapped, fully private. See [`adapters/LOCAL-LLM.md`](adapters/LOCAL-LLM.md) for local model setup.
-
----
-
-## How it works
-
-```text
-  YOU (human)                         AI CODING AGENT (software)
-  meetings, judgment         @fde      routes -> right skill -> drafts the artifact
-        |                 ----->      .fde/ memory (written as you work)
-        |                                   |
-        +--------------->  client workspace (code, VPN, tickets)
-```
-
-1. **Describe** - tell the agent what's happening ("new client", "production is down", "need a board update")
-2. **Route** - the system picks the right skill from 34 options across 6 domains
-3. **Execute** - the skill's method runs, artifacts are written to `.fde/`, you review at checkpoints
-
----
-
-## The 6 domains - 35 skills + 5 overlays
-
-| Domain | Skills | What it covers |
-|--------|--------|---------------|
-| **Embed & Trust** | land, audit, stakeholder-radar, trust-engineering, scope-defense | First days: access, credibility, scope |
-| **Discover & Diagnose** | discover, assumption-audit, use-case-scoring, sketch | Finding the real problem behind the brief |
-| **Plan & Align** | plan, business-case, options-analysis, initiative-triage | Sequencing work, getting sponsor alignment |
-| **Build & Guard** | build, incremental-build, test-on-legacy, blast-radius, debug, rescue, security-audit, observability | Helping you build safely on their codebase |
-| **Ship & Verify** | ship, review, rollback-drill, qa-live | Getting to production without surprises |
-| **Operate & Close** | status, demo-prep, debrief, exec-narrative, dashboard, multi-customer-ops, close, handoff-engineering, pattern-extract, red-team | Running and ending the engagement well |
-
-**Overlays** activate automatically when your engagement involves AI projects, executive reporting, fintech, healthcare, or government compliance.
-
-Full skill details: [docs/skills-reference.md](docs/skills-reference.md)
-
----
-
-## Engagement memory (`.fde/`)
-
-Your **fieldbook** - one per client, private to you, plain markdown:
-
-| File | Role | Written by |
-|------|------|-----------|
-| `context.md` | Where you are; loaded first every session | every phase + session-stop hook |
-| `brief.md` | What they said - hypothesis until discover | land |
-| `success.md` | Done, measured, signed-off by whom | land |
-| `reality.md` | The real problem, with evidence | discover / audit |
-| `terrain.md` | Codebase map: hotspots, test gaps, AI components, data estate | discover / audit |
-| `stakeholders.md` | Champions, resistance, trust signals | land, updated continuously |
-| `trust-profile.md` | Sacred data, AI policy, approval chain | land + overlays |
-| `decisions.md` | Plan + choices + integration contracts + sizing | plan / build / review / rescue |
-| `risks.md` | Live risk register | all phases |
-| `delivery.md` | What shipped, business value, rollback, pulse, adoption metrics | build / ship |
-
-Every claim is tagged with its source and date so you can defend it in front of skeptical stakeholders.
-
----
-
-## The CLI
-
-These commands run locally on your machine. No AI needed, no API costs, works offline.
-
-```bash
-fde scan       # day-1 recon: hotspots, test gaps, "temporary" code, AI components, secrets
-fde resume     # initialize or resume an engagement
-fde log        # write decisions, risks, delivery, contacts
-fde receipts   # search memory with dates
-fde capture    # session-end snapshot
-fde status     # portfolio triage across all customers
-fde dashboard  # render every engagement into one offline dashboard
-```
-
----
-
-## Principles
-
-- **The artifact is the memory** - producing work and recording it are one action
-- **Trust before production** - earn the right to touch their systems
-- **Brief is a hypothesis** - discover before building the wrong thing
-- **Evidence on every claim** - these files get defended in front of skeptical clients
-- **Map before moving** - unknown terrain gets characterisation tests
-- **Thin slices** - ship learning, not theatre
-- **One customer, one folder** - context never bleeds
-
----
-
-## Updating
-
-```bash
-cd fdeops && git pull && node bin/install.js
-```
-
----
-
-## Contributing
-
-Maintained by **[Subash Natarajan](https://www.linkedin.com/in/subashn/)**. Feedback via [Issues](https://github.com/suboss87/fdeops/issues) - see [CONTRIBUTING.md](CONTRIBUTING.md).
-
-[FDE Methodology](FDE-METHODOLOGY.md) · [ATTRIBUTION.md](ATTRIBUTION.md) · [SECURITY.md](SECURITY.md) · [PRIVACY.md](PRIVACY.md) · [Repo layout](docs/REPO_LAYOUT.md) · [Skills reference](docs/skills-reference.md) · MIT