fdeops 3.9.18 → 3.9.20

package/README.md

@@ -31,6 +31,7 @@ Day to day you only need `@fde` and normal English. No command cheat sheet.
 |------|--------------|--------------|
 | **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 |
+| **Pull from tools** | `@fde` connect Granola *(once)* · then `@fde` pull today's Acme transcript | Wire any source MCP you choose; FDEOps stages → proposes → you confirm. Recipes: [mcp/recipes/](mcp/recipes/) |
 | **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 |
@@ -91,6 +92,7 @@ npx fdeops resume                 # prints a short "where we are" for this clien
 - **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)
 - **Local CLI** - memory writes, search, and status with no model tokens; the agent runs it. You do not need to learn it for daily use ([docs/USAGE.md](docs/USAGE.md))
+- **Pluggable pull (ingest)** - FDEOps is the **sink**, not a connector pack. You add any source MCP (Granola, Notion, Drive, …) in Cursor/Claude; say `@fde connect …` for a guided config + recipe, then pull in plain language. Raw text → `.inbox/` → propose → you confirm → `.fde/`. No ambient sync; nothing unreviewed enters the fieldbook. See [mcp/recipes/](mcp/recipes/).
 
 fdeops complements repo memory: CLAUDE.md holds how the *code* works; the fieldbook holds how the *client engagement* works.
 

package/bin/check.js

@@ -316,7 +316,7 @@ if (!fs.existsSync(path.join(root, 'bin', 'fde.js'))) {
       .map(name => path.join('bin', 'lib', name)),
   ]
   const cliSource = cliFiles.map(read).join('\n')
-  for (const sub of ['cmdScan', 'cmdResume', 'cmdLog', 'cmdDebrief', 'cmdReceipts', 'cmdCapture', 'cmdStatus', 'cmdDashboard']) {
+  for (const sub of ['cmdScan', 'cmdResume', 'cmdLog', 'cmdDebrief', 'cmdIngest', 'cmdReceipts', 'cmdCapture', 'cmdStatus', 'cmdDashboard']) {
     if (!cliSource.includes(sub)) fail(`CLI sources missing ${sub}`)
   }
   if (!JSON.parse(read('package.json')).bin.fde) fail('package.json must expose the fde bin')
@@ -345,6 +345,22 @@ if (pkg.version !== plugin.version) {
   fail(`version mismatch package.json ${pkg.version} vs plugin ${plugin.version}`)
 } else ok('plugin version aligned')
 
+if (!fs.existsSync(path.join(root, 'mcp', 'fdeops-ingest', 'server.js'))) {
+  fail('mcp/fdeops-ingest/server.js missing (ingest MCP sink)')
+} else if (!read('mcp/fdeops-ingest/server.js').includes('ingest_stage')) {
+  fail('ingest MCP must expose ingest_stage')
+} else if (!read('skills/fde/references/ingest.md').includes('stage')) {
+  fail('skills/fde/references/ingest.md missing stage contract')
+} else if (!fs.existsSync(path.join(root, 'skills', 'fde', 'references', 'ingest-connect.md'))) {
+  fail('skills/fde/references/ingest-connect.md missing')
+} else {
+  for (const recipe of ['file.md', 'granola.md', 'notion.md']) {
+    if (!fs.existsSync(path.join(root, 'mcp', 'recipes', recipe))) fail(`mcp/recipes/${recipe} missing`)
+  }
+  if (!read('README.md').includes('mcp/recipes')) fail('README must point at mcp/recipes for connect clarity')
+  ok('ingest MCP + connect recipes + skill reference')
+}
+
 if (!fs.existsSync(path.join(root, '.github', 'ISSUE_TEMPLATE', 'bug_report.yml'))) {
   fail('GitHub issue template missing')
 } else ok('issue templates')

package/bin/fde.js

@@ -19,6 +19,7 @@
  *   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 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)
@@ -1399,6 +1400,188 @@ function cmdDebrief(args) {
   console.log(parts.length ? `${verb} → ${parts.join(', ')}` : 'debrief empty - nothing routed')
 }
 
+// Pull sink: stage raw artifacts outside the memory ledger, then reuse debrief
+// propose/apply. Never writes .fde/ until the FDE confirms apply. Source SaaS
+// (Granola/Gmail/…) is not here — only staging + the existing confirm gate.
+function inboxDir(eng) {
+  return path.join(path.dirname(eng), '.inbox')
+}
+
+function sanitizeIngestToken(s, fallback) {
+  const t = String(s || '').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48)
+  return t || fallback
+}
+
+function parseIngestFrontMatter(raw) {
+  const text = String(raw || '')
+  if (!text.startsWith('---\n')) return { meta: {}, body: text }
+  const end = text.indexOf('\n---\n', 4)
+  if (end === -1) return { meta: {}, body: text }
+  const head = text.slice(4, end)
+  const body = text.slice(end + 5)
+  const meta = {}
+  for (const line of head.split('\n')) {
+    const m = /^([a-z_]+):\s*(.*)$/i.exec(line.trim())
+    if (m) meta[m[1].toLowerCase()] = m[2].trim()
+  }
+  return { meta, body }
+}
+
+function resolveInboxItem(eng, id) {
+  const box = inboxDir(eng)
+  const want = String(id || '').trim()
+  if (!want) return null
+  const direct = path.join(box, want)
+  if (fs.existsSync(direct) && fs.statSync(direct).isFile()) return direct
+  const withMd = want.endsWith('.md') ? want : `${want}.md`
+  const alt = path.join(box, withMd)
+  if (fs.existsSync(alt) && fs.statSync(alt).isFile()) return alt
+  try {
+    const hits = fs.readdirSync(box).filter(f => f === want || f.startsWith(want) || f.includes(want))
+    if (hits.length === 1) return path.join(box, hits[0])
+  } catch (_) {}
+  return null
+}
+
+function cmdIngest(args) {
+  args = args.slice()
+  const sub = (args.shift() || '').toLowerCase()
+  if (!['stage', 'list', 'propose', 'apply'].includes(sub)) {
+    console.error('usage: fde ingest stage [--source NAME] [--title TEXT] [--force] [file|-]\n' +
+      '       fde ingest list\n' +
+      '       fde ingest propose <id>\n' +
+      '       fde ingest apply')
+    process.exit(1)
+  }
+
+  if (sub === 'apply') {
+    cmdDebrief(['--apply', ...args])
+    return
+  }
+
+  const eng = resolveEngagement({ forWrite: true })
+  if (!eng) { console.error('no engagement - run: fde resume --init <name>'); process.exit(2) }
+
+  if (sub === 'list') {
+    const box = inboxDir(eng)
+    if (!fs.existsSync(box)) {
+      console.log(`inbox empty → ${box}`)
+      console.log('(stage with: fde ingest stage --source granola notes.md)')
+      return
+    }
+    const files = fs.readdirSync(box).filter(f => f.endsWith('.md')).sort().reverse()
+    if (!files.length) {
+      console.log(`inbox empty → ${box}`)
+      return
+    }
+    console.log(`INBOX → ${box}\n`)
+    for (const f of files) {
+      const raw = fs.readFileSync(path.join(box, f), 'utf8')
+      const { meta } = parseIngestFrontMatter(raw)
+      const src = meta.source || '?'
+      const title = meta.title || ''
+      const when = meta.staged || ''
+      console.log(`  ${f}${title ? `  ${title}` : ''}  via:${src}${when ? `  ${when}` : ''}`)
+    }
+    console.log(`\npropose:  fde ingest propose <id>`)
+    return
+  }
+
+  if (sub === 'propose') {
+    const id = args[0]
+    if (!id) { console.error('usage: fde ingest propose <id>'); process.exit(1) }
+    const item = resolveInboxItem(eng, id)
+    if (!item) {
+      console.error(`ingest propose: no staged item matching "${id}" - run: fde ingest list`)
+      process.exit(1)
+    }
+    const raw = stripControlChars(fs.readFileSync(item, 'utf8'))
+    const { meta, body } = parseIngestFrontMatter(raw)
+    const source = meta.source || 'manual'
+    const title = meta.title || path.basename(item, '.md')
+    const stamped = meta.staged || 'unknown'
+    const viaLine = `via:${source} ${title} (staged ${stamped}; file ${path.basename(item)})`
+    const input = `${viaLine}\n\n${body.trim()}\n`
+    if (Buffer.byteLength(input) > DEBRIEF_MAX_BYTES) {
+      console.error(`ingest propose refused: staged item is over ${DEBRIEF_MAX_BYTES} bytes after provenance. Split it.`)
+      process.exit(1)
+    }
+    const proposed = smartProposeText(input)
+    const proposePath = path.join(eng, DEBRIEF_PROPOSE)
+    withFileLock(proposePath, () => { atomicWriteFile(proposePath, proposed) })
+    console.log(`INGEST PROPOSE from ${path.basename(item)} (via:${source})\n`)
+    routeDebriefInput(eng, proposed, { dry: true, force: false })
+    console.log(`\nproposal saved → ${proposePath}`)
+    console.log('confirm:  fde ingest apply')
+    console.log('(agent: rewrite lines with decision:/risk:/contact:/next: prefixes before apply)')
+    return
+  }
+
+  // stage
+  let source = 'manual'
+  let title = ''
+  let force = false
+  const rest = []
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--source' && args[i + 1]) { source = args[++i]; continue }
+    if (args[i] === '--title' && args[i + 1]) { title = args[++i]; continue }
+    if (args[i] === '--force') { force = true; continue }
+    rest.push(args[i])
+  }
+  source = sanitizeIngestToken(source, 'manual')
+  const titleSlug = sanitizeIngestToken(title || 'notes', 'notes')
+  if (!title) title = titleSlug
+
+  let input = ''
+  if (rest[0] && rest[0] !== '-') {
+    const p = path.resolve(rest[0])
+    try {
+      const st = fs.statSync(p)
+      if (st.size > DEBRIEF_MAX_BYTES) {
+        console.error(`ingest stage refused: ${rest[0]} is ${st.size} bytes (max ${DEBRIEF_MAX_BYTES}). Split or stage a relevant section.`)
+        process.exit(1)
+      }
+      input = stripControlChars(fs.readFileSync(p, 'utf8'))
+    } catch (e) {
+      failFs(e, 'read', p)
+    }
+  } else {
+    input = stripControlChars(fs.readFileSync(0, 'utf8'))
+    if (Buffer.byteLength(input) > DEBRIEF_MAX_BYTES) {
+      console.error(`ingest stage refused: stdin is over ${DEBRIEF_MAX_BYTES} bytes. Split the notes.`)
+      process.exit(1)
+    }
+  }
+  if (!input.trim()) {
+    console.error('ingest stage refused: empty input')
+    process.exit(1)
+  }
+  const hit = findSecretHit(input)
+  if (hit && !force) { refuseSecret('ingest stage', hit); process.exit(1) }
+  if (hit && force) console.error(`warning: staging possible ${hit} (--force)`)
+
+  const box = inboxDir(eng)
+  try { fs.mkdirSync(box, { recursive: true }) } catch (e) { failFs(e, 'create inbox', box) }
+  const compact = new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z')
+  const id = `${compact}-${source}-${titleSlug}.md`
+  const dest = path.join(box, id)
+  const body = [
+    '---',
+    `source: ${source}`,
+    `title: ${title.replace(/\n/g, ' ').slice(0, 120)}`,
+    `staged: ${new Date().toISOString()}`,
+    `id: ${id}`,
+    '---',
+    '',
+    input.replace(/\s+$/, '') + '\n',
+  ].join('\n')
+  withFileLock(dest, () => { atomicWriteFile(dest, body) })
+  console.log(`staged → ${dest}`)
+  console.log(`id: ${id}`)
+  console.log('next:   fde ingest propose ' + id)
+  console.log('(does not write .fde/ — confirm via propose → apply)')
+}
+
 function cmdReceipts(args) {
   const term = args.join(' ')
   if (!term) { console.error('usage: fde receipts <search term>'); process.exit(1) }
@@ -2293,6 +2476,10 @@ function printUsage() {
   fde log --undo           remove the last CLI log/debrief entry from memory
   fde debrief [file]       meeting notes → memory (prefixed lines; --dry-run; --force)
   fde debrief --smart      heuristic propose (prefix + light keywords); agent routes, CLI gates → --apply
+  fde ingest stage …       stage raw pull into <engagement>/.inbox/ (not .fde/)
+  fde ingest list          list staged inbox items
+  fde ingest propose <id>  smart-propose a staged item → .debrief-propose (confirm before apply)
+  fde ingest apply         same as: fde debrief --apply
   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)
@@ -2305,7 +2492,8 @@ function printUsage() {
   fde dashboard [--all]    current engagement fieldbook (pass --all for every client)
   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)`)
+  .fde/ is git-versioned locally for tamper-evident receipts (no remote, no telemetry)
+  ingest is a sink only - source MCPs (Granola/Gmail/…) are user-configured; never ambient sync`)
 }
 
 const [cmd, ...args] = process.argv.slice(2)
@@ -2315,6 +2503,7 @@ switch (cmd) {
   case 'triage': cmdTriage(); break
   case 'log': cmdLog(args); break
   case 'debrief': cmdDebrief(args); break
+  case 'ingest': cmdIngest(args); break
   case 'prep': cmdPrep(args); break
   case 'doctor': cmdDoctor(); break
   case 'redact': cmdRedact(args); break

package/bin/install.js

@@ -225,7 +225,7 @@ function cmdInstall() {
 // `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', 'triage', 'log', 'debrief', 'prep', 'doctor', 'redact',
+  'scan', 'resume', 'triage', 'log', 'debrief', 'ingest', 'prep', 'doctor', 'redact',
   'garden', 'owner', 'receipts', 'capture', 'status', 'dashboard', 'help',
 ]
 

package/mcp/README.md

@@ -0,0 +1,55 @@
+# FDEOps MCP packages
+
+FDEOps MCP servers follow a **pluggable source model**: core owns the **sink**, sources are **user-added**.
+
+## Sink vs sources
+
+| Role | Owner | Examples |
+|------|-------|----------|
+| **Source** | FDE configures separately | Granola, Gmail, Notion, custom scrapers |
+| **Sink** | FDEOps (`fdeops-ingest`) | stage → propose → apply into engagement memory |
+
+Source MCPs fetch raw text from SaaS APIs using credentials the FDE manages. The ingest MCP never stores OAuth tokens or calls external services — it only shells out to the local `fde` CLI.
+
+## Ground loop
+
+```
+Source MCP(s)          fdeops-ingest MCP           fde CLI
+     │                        │                      │
+     │  raw transcript/email  │                      │
+     └───────────────────────►│  ingest_stage        │
+                              ├─────────────────────►│  .inbox/
+                              │  ingest_list         │
+                              │  ingest_propose      ├─► .debrief-propose
+                              │  (FDE confirms)      │
+                              │  ingest_apply        ├─► .fde/
+```
+
+1. Agent pulls from whichever source MCPs are configured.
+2. Agent stages raw content via `ingest_stage` (with `source` provenance).
+3. Agent proposes routing via `ingest_propose`; FDE confirms.
+4. Agent applies via `ingest_apply` — nothing writes `.fde/` unreviewed.
+
+## Packages
+
+| Package | Path | Purpose |
+|---------|------|---------|
+| `fdeops-ingest-mcp` | [`fdeops-ingest/`](./fdeops-ingest/) | Ingest sink (stage, list, propose, apply) |
+
+## Recipes (copy-paste connect)
+
+See [`recipes/`](./recipes/) for file, Granola-shaped, and Notion-shaped setup. In chat: `@fde I want to connect Granola` → skill `ingest-connect` walks the FDE through config + reload + verify.
+
+## Adding a source MCP
+
+Source MCPs are **not** bundled in fdeops. To add Granola, Gmail, or another provider:
+
+1. Install or configure that provider's MCP in your Cursor/Claude `mcp.json`.
+2. Configure `fdeops-ingest` separately (see [`fdeops-ingest/README.md`](./fdeops-ingest/README.md)).
+3. In your daily workflow, the agent uses source tools to fetch, then ingest tools to stage and commit.
+
+FDEOps credentials stay local to the CLI; source MCP credentials stay with that MCP.
+
+## Design reference
+
+See [`docs/plans/2026-07-29-ingest-mcp-design.md`](../docs/plans/2026-07-29-ingest-mcp-design.md) for the approved ingest MCP design.

package/mcp/fdeops-ingest/README.md

@@ -0,0 +1,90 @@
+# fdeops-ingest MCP
+
+Thin stdio MCP server for the FDEOps **ingest sink** only: **stage → propose → apply**.
+
+This package shells out to the local `fde` CLI. It never calls SaaS APIs. Source MCPs (Granola, Gmail, Notion, etc.) are **separate** — you add those in your own `mcp.json`.
+
+## Tools
+
+| Tool | CLI equivalent |
+|------|----------------|
+| `ingest_stage` | `fde ingest stage [--source NAME] [--title TEXT]` (content on stdin) |
+| `ingest_list` | `fde ingest list` |
+| `ingest_propose` | `fde ingest propose <id>` |
+| `ingest_apply` | `fde ingest apply` |
+
+Each tool returns `{ stdout, stderr, status }` from the CLI.
+
+## Requirements
+
+- Node.js ≥ 18
+- `fde` CLI on PATH, or run from a checkout (auto-resolves `../../bin/fde.js`)
+
+## Configure in Cursor / Claude
+
+Add to your MCP config (`~/.cursor/mcp.json`, Claude Desktop config, etc.):
+
+```json
+{
+  "mcpServers": {
+    "fdeops-ingest": {
+      "command": "node",
+      "args": [
+        "/absolute/path/to/fdeops/mcp/fdeops-ingest/server.js"
+      ],
+      "env": {
+        "FDEOPS_ENGAGEMENT": "/Users/you/fde-engagements/acme/.fde"
+      }
+    }
+  }
+}
+```
+
+Or after `npm link` in this directory:
+
+```json
+{
+  "mcpServers": {
+    "fdeops-ingest": {
+      "command": "fdeops-ingest-mcp",
+      "env": {
+        "FDEOPS_ENGAGEMENT": "/Users/you/fde-engagements/acme/.fde"
+      }
+    }
+  }
+}
+```
+
+### Environment
+
+| Variable | Purpose |
+|----------|---------|
+| `FDEOPS_ENGAGEMENT` | Bind to a specific engagement (path to `.fde/`) |
+| `FDEOPS_ENGAGEMENTS_ROOT` | Override engagements root (default `~/fde-engagements`) |
+| `FDEOPS_FDE` | Override `fde` binary (default: repo `bin/fde.js`, else `fde` on PATH) |
+| `HOME` | Passed through for engagement resolution |
+
+## Daily loop (with separate source MCPs)
+
+1. **Fetch** — Use your source MCP (e.g. Granola, Gmail) to pull raw text. FDEOps does not bundle these.
+2. **Stage** — `ingest_stage` with `content`, `source` (e.g. `"granola"`), optional `title`.
+3. **List** — `ingest_list` to see staged items in `.inbox/`.
+4. **Propose** — `ingest_propose` with the staged `id`; agent reviews `.debrief-propose`.
+5. **Confirm** — FDE approves the proposal in chat.
+6. **Apply** — `ingest_apply` writes dated facts into `.fde/` with provenance.
+
+Raw artifacts stay in `.inbox/`; the system of record (`.fde/`) stays thin and reviewed.
+
+## Architecture
+
+```
+[Granola MCP] ──┐
+[Gmail MCP]   ──┼──► agent ──► fdeops-ingest MCP ──► fde CLI ──► .inbox/ → .fde/
+[manual paste]──┘         (this package)
+```
+
+Sources are pluggable and user-configured. This MCP owns the sink only.
+
+## Zero dependencies
+
+Hand-rolled MCP over stdio (Content-Length framed JSON-RPC). No `@modelcontextprotocol/sdk` required at runtime.

package/mcp/fdeops-ingest/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "fdeops-ingest-mcp",
+  "version": "3.9.20",
+  "private": true,
+  "description": "Thin stdio MCP sink for FDEOps ingest (stage → propose → apply). Zero runtime dependencies.",
+  "bin": {
+    "fdeops-ingest-mcp": "./server.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/mcp/fdeops-ingest/server.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+'use strict'
+
+/**
+ * fdeops-ingest MCP — thin stdio sink for FDEOps ingest.
+ * Shells out to local `fde` CLI only. Never calls SaaS.
+ * MCP stdio transport: Content-Length framed JSON-RPC 2.0.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { spawnSync } = require('child_process')
+
+const PROTOCOL_VERSION = '2024-11-05'
+const SERVER_NAME = 'fdeops-ingest'
+const SERVER_VERSION = require('./package.json').version
+
+const TOOLS = [
+  {
+    name: 'ingest_stage',
+    description:
+      'Stage raw content into the engagement inbox (.inbox/). Does not write .fde/.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'Raw text to stage (transcript, email body, notes).',
+        },
+        source: {
+          type: 'string',
+          description: 'Provenance label (e.g. granola, gmail, manual). Default: manual.',
+        },
+        title: {
+          type: 'string',
+          description: 'Optional human-readable title for the staged item.',
+        },
+      },
+      required: ['content'],
+    },
+  },
+  {
+    name: 'ingest_list',
+    description: 'List staged items in the current engagement inbox.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'ingest_propose',
+    description:
+      'Propose debrief routing for a staged item (writes .fde/.debrief-propose; does not apply).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          description: 'Staged filename or id from ingest_list.',
+        },
+      },
+      required: ['id'],
+    },
+  },
+  {
+    name: 'ingest_apply',
+    description:
+      'Apply the current debrief proposal into .fde/ memory (requires prior FDE confirm).',
+    inputSchema: { type: 'object', properties: {} },
+  },
+]
+
+let readBuffer = Buffer.alloc(0)
+
+function writeMessage(obj) {
+  const body = JSON.stringify(obj)
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`)
+}
+
+function parseMessages() {
+  const messages = []
+  while (true) {
+    const headerEnd = readBuffer.indexOf('\r\n\r\n')
+    if (headerEnd === -1) break
+
+    const header = readBuffer.slice(0, headerEnd).toString('utf8')
+    const match = header.match(/Content-Length:\s*(\d+)/i)
+    if (!match) {
+      readBuffer = readBuffer.slice(headerEnd + 4)
+      continue
+    }
+
+    const length = parseInt(match[1], 10)
+    const bodyStart = headerEnd + 4
+    if (readBuffer.length < bodyStart + length) break
+
+    const body = readBuffer.slice(bodyStart, bodyStart + length).toString('utf8')
+    readBuffer = readBuffer.slice(bodyStart + length)
+    try {
+      messages.push(JSON.parse(body))
+    } catch (_) {}
+  }
+  return messages
+}
+
+function resolveFde() {
+  const override = (process.env.FDEOPS_FDE || '').trim()
+  if (override) return { cmd: override, prefix: [] }
+
+  const local = path.join(__dirname, '..', '..', 'bin', 'fde.js')
+  if (fs.existsSync(local)) return { cmd: process.execPath, prefix: [local] }
+
+  return { cmd: 'fde', prefix: [] }
+}
+
+function fdeEnv() {
+  const env = { ...process.env }
+  for (const key of ['HOME', 'FDEOPS_ENGAGEMENT', 'FDEOPS_ENGAGEMENTS_ROOT']) {
+    if (process.env[key] !== undefined) env[key] = process.env[key]
+  }
+  return env
+}
+
+function runFde(args, stdin) {
+  const { cmd, prefix } = resolveFde()
+  const result = spawnSync(cmd, [...prefix, ...args], {
+    env: fdeEnv(),
+    input: stdin ?? undefined,
+    encoding: 'utf8',
+    maxBuffer: 16 * 1024 * 1024,
+  })
+  return {
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+    status: result.status ?? (result.error ? 1 : 0),
+    error: result.error ? String(result.error.message || result.error) : null,
+  }
+}
+
+function cliPayload(out) {
+  const payload = { stdout: out.stdout, stderr: out.stderr, status: out.status }
+  if (out.error) payload.spawnError = out.error
+  return payload
+}
+
+function toolResult(payload) {
+  const text = typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2)
+  return { content: [{ type: 'text', text }] }
+}
+
+function toolError(payload) {
+  const result = toolResult(payload)
+  result.isError = true
+  return result
+}
+
+function handleToolCall(name, args) {
+  args = args || {}
+
+  switch (name) {
+    case 'ingest_stage': {
+      if (!args.content || typeof args.content !== 'string') {
+        return toolError('Missing required argument: content')
+      }
+      const source = args.source || 'manual'
+      const cliArgs = ['ingest', 'stage', '--source', source]
+      if (args.title) cliArgs.push('--title', args.title)
+      const out = runFde(cliArgs, args.content)
+      const payload = cliPayload(out)
+      return out.status === 0 ? toolResult(payload) : toolError(payload)
+    }
+    case 'ingest_list': {
+      const out = runFde(['ingest', 'list'])
+      const payload = cliPayload(out)
+      return out.status === 0 ? toolResult(payload) : toolError(payload)
+    }
+    case 'ingest_propose': {
+      if (!args.id) return toolError('Missing required argument: id')
+      const out = runFde(['ingest', 'propose', String(args.id)])
+      const payload = cliPayload(out)
+      return out.status === 0 ? toolResult(payload) : toolError(payload)
+    }
+    case 'ingest_apply': {
+      const out = runFde(['ingest', 'apply'])
+      const payload = cliPayload(out)
+      return out.status === 0 ? toolResult(payload) : toolError(payload)
+    }
+    default:
+      return toolError(`Unknown tool: ${name}`)
+  }
+}
+
+function handleMessage(msg) {
+  if (!msg || typeof msg !== 'object') return
+
+  const { id, method, params } = msg
+
+  if (id === undefined && method) return
+
+  if (method === 'initialize') {
+    writeMessage({
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+      },
+    })
+    return
+  }
+
+  if (method === 'tools/list') {
+    writeMessage({ jsonrpc: '2.0', id, result: { tools: TOOLS } })
+    return
+  }
+
+  if (method === 'tools/call') {
+    try {
+      const result = handleToolCall(params?.name, params?.arguments)
+      writeMessage({ jsonrpc: '2.0', id, result })
+    } catch (err) {
+      writeMessage({
+        jsonrpc: '2.0',
+        id,
+        result: toolError(String(err.message || err)),
+      })
+    }
+    return
+  }
+
+  if (method === 'ping') {
+    writeMessage({ jsonrpc: '2.0', id, result: {} })
+    return
+  }
+
+  if (id !== undefined) {
+    writeMessage({
+      jsonrpc: '2.0',
+      id,
+      error: { code: -32601, message: `Method not found: ${method}` },
+    })
+  }
+}
+
+process.stdin.on('data', (chunk) => {
+  readBuffer = Buffer.concat([readBuffer, chunk])
+  for (const msg of parseMessages()) handleMessage(msg)
+})
+
+process.stdin.resume()

package/mcp/recipes/README.md

@@ -0,0 +1,15 @@
+# Ingest source recipes
+
+FDEOps does **not** bundle Granola / Notion / Drive OAuth. These recipes show how an FDE wires a **source MCP** (or file drop) into the FDEOps **sink**.
+
+**Contract every source must satisfy:** fetch text → `fde ingest stage` (or MCP `ingest_stage`) with `{ source, title, content }` → propose → FDE confirms → apply.
+
+| Recipe | When |
+|--------|------|
+| [file.md](./file.md) | Local transcript / export already on disk (no source MCP) |
+| [granola.md](./granola.md) | Meeting transcripts via a Granola-shaped MCP (or export) |
+| [notion.md](./notion.md) | Notion pages / meeting notes via a Notion MCP |
+
+Also wire the sink once: [fdeops-ingest/README.md](../fdeops-ingest/README.md).
+
+**Natural language:** `@fde I want to connect Granola` → agent follows `skills/fde/references/ingest-connect.md` and this recipe.

package/mcp/recipes/file.md

@@ -0,0 +1,25 @@
+# Recipe: local file / paste (no source MCP)
+
+**Use when:** you already have a transcript, `.eml`, or export on disk — or you paste into chat.
+
+## Setup
+
+None beyond the FDEOps sink (`fde` CLI and optionally `fdeops-ingest` MCP).
+
+## Pull phrase
+
+```text
+@fde stage this transcript into the fieldbook and propose updates
+```
+
+(or attach / point at a path)
+
+## Agent steps
+
+1. Bind engagement.
+2. `fde ingest stage --source file --title "<short>" <path>` (or stdin).
+3. `fde ingest propose <id>` → rewrite prefixes → show FDE → on confirm `fde ingest apply`.
+
+## mcp.json
+
+Not required for the source. Optional sink only — see [../fdeops-ingest/README.md](../fdeops-ingest/README.md).

package/mcp/recipes/granola.md

@@ -0,0 +1,58 @@
+# Recipe: Granola-shaped meeting transcripts
+
+**Use when:** meeting notes live in Granola (or a similar notes MCP). FDEOps does not ship a Granola server — you add whichever MCP/export path you trust.
+
+## Setup (once)
+
+1. Install / enable a **Granola (or notes) MCP** in Cursor/Claude per that product’s docs.
+2. Add the FDEOps **sink** MCP (`fdeops-ingest`) — [../fdeops-ingest/README.md](../fdeops-ingest/README.md).
+3. Reload MCP / restart the agent host.
+4. Test: `@fde what can you pull?` — agent should see both sink tools and the notes source tools.
+
+### Example mcp.json shape (illustrative)
+
+Replace `granola-mcp` command/args with whatever the real server documents. FDEOps only needs *some* tool that returns transcript text.
+
+```json
+{
+  "mcpServers": {
+    "granola": {
+      "command": "npx",
+      "args": ["-y", "YOUR-GRANOLA-MCP-PACKAGE"],
+      "env": {
+        "GRANOLA_API_KEY": "from-your-secrets"
+      }
+    },
+    "fdeops-ingest": {
+      "command": "node",
+      "args": ["/absolute/path/to/fdeops/mcp/fdeops-ingest/server.js"],
+      "env": {
+        "FDEOPS_ENGAGEMENT": "/Users/you/fde-engagements/acme/.fde"
+      }
+    }
+  }
+}
+```
+
+**No Granola MCP available?** Export transcript to a file → follow [file.md](./file.md).
+
+## Pull phrase
+
+```text
+@fde pull today's Acme Granola into the fieldbook
+```
+
+## Agent steps
+
+1. Capability check — if no notes/Granola tools, run connect flow (`ingest-connect.md`).
+2. Fetch transcript via source MCP (or ask which meeting).
+3. `ingest_stage` / `fde ingest stage --source granola --title "…"`.
+4. Propose → confirm → apply. Never auto-apply.
+
+## Common fails
+
+| Symptom | Fix |
+|---------|-----|
+| Agent says it can’t reach Granola | MCP not saved / host not reloaded / wrong env key |
+| Wrong client inbox | Set `FDEOPS_ENGAGEMENT` or bind workspace (`fde resume --init`) |
+| Empty propose | Agent must rewrite `.debrief-propose` with type prefixes |

package/mcp/recipes/notion.md

@@ -0,0 +1,56 @@
+# Recipe: Notion docs / meeting notes
+
+**Use when:** useful engagement notes live in Notion. FDEOps does not ship a Notion server — use a Notion MCP (or export markdown).
+
+## Setup (once)
+
+1. Enable a **Notion MCP** (official or community) with a token that can read the pages you need.
+2. Add **fdeops-ingest** sink — [../fdeops-ingest/README.md](../fdeops-ingest/README.md).
+3. Reload MCP / restart host.
+4. Test: `@fde what can you pull?`
+
+### Example mcp.json shape (illustrative)
+
+```json
+{
+  "mcpServers": {
+    "notion": {
+      "command": "npx",
+      "args": ["-y", "YOUR-NOTION-MCP-PACKAGE"],
+      "env": {
+        "NOTION_TOKEN": "from-your-secrets"
+      }
+    },
+    "fdeops-ingest": {
+      "command": "node",
+      "args": ["/absolute/path/to/fdeops/mcp/fdeops-ingest/server.js"],
+      "env": {
+        "FDEOPS_ENGAGEMENT": "/Users/you/fde-engagements/acme/.fde"
+      }
+    }
+  }
+}
+```
+
+**No Notion MCP?** Export page to markdown → [file.md](./file.md).
+
+## Pull phrase
+
+```text
+@fde pull the Acme discovery notes Notion page into the fieldbook
+```
+
+## Agent steps
+
+1. Capability check — Notion tools present?
+2. Fetch page/block text via Notion MCP (ask which page if ambiguous).
+3. Stage with `--source notion`.
+4. Propose → confirm → apply.
+
+## Common fails
+
+| Symptom | Fix |
+|---------|-----|
+| 401 / forbidden | Token lacks access to that workspace/page |
+| Huge page dump | Stage full text in `.inbox/`; propose only short dated facts |
+| Wrong engagement | Bind / `FDEOPS_ENGAGEMENT` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fdeops",
-  "version": "3.9.18",
+  "version": "3.9.20",
   "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",
@@ -18,6 +18,7 @@
     "hooks/",
     "templates/",
     "adapters/",
+    "mcp/",
     "CLAUDE.md.template",
     "AGENTS.md"
   ],

package/skills/fde/SKILL.md

@@ -83,6 +83,8 @@ When NOT to interrogate or challenge: unambiguous one-liners, mechanical ops, FD
 | (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>` → **you** (the agent) rewrite `.debrief-propose` with `decision:`/`risk:`/`delivery:`/`contact:`/`next:` prefixes where needed → show FDE → on confirm `fde debrief --apply`. `--smart` is a prefix/keyword gate, not a brain. Fallback: structure prefixed lines yourself, show FDE, then `fde debrief` |
+| "Make sure we're up to date" / "pull relevant info" / "pull from Granola/email/transcript" | Bind engagement; **capability check** (which source MCPs exist this session — never pretend). If missing → connect flow. Else fetch → `fde ingest stage` → `fde ingest propose` → rewrite prefixes → show FDE → on confirm `fde ingest apply`. **Never auto-apply. Never ambient sync.** Detail: `references/ingest.md` |
+| "Connect a new MCP" / "connect Granola/Notion" / "what can you pull?" | Follow `references/ingest-connect.md`: ask which source → emit `mcp.json` from `mcp/recipes/` + sink block → they save/reload in Cursor/Claude → verify tools → optional test stage to `.inbox/` only. You cannot silently install host MCPs. |
 | "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 |
@@ -269,6 +271,8 @@ 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` |
+| Make sure we're up to date, pull what's relevant, fetch from Granola/Gmail/transcript | ingest | `references/ingest.md` (capability check → stage → propose → confirm → apply) |
+| Connect a new MCP / connect Granola or Notion / what can you pull | ingest-connect | `references/ingest-connect.md` (+ `mcp/recipes/`) |
 | 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` |

package/skills/fde/references/debrief.md

@@ -2,6 +2,8 @@
 
 **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.
 
+**Large transcripts or emails** sitting in Granola/Gmail/Notion → prefer **`fde ingest stage`** first (via source MCPs the FDE configured), then the same propose → confirm → **`fde ingest apply`** path. See `references/ingest.md`. Pasted short notes stay on this debrief verb.
+
 **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 …`.

package/skills/fde/references/ingest-connect.md

@@ -0,0 +1,36 @@
+# ingest-connect - wire a source MCP in plain language
+
+**Enter when:** the FDE says "I want to connect a new MCP", "connect Granola / Notion / Drive", "how do I pull from …", or a pull request fails because no source tools exist.
+
+**Read first:** `references/ingest.md` (sink contract). Recipe pack: `mcp/recipes/` in the fdeops install (file, granola, notion).
+
+**Who runs setup:** you guide; the **host** (Cursor/Claude) must save MCP config. You cannot silently install servers into the host.
+
+## Honest contract
+
+- FDEOps = **sink** (`fdeops-ingest` / `fde ingest`). Sources = **whatever MCP the FDE adds**.
+- You produce a ready config snippet + steps. They save + reload. Then you verify with a capability check + optional test stage.
+- Never invent that Granola/Notion is available if tools are missing. Never ambient sync. Never auto-apply to `.fde/`.
+
+## Method
+
+1. **Ask one question** — which source? (`file` / `granola` / `notion` / other name). If "other", ask for the MCP package or docs URL they intend to use.
+2. **Capability check (current session)** — list MCP tools you can actually call:
+   - Sink present? (`ingest_stage` / `ingest_list` / or `fde ingest` CLI)
+   - Source present? (anything that can fetch that system's content)
+   - Say clearly: *available now* vs *needs config*.
+3. **Emit config** — open the matching recipe under `mcp/recipes/<source>.md`. Fill absolute paths:
+   - path to `mcp/fdeops-ingest/server.js` (from this fdeops install)
+   - `FDEOPS_ENGAGEMENT` → this client's `…/<slug>/.fde`
+   - placeholders for source API keys (tell them to paste secrets into host env — do not commit keys into the fieldbook)
+4. **Tell them where to paste** — Cursor: MCP settings / `~/.cursor/mcp.json` (or project MCP). Claude Code: MCP config per their docs. One sentence: save → reload MCP / restart session.
+5. **Verify** — after they confirm reload: re-run capability check. If source tools appear, offer a **test pull** into `.inbox/` only (stage + show list). Stop before apply unless they ask to propose.
+6. **Handoff phrase** — give them the daily line, e.g. `@fde pull today's Acme Granola into the fieldbook`.
+
+## If they only want the sink
+
+Still wire `fdeops-ingest` (or rely on CLI). File drops work with [mcp/recipes/file.md](../../../mcp/recipes/file.md) without any source MCP.
+
+## Checkpoint
+
+Before ending connect: (1) sink reachable, (2) source reachable or honest gap, (3) they know the pull phrase. Do not write `.fde/` during connect.

package/skills/fde/references/ingest.md

@@ -0,0 +1,72 @@
+# ingest - pull large artifacts into the fieldbook loop
+
+**Enter when:** the FDE wants to catch the engagement up from external sources — "make sure Acme is up to date," "pull what's relevant," "grab today's Granola and Denise's last email." Raw transcripts and long emails that are too big to paste usefully.
+
+**Connect / capability (different entry):** "connect a new MCP", "connect Granola/Notion", "what can you pull?" → `references/ingest-connect.md` first. Recipes: `mcp/recipes/` (file, granola, notion).
+
+**Read first:** `context.md` (what's already logged, what's stale). Bind the engagement before staging anything.
+
+**Who runs the CLI:** you (the agent). Never tell the FDE to type `fde ingest …`. Never auto-apply. Never background-sync or poll sources on your own.
+
+## Honest contract (read once)
+
+- FDEOps owns the **sink only**: stage raw pulls → propose → confirm → apply. Nothing writes `.fde/` unreviewed.
+- **Source MCPs are the FDE's.** Granola, Gmail, Notion, custom — whatever they configured in Cursor/Claude. fdeops does not bundle OAuth, connectors, or ambient sync.
+- The core `fde` CLI stays local (git + file reads). Source credentials live with that MCP; fdeops never stores them.
+- After apply, raw stays in `.inbox/`; the system of record (`.fde/`) stays thin dated facts.
+
+## Capability check (before every pull)
+
+List what you can actually call **this session**:
+
+1. **Sink** — `ingest_stage` / `fde ingest` available?
+2. **Sources** — which fetch tools exist (Granola-shaped, Notion, Drive, file-only)?
+3. Tell the FDE in one line: *I can pull from X; Y is not connected.* If they asked to pull Y and it is missing → switch to `ingest-connect.md`. Never pretend a source exists.
+
+## Ground loop (you do this work)
+
+1. **Bind** the engagement (`fde resume` / registry). If multiple meetings or threads could apply, ask **one** clarifying question — which meeting, which thread, which date range.
+2. **Capability check** (above). Then **fetch** via available source MCP(s). You pull; the CLI does not reach the network.
+3. **Stage** — `fde ingest stage [--source NAME] [--title TEXT] [file|-]` writes raw text into `<engagement>/.inbox/` (outside the memory git ledger).
+4. **List** (optional) — `fde ingest list` shows staged items when you need an id or filename.
+5. **Propose** — `fde ingest propose <id-or-filename>` runs the debrief `--smart` path on the staged body (+ provenance line). Opens `.debrief-propose`.
+6. **Rewrite prefixes** — same as debrief: lines without `decision:` / `risk:` / `delivery:` / `contact:` / `next:` need **you** to rewrite before showing the FDE. `--smart` is a gate, not a brain.
+7. **Show** the proposed routing in plain language. Wait for confirm.
+8. **Apply** — on FDE confirm only → `fde ingest apply` (= `fde debrief --apply`). On reject → stop; ask what to change.
+
+No invented names, meetings, or quotes. If the propose looks wrong, fix prefixes with judgment, then re-show before apply.
+
+## Paths
+
+| Path | Role |
+|------|------|
+| `~/fde-engagements/<slug>/.inbox/` | Staging for raw pulls. Not the memory ledger. NDA surface — same home tree as `.fde/`. |
+| `~/fde-engagements/<slug>/.fde/` | System of record (unchanged contract). |
+| `.fde/.debrief-propose` | Propose file (shared with debrief). |
+
+## CLI verbs
+
+```bash
+fde ingest stage [--source NAME] [--title TEXT] [file|-]
+fde ingest list
+fde ingest propose <id-or-filename>
+fde ingest apply
+```
+
+## Provenance
+
+When a staged fact came from a named source, carry `via:<source>` on the applied line where useful (e.g. `via:granola`, `via:gmail`). Helps receipts and sponsor disputes later — not mandatory on every context line.
+
+## MCP sink + recipes
+
+Optional `mcp/fdeops-ingest` wraps the same verbs over stdio. Source MCPs remain separate — the FDE adds whichever fetch tools they trust. Setup coach: `ingest-connect.md`. Copy-paste recipes: `mcp/recipes/`.
+
+## Checkpoint
+
+Before apply, read back the 2–3 most consequential captures in one breath — same as debrief. Confirm which sources you staged and what would land in the record. Then stop.
+
+## Principles
+
+- Pull on request, not on a schedule. No auto-poll, no vacuum of inbox or Slack.
+- Staging is not memory. Only `--apply` after confirm writes `.fde/`.
+- Large artifact → ingest stage first; pasted short notes → debrief verb directly (`references/debrief.md`).