fdeops 3.11.1 → 3.15.0

package/bin/check.js

@@ -41,12 +41,11 @@ for (const f of requiredTemplates) {
   else ok(`template ${f}`)
 }
 
-const gif = path.join(root, 'media', 'demo.gif')
-if (!fs.existsSync(gif) || fs.statSync(gif).size < 1000) {
-  fail('media/demo.gif missing or too small')
-} else {
-  ok('media/demo.gif')
+const deadMedia = ['demo.gif', 'demo.sh', 'demo.tape', 'terminal-demo.svg', 'fieldbook-dashboard.png', 'fieldbook-detail.png', 'fieldbook-walkthrough.gif']
+for (const name of deadMedia) {
+  if (fs.existsSync(path.join(root, 'media', name))) fail(`dead media/${name} must not ship — the recorded session is session.gif`)
 }
+ok('no staged mock media')
 
 for (const dir of fs.readdirSync(path.join(root, 'skills'))) {
   const skill = path.join(root, 'skills', dir, 'SKILL.md')
@@ -57,10 +56,14 @@ for (const dir of fs.readdirSync(path.join(root, 'skills'))) {
 }
 ok('skills structure')
 
+if (fs.existsSync(path.join(root, 'skills', 'fde', 'archive'))) {
+  fail('skills/fde/archive must not exist — unrouted methods are dead code')
+} else ok('no archived skill dump')
+
 // v3: one skill + phase references (progressive disclosure)
 const requiredReferences = [
-  'land.md', 'discover.md', 'audit.md', 'plan.md', 'build.md', 'review.md',
-  'debug.md', 'rescue.md', 'ship.md', 'sketch.md', 'close.md', 'dashboard.md',
+  'land.md', 'discover.md', 'audit.md', 'plan.md', 'review.md',
+  'rescue.md', 'ship.md', 'sketch.md', 'close.md', 'dashboard.md',
   'debrief.md', 'status.md', 'demo-prep.md',
   'healthcare.md', 'fintech.md', 'gov.md',
   'ai.md', 'eval-pack.md',
@@ -80,7 +83,7 @@ ok('phase references')
 // every judgment-heavy reference carries a worked example that names the memory
 // file the work lands in. Prose-only guidance drifts into advice nobody can apply.
 const exampleReferences = [
-  'land.md', 'discover.md', 'plan.md', 'build.md', 'ship.md', 'close.md',
+  'land.md', 'discover.md', 'plan.md', 'ship.md', 'close.md',
   'status.md', 'stakeholder-radar.md', 'options-analysis.md', 'business-case.md',
   'assumption-audit.md', 'scope-defense.md',
 ]
@@ -118,7 +121,7 @@ ok(`router dispatch (${mentioned.length} reference targets verified) + memory co
   // Every routing row must parse. A row this misses is a method that could go
   // undocumented for free, so an unparsed row is a hard failure, not a silent skip.
   const routed = new Set()
-  const routing = (router.split('## Routing - 6 domains')[1] || '').split('**Overlays')[0]
+  const routing = (router.split(/^## Routing[^\n]*$/m)[1] || '').split('**Overlays')[0]
   const methodCell = line => (line.split('|')[2] || '').trim().replace(/\s*\([^)]*\)\s*$/, '')
   for (const line of routing.split('\n')) {
     if (!/^\|/.test(line)) continue
@@ -197,6 +200,11 @@ ok(`router dispatch (${mentioned.length} reference targets verified) + memory co
     }
   }
   ok(`public method count is verifiable (${documented.size} documented, ${routed.size} routed)`)
+
+  const refDir = path.join(root, 'skills', 'fde', 'references')
+  const extra = fs.readdirSync(refDir).filter(f => f.endsWith('.md') && !mentioned.includes(f))
+  if (extra.length) fail(`unrouted reference file(s) — dead method: ${extra.join(', ')}`)
+  else ok('no unrouted reference files')
 }
 
 const install = read('bin/install.js')
@@ -215,26 +223,20 @@ if (read('package.json').includes('postinstall')) {
 }
 
 const readme = read('README.md')
-// The README shows one recording: media/session.gif, a real CLI session.
-// media/demo.gif is a hand-typed mock kept for history - it must never be embedded,
-// or the front door shows output no command actually produced.
-if (readme.includes('demo.gif')) fail('README must not embed media/demo.gif (staged mock, not real CLI output)')
-else ok('README no staged demo gif')
-
-// The recording may live on the front door or one click in (docs/USAGE.md), but
-// it must stay reachable and reproducible - an orphaned gif rots silently.
-const recordingHosts = ['README.md', 'docs/USAGE.md'].filter(f => read(f).includes('media/session.gif'))
-if (!recordingHosts.length) {
-  fail('media/session.gif must be embedded in README.md or docs/USAGE.md (the recorded session is the proof)')
-} else if (!recordingHosts.some(f => read(f).includes('media/record-session.sh'))) {
-  fail('link media/record-session.sh next to the recording, so it can be re-recorded')
+if (/session\.gif|demo\.gif|<img /i.test(readme)) {
+  fail('README must not embed images — front door is text; the recording lives in docs/USAGE.md')
+} else ok('README is text (no gif)')
+
+const usage = read('docs/USAGE.md')
+if (!usage.includes('media/session.gif') || !usage.includes('media/record-session.sh')) {
+  fail('docs/USAGE.md must embed media/session.gif and link media/record-session.sh')
 } else {
   const gifPath = path.join(root, 'media', 'session.gif')
   const rec = path.join(root, 'media', 'record-session.sh')
   if (!fs.existsSync(gifPath) || fs.statSync(gifPath).size < 50000) fail('media/session.gif missing or too small')
   else if (!fs.existsSync(rec)) fail('media/record-session.sh missing - the recording must be reproducible')
   else if (!fs.existsSync(path.join(root, 'media', 'session.cast'))) fail('media/session.cast missing - keep the source recording next to the gif')
-  else ok(`recorded session in ${recordingHosts.join(' + ')} (gif + reproducible recorder + cast)`)
+  else ok('recorded session in docs/USAGE.md (gif + reproducible recorder + cast)')
 }
 
 // Every repo-relative README link and image must resolve, or the front door 404s.
@@ -249,10 +251,10 @@ else ok('README links all resolve')
 
 for (const section of [
   'How it works',
-  'Quickstart',
+  'Quick Start',
   'Engagement memory',
   'Who this is for',
-  'The week',
+  'Commands',
   'Principles',
 ]) {
   if (!readme.includes(section)) fail(`README missing section: ${section}`)
@@ -262,6 +264,16 @@ if (!readme.includes('AI coding agent')) {
 }
 ok('README clarity sections')
 
+for (const cmd of ['/brief', '/discover', '/plan', '/ship', '/got', '/close', '/debrief', '/prep', '/quiet', '/agreed', '/status']) {
+  if (!readme.includes(cmd)) fail(`README must document slash command ${cmd}`)
+}
+ok('README slash commands documented')
+
+// Front-door map is the embed left-to-right (LAND → CLOSE), not a pile of situations.
+if (!readme.slice(0, 4000).includes('LAND') || !readme.slice(0, 4000).includes('/discover')) {
+  fail('README must include the LAND→CLOSE command-map diagram near the top')
+} else ok('README command-map diagram')
+
 if (readme.includes('your-client-repo')) {
   fail('README must not instruct install in customer repo (your-client-repo)')
 } else ok('README no customer-repo install')
@@ -286,6 +298,33 @@ if (!read('skills/fde/SKILL.md').includes('npx --yes fdeops')) {
   fail('skills/fde/SKILL.md must fall back to npx --yes fdeops when the CLI is not installed')
 } else ok('SKILL.md npx CLI fallback')
 
+// The frontmatter description is the only text every host reads before deciding
+// to load the skill. If it triggers on "@fde" alone, an FDE who just talks about
+// their client gets no memory - so it must carry natural-intent triggers in the
+// "Use when …" convention, and @fde must be one of several, never the gate.
+{
+  const fm = /^---\n([\s\S]*?)\n---/.exec(read('skills/fde/SKILL.md'))
+  const desc = fm ? (/^description:[^\S\n]*(.*)$/m.exec(fm[1]) || [])[1] || '' : ''
+  const triggers = desc.match(/Use when/g) || []
+  if (triggers.length < 4) {
+    fail(`SKILL.md description needs several "Use when …" triggers so it fires on intent (found ${triggers.length})`)
+  } else if (/Use when the human says @fde or/.test(desc)) {
+    fail('SKILL.md description must not gate on @fde - name the client-work intents first')
+  } else ok('SKILL.md description triggers on intent')
+}
+
+// Six invented words (fieldbook, terrain, reality, trust signal, receipts,
+// vault) carry the method. They were never defined in one place, so a stranger
+// met them scattered through the docs and guessed.
+{
+  const gloss = /Words used here[\s\S]{0,1200}/.exec(readme)
+  const missing = ['fieldbook', 'reality', 'terrain', 'trust signal', 'receipts', 'vault']
+    .filter(w => !gloss || !new RegExp(w, 'i').test(gloss[0]))
+  if (!gloss) fail('README must define its invented words once (a "Words used here" line)')
+  else if (missing.length) fail(`README glossary is missing: ${missing.join(', ')}`)
+  else ok('README defines its own vocabulary')
+}
+
 if (!fs.existsSync(path.join(root, 'docs', 'USAGE.md'))) {
   fail('docs/USAGE.md missing')
 } else ok('docs/USAGE.md')
@@ -508,6 +547,16 @@ const plugin = JSON.parse(read('.claude-plugin/plugin.json'))
 if (pkg.version !== plugin.version) {
   fail(`version mismatch package.json ${pkg.version} vs plugin ${plugin.version}`)
 } else ok('plugin version aligned')
+if (plugin.commands !== './.claude/commands' || plugin.skills !== './skills') {
+  fail('.claude-plugin/plugin.json must declare skills and commands')
+} else {
+  for (const cmd of ['brief', 'discover', 'plan', 'ship', 'got', 'close', 'debrief', 'prep', 'quiet', 'agreed', 'status']) {
+    const rel = `.claude/commands/${cmd}.md`
+    if (!fs.existsSync(path.join(root, rel))) fail(`${rel} missing`)
+    else if (!read(rel).includes('@fde')) fail(`${rel} must load @fde`)
+  }
+  ok('slash commands load @fde')
+}
 
 if (!fs.existsSync(path.join(root, 'mcp', 'fdeops-ingest', 'server.js'))) {
   fail('mcp/fdeops-ingest/server.js missing (ingest MCP sink)')

package/bin/fde.js

@@ -18,13 +18,13 @@
  *   fde debrief --smart     propose routing from messy notes; --apply commits it
  *   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 tidy [--apply]      propose safe consolidations; apply only with --apply (was: garden)
  *   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)
  *   fde preserve            pre-compaction context snapshot (hook-internal; hooks use this)
- *   fde status [--all]      current engagement (default) or full portfolio (--all)
+ *   fde status [--all]      value ledger first, then trust (pass --all for portfolio)
  *   fde dashboard [--all]   current engagement fieldbook (default) or all (--all)
  *   fde vault               derived Obsidian vault of the fieldbook (disposable; --redacted)
  */
@@ -738,11 +738,20 @@ function appendLogEntry(eng, type, entry, opts = {}) {
 // degrading to "nothing found" rather than guessing when the shape does not
 // match. Never fabricate a number, a name, or a signal that is not in the text.
 
+const PHASES = ['land', 'discover', 'plan', 'ship', 'prove', 'close']
+const PHASE_ALIASES = { build: 'ship' } // legacy SDLC name; public map is ship
 const PHASE_LABELS = {
-  land: 'Embed & Trust', discover: 'Discover & Diagnose', plan: 'Plan & Align',
-  build: 'Build & Guard', ship: 'Ship & Verify', close: 'Operate & Close',
+  land: 'Land', discover: 'Discover', plan: 'Plan',
+  ship: 'Ship', prove: 'Prove', close: 'Close',
+}
+function canonicalPhase(phase) {
+  const p = String(phase).toLowerCase()
+  return PHASE_ALIASES[p] || p
+}
+function phaseLabel(phase) {
+  const p = canonicalPhase(phase)
+  return PHASE_LABELS[p] || phase
 }
-function phaseLabel(phase) { return PHASE_LABELS[String(phase).toLowerCase()] || phase }
 
 // First real (non-blank, non-heading) line of a prose file, bold-label prefix
 // stripped ("**Confirmed:** text..." -> "text...") - same spirit as the
@@ -1223,7 +1232,7 @@ function cmdResume(args) {
         .filter(d => !d.startsWith('.') && fs.existsSync(path.join(ENGAGEMENTS_ROOT, d, '.fde')))
         .join(', ') || '(none yet)'
       : '(none yet)'
-    console.log(`NO ENGAGEMENT for this workspace.\nexisting: ${list}\ncreate + bind one:  fde resume --init <client-name>`)
+    console.log(`NO ENGAGEMENT for this workspace.\nexisting: ${list}\nAsk the human the client name (one question), then run: fde resume --init <client-name>\nDo not tell them to type that command.`)
     process.exit(2)
   }
   // Monday-morning: triage + proactive hygiene (silent when clean), then memory.
@@ -1312,11 +1321,11 @@ function cmdLog(args) {
   const eng = resolveEngagement({ forWrite: true })
   if (!eng) { console.error('no engagement - run: fde resume --init <name>'); process.exit(2) }
 
-  // fde log phase <land|discover|plan|build|ship|close> - advances portfolio phase
+  // fde log phase <land|discover|plan|ship|prove|close> - advances portfolio phase
   if (type === 'phase') {
-    const phase = (text || '').toLowerCase().trim()
-    if (!['land', 'discover', 'plan', 'build', 'ship', 'close'].includes(phase)) {
-      console.error('usage: fde log phase <land|discover|plan|build|ship|close>')
+    const phase = canonicalPhase((text || '').toLowerCase().trim())
+    if (!PHASES.includes(phase)) {
+      console.error(`usage: fde log phase <${PHASES.join('|')}>`)
       process.exit(1)
     }
     const hash = setContextPhase(eng, phase)
@@ -1324,7 +1333,7 @@ function cmdLog(args) {
     return
   }
 
-  if (!LOG_FILES[type] || !text) { console.error('usage: fde log <decision|risk|delivery|contact> <text> [--signal red|amber|green] [--force]\n       fde log phase <land|discover|plan|build|ship|close>\n       fde log --undo'); process.exit(1) }
+  if (!LOG_FILES[type] || !text) { console.error(`usage: fde log <decision|risk|delivery|contact> <text> [--signal red|amber|green] [--force]\n       fde log phase <${PHASES.join('|')}>\n       fde log --undo`); process.exit(1) }
   if (signal && type !== 'contact') { console.error('--signal only applies to: fde log contact'); process.exit(1) }
   const hit = findSecretHit(text)
   if (hit && !force) { refuseSecret('log text', hit); process.exit(1) }
@@ -2091,7 +2100,7 @@ function collectDoctorIssues(eng) {
 
   if (s.phase === '?' || s.phase === 'unset') {
     if (hasDatedWork) {
-      issues.push('phase is unset but dated work exists - run: fde log phase <land|discover|plan|build|ship|close>')
+      issues.push(`phase is unset but dated work exists - run: fde log phase <${PHASES.join('|')}>`)
     }
   }
   if (s.stale) issues.push(`trust signal is STALE (${s.signalAge}d) - reconfirm with fde log contact ... --signal`)
@@ -2161,7 +2170,7 @@ function collectDoctorIssues(eng) {
   }
   // Failure-path (exception-led operating map): required once past discover.
   // Land seeds; discover fills; plan+ without a real break→owner row is wallpaper.
-  if (/^(plan|build|ship|close)$/.test(s.phase) && !hasOperatingMapContent(eng)) {
+  if (/^(plan|ship|prove|close)$/.test(s.phase) && !hasOperatingMapContent(eng)) {
     issues.push(
       `phase is ${s.phase} with empty operating map - fill terrain.md ## Operating map (exception-led): break → who notices → workaround → evidence`
     )
@@ -2295,21 +2304,59 @@ function hasValueBucket(eng) {
 const PENDING_CELL_RE =
   /^(?:pending|tbd|to ?be ?(?:measured|confirmed|determined)|n\s*\/\s*a|na|none|unknown|not measured|\?+|\.{2,}|…|-+|—+|–+)(?:[^\w].*)?$/i
 
-function claimedValueRows(eng) {
+function parseValueLedger(eng) {
   const ledger = stripTemplateNoise(sectionBody(readClean(eng, 'delivery.md'), 'Value ledger') || '')
   const table = parseMdTable(ledger)
-  if (!table) return { claimed: 0, columnMissing: false }
-  const mIdx = colIndex(table.headers, /measured/i)
-  if (mIdx === -1) return { claimed: 0, columnMissing: false }
-  const aIdx = colIndex(table.headers, /accept/i)
-  let claimed = 0
+  if (!table) return { rows: [], columnMissing: false }
+  const idx = {
+    slice: colIndex(table.headers, /slice/i),
+    promised: colIndex(table.headers, /promised/i),
+    measured: colIndex(table.headers, /measured/i),
+    accepted: colIndex(table.headers, /accept/i),
+  }
+  const cell = (row, i) => (i === -1 ? '' : String(row[i] || '').trim())
+  const rows = []
   for (const row of table.rows) {
-    const measured = String(row[mIdx] || '').trim()
-    if (!measured || PENDING_CELL_RE.test(measured)) continue
-    const accepted = aIdx === -1 ? '' : String(row[aIdx] || '').trim()
-    if (!accepted || PENDING_CELL_RE.test(accepted)) claimed++
+    const slice = cell(row, idx.slice)
+    const promised = cell(row, idx.promised)
+    const measured = cell(row, idx.measured)
+    const accepted = cell(row, idx.accepted)
+    if (!slice && !promised && !measured) continue
+    const measuredPending = !measured || PENDING_CELL_RE.test(measured)
+    const acceptedPending = idx.accepted === -1 || !accepted || PENDING_CELL_RE.test(accepted)
+    let state = 'unmeasured'
+    if (!measuredPending && acceptedPending) state = 'claimed'
+    else if (!measuredPending) state = 'accepted'
+    rows.push({ slice, promised, measured, accepted, state })
   }
-  return { claimed, columnMissing: aIdx === -1 }
+  return { rows, columnMissing: idx.accepted === -1 }
+}
+
+function claimedValueRows(eng) {
+  const { rows, columnMissing } = parseValueLedger(eng)
+  return { claimed: rows.filter(r => r.state === 'claimed').length, columnMissing }
+}
+
+function formatValueLedgerLine(r) {
+  const name = r.slice || 'value'
+  let body = r.promised || ''
+  if (r.state !== 'unmeasured' && r.measured) {
+    if (!body) body = r.measured
+    else if (!body.includes(r.measured)) body = `${body} → ${r.measured}`
+  }
+  const head = body ? `${name}: ${body}` : name
+  if (r.state === 'accepted') return `${head} · accepted by ${r.accepted}`
+  if (r.state === 'claimed') return `${head} · claimed, not yet accepted`
+  return `${head} · not yet measured`
+}
+
+function valueLedgerStatusLines(eng, opts = {}) {
+  const { rows } = parseValueLedger(eng)
+  if (!rows.length) return ['    value: none yet']
+  const cap = opts.compact ? 1 : 8
+  const lines = rows.slice(0, cap).map(r => `    ${formatValueLedgerLine(r)}`)
+  if (rows.length > cap) lines.push(`    … ${rows.length - cap} more in delivery.md`)
+  return lines
 }
 
 // AI in scope for ship/close hygiene — delivery/decisions/trust evidence only.
@@ -2488,18 +2535,18 @@ function cmdGarden(args) {
   // Gardener contract (from Rowboat note_curation): no new facts, no deleted substance,
   // reversible via git when healthy, confirm before apply. Mechanical only - no LLM rewrite.
   if (gitHealth.ok) {
-    console.log('GARDEN (contract: no new facts · no deleted substance · reversible via memory git)')
+    console.log('TIDY (contract: no new facts · no deleted substance · reversible via memory git)')
   } else if (gitHealth.reason === 'broken') {
-    console.log('GARDEN (contract: no new facts · no deleted substance · ⚠ memory git BROKEN — NOT reversible until ledger is repaired)')
+    console.log('TIDY (contract: no new facts · no deleted substance · ⚠ memory git BROKEN — NOT reversible until ledger is repaired)')
   } else {
-    console.log('GARDEN (contract: no new facts · no deleted substance · ⚠ memory not git-versioned — NOT reversible)')
+    console.log('TIDY (contract: no new facts · no deleted substance · ⚠ memory not git-versioned — NOT reversible)')
   }
   console.log(resumeTriage(eng))
   if (!gitHealth.ok) {
     console.log(
       gitHealth.reason === 'broken'
-        ? '\n⚠ ledger is UNVERSIONED (corrupt .git). Repair before trusting garden apply: mv .fde/.git .fde/.git.broken && run any fde write to re-init.'
-        : '\n⚠ no memory git — garden apply cannot create a reversible commit until the ledger exists.'
+        ? '\n⚠ ledger is UNVERSIONED (corrupt .git). Repair before trusting tidy apply: mv .fde/.git .fde/.git.broken && run any fde write to re-init.'
+        : '\n⚠ no memory git — tidy apply cannot create a reversible commit until the ledger exists.'
     )
   }
   const proposals = []
@@ -2539,18 +2586,18 @@ function cmdGarden(args) {
     })
   }
   if (!proposals.length) {
-    console.log('\nNothing to garden.')
+    console.log('\nNothing to tidy.')
     return
   }
   console.log(`\n${proposals.length} proposal(s):`)
   proposals.forEach((p, i) => console.log(`  ${i + 1}. [${p.kind}] ${p.text}`))
   if (!apply) {
-    console.log('\nApply mechanical items only:  fde garden --apply')
+    console.log('\nApply mechanical items only:  fde tidy --apply')
     console.log('Manual items stay yours. Every apply commits to memory git when the ledger is healthy.')
     return
   }
   if (!gitHealth.ok && gitHealth.reason === 'broken') {
-    console.error('refusing garden --apply while memory git is broken - repair the ledger first')
+    console.error('refusing tidy --apply while memory git is broken - repair the ledger first')
     process.exit(1)
   }
   ensureMemoryGit(eng)
@@ -2603,9 +2650,9 @@ function cmdGarden(args) {
     touched.add('context-archive.md')
     console.log(`applied: archived ${p.sessionBlocks.length} old session-end blocks → context-archive.md`)
   }
-  const hash = commitMemory(eng, 'garden', { files: [...touched] })
+  const hash = commitMemory(eng, 'tidy', { files: [...touched] })
   if (!applied) console.log('no mechanical proposals applied (manual items remain)')
-  else console.log(`garden done${hash ? ` @${hash}` : ''}`)
+  else console.log(`tidy done${hash ? ` @${hash}` : ''}`)
 }
 
 // Keep the first open-risk bullet per fingerprint; move later echoes under ## Retired.
@@ -2647,7 +2694,7 @@ function applyRiskDedupe(eng, clusters) {
   const stamp = new Date().toISOString().slice(0, 10)
   const block = retiredLines.map(l => {
     const body = l.trim().replace(/^-\s*/, '')
-    return `- [${stamp}] (garden dedupe) ${body}`
+    return `- [${stamp}] (tidy dedupe) ${body}`
   }).join('\n')
   out = appendUnderSection(out, 'Retired', block)
   withFileLock(p, () => { atomicWriteFile(p, out.endsWith('\n') ? out : out + '\n') })
@@ -2669,7 +2716,7 @@ function cmdStatus(args) {
       if (!fs.existsSync(eng)) continue
       const s = computeSignals(eng)
       const note = [s.memoryWarn, (s.dirtyFiles && s.dirtyFiles.length) ? `dirty:${s.dirtyFiles.length}` : '', s.reason || s.topRisk].filter(Boolean).join(' · ').slice(0, 70)
-      rows.push({ name: d, phase: s.phase, trust: s.trust, signalAge: s.signalAge, stale: s.stale, updated: s.updated, reason: note, memoryWarn: s.memoryWarn, dirtyFiles: s.dirtyFiles })
+      rows.push({ name: d, phase: s.phase, trust: s.trust, signalAge: s.signalAge, stale: s.stale, updated: s.updated, reason: note, memoryWarn: s.memoryWarn, dirtyFiles: s.dirtyFiles, valueLines: valueLedgerStatusLines(eng, { compact: true }) })
     }
   } else {
     const eng = resolveEngagement()
@@ -2679,13 +2726,14 @@ function cmdStatus(args) {
     }
     const s = computeSignals(eng)
     const note = [s.memoryWarn, (s.dirtyFiles && s.dirtyFiles.length) ? `dirty:${s.dirtyFiles.length}` : '', s.reason || s.topRisk].filter(Boolean).join(' · ').slice(0, 70)
-    rows.push({ name: engagementSlugFromPath(eng), phase: s.phase, trust: s.trust, signalAge: s.signalAge, stale: s.stale, updated: s.updated, reason: note, memoryWarn: s.memoryWarn, dirtyFiles: s.dirtyFiles })
+    rows.push({ name: engagementSlugFromPath(eng), phase: s.phase, trust: s.trust, signalAge: s.signalAge, stale: s.stale, updated: s.updated, reason: note, memoryWarn: s.memoryWarn, dirtyFiles: s.dirtyFiles, valueLines: valueLedgerStatusLines(eng) })
   }
   if (!rows.length) { console.log('no engagements yet'); return }
   const order = { RED: 0, amber: 1, green: 2 }
   rows.sort((a, b) => order[a.trust] - order[b.trust])
-  console.log((all ? 'FDE PORTFOLIO' : 'FDE STATUS') + ' - trust-first triage (heuristic: red > amber > green)\n')
+  console.log((all ? 'FDE PORTFOLIO' : 'FDE STATUS') + ' - value first, then trust\n')
   for (const r of rows) {
+    for (const line of r.valueLines) console.log(line)
     // "amber?" = structured signal went stale (>21d) - reconfirm before trusting it
     const label = r.trust + (r.stale ? '?' : '')
     const sig = r.signalAge != null ? `signal ${r.signalAge}d old${r.stale ? ' (STALE - reconfirm)' : ''}  ` : ''
@@ -3139,7 +3187,7 @@ function printUsage() {
   fde resume --bind        show what this workspace is bound to, and what resolves
   fde triage               TRIAGE block only (hooks / Cursor session entry)
   fde log <type> <text>    append decision|risk|delivery|contact (contact takes --signal red|amber|green; --force to allow secret-like text)
-  fde log phase <phase>    set engagement phase (land|discover|plan|build|ship|close)
+  fde log phase <phase>    set engagement phase (land|discover|plan|ship|prove|close)
   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
@@ -3150,14 +3198,13 @@ function printUsage() {
   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)
-  fde garden [--apply]     propose safe consolidations (contract: no new facts; git-reversible)
+  fde tidy [--apply]       propose safe consolidations (contract: no new facts; git-reversible)
   fde owner [set email]    who keeps this engagement record
   fde receipts <term>      "what did we agree?" with dates
-  fde capture              session-end memory snapshot (hooks use this)
-  fde preserve             pre-compaction context snapshot (hook-internal; hooks use this)
-  fde status [--all]       current engagement status (pass --all for full portfolio)
+  fde status [--all]       value ledger, then trust (pass --all for full portfolio)
   fde dashboard [--all]    current engagement fieldbook (pass --all for every client)
   fde vault                derived Obsidian vault of every engagement (--current for one, --redacted for a shared screen, --out <dir>)
+  hooks call these; you do not: capture (session-end snapshot), preserve (pre-compaction snapshot)
   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)
@@ -3176,6 +3223,8 @@ switch (cmd) {
   case 'prep': cmdPrep(args); break
   case 'doctor': cmdDoctor(); break
   case 'redact': cmdRedact(args); break
+  // `garden` was the name through 3.11.x; it keeps working.
+  case 'tidy':
   case 'garden': cmdGarden(args); break
   case 'owner': cmdOwner(args); break
   case 'receipts': cmdReceipts(args); break

package/bin/install.js

@@ -355,7 +355,7 @@ function cmdInstall(opts = {}) {
 // through to the CLI (fde.js reads process.argv itself, so require() is enough).
 const FDE_SUBCOMMANDS = [
   'demo', 'scan', 'resume', 'triage', 'log', 'debrief', 'ingest', 'prep', 'doctor', 'redact',
-  'garden', 'owner', 'receipts', 'capture', 'preserve', 'status', 'dashboard', 'vault', 'help',
+  'tidy', 'garden', 'owner', 'receipts', 'capture', 'preserve', 'status', 'dashboard', 'vault', 'help',
 ]
 
 const INSTALL_SUBCOMMANDS = ['init', 'adapters', 'install']

package/bin/lib/trust.js

@@ -64,8 +64,9 @@ function createTrustApi(deps) {
     if (!m) return '?'
     const raw = m[1].replace(/\*/g, '').trim()
     if (!raw || /\|/.test(raw) || /^unset$/i.test(raw) || /^[\[(]/.test(raw)) return '?'
-    const one = raw.toLowerCase().match(/^(land|discover|plan|build|ship|close)\b/)
-    return one ? one[1] : '?'
+    const one = raw.toLowerCase().match(/^(land|discover|plan|build|ship|prove|close)\b/)
+    if (!one) return '?'
+    return one[1] === 'build' ? 'ship' : one[1]
   }
 
   function countOpenRisks(eng) {

package/mcp/fdeops-ingest/package.json

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fdeops",
-  "version": "3.11.1",
-  "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.",
+  "version": "3.15.0",
+  "description": "Forward deployed engineering skills for AI coding agents. Your agent forgets the client every morning - the sponsor, the promise, who signed off. FDEOps keeps that as dated markdown on your laptop: one @fde skill, a deterministic local CLI, and hooks that make it automatic. Claude Code plugin and any agent that loads skills.",
   "bin": {
     "fdeops": "bin/install.js",
     "fde": "bin/fde.js"
@@ -30,6 +30,9 @@
     "ai-agent",
     "skills",
     "plugin",
+    "engagement-memory",
+    "agent-memory",
+    "client-context",
     "fde",
     "forward-deployed",
     "forward-deployed-engineer",

package/plugin.json

@@ -1,13 +1,13 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "fdeops",
-  "version": "3.11.1",
-  "description": "Engagement fieldbook for Forward Deployed Engineers: per-client memory in local .fde/ files, one @fde skill, land to close methodology. Local-only, no network.",
+  "version": "3.15.0",
+  "description": "Forward deployed engineering skills for AI coding agents: per-client memory in local .fde/ files, one @fde skill. Local-only, no network.",
   "author": {
     "name": "Subash Natarajan",
     "url": "https://github.com/suboss87"
   },
-  "homepage": "https://fdeops.io/",
+  "homepage": "https://github.com/suboss87/fdeops",
   "repository": "https://github.com/suboss87/FDEOps",
   "license": "MIT",
   "keywords": [