FDEOps

Your AI agent forgets your client every morning. fdeops remembers.

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
    |           |           |         |          |         |
    +-----------+-----------+---------+----------+---------+
          the fieldbook (.fde/) - one per engagement
             written as a side effect of the work

Describe your situation - @fde routes to the phase, runs the method, and every artifact lands in that shared memory. Nothing to maintain by hand.

The problem

Your AI agent's memory is scoped to a repo. Client work isn't: one engagement spans several repos, a dozen stakeholders, and decisions made in meetings your agent never saw. That context lives in rooms, chats, and hallway conversations - nothing writes it down where your tools can use it.

fdeops adds the missing layer: memory scoped to the client - plain markdown at ~/fde-engagements/<client>/.fde/, written as a side effect of doing the work. Local only, zero dependencies, no network, no telemetry.

A notes app stores what you type. fdeops loads the right client into your AI agent's context automatically and turns meetings into dated receipts you can defend - the difference is what happens without you opening it.

Without fdeops vs with fdeops

Quickstart

1. Install (Claude Code)

/plugin marketplace add suboss87/fdeops
/plugin install fdeops@fdeops

2. Bind your client workspace - run once, inside the workspace:

npx fdeops resume --init garvey

(npx needs nothing pre-installed. Want the bare fde command the rest of this README uses? npm i -g fdeops - the plugin install alone does not put fde on your PATH.)

fdeops' --init creates the engagement memory at ~/fde-engagements/garvey/.fde/ (plain markdown, private to your machine) and binds this workspace to it. The hooks read that binding - context auto-loads at session start, auto-captures at session end. That is the whole setup.

3. Work

@fde I just got the brief. New client, payments platform, they want it live before their Q3 audit.

@fde is the one skill fdeops installs. Describe what's happening; it routes to the right field method and the memory writes itself. Full workflow: docs/USAGE.md.

Not ready to install? npx fdeops scan runs on any repo you can read - day-1 recon (pure git + file reads, no config, no account) that maps hotspots, test gaps, and reverted attempts, and ends with the ASK ON DAY 1 questions the brief never mentions. The scan is heuristic by design - treat its output as leads to verify on day one, not findings.

• Cursor / Codex / Copilot / Gemini CLI: npx fdeops adapters . drops a thin pointer to the same @fde skill - adapters/
• Local LLMs (Ollama, LM Studio, llama.cpp): load skills/fde/SKILL.md as the system prompt - guide
• Skills CLI: npx skills add suboss87/fdeops
• Manual / air-gapped: git clone https://github.com/suboss87/fdeops.git && cd fdeops && node bin/install.js
• Requires: Node.js >= 18 for the CLI and adapters; the Claude Code plugin install does not need Node separately.
• Advanced: the FDEOPS_ENGAGEMENT env var overrides the workspace registry - only for unusual setups. Full matrix: docs/install.md

The week

This is the actual habit, not the 35 skills:

• Monday morning - open your agent, context loads, you're not re-explaining anything
• After a meeting - fde debrief turns raw notes into dated decisions, risks, and signals
• Mid-scope-fight - fde receipts <term> answers "when did we agree to that?"
• Friday - fde status gives you the sponsor update from the week's actual record

How it works

Two hooks and one router, 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
• After meetings - fde debrief notes.md routes lines prefixed decision: / risk: / delivery: / contact: to the matching file, dated; everything else lands as a dated block in context.md
• On top of the memory - the @fde skill routes six phase verbs:

Overlays for regulated domains (AI, fintech, healthcare, government) activate on signal. fdeops complements your agent's native repo memory: CLAUDE.md holds how the code works; the fieldbook holds how the engagement works. Full matrix: docs/skills.md.

Works with Claude Code - Cursor - Copilot - Gemini CLI - Ollama - LM Studio - any model that reads a markdown file.

Engagement memory (.fde/)

The fieldbook - one folder per client, plain markdown you can read, grep, and take with you:

Every entry is dated and sourced, so you can defend it in front of skeptical stakeholders. Schema: docs/schema.md.

The CLI

Deterministic, offline, zero tokens - the skill adds judgment on top:

fde scan                          # day-1 recon + ASK ON DAY 1 questions (works via npx)
fde resume                        # load this workspace's engagement
fde resume --init <client>        # THE setup step: create + bind an engagement
fde debrief notes.md              # route meeting notes into memory (also reads stdin)
fde log decision "descope agreed with Kowalczyk"
fde log contact "Denise gone quiet" --signal amber
fde receipts <term>               # dated search; no hit = a gap in the record, not proof of absence
fde status                        # portfolio triage across all clients (red > amber > green)
fde dashboard                     # render every engagement into one offline HTML fieldbook

The latest dated [signal:...] token per stakeholder drives the trust column in status and dashboard; signals older than 21 days show as stale.

fde dashboard (FieldBook) renders every engagement into one offline HTML fieldbook - engagements sorted by trust, next action and open risks per client, one glance to know where to start:

Who this is for

Your data stays yours

• Local only. Pure git + file reads - no network calls, no telemetry, no account. Works air-gapped.
• Plain markdown. No database, no lock-in.
• No new data path. The AI sees client code only when you poi