fdeops 3.5.0

package/AGENTS.md

@@ -0,0 +1,18 @@
+# AGENTS.md - working in the fdeops repository
+
+This repository **is** fdeops - the operating system for Forward Deployed Engineers. One `@fde` skill routes an entire client engagement across six domains, the `fde` CLI does the deterministic work, and per-customer memory writes itself into `.fde/` files.
+
+## If you are helping use fdeops in an engagement
+
+Route via **`@fde`** - read `skills/fde/SKILL.md` (the single source of truth), pick the phase, do the work, and write `.fde/` memory. Never ask the human to pick a skill. Other tools get the same behavior through thin pointer files in [`adapters/`](adapters/README.md).
+
+## If you are contributing to this repository
+
+- **One brain.** Method lives once in `skills/fde/SKILL.md` + `skills/fde/references/`. Adapters in `adapters/` only point at it - never fork logic per platform.
+- **Deterministic core.** `bin/fde.js` is local-only (git + file reads, no network, no AI). Keep it that way.
+- **Run the checks.** `npm run check` must pass before any PR (`node bin/check.js`).
+- **Conventions.** See `CONTRIBUTING.md`, `docs/REPO_LAYOUT.md`, and `docs/schema.md`.
+
+## Boundaries
+
+The `fde` CLI never reaches the network. Data marked `<private>` in `trust-profile.md` never enters a model prompt. fdeops installs on the FDE's own machine, never on customer infrastructure.

package/CLAUDE.md.template

@@ -0,0 +1,25 @@
+# fdeops - use in workspace only if the engagement permits this file
+
+# Prefer ~/.claude/FDEOPS-CLAUDE.md for the pointer (tells your AI coding agent where .fde/ lives).
+
+FDEOPS_ENGAGEMENT=~/fde-engagements/YOUR-ENGAGEMENT/.fde
+
+Co-pilot for a Forward Deployed Engineer. fdeops runs on **your** environment - not on systems you do not operate.
+
+Load engagement files from **FDEOPS_ENGAGEMENT** (expand `~`). If unset, use `./.fde/` only when approved and gitignored.
+
+## Engage
+
+Listen first. One clarifying question if needed. **Never ask the FDE to pick a skill** - route via `@fde` in skills/fde/SKILL.md.
+
+## Entry
+
+**`@fde`** - plain language. Route silently.
+
+## Voice
+
+Experienced FDE peer: direct, no fluff, no assumptions. Ask once if a fact changes the move.
+
+## Pause before
+
+Production changes, irreversible actions, surprises that affect trust. `<private>` in trust-profile never enters prompts.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Subash Natarajan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,328 @@
+# fdeops - The Operating System for Forward Deployed Engineers
+
+> **One command. Six domains. Your second brain for client engagements.**
+
+You type **`@fde`**, describe your situation, and the system routes to the right method - from first stakeholder meeting to final handoff. Every skill writes its output to your private engagement memory (`.fde/`), so tomorrow starts where today ended. No re-pasting context. No maintaining notes. No picking from a catalog.
+
+```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(auto-written)"]
+    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** · any agent that reads SKILL.md
+
+<p align="center"><strong>The CLI (zero tokens, zero network)</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 (one offline HTML file)</strong></p>
+<p align="center"><img src="media/fieldbook-dashboard.png" alt="FDE Fieldbook - portfolio view" width="720"/></p>
+
+---
+
+## Who does what
+
+| Role | Who | What they do |
+|------|-----|----------------|
+| **You (the FDE)** | **Human** on the engagement | Stakeholder meetings, calls, judgment, sign-off, typing `@fde`, owning what ships |
+| **AI coding agent** | **Software** on your laptop (e.g. Claude Code) - **not** a human colleague | Loads the `@fde` skill, runs the phase methods, writes code and `.fde/` artifacts |
+| **`@fde`** | **One skill** inside the AI agent | Hears your situation, routes to the right phase, does that phase's work |
+
+**In this repo, "agent" always means the AI coding agent, never a person.**
+
+---
+
+## Without fdeops vs with fdeops
+
+| | **Without fdeops** | **With fdeops** |
+|---|-------------------|----------------|
+| **Memory** | Re-paste context every session | `.fde/` writes itself - next session starts where today ended |
+| **Discovery** | Agent treats the brief as the task | Agent scans churn, test gaps, "temporary" code; hands you the real problem with evidence |
+| **Multiple customers** | Details blur between clients | One folder per customer, auto-loaded, never merged |
+| **The output** | Advice you already knew | An artifact you carry into the sponsor meeting |
+
+---
+
+## Quickstart
+
+```bash
+# Option A: Skills CLI (any agent)
+npx skills add suboss87/fdeops
+
+# Option B: Clone + install
+git clone https://github.com/suboss87/fdeops.git
+cd fdeops && node bin/install.js
+```
+
+Start your first engagement:
+```bash
+node bin/install.js init my-client
+# or: npx fdeops init my-client (engagement memory at ~/fde-engagements/my-client/.fde/)
+```
+
+Point the AI coding agent at it:
+```bash
+export FDEOPS_ENGAGEMENT=~/fde-engagements/my-client/.fde
+```
+
+Then talk to your agent:
+```
+@fde I'm on site. First stakeholder meeting tomorrow. Brief says fix the payments API.
+```
+
+That's it. The system takes over from there.
+
+### Use it in any tool
+
+One brain (`skills/fde/SKILL.md`), a thin pointer per tool. Wire up an engagement workspace for every AI tool you use:
+
+```bash
+node bin/install.js adapters ~/fde-engagements/my-client
+# or: npx fdeops@latest adapters ~/fde-engagements/my-client
+```
+
+| Tool | Pointer file 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` |
+
+Each file just points at `@fde` - so the method, overlays, and memory stay in one place. Details: [`adapters/`](adapters/README.md).
+
+---
+
+## How it works
+
+```text
+  YOU (human FDE)                    AI CODING AGENT (software)
+  meetings, judgment        @fde      routes → right skill → does the work
+        │                 ─────►      .fde/ memory (self-writing)
+        │                                   │
+        └──────────────►  client workspace (code, VPN, tickets)
+```
+
+| Layer | What | Where |
+|-------|------|-------|
+| **Surface** | One command: `@fde` | You type it |
+| **Router** | Hears your situation, picks the skill | `SKILL.md` |
+| **Skills** | 34 methods across 6 domains | `references/` |
+| **Overlays** | Activate on signal (AI, fintech, healthcare, gov, artifacts) | Layer on top |
+| **Memory** | `.fde/` - engagement record, per customer | Your machine |
+
+---
+
+## The basic workflow
+
+You only ever type **`@fde`**. The AI coding agent reads `context.md` from your engagement folder, routes to the matching skill, and follows that skill's method:
+
+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
+
+### 1. Embed & Trust
+*First days. Getting access, building credibility, understanding scope.*
+
+| Skill | What it does |
+|-------|-------------|
+| **land** | First 48 hours: interrogate the brief, map stakeholders, define success before code |
+| **audit** | Taking over mid-project: verify claims, find the load-bearing wall |
+| **stakeholder-radar** | Map who decides, who blocks, who's about to escalate |
+| **trust-engineering** | The trust ladder from observer to trusted; navigate AI policy |
+| **scope-defense** | "Let me place it": scope receipts, the accumulation conversation |
+
+### 2. Discover & Diagnose
+*Finding the real problem. Testing what the brief claims.*
+
+| Skill | What it does |
+|-------|-------------|
+| **discover** | Scan repo + hunt the workaround + **workshop facilitation** + **data estate assessment** |
+| **assumption-audit** | Extract untested assumptions, classify by blast radius, kill the riskiest first |
+| **use-case-scoring** | Score on value × urgency × alignment × data readiness ÷ complexity |
+| **sketch** | Prototype the killer assumption in one day; kill fast, log the learning |
+
+### 3. Plan & Align
+*Sequencing work and getting sponsor alignment.*
+
+| Skill | What it does |
+|-------|-------------|
+| **plan** | Work backwards from success + **estimation** (3-point sizing) + **migration strategy** |
+| **business-case** | Cost of doing nothing → investment → return → sensitivity check |
+| **options-analysis** | Three genuine options (conservative / pragmatic / ambitious) |
+| **initiative-triage** | 20 things are "urgent"; pick 3 for Now, make trade-offs visible |
+
+### 4. Build & Guard
+*Safe implementation on someone else's codebase.*
+
+| Skill | What it does |
+|-------|-------------|
+| **build** | Blast radius + legacy safety + **integration design** + **team amplification** |
+| **incremental-build** | Vertical slices, 100–300 lines each, visible progress every 2–3 days |
+| **test-on-legacy** | Characterise first, Strangler Fig, spot lying tests |
+| **blast-radius** | Trace dependencies, classify impact (CONTAINED → IRREVERSIBLE) |
+| **debug** | Systematic: reproduce → isolate → one hypothesis → verify |
+| **rescue** | Production fire, trust fire, wrong-brief-mid-build, **or full pivot** |
+| **security-audit** | Threat model in 5 minutes, STRIDE pass, secrets scan |
+| **observability** | Define "working" before instrumenting; the four metrics |
+
+### 5. Ship & Verify
+*Getting to production without surprises.*
+
+| Skill | What it does |
+|-------|-------------|
+| **ship** | Pre-flight + canary + rollback + **scale-readiness gate** + **progressive adoption** |
+| **review** | Scope first (did we build what was agreed), then safety |
+| **rollback-drill** | Test the escape route on staging before you need it at 2am |
+| **qa-live** | Test from the user's chair, real browser, five perspectives |
+
+### 6. Operate & Close
+*Running the engagement and ending it well.*
+
+| Skill | What it does |
+|-------|-------------|
+| **status** | Sponsor update from the week's actual record |
+| **demo-prep** | The one number, live-vs-canned, five hard questions |
+| **debrief** | Walk out of any meeting → decisions, signals, actions in memory |
+| **exec-narrative** | Pyramid: governing thought, three supports, SCQA frame |
+| **dashboard** | Portfolio view across all customers, trust-ordered |
+| **multi-customer-ops** | Daily triage, context-switch, cross-contamination prevention |
+| **close** | Retrospective, the 2am handoff document, what we learned |
+| **handoff-engineering** | Operations runbook, knowledge transfer, confidence scoring |
+| **pattern-extract** | If you did it twice, encode it; patterns are compound interest |
+
+### Overlays (activate on signal)
+
+| Overlay | Triggers on | What it adds |
+|---------|------------|-------------|
+| **ai** | AI, ML, LLM, model, embeddings, RAG, agents | Model selection, RAG architecture, agent safety, governance, drift monitoring, cost management |
+| **artifacts** | deck, slides, report, governance, compliance | Executive decks, governance frameworks, ADRs, compliance packs, value reports |
+| **fintech** | payments, PCI, banking, cardholder data | Idempotency, transaction integrity, fraud signals, silent-failure prevention |
+| **healthcare** | PHI, HIPAA, patient data | De-identification, minimum-necessary, audit trails |
+| **gov** | FedRAMP, ATO, CUI, classified | Authority boundaries, CUI marking, continuous monitoring |
+
+---
+
+## What makes fdeops different
+
+| Other skill repos | fdeops |
+|---|---|
+| No client memory - re-paste every session | `.fde/` writes itself; next session loads automatically |
+| No engagement politics - pure engineering | Skills for stakeholder radar, trust, scope defense, exec narratives |
+| No multi-customer support | One folder per client, portfolio dashboard, hard isolation |
+| Flat list of skills - find it yourself | Type `@fde`, describe the situation, it routes |
+| Generic engineering or startup advice | FDE-specific: brownfield safety, earned access, sponsor alignment, workshop facilitation |
+| No document generation | **Artifacts overlay:** governance frameworks, exec decks, compliance packs, ADRs from memory |
+| No AI project guidance | **AI overlay:** model selection, RAG, agents, governance, drift, cost at scale |
+
+---
+
+## 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 carries evidence: `(ops lead, Day 5)` · `(churn: 47/90d)` · `(stated, unverified)`.
+
+---
+
+## The CLI (works without AI)
+
+```bash
+fde scan       # day-1 recon: hotspots × tests, "temporary" code, AI calls, 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 fieldbook.html (0 tokens)
+```
+
+---
+
+## Who this is for
+
+| You are... | fdeops helps when... |
+|----------|-------------------|
+| **New to embed work** | You get a method per phase, not just encouragement |
+| **Senior operator, solo on site** | The agent is your second brain: memory + grunt work |
+| **Multi-client consultant** | One `.fde/` per customer, never cross-contaminated |
+| **Running AI transformations** | AI overlay: model selection → RAG → agents → scale → governance |
+| **Enterprise programme lead** | Estimation, migration strategy, scale-readiness, governance artifacts |
+
+**Works with:** Claude Code, Cursor, Copilot, Windsurf, Cline, Devin, Gemini CLI - any agent that reads SKILL.md.
+
+---
+
+## What's inside
+
+```
+bin/fde.js              the CLI - deterministic core, works without AI:
+                          fde scan · resume · log · receipts · capture · status · dashboard
+skills/fde/
+  SKILL.md              the router: voice, memory contract, 6-domain routing
+  references/
+    34 skill files      one method per file
+    5 overlays          ai.md, artifacts.md, fintech.md, healthcare.md, gov.md
+hooks/                  session-start, session-stop, pre-compact
+templates/.fde/         the 10 core memory files an init creates
+docs/                   install guides, schema, methodology
+```
+
+---
+
+## 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
+- **AI degrades silently** - monitor outputs, not just uptime
+- **Scale readiness is organizational** - not just technical
+
+---
+
+## Updating
+
+```bash
+cd fdeops && git pull && node bin/install.js
+```
+
+---
+
+## Contributing
+
+Maintained by **Subash Natarajan**. Feedback via [Issues](https://github.com/suboss87/fdeops/issues) - see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+[ATTRIBUTION.md](ATTRIBUTION.md) · [SECURITY.md](SECURITY.md) · [Repo layout](docs/REPO_LAYOUT.md) · MIT

package/adapters/AGENTS.md

@@ -0,0 +1,24 @@
+# fdeops - AGENTS.md (Codex, OpenAI, and any agent that reads AGENTS.md)
+
+You are the AI coding agent for a **Forward Deployed Engineer (FDE)** - the human in this chat. fdeops runs on the FDE's own machine, never on systems they do not operate.
+
+## 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.
+
+- 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.
+
+## Engagement memory
+
+Read and write engagement files under **`FDEOPS_ENGAGEMENT`** (expand `~`). Default `~/fde-engagements/<name>/.fde/`. If unset, use `./.fde/` only when the engagement approves it and it is gitignored.
+
+On entry, run `fde resume` (fallback `node ~/.claude/fdeops/fde.js resume`) to load `context.md`. Use the CLI for deterministic work - `fde scan | log | receipts | status | dashboard` - instead of improvising shell.
+
+## Voice
+
+A 20-year FDE peer: direct, no fluff, no assumptions. One sharp question when a missing fact changes the move, then act.
+
+## Pause before
+
+Production changes, irreversible actions, anything that affects client trust. Data marked `<private>` in `trust-profile.md` **never enters your context or any subagent prompt** - work around it, never with it.

package/adapters/GEMINI.md

@@ -0,0 +1,24 @@
+# fdeops - GEMINI.md (Gemini CLI)
+
+Context for Gemini CLI when assisting a **Forward Deployed Engineer (FDE)** - the human in this chat. fdeops runs on the FDE's own machine, never on systems they do not operate.
+
+## 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.
+
+- 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.
+
+## Engagement memory
+
+Read and write engagement files under **`FDEOPS_ENGAGEMENT`** (expand `~`). Default `~/fde-engagements/<name>/.fde/`. If unset, use `./.fde/` only when the engagement approves it and it is gitignored.
+
+On entry, run `fde resume` (fallback `node ~/.claude/fdeops/fde.js resume`) to load `context.md`. Use the CLI for deterministic work - `fde scan | log | receipts | status | dashboard` - instead of improvising shell.
+
+## Voice
+
+A 20-year FDE peer: direct, no fluff, no assumptions. One sharp question when a missing fact changes the move, then act.
+
+## Pause before
+
+Production changes, irreversible actions, anything that affects client trust. Data marked `<private>` in `trust-profile.md` **never enters your context or any subagent prompt** - work around it, never with it.

package/adapters/README.md

@@ -0,0 +1,31 @@
+# Cross-platform adapters
+
+**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.*
+
+## What goes where
+
+| Tool | File in your engagement workspace | Source template |
+|------|-----------------------------------|-----------------|
+| Claude Code | plugin + `~/.claude/FDEOPS-CLAUDE.md` (created on install) | `../CLAUDE.md.template` |
+| Codex / OpenAI / generic | `AGENTS.md` | `AGENTS.md` |
+| Gemini CLI | `GEMINI.md` | `GEMINI.md` |
+| Cursor | `.cursor/rules/fde.mdc` | `cursor.fde.mdc` |
+| GitHub Copilot | `.github/copilot-instructions.md` | `copilot-instructions.md` |
+
+`AGENTS.md` is the emerging cross-tool standard - many agents read it, so it doubles as the universal fallback.
+
+## Install them in one command
+
+From your fdeops clone, drop every pointer into a workspace at the right path:
+
+```bash
+node bin/install.js adapters /path/to/your/engagement-workspace
+# or, with npm 3.2.0+:
+npx fdeops@latest adapters /path/to/your/engagement-workspace
+```
+
+Defaults to the current directory if no path is given. Existing files are never clobbered - if a `CLAUDE.md` / `AGENTS.md` already exists, an fdeops pointer block is appended once (idempotent); files unique to fdeops are created fresh.
+
+## The principle
+
+The adapter only tells the tool **where the brain is and how to behave**. All the method - the 34 skills, 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

@@ -0,0 +1,24 @@
+# fdeops - GitHub Copilot instructions
+
+You are the AI coding agent for a **Forward Deployed Engineer (FDE)** - the human in this chat. fdeops runs on the FDE's own machine, never on systems they do not operate.
+
+## 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.
+
+- 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.
+
+## Engagement memory
+
+Read and write engagement files under **`FDEOPS_ENGAGEMENT`** (expand `~`). Default `~/fde-engagements/<name>/.fde/`. If unset, use `./.fde/` only when the engagement approves it and it is gitignored.
+
+On entry, run `fde resume` (fallback `node ~/.claude/fdeops/fde.js resume`) to load `context.md`. Use the CLI for deterministic work - `fde scan | log | receipts | status | dashboard` - instead of improvising shell.
+
+## Voice
+
+A 20-year FDE peer: direct, no fluff, no assumptions. One sharp question when a missing fact changes the move, then act.
+
+## Pause before
+
+Production changes, irreversible actions, anything that affects client trust. Data marked `<private>` in `trust-profile.md` **never enters your context or any subagent prompt** - work around it, never with it.

package/adapters/cursor.fde.mdc

@@ -0,0 +1,29 @@
+---
+description: fdeops - route Forward Deployed Engineer work via @fde
+alwaysApply: true
+---
+
+# fdeops (Cursor rule)
+
+You are the AI coding agent for a **Forward Deployed Engineer (FDE)** - the human in this chat. fdeops runs on the FDE's own machine, never on systems they do not operate.
+
+## 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.
+
+- 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.
+
+## Engagement memory
+
+Read and write engagement files under **`FDEOPS_ENGAGEMENT`** (expand `~`). Default `~/fde-engagements/<name>/.fde/`. If unset, use `./.fde/` only when the engagement approves it and it is gitignored.
+
+On entry, run `fde resume` (fallback `node ~/.claude/fdeops/fde.js resume`) to load `context.md`. Use the CLI for deterministic work - `fde scan | log | receipts | status | dashboard` - instead of improvising shell.
+
+## Voice
+
+A 20-year FDE peer: direct, no fluff, no assumptions. One sharp question when a missing fact changes the move, then act.
+
+## Pause before
+
+Production changes, irreversible actions, anything that affects client trust. Data marked `<private>` in `trust-profile.md` **never enters your context or any subagent prompt** - work around it, never with it.