fdeops 3.10.0 → 3.11.0

package/bin/lib/vault.js

@@ -0,0 +1,323 @@
+'use strict'
+
+// Derived Obsidian view of the fieldbook. Pure builders: in comes already-redacted
+// engagement data, out comes a list of { rel, content } files. No fs, no network.
+//
+// Two rules this file exists to keep:
+//   1. `.fde/` stays the only source of truth. Nothing here is ever parsed back,
+//      so an FDE can edit the vault, delete it, or ignore it with no consequence.
+//   2. The vault is an output of the CLI, so <private> blocks are already gone
+//      before anything reaches these builders (callers use readClean). `redacted`
+//      goes further and drops the political layer for a shared screen.
+
+const FORMAT = 1
+const STAMP = '.fdeops-vault'
+
+// Obsidian resolves [[links]] by note name, and | # ^ [ ] break the link syntax.
+// A client called "Acme | EU" must still get a reachable page.
+function safeTitle(s) {
+  return String(s || '')
+    .replace(/[[\]|#^\\/:*?"<>]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim() || 'untitled'
+}
+
+function cell(s) {
+  return String(s || '').replace(/\|/g, '\\|').replace(/\n+/g, ' ').trim()
+}
+
+function yamlStr(s) {
+  return `"${String(s == null ? '' : s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+}
+
+// Frontmatter is what makes the vault queryable (Obsidian properties, Dataview,
+// Bases). It exists only in generated files - the authoritative .fde/ markdown
+// stays plain, so a client can read it without a tool.
+function frontmatter(fields) {
+  const lines = ['---']
+  for (const [k, v] of Object.entries(fields)) {
+    if (v == null || v === '') continue
+    if (Array.isArray(v)) {
+      if (!v.length) continue
+      lines.push(`${k}:`)
+      v.forEach(item => lines.push(`  - ${yamlStr(item)}`))
+    } else if (typeof v === 'number' || typeof v === 'boolean') {
+      lines.push(`${k}: ${v}`)
+    } else {
+      lines.push(`${k}: ${yamlStr(v)}`)
+    }
+  }
+  lines.push('---', '')
+  return lines.join('\n')
+}
+
+function trustWord(trust) {
+  return String(trust || '').toLowerCase() === 'red' ? 'red' : String(trust || '')
+}
+
+// A signal token is internal shorthand; the sponsor view keeps the fact and
+// drops the grading. Whole section bodies pass through here, so only the space
+// the token itself occupied is closed up: a global whitespace collapse ate the
+// newlines, glued headings to prose and broke every table on these pages.
+function stripInternalTokens(text) {
+  return String(text || '')
+    .replace(/[^\S\n]*\[signal:(red|amber|green)\]/gi, '')
+    .replace(/[^\S\n]*\[@[^\]]+\]/g, '')
+    .trim()
+}
+
+function sectionPage({ eng, title, body, kind, redacted, today }) {
+  return frontmatter({
+    client: eng.name,
+    fde_page: kind,
+    phase: eng.signals.phase === '?' ? '' : eng.signals.phase,
+    generated: today,
+    tags: ['fdeops', `fdeops/${kind}`],
+  }) + `# ${safeTitle(eng.name)} - ${title}\n\n` +
+    `Engagement: [[${safeTitle(eng.name)}]]\n\n` +
+    (body.trim() ? body.trim() + '\n' : `*(nothing recorded yet)*\n`) +
+    `\n---\n*Generated from \`${eng.name}/.fde/${kind}.md\`${redacted ? ' - sponsor-safe copy' : ''}. Edit the fieldbook, not this page.*\n`
+}
+
+function personPage({ eng, person, today }) {
+  return frontmatter({
+    client: eng.name,
+    fde_page: 'person',
+    role: person.role,
+    signal: person.signal,
+    generated: today,
+    tags: ['fdeops', 'fdeops/person', `fdeops/signal/${person.signal || 'unknown'}`],
+  }) + `# ${safeTitle(person.name)}\n\n` +
+    `${person.role ? `**Role:** ${person.role}  \n` : ''}` +
+    `**Latest signal:** ${person.signal || 'unrecorded'}\n\n` +
+    (person.note ? `${person.note}\n\n` : '') +
+    `Engagement: [[${safeTitle(eng.name)}]]\n`
+}
+
+function hubPage({ eng, today, redacted }) {
+  const s = eng.signals
+  // Next action / Brief / Reality are free text an FDE types, so they carry the
+  // same internal tokens the timeline does - strip them on the sponsor page too.
+  const plain = (text) => redacted ? stripInternalTokens(text) : String(text || '')
+  const links = [
+    ['Decisions', 'decisions'],
+    ['Risks', 'risks'],
+    ['Delivery', 'delivery'],
+    ...(redacted ? [] : [['Stakeholders', 'stakeholders']]),
+    ['Terrain', 'terrain'],
+    ['Success', 'success'],
+    ...(redacted ? [] : [['Trust profile', 'trust-profile']]),
+  ].filter(([, kind]) => eng.pages[kind] != null)
+
+  const timeline = (redacted ? eng.log.filter(e => e.kind !== 'note') : eng.log)
+    .map(e => `- **${e.date}** ${cell(redacted ? stripInternalTokens(e.text) : e.text)}${e.sig && !redacted ? ` \`[${e.sig}]\`` : ''}`)
+
+  const people = redacted ? [] : eng.stakeholders.map(p =>
+    `- [[${safeTitle(eng.name)}/People/${safeTitle(p.name)}|${safeTitle(p.name)}]]${p.role ? ` - ${cell(p.role)}` : ''} \`${p.signal || 'unrecorded'}\``)
+
+  return frontmatter({
+    client: eng.name,
+    fde_page: 'engagement',
+    phase: s.phase === '?' ? '' : s.phase,
+    ...(redacted ? {} : { trust: trustWord(s.trust), signal_age_days: s.signalAge == null ? '' : s.signalAge, signal_stale: !!s.stale }),
+    open_risks: s.openRisks,
+    days_elapsed: eng.days == null ? '' : eng.days,
+    last_updated: s.updated,
+    overlay: eng.overlay || '',
+    generated: today,
+    tags: ['fdeops', 'fdeops/engagement', ...(redacted ? [] : [`fdeops/trust/${trustWord(s.trust) || 'unknown'}`])],
+  }) + [
+    `# ${safeTitle(eng.name)}`,
+    '',
+    `**Phase:** ${s.phase === '?' ? 'unset' : s.phase}` +
+      (redacted ? '' : `  ·  **Trust:** ${trustWord(s.trust)}${s.stale ? ' (signal stale - reconfirm)' : ''}`) +
+      `  ·  **Open risks:** ${s.openRisks}  ·  **Updated:** ${s.updated}`,
+    '',
+    '## Next action',
+    '',
+    eng.next ? plain(eng.next) : '*(none recorded - `fde log`/`@fde` writes one)*',
+    '',
+    ...(eng.brief ? ['## Brief', '', plain(eng.brief), ''] : []),
+    ...(eng.reality ? ['## Reality', '', plain(eng.reality), ''] : []),
+    '## The record',
+    '',
+    ...links.map(([label, kind]) => `- [[${safeTitle(eng.name)}/${label}|${label}]]`),
+    '',
+    ...(people.length ? ['## People', '', ...people, ''] : []),
+    ...(timeline.length ? ['## Timeline', '', ...timeline, ''] : []),
+    '---',
+    `*Derived from \`${eng.name}/.fde/\` on ${today}. Regenerate with \`fde vault${redacted ? ' --redacted' : ''}\`.*`,
+    '',
+  ].join('\n')
+}
+
+function portfolioPage({ engagements, today, redacted }) {
+  const order = { RED: 0, amber: 1, green: 2 }
+  const rows = [...engagements].sort((a, b) =>
+    (order[a.signals.trust] ?? 3) - (order[b.signals.trust] ?? 3) || a.name.localeCompare(b.name))
+
+  const head = redacted
+    ? ['| Engagement | Phase | Open risks | Next action |', '|---|---|---|---|']
+    : ['| Engagement | Phase | Trust | Open risks | Updated | Next action |', '|---|---|---|---|---|---|']
+
+  const body = rows.map(e => {
+    const link = `[[${safeTitle(e.name)}]]`
+    const phase = e.signals.phase === '?' ? 'unset' : e.signals.phase
+    const next = cell(redacted ? stripInternalTokens(e.next) : e.next) || '-'
+    return redacted
+      ? `| ${link} | ${phase} | ${e.signals.openRisks} | ${next} |`
+      : `| ${link} | ${phase} | ${trustWord(e.signals.trust)}${e.signals.stale ? '?' : ''} | ${e.signals.openRisks} | ${cell(e.signals.updated)} | ${next} |`
+  })
+
+  return frontmatter({
+    fde_page: 'portfolio',
+    engagements: rows.length,
+    generated: today,
+    tags: ['fdeops', 'fdeops/portfolio'],
+  }) + [
+    '# Portfolio',
+    '',
+    rows.length
+      ? `${rows.length} engagement${rows.length === 1 ? '' : 's'}${redacted ? '' : ', worst trust first'}.`
+      : 'No engagements yet - `fde resume --init <name>`.',
+    '',
+    ...(rows.length ? [...head, ...body, ''] : []),
+    ...(redacted ? [] : ['See [[Questions]] for what the record is missing.', '']),
+  ].join('\n')
+}
+
+// Deterministic answers, computed here rather than shipped as Dataview queries:
+// the vault must work in a stock Obsidian with no plugins installed.
+function questionsPage({ engagements, today }) {
+  const quiet = engagements.filter(e => e.signals.ageDays !== Infinity && e.signals.ageDays >= 14)
+  const staleSignal = engagements.filter(e => e.signals.stale)
+  const noNext = engagements.filter(e => !e.next)
+  const unaccepted = []
+  const noSignal = []
+  for (const e of engagements) {
+    for (const row of e.valueRows || []) {
+      if (!row.acceptedBy) unaccepted.push({ eng: e, row })
+    }
+    if (!e.stakeholders.length) noSignal.push(e)
+  }
+
+  const list = (items, empty) => items.length ? items : [`- ${empty}`]
+
+  return frontmatter({
+    fde_page: 'questions',
+    generated: today,
+    tags: ['fdeops', 'fdeops/questions'],
+  }) + [
+    '# Questions',
+    '',
+    'What the record cannot answer is the part worth reading. Recomputed on every `fde vault`.',
+    '',
+    '## Gone quiet (14+ days since a memory write)',
+    '',
+    ...list(quiet.map(e => `- [[${safeTitle(e.name)}]] - ${e.signals.updated}`), 'none'),
+    '',
+    '## Value promised but nobody accepted it',
+    '',
+    ...list(unaccepted.map(({ eng, row }) => `- [[${safeTitle(eng.name)}]] - ${cell(row.slice || row.promised || 'unnamed slice')}`),
+      'none - every delivered slice names a customer-side acceptor'),
+    '',
+    '## Trust signal older than 21 days',
+    '',
+    ...list(staleSignal.map(e => `- [[${safeTitle(e.name)}]] - signal ${e.signals.signalAge}d old`), 'none'),
+    '',
+    '## No stakeholder signal at all',
+    '',
+    ...list(noSignal.map(e => `- [[${safeTitle(e.name)}]]`), 'none'),
+    '',
+    '## No next action recorded',
+    '',
+    ...list(noNext.map(e => `- [[${safeTitle(e.name)}]]`), 'none'),
+    '',
+    `Portfolio: [[Portfolio]]`,
+    '',
+  ].join('\n')
+}
+
+function readmePage({ engagements, today, redacted, engagementsRoot }) {
+  return [
+    '# FDEOps vault (generated - do not keep anything here)',
+    '',
+    `Generated ${today} from \`${engagementsRoot}\`. ${engagements.length} engagement${engagements.length === 1 ? '' : 's'}.`,
+    '',
+    'Open this folder as an Obsidian vault. Start at [[Portfolio]]' + (redacted ? '.' : ' and [[Questions]].'),
+    '',
+    '## What this is',
+    '',
+    '- A **derived** view. The fieldbook at `~/fde-engagements/<client>/.fde/` is the only source of truth.',
+    '- **Disposable.** `fde vault` deletes and rebuilds this folder, so anything you type here is lost. Log to the fieldbook instead (`@fde` or `fde log`).',
+    '- **Nothing is read back.** No plugin required, no sync, no network - plain markdown, wikilinks and frontmatter.',
+    '',
+    '## What is not here',
+    '',
+    '- `<private>` blocks. They never leave `.fde/`; every page here is built from redacted reads.',
+    ...(redacted
+      ? [
+        '- Stakeholders, people pages, trust signals and `trust-profile.md` - this is the `--redacted` build, meant for a shared screen.',
+        '- Internal `[signal:x]` and `[@owner]` tokens, and contact notes in the timeline.',
+        '',
+        '**Still check before you screen-share.** Redaction removes the political layer, not judgement: `decisions.md`, `risks.md` and `delivery.md` are shown as written.',
+      ]
+      : [
+        '- Nothing else. This is the full working view, for your machine only. For a sponsor meeting run `fde vault --redacted`.',
+      ]),
+    '',
+  ].join('\n')
+}
+
+function buildVaultFiles({ engagements, today, redacted = false, engagementsRoot = '~/fde-engagements', version = '' }) {
+  const files = []
+  const SECTIONS = [
+    ['Decisions', 'decisions'],
+    ['Risks', 'risks'],
+    ['Delivery', 'delivery'],
+    ['Stakeholders', 'stakeholders'],
+    ['Terrain', 'terrain'],
+    ['Success', 'success'],
+    ['Trust profile', 'trust-profile'],
+  ]
+  const REDACTED_OUT = new Set(['stakeholders', 'trust-profile'])
+
+  files.push({ rel: 'README.md', content: readmePage({ engagements, today, redacted, engagementsRoot }) })
+  files.push({ rel: 'Portfolio.md', content: portfolioPage({ engagements, today, redacted }) })
+  if (!redacted) files.push({ rel: 'Questions.md', content: questionsPage({ engagements, today }) })
+
+  for (const eng of engagements) {
+    const dir = safeTitle(eng.name)
+    files.push({ rel: `${dir}/${dir}.md`, content: hubPage({ eng, today, redacted }) })
+    for (const [title, kind] of SECTIONS) {
+      if (redacted && REDACTED_OUT.has(kind)) continue
+      const body = eng.pages[kind]
+      if (body == null) continue
+      files.push({
+        rel: `${dir}/${title}.md`,
+        content: sectionPage({ eng, title, body: redacted ? stripInternalTokens(body) : body, kind, redacted, today }),
+      })
+    }
+    if (!redacted) {
+      for (const person of eng.stakeholders) {
+        files.push({ rel: `${dir}/People/${safeTitle(person.name)}.md`, content: personPage({ eng, person, today }) })
+      }
+    }
+  }
+
+  // A generated vault must not become a commit. `*` covers the whole tree, so a
+  // vault written inside a repo checkout stays out of `git status` too.
+  files.push({ rel: '.gitignore', content: '# generated by fde vault - never commit a client record\n*\n' })
+  files.push({
+    rel: STAMP,
+    content: JSON.stringify({
+      tool: 'fdeops', format: FORMAT, version, generated: today,
+      mode: redacted ? 'redacted' : 'full', engagements: engagements.length,
+      source: engagementsRoot,
+      note: 'Written by `fde vault`. Deleted and rebuilt on every run - this file is how the CLI knows the folder is safe to replace.',
+    }, null, 2) + '\n',
+  })
+  return files
+}
+
+module.exports = { buildVaultFiles, safeTitle, stripInternalTokens, frontmatter, STAMP, FORMAT }

package/hooks/pre-compact

@@ -7,7 +7,23 @@ resolve_engagement_dir() {
   [ -z "$raw" ] && return 1
   # strip surrounding whitespace/quotes only - paths may contain spaces
   raw=$(printf '%s' "$raw" | sed -e 's/^[[:space:]"'"'"']*//' -e 's/[[:space:]"'"'"']*$//' -e "s|^~|$HOME|")
-  [ -d "$raw" ] && printf '%s\n' "$raw" && return 0
+  # Same forms bin/fde.js accepts: an absolute .fde, an absolute engagement
+  # folder, or a bare slug under the engagements root - keep the two in lockstep.
+  # Anything relative is refused: it would resolve against whatever directory
+  # the agent happened to start in.
+  case $raw in
+    /*)
+      [ -d "$raw/.fde" ] && printf '%s\n' "$raw/.fde" && return 0
+      [ -d "$raw" ] && printf '%s\n' "$raw" && return 0
+      return 1
+      ;;
+    */*|.*) return 1 ;;
+  esac
+  local root="${FDEOPS_ENGAGEMENTS_ROOT:-$HOME/fde-engagements}"
+  root="${root/#\~/$HOME}"
+  local slug
+  slug=$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]' | sed -e 's/[^a-z0-9]\+/-/g' -e 's/^-//' -e 's/-$//')
+  [ -n "$slug" ] && [ -d "$root/$slug/.fde" ] && printf '%s\n' "$root/$slug/.fde" && return 0
   return 1
 }
 
@@ -57,6 +73,13 @@ resolve_fde() {
 
 ENG_DIR=$(resolve_engagement_dir "${FDEOPS_ENGAGEMENT:-${FDEOS_ENGAGEMENT:-}}")
 
+# An override that cannot be honored is never ignored: falling through to the
+# registry would write this session into whichever engagement the workspace is
+# bound to, and the operator named a different one. bin/fde.js refuses; so do we.
+if [ -z "$ENG_DIR" ] && [ -n "${FDEOPS_ENGAGEMENT:-${FDEOS_ENGAGEMENT:-}}" ]; then
+  exit 0
+fi
+
 if [ -z "$ENG_DIR" ]; then
   ENG_DIR=$(registry_engagement_dir)
 fi

package/hooks/session-start

@@ -11,7 +11,23 @@ resolve_engagement_dir() {
   [ -z "$raw" ] && return 1
   # strip surrounding whitespace/quotes only - paths may contain spaces
   raw=$(printf '%s' "$raw" | sed -e 's/^[[:space:]"'"'"']*//' -e 's/[[:space:]"'"'"']*$//' -e "s|^~|$HOME|")
-  [ -d "$raw" ] && printf '%s\n' "$raw" && return 0
+  # Same forms bin/fde.js accepts: an absolute .fde, an absolute engagement
+  # folder, or a bare slug under the engagements root - keep the two in lockstep.
+  # Anything relative is refused: it would resolve against whatever directory
+  # the agent happened to start in.
+  case $raw in
+    /*)
+      [ -d "$raw/.fde" ] && printf '%s\n' "$raw/.fde" && return 0
+      [ -d "$raw" ] && printf '%s\n' "$raw" && return 0
+      return 1
+      ;;
+    */*|.*) return 1 ;;
+  esac
+  local root="${FDEOPS_ENGAGEMENTS_ROOT:-$HOME/fde-engagements}"
+  root="${root/#\~/$HOME}"
+  local slug
+  slug=$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]' | sed -e 's/[^a-z0-9]\+/-/g' -e 's/^-//' -e 's/-$//')
+  [ -n "$slug" ] && [ -d "$root/$slug/.fde" ] && printf '%s\n' "$root/$slug/.fde" && return 0
   return 1
 }
 
@@ -46,6 +62,13 @@ if [ -z "$CONTEXT_FILE" ]; then
   [ -n "$ENG_DIR" ] && CONTEXT_FILE="$ENG_DIR/context.md"
 fi
 
+# An override that cannot be honored is never ignored: falling through to the
+# registry would load whichever engagement the workspace is bound to, and the
+# operator named a different one. bin/fde.js refuses; so do we.
+if [ -z "$CONTEXT_FILE" ] && [ -n "${FDEOPS_ENGAGEMENT:-${FDEOS_ENGAGEMENT:-}}" ]; then
+  exit 0
+fi
+
 # 2) Workspace registry binding (written by fde resume --init)
 if [ -z "$CONTEXT_FILE" ]; then
   ENG_DIR=$(registry_engagement_dir)

package/hooks/session-stop

@@ -14,7 +14,23 @@ resolve_engagement_dir() {
   [ -z "$raw" ] && return 1
   # strip surrounding whitespace/quotes only - paths may contain spaces
   raw=$(printf '%s' "$raw" | sed -e 's/^[[:space:]"'"'"']*//' -e 's/[[:space:]"'"'"']*$//' -e "s|^~|$HOME|")
-  [ -d "$raw" ] && printf '%s\n' "$raw" && return 0
+  # Same forms bin/fde.js accepts: an absolute .fde, an absolute engagement
+  # folder, or a bare slug under the engagements root - keep the two in lockstep.
+  # Anything relative is refused: it would resolve against whatever directory
+  # the agent happened to start in.
+  case $raw in
+    /*)
+      [ -d "$raw/.fde" ] && printf '%s\n' "$raw/.fde" && return 0
+      [ -d "$raw" ] && printf '%s\n' "$raw" && return 0
+      return 1
+      ;;
+    */*|.*) return 1 ;;
+  esac
+  local root="${FDEOPS_ENGAGEMENTS_ROOT:-$HOME/fde-engagements}"
+  root="${root/#\~/$HOME}"
+  local slug
+  slug=$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]' | sed -e 's/[^a-z0-9]\+/-/g' -e 's/^-//' -e 's/-$//')
+  [ -n "$slug" ] && [ -d "$root/$slug/.fde" ] && printf '%s\n' "$root/$slug/.fde" && return 0
   return 1
 }
 
@@ -77,6 +93,13 @@ ENG_DIR=""
 # 1) Environment variable (any agent)
 ENG_DIR=$(resolve_engagement_dir "${FDEOPS_ENGAGEMENT:-${FDEOS_ENGAGEMENT:-}}")
 
+# An override that cannot be honored is never ignored: falling through to the
+# registry would write this session into whichever engagement the workspace is
+# bound to, and the operator named a different one. bin/fde.js refuses; so do we.
+if [ -z "$ENG_DIR" ] && [ -n "${FDEOPS_ENGAGEMENT:-${FDEOS_ENGAGEMENT:-}}" ]; then
+  exit 0
+fi
+
 # 2) Workspace registry binding (written by fde resume --init)
 if [ -z "$ENG_DIR" ]; then
   ENG_DIR=$(registry_engagement_dir)

package/mcp/README.md

@@ -6,7 +6,7 @@ FDEOps MCP servers follow a **pluggable source model**: core owns the **sink**,
 
 | Role | Owner | Examples |
 |------|-------|----------|
-| **Source** | FDE configures separately | Granola, Gmail, Notion, custom scrapers |
+| **Source** | FDE configures separately | Granola, Slack, Notion, Gmail, file |
 | **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.

package/mcp/fdeops-ingest/README.md

@@ -2,7 +2,9 @@
 
 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`.
+This package shells out to the local `fde` CLI. It never calls SaaS APIs. Source MCPs (Granola, Slack, Notion, etc.) are **separate** — you add those in your own `mcp.json`.
+
+**Prefer the CLI when this workspace is bound:** `fde ingest stage|list|propose|apply`. Use this MCP when the host did not start in a bound workspace — then pass `engagement` (path to `.fde/` from `fde resume --bind`) on every tool call.
 
 ## Tools
 
@@ -89,4 +91,4 @@ 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.
+Hand-rolled MCP over stdio (newline-delimited JSON-RPC). No `@modelcontextprotocol/sdk` required at runtime.

package/mcp/fdeops-ingest/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fdeops-ingest-mcp",
-  "version": "3.10.0",
+  "version": "3.11.0",
   "private": true,
   "description": "Thin stdio MCP sink for FDEOps ingest (stage → propose → apply). Zero runtime dependencies.",
   "bin": {

package/mcp/fdeops-ingest/server.js

@@ -4,7 +4,8 @@
 /**
  * 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.
+ * MCP stdio transport: newline-delimited JSON-RPC 2.0
+ * (Content-Length frames are accepted on input).
  */
 
 const fs = require('fs')
@@ -15,11 +16,17 @@ const PROTOCOL_VERSION = '2024-11-05'
 const SERVER_NAME = 'fdeops-ingest'
 const SERVER_VERSION = require('./package.json').version
 
+const ENGAGEMENT_PROP = {
+  type: 'string',
+  description:
+    'Path to this client\'s .fde/ folder (from `fde resume --bind`). Optional if FDEOPS_ENGAGEMENT is set or the process cwd is already bound.',
+}
+
 const TOOLS = [
   {
     name: 'ingest_stage',
     description:
-      'Stage raw content into the engagement inbox (.inbox/). Does not write .fde/.',
+      'Stage raw content into the engagement inbox (.inbox/). Does not write .fde/. Prefer the fde ingest CLI when the workspace is already bound.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -29,12 +36,13 @@ const TOOLS = [
         },
         source: {
           type: 'string',
-          description: 'Provenance label (e.g. granola, gmail, manual). Default: manual.',
+          description: 'Provenance label (e.g. granola, slack, notion, file, manual). Default: manual.',
         },
         title: {
           type: 'string',
           description: 'Optional human-readable title for the staged item.',
         },
+        engagement: ENGAGEMENT_PROP,
       },
       required: ['content'],
     },
@@ -42,7 +50,10 @@ const TOOLS = [
   {
     name: 'ingest_list',
     description: 'List staged items in the current engagement inbox.',
-    inputSchema: { type: 'object', properties: {} },
+    inputSchema: {
+      type: 'object',
+      properties: { engagement: ENGAGEMENT_PROP },
+    },
   },
   {
     name: 'ingest_propose',
@@ -55,6 +66,7 @@ const TOOLS = [
           type: 'string',
           description: 'Staged filename or id from ingest_list.',
         },
+        engagement: ENGAGEMENT_PROP,
       },
       required: ['id'],
     },
@@ -63,7 +75,10 @@ const TOOLS = [
     name: 'ingest_apply',
     description:
       'Apply the current debrief proposal into .fde/ memory (requires prior FDE confirm).',
-    inputSchema: { type: 'object', properties: {} },
+    inputSchema: {
+      type: 'object',
+      properties: { engagement: ENGAGEMENT_PROP },
+    },
   },
 ]
 
@@ -128,10 +143,10 @@ function fdeEnv() {
   return env
 }
 
-function runFde(args, stdin) {
+function runFde(args, stdin, extraEnv) {
   const { cmd, prefix } = resolveFde()
   const result = spawnSync(cmd, [...prefix, ...args], {
-    env: fdeEnv(),
+    env: { ...fdeEnv(), ...(extraEnv || {}) },
     input: stdin ?? undefined,
     encoding: 'utf8',
     maxBuffer: 16 * 1024 * 1024,
@@ -144,6 +159,11 @@ function runFde(args, stdin) {
   }
 }
 
+function engagementEnv(args) {
+  const p = args && typeof args.engagement === 'string' ? args.engagement.trim() : ''
+  return p ? { FDEOPS_ENGAGEMENT: p } : {}
+}
+
 function cliPayload(out) {
   const payload = { stdout: out.stdout, stderr: out.stderr, status: out.status }
   if (out.error) payload.spawnError = out.error
@@ -163,6 +183,7 @@ function toolError(payload) {
 
 function handleToolCall(name, args) {
   args = args || {}
+  const extraEnv = engagementEnv(args)
 
   switch (name) {
     case 'ingest_stage': {
@@ -172,23 +193,23 @@ function handleToolCall(name, args) {
       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 out = runFde(cliArgs, args.content, extraEnv)
       const payload = cliPayload(out)
       return out.status === 0 ? toolResult(payload) : toolError(payload)
     }
     case 'ingest_list': {
-      const out = runFde(['ingest', 'list'])
+      const out = runFde(['ingest', 'list'], undefined, extraEnv)
       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 out = runFde(['ingest', 'propose', String(args.id)], undefined, extraEnv)
       const payload = cliPayload(out)
       return out.status === 0 ? toolResult(payload) : toolError(payload)
     }
     case 'ingest_apply': {
-      const out = runFde(['ingest', 'apply'])
+      const out = runFde(['ingest', 'apply'], undefined, extraEnv)
       const payload = cliPayload(out)
       return out.status === 0 ? toolResult(payload) : toolError(payload)
     }

package/mcp/recipes/README.md

@@ -1,15 +1,16 @@
 # 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**.
+FDEOps does **not** bundle Granola / Slack / Notion OAuth and does **not** push to those tools.
 
-**Contract every source must satisfy:** fetch text → `fde ingest stage` (or MCP `ingest_stage`) with `{ source, title, content }` → propose → FDE confirms → apply.
+**Daily (no MCP):** paste notes to `@fde debrief`, or drop a file ([file.md](./file.md)).
+
+**Pull (optional):** you add a **source** MCP. The agent fetches text, then runs `fde ingest` in this bound workspace (stage → propose → you confirm → apply). The `fdeops-ingest` MCP is optional — only if you are not using the CLI from a bound workspace.
 
 | 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).
+| [file.md](./file.md) | Transcript / export already on disk, or paste |
+| [granola.md](./granola.md) | Meeting transcripts via a notes MCP (or export) |
+| [slack.md](./slack.md) | Pull a thread/channel as text — never post |
+| [notion.md](./notion.md) | Read a Notion page (or export markdown) |
 
-**Natural language:** `@fde I want to connect Granola` → agent follows `skills/fde/references/ingest-connect.md` and this recipe.
+**Natural language:** `@fde I want to connect Granola` (or Slack / Notion) → `skills/fde/references/ingest-connect.md`.