moflo 4.9.0-rc.8 → 4.9.0

package/.claude/helpers/auto-memory-hook.mjs

@@ -16,7 +16,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PROJECT_ROOT = join(__dirname, '../..');
-const DATA_DIR = join(PROJECT_ROOT, '.claude-flow', 'data');
+const DATA_DIR = join(PROJECT_ROOT, '.moflo', 'data');
 const STORE_PATH = join(DATA_DIR, 'auto-memory-store.json');
 
 const DIM = '\x1b[2m';

package/.claude/helpers/gate-hook.mjs

@@ -25,6 +25,13 @@ try { if (stdinData.trim()) hookContext = JSON.parse(stdinData); } catch (e) {}
 // Pass tool info as env vars for gate.cjs
 var env = Object.assign({}, process.env);
 if (hookContext.tool_name) env.TOOL_NAME = hookContext.tool_name;
+// Forward Claude Code's session_id so gate.cjs can enforce memory-first
+// per-actor (#838) — each spawned subagent gets its own session_id, so a
+// shared workflow-state.json no longer lets one subagent's directive be
+// silently satisfied by the parent's earlier search.
+if (typeof hookContext.session_id === 'string' && hookContext.session_id) {
+  env.HOOK_SESSION_ID = hookContext.session_id;
+}
 if (hookContext.tool_input && typeof hookContext.tool_input === 'object') {
   Object.keys(hookContext.tool_input).forEach(function(key) {
     if (typeof hookContext.tool_input[key] === 'string') {

package/.claude/helpers/gate.cjs

@@ -6,7 +6,37 @@ var path = require('path');
 var PROJECT_DIR = (process.env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\/([a-z])\//i, '$1:/');
 var STATE_FILE = path.join(PROJECT_DIR, '.claude', 'workflow-state.json');
 
-var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, memorySearched: false, memoryRequired: true, learningsStored: false, interactionCount: 0, sessionStart: null, lastBlockedAt: null };
+var STATE_DEFAULTS = { tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, interactionCount: 0, sessionStart: null, lastBlockedAt: null };
+
+// Per-actor memory-search tracking (#838). The legacy `memorySearched` boolean
+// is session-wide, so once the parent searches memory, every spawned subagent
+// inherits the satisfied flag and the directive's "WILL BLOCK" promise becomes
+// false. When gate-hook.mjs forwards Claude Code's stdin `session_id` as
+// HOOK_SESSION_ID, prefer the per-session map so each subagent must search
+// memory itself before its first Glob/Grep/Read. Falls back to the legacy
+// boolean when no session id is present (CLI invocations, tests, older hosts).
+function isMemorySearchedFor(state) {
+  var sid = process.env.HOOK_SESSION_ID || '';
+  if (sid) {
+    var map = state.memorySearchedBy || {};
+    return map[sid] === true;
+  }
+  return state.memorySearched === true;
+}
+
+// Stamp the legacy bool plus (when HOOK_SESSION_ID is set) the per-actor map.
+// Returns true if anything actually changed — callers gate writeState() on it
+// to avoid redundant fsyncs in tight bash-memory loops.
+function markMemorySearched(state) {
+  var sid = process.env.HOOK_SESSION_ID || '';
+  var changed = false;
+  if (state.memorySearched !== true) { state.memorySearched = true; changed = true; }
+  if (sid) {
+    if (!state.memorySearchedBy) state.memorySearchedBy = {};
+    if (state.memorySearchedBy[sid] !== true) { state.memorySearchedBy[sid] = true; changed = true; }
+  }
+  return changed;
+}
 
 function readState() {
   try {
@@ -29,7 +59,7 @@ function writeState(s) {
 
 // Load moflo.yaml gate config (defaults: all enabled)
 function loadGateConfig() {
-  var defaults = { memory_first: true, task_create_first: true, context_tracking: true };
+  var defaults = { memory_first: true, task_create_first: true, context_tracking: true, testing_gate: true, simplify_gate: true, learnings_gate: true };
   try {
     var yamlPath = path.join(PROJECT_DIR, 'moflo.yaml');
     if (fs.existsSync(yamlPath)) {
@@ -37,6 +67,9 @@ function loadGateConfig() {
       if (/memory_first:\s*false/i.test(content)) defaults.memory_first = false;
       if (/task_create_first:\s*false/i.test(content)) defaults.task_create_first = false;
       if (/context_tracking:\s*false/i.test(content)) defaults.context_tracking = false;
+      if (/testing_gate:\s*false/i.test(content)) defaults.testing_gate = false;
+      if (/simplify_gate:\s*false/i.test(content)) defaults.simplify_gate = false;
+      if (/learnings_gate:\s*false/i.test(content)) defaults.learnings_gate = false;
     }
   } catch (e) { /* use defaults */ }
   return defaults;
@@ -49,6 +82,13 @@ var EXEMPT = ['.claude/', '.claude\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-state
 var DANGEROUS = ['rm -rf /', 'format c:', 'del /s /q c:\\', ':(){:|:&};:', 'mkfs.', '> /dev/sda'];
 var DIRECTIVE_RE = /^(yes|no|yeah|yep|nope|sure|ok|okay|correct|right|exactly|perfect)\b/i;
 var TASK_RE = /\b(fix|bug|error|implement|add|create|build|write|refactor|debug|test|feature|issue|security|optimi)\b/i;
+// Match npm/yarn/pnpm/bun test, npx vitest|jest|..., bare runners at command-start only,
+// and language-native test commands. The bare-runner arm is anchored so that
+// `npm install jest`, `grep -r vitest src/`, and similar don't false-positive.
+var TEST_RUNNER_RE = /(?:^|[^a-z])(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?(?:test|t)(?:[:\s]|$)|\b(?:npx|pnpx)\s+(?:vitest|jest|mocha|ava|tap|jasmine|pytest)\b|(?:^|;|&&|\|\|)\s*(?:vitest|jest|pytest|mocha|jasmine|tap|ava)\s|\b(?:cargo|go|deno|dotnet|mvn)\s+test\b|\bgradle\w*\s+test\b/i;
+// Edits to these don't change runtime behaviour, so they don't invalidate prior test/simplify runs.
+// Lock files and .gitignore are tracked but inert; package.json/*.yaml ARE source — they reset.
+var EDIT_RESET_SKIP_RE = /\.(md|markdown|txt|rst|adoc|lock|gitignore)$|(?:^|[\\\/])(CHANGELOG(?:\.md)?|\.env\.example|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb)$/i;
 
 switch (command) {
   case 'check-before-agent': {
@@ -67,7 +107,7 @@ switch (command) {
   case 'check-before-scan': {
     if (!config.memory_first) break;
     var s = readState();
-    if (s.memorySearched || !s.memoryRequired) break;
+    if (!s.memoryRequired || isMemorySearchedFor(s)) break;
     var target = (process.env.TOOL_INPUT_pattern || '') + ' ' + (process.env.TOOL_INPUT_path || '');
     if (EXEMPT.some(function(p) { return target.indexOf(p) >= 0; })) break;
     process.stderr.write('BLOCKED: Search memory before exploring files. Use mcp__moflo__memory_search.\n');
@@ -76,7 +116,7 @@ switch (command) {
   case 'check-before-read': {
     if (!config.memory_first) break;
     var s = readState();
-    if (s.memorySearched || !s.memoryRequired) break;
+    if (!s.memoryRequired || isMemorySearchedFor(s)) break;
     var fp = process.env.TOOL_INPUT_file_path || '';
     var isGuidance = fp.indexOf('.claude/guidance/') >= 0 || fp.indexOf('.claude\\guidance\\') >= 0;
     if (!isGuidance && EXEMPT.some(function(p) { return fp.indexOf(p) >= 0; })) break;
@@ -92,16 +132,14 @@ switch (command) {
   }
   case 'record-memory-searched': {
     var s = readState();
-    s.memorySearched = true;
-    writeState(s);
+    if (markMemorySearched(s)) writeState(s);
     break;
   }
   case 'check-bash-memory': {
     var cmd = process.env.TOOL_INPUT_command || '';
     if (/semantic-search|memory search|memory retrieve|memory-search/.test(cmd)) {
       var s = readState();
-      s.memorySearched = true;
-      writeState(s);
+      if (markMemorySearched(s)) writeState(s);
     }
     break;
   }
@@ -113,21 +151,64 @@ switch (command) {
   }
   case 'record-learnings-stored': {
     var s = readState();
-    s.learningsStored = true;
-    writeState(s);
+    if (!s.learningsStored) {
+      s.learningsStored = true;
+      writeState(s);
+    }
     break;
   }
-  case 'check-before-pr': {
+  case 'record-test-run': {
     var cmd = process.env.TOOL_INPUT_command || '';
-    if (/gh\s+pr\s+create/.test(cmd)) {
+    if (TEST_RUNNER_RE.test(cmd)) {
+      var s = readState();
+      if (!s.testsRun) {
+        s.testsRun = true;
+        writeState(s);
+      }
+    }
+    break;
+  }
+  case 'record-skill-run': {
+    if ((process.env.TOOL_INPUT_skill || '') === 'simplify') {
       var s = readState();
-      if (!s.learningsStored && (s.interactionCount || 0) > 5) {
-        // Advisory for long sessions — remind but don't block
-        process.stdout.write('ADVISORY: Consider storing learnings (mcp__moflo__memory_store) before creating a PR — this was a substantial session.\n');
+      if (!s.simplifyRun) {
+        s.simplifyRun = true;
+        writeState(s);
       }
     }
     break;
   }
+  case 'reset-edit-gates': {
+    var fp = process.env.TOOL_INPUT_file_path || '';
+    if (fp && EDIT_RESET_SKIP_RE.test(fp)) break;
+    var s = readState();
+    if (!s.testsRun && !s.simplifyRun) break;
+    s.testsRun = false;
+    s.simplifyRun = false;
+    writeState(s);
+    break;
+  }
+  case 'check-before-pr': {
+    // Anchored to command-start (or chained via && / || / ;) so heredoc bodies
+    // and quoted strings that contain the literal "gh pr create" don't trip
+    // the gate during regular `git commit -m "...gh pr create..."` flows. The
+    // optional ENV=val prefix segment catches `GH_TOKEN=x gh pr create`.
+    var cmd = process.env.TOOL_INPUT_command || '';
+    if (!/(?:^|&&\s*|\|\|\s*|;\s*)\s*(?:[A-Z_][A-Z0-9_]*=\S+\s+)*gh\s+pr\s+create\b/.test(cmd)) break;
+    var s = readState();
+    var missing = [];
+    if (config.testing_gate && !s.testsRun) missing.push('tests have not run since the last code edit (run npm test, vitest, jest, pytest, or similar)');
+    if (config.simplify_gate && !s.simplifyRun) missing.push('/simplify has not run since the last code edit');
+    if (config.learnings_gate && !s.learningsStored) missing.push('learnings have not been stored (call mcp__moflo__memory_store)');
+    if (missing.length === 0) break;
+    process.stderr.write('BLOCKED: gh pr create requires the following before opening a PR:\n');
+    for (var i = 0; i < missing.length; i++) {
+      process.stderr.write('  - ' + missing[i] + '\n');
+    }
+    process.stderr.write('Disable per-gate via moflo.yaml:\n');
+    process.stderr.write('  gates:\n    testing_gate: false\n    simplify_gate: false\n    learnings_gate: false\n');
+    process.exit(2);
+  }
   case 'check-dangerous-command': {
     var cmd = (process.env.TOOL_INPUT_command || '').toLowerCase();
     for (var i = 0; i < DANGEROUS.length; i++) {
@@ -141,6 +222,9 @@ switch (command) {
   case 'prompt-reminder': {
     var s = readState();
     s.memorySearched = false;
+    // Wipe per-actor memory tracking too — a new user prompt is a fresh window
+    // for both parent AND any subagents the parent may spawn during this turn.
+    s.memorySearchedBy = {};
     // learningsStored is session-scoped — once stored, it stays true until session reset.
     // Resetting per-prompt caused false blocks when PR creation was on a later prompt.
     var prompt = process.env.CLAUDE_USER_PROMPT || '';
@@ -163,7 +247,7 @@ switch (command) {
     break;
   }
   case 'session-reset': {
-    writeState({ tasksCreated: false, taskCount: 0, memorySearched: false, memoryRequired: true, learningsStored: false, interactionCount: 0, sessionStart: new Date().toISOString(), lastBlockedAt: null });
+    writeState({ tasksCreated: false, taskCount: 0, memorySearched: false, memorySearchedBy: {}, memoryRequired: true, learningsStored: false, testsRun: false, simplifyRun: false, interactionCount: 0, sessionStart: new Date().toISOString(), lastBlockedAt: null });
     break;
   }
   default:

package/.claude/helpers/intelligence.cjs

@@ -11,11 +11,11 @@ const path = require('path');
 const os = require('os');
 
 const PROJECT_ROOT = (process.env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\/([a-z])\//i, '$1:/');
-const DATA_DIR = path.join(PROJECT_ROOT, '.claude-flow', 'data');
+const DATA_DIR = path.join(PROJECT_ROOT, '.moflo', 'data');
 const STORE_PATH = path.join(DATA_DIR, 'auto-memory-store.json');
 const RANKED_PATH = path.join(DATA_DIR, 'ranked-context.json');
 const PENDING_PATH = path.join(DATA_DIR, 'pending-insights.jsonl');
-const SESSION_DIR = path.join(PROJECT_ROOT, '.claude-flow', 'sessions');
+const SESSION_DIR = path.join(PROJECT_ROOT, '.moflo', 'sessions');
 const SESSION_FILE = path.join(SESSION_DIR, 'current.json');
 
 function ensureDir(dir) {
@@ -55,7 +55,7 @@ function bootstrapFromMemoryFiles() {
   var entries = [];
   var candidates = [
     path.join(os.homedir(), ".claude", "projects"),
-    path.join(PROJECT_ROOT, ".claude-flow", "memory"),
+    path.join(PROJECT_ROOT, ".moflo", "memory"),
     path.join(PROJECT_ROOT, ".claude", "memory"),
   ];
   for (var i = 0; i < candidates.length; i++) {

package/.claude/helpers/statusline.cjs

@@ -51,7 +51,6 @@ function loadStatusLineConfig() {
     show_mcp: true,
     show_security: true,
     show_adrs: true,
-    show_agentdb: true,
     show_tests: true,
     mode: 'compact',
   };
@@ -383,7 +382,7 @@ function getSwarmStatus() {
 function getSystemMetrics() {
   const memoryMB = Math.floor(process.memoryUsage().heapUsed / 1024 / 1024);
   const learning = getLearningStats();
-  const agentdb = getAgentDBStats();
+  const embeddings = getEmbeddingsStats();
 
   // Intelligence from learning.json
   const learningData = readJSON(path.join(CWD, '.moflo', 'metrics', 'learning.json'));
@@ -394,7 +393,7 @@ function getSystemMetrics() {
     intelligencePct = Math.min(100, Math.floor(learningData.intelligence.score));
   } else {
     const fromPatterns = learning.patterns > 0 ? Math.min(100, Math.floor(learning.patterns / 10)) : 0;
-    const fromVectors = agentdb.vectorCount > 0 ? Math.min(100, Math.floor(agentdb.vectorCount / 100)) : 0;
+    const fromVectors = embeddings.vectorCount > 0 ? Math.min(100, Math.floor(embeddings.vectorCount / 100)) : 0;
     intelligencePct = Math.max(fromPatterns, fromVectors);
   }
 
@@ -424,7 +423,7 @@ function getSystemMetrics() {
     subAgents = activityData.processes.estimated_agents;
   }
 
-  return { memoryMB, contextPct, intelligencePct, subAgents };
+  return { memoryMB, contextPct, intelligencePct, subAgents, embeddings };
 }
 
 // ADR status (count files only — don't read contents)
@@ -485,9 +484,9 @@ function getHooksStatus() {
   return { enabled, total };
 }
 
-// AgentDB stats — reads from cache file written by embedding/memory operations.
+// Embeddings stats — reads from cache file written by embedding/memory ops.
 // No subprocess spawning. Falls back to DB file size estimate if cache is missing.
-function getAgentDBStats() {
+function getEmbeddingsStats() {
   let vectorCount = 0;
   let dbSizeKB = 0;
   let namespaces = 0;
@@ -602,20 +601,25 @@ function getIntegrationStatus() {
   return { mcpServers, hasDatabase, hasApi };
 }
 
-// Upgrade notice (#636, #738, #743) — written by the session-start launcher
-// ONLY while upgrade work is in flight; the launcher deletes the file when
-// work completes. We render it strictly for status='in-progress' so a stale
-// notice (legacy "complete" file from pre-#738 launchers, zombie write from
-// an aborted launcher, future writer mistakes) cannot turn the statusline
-// segment into a permanent column. The launcher's section 0-pre also drops
-// any leftover file at session start as a second line of defence.
+// Upgrade notice (#636, #738, #743) — written by the session-start launcher.
+//   status='in-progress' — work is running; rendered with "(updating…)".
+//   status='completed'   — work just finished; short-TTL post-upgrade badge so
+//                          the user sees something on the very next render
+//                          (Claude Code only paints the statusline AFTER the
+//                          SessionStart hook returns, so the in-progress badge
+//                          has effectively zero visibility window).
+// Anything else is dropped (legacy "complete" pre-#738 files, zombie writes,
+// future writer mistakes) so a stale notice can never turn the segment into a
+// permanent column. Section 0-pre of the launcher also wipes any leftover at
+// session start as a second line of defence.
 function getUpgradeNotice() {
   const data = readJSON(path.join(CWD, '.moflo', 'upgrade-notice.json'));
   if (!data || typeof data !== 'object') return null;
-  if (data.status !== 'in-progress') return null;
+  if (data.status !== 'in-progress' && data.status !== 'completed') return null;
   const expiresAt = data.expiresAt ? new Date(data.expiresAt).getTime() : 0;
   if (!expiresAt || Date.now() > expiresAt) return null;
   return {
+    status: data.status,
     kind: data.kind === 'repair' ? 'repair' : 'upgrade',
     from: typeof data.from === 'string' ? data.from : '',
     to: typeof data.to === 'string' ? data.to : '',
@@ -624,14 +628,20 @@ function getUpgradeNotice() {
 
 function formatUpgradeNoticeSegment(notice) {
   if (!notice) return '';
-  const suffix = ` ${c.dim}(updating…)${c.reset}`;
+  const inFlight = notice.status === 'in-progress';
+  const suffix = inFlight ? ` ${c.dim}(updating…)${c.reset}` : '';
+  // Pick body text: repair > in-flight version range > completed "upgraded to"
+  // > bare "upgraded" fallback when no version is known.
+  let body;
   if (notice.kind === 'repair') {
-    return `${c.brightYellow}📦 install repaired${c.reset}${suffix}`;
+    body = 'install repaired';
+  } else if (inFlight) {
+    body = notice.from && notice.to ? `${notice.from} → ${notice.to}` : (notice.to || 'upgraded');
+  } else {
+    const target = notice.to || notice.from || '';
+    body = target ? `upgraded to ${target}` : 'upgraded';
   }
-  const versions = notice.from && notice.to
-    ? `${notice.from} → ${notice.to}`
-    : (notice.to || 'upgraded');
-  return `${c.brightYellow}📦 ${versions}${c.reset}${suffix}`;
+  return `${c.brightYellow}📦 ${body}${c.reset}${suffix}`;
 }
 
 // Session stats (pure file reads)
@@ -785,28 +795,37 @@ function generateDashboard() {
     );
   }
 
-  // AgentDB + MCP line (if either enabled)
-  if (SL_CONFIG.show_agentdb || SL_CONFIG.show_mcp) {
-    const parts = [];
-    if (SL_CONFIG.show_agentdb) {
-      const agentdb = getAgentDBStats();
-      const hnswInd = agentdb.hasHnsw ? `${c.brightGreen}\u26A1${c.reset}` : '';
-      const sizeDisp = agentdb.dbSizeKB >= 1024 ? `${(agentdb.dbSizeKB / 1024).toFixed(1)}MB` : `${agentdb.dbSizeKB}KB`;
-      const vectorColor = agentdb.vectorCount > 0 ? c.brightGreen : c.dim;
-      parts.push(`${c.cyan}Vectors${c.reset} ${vectorColor}\u25CF${agentdb.vectorCount}${hnswInd}${c.reset}`);
-      parts.push(`${c.cyan}Size${c.reset} ${c.brightWhite}${sizeDisp}${c.reset}`);
-    }
-    if (SL_CONFIG.show_mcp) {
-      const integration = getIntegrationStatus();
-      if (integration.mcpServers.total > 0) {
-        const mcpCol = integration.mcpServers.enabled === integration.mcpServers.total ? c.brightGreen :
-                       integration.mcpServers.enabled > 0 ? c.brightYellow : c.red;
-        parts.push(`${c.cyan}MCP${c.reset} ${mcpCol}\u25CF${integration.mcpServers.enabled}/${integration.mcpServers.total}${c.reset}`);
+  // Embeddings line \u2014 vector store stats from .moflo/vector-stats.json.
+  // Reuses `system.embeddings` (already computed by getSystemMetrics()) instead
+  // of re-probing the cache file on every render.
+  {
+    const vec = system.embeddings;
+    if (vec.vectorCount > 0) {
+      const hnswInd = vec.hasHnsw ? `${c.brightGreen}\u26A1${c.reset}` : '';
+      const sizeDisp = vec.dbSizeKB >= 1024 ? `${(vec.dbSizeKB / 1024).toFixed(1)}MB` : `${vec.dbSizeKB}KB`;
+      const eParts = [
+        `${c.cyan}Vectors${c.reset} ${c.brightGreen}\u25CF${vec.vectorCount}${c.reset}${hnswInd}`,
+        `${c.cyan}Size${c.reset} ${c.brightWhite}${sizeDisp}${c.reset}`,
+      ];
+      if (vec.namespaces > 0) {
+        eParts.push(`${c.cyan}NS${c.reset} ${c.brightWhite}${vec.namespaces}${c.reset}`);
       }
-      if (integration.hasDatabase) parts.push(`${c.brightGreen}\u25C6${c.reset}DB`);
+      lines.push(`${c.brightCyan}\uD83D\uDCCA Embeddings${c.reset}  ${eParts.join(`  ${c.dim}\u2502${c.reset}  `)}`);
+    }
+  }
+
+  // MCP line
+  if (SL_CONFIG.show_mcp) {
+    const parts = [];
+    const integration = getIntegrationStatus();
+    if (integration.mcpServers.total > 0) {
+      const mcpCol = integration.mcpServers.enabled === integration.mcpServers.total ? c.brightGreen :
+                     integration.mcpServers.enabled > 0 ? c.brightYellow : c.red;
+      parts.push(`${c.cyan}MCP${c.reset} ${mcpCol}\u25CF${integration.mcpServers.enabled}/${integration.mcpServers.total}${c.reset}`);
     }
+    if (integration.hasDatabase) parts.push(`${c.brightGreen}\u25C6${c.reset}DB`);
     if (parts.length > 0) {
-      lines.push(`${c.brightCyan}\uD83D\uDCCA AgentDB${c.reset}    ${parts.join(`  ${c.dim}\u2502${c.reset}  `)}`);
+      lines.push(`${c.brightCyan}\uD83D\uDD0C MCP${c.reset}  ${parts.join(`  ${c.dim}\u2502${c.reset}  `)}`);
     }
   }
 
@@ -846,7 +865,7 @@ function generateCompactDashboard() {
   pushUpgradeNoticeSegment(lines);
   lines.push(header);
 
-  // Combined swarm + agentdb + mcp line
+  // Combined swarm + embeddings + mcp line
   const segments = [];
   if (SL_CONFIG.show_swarm) {
     const swarm = getSwarmStatus();
@@ -856,14 +875,17 @@ function generateCompactDashboard() {
       `${c.brightYellow}\uD83E\uDD16${c.reset} ${swarmInd}[${agentsColor}${swarm.activeAgents}${c.reset}/${c.brightWhite}${swarm.maxAgents}${c.reset}]`
     );
   }
-  if (SL_CONFIG.show_agentdb) {
-    const agentdb = getAgentDBStats();
-    const hnswInd = agentdb.hasHnsw ? `\u26A1` : '';
-    const sizeDisp = agentdb.dbSizeKB >= 1024 ? `${(agentdb.dbSizeKB / 1024).toFixed(1)}MB` : `${agentdb.dbSizeKB}KB`;
-    const vectorColor = agentdb.vectorCount > 0 ? c.brightGreen : c.dim;
-    segments.push(
-      `${c.brightCyan}\uD83D\uDCCA${c.reset} ${vectorColor}${agentdb.vectorCount}${hnswInd}${c.reset} ${c.dim}(${sizeDisp})${c.reset}`
-    );
+  // Embeddings \u2014 always-on when vectorCount > 0; self-hides on a fresh install.
+  // Compact doesn't call getSystemMetrics() so this is the only probe per render.
+  {
+    const vec = getEmbeddingsStats();
+    if (vec.vectorCount > 0) {
+      const hnswInd = vec.hasHnsw ? '\u26A1' : '';
+      const sizeDisp = vec.dbSizeKB >= 1024 ? `${(vec.dbSizeKB / 1024).toFixed(1)}MB` : `${vec.dbSizeKB}KB`;
+      segments.push(
+        `${c.brightCyan}\uD83D\uDCCA${c.reset} ${c.brightGreen}${vec.vectorCount}${hnswInd}${c.reset} ${c.dim}(${sizeDisp})${c.reset}`
+      );
+    }
   }
   if (SL_CONFIG.show_mcp) {
     const integration = getIntegrationStatus();
@@ -883,15 +905,16 @@ function generateCompactDashboard() {
 // JSON output
 function generateJSON() {
   const git = getGitInfo();
+  const system = getSystemMetrics();
   return {
     user: { name: git.name, gitBranch: git.gitBranch, modelName: getModelName() },
     v3Progress: getV3Progress(),
     security: getSecurityStatus(),
     swarm: getSwarmStatus(),
-    system: getSystemMetrics(),
+    system,
     adrs: getADRStatus(),
     hooks: getHooksStatus(),
-    agentdb: getAgentDBStats(),
+    embeddings: system.embeddings,
     tests: getTestStats(),
     git: { modified: git.modified, untracked: git.untracked, staged: git.staged, ahead: git.ahead, behind: git.behind },
     upgradeNotice: getUpgradeNotice(),

package/.claude/helpers/subagent-bootstrap.json

@@ -0,0 +1,3 @@
+{
+  "directive": "MANDATORY FIRST ACTION: Your very first tool call MUST be mcp__moflo__memory_search (any query, any namespace). The memory-first gate WILL BLOCK all Glob, Grep, and Read calls until you do this. After memory search, follow `.claude/guidance/shipped/moflo-subagents.md` protocol."
+}

package/.claude/helpers/subagent-start.cjs

@@ -1,22 +1,58 @@
-#!/usr/bin/env node
-/**
- * SubagentStart Hook — injects a directive into every subagent's context
- * telling it to read the subagent protocol guidance before doing any work.
- *
- * Output format: JSON with additionalContext (Claude Code hook protocol).
- * Exit 0 = allow (SubagentStart cannot block).
- */
-'use strict';
-
-const output = {
-  hookSpecificOutput: {
-    hookEventName: 'SubagentStart',
-    additionalContext:
-      'MANDATORY FIRST ACTION: Your very first tool call MUST be mcp__moflo__memory_search (any query, any namespace). ' +
-      'The memory-first gate WILL BLOCK all Glob, Grep, and Read calls until you do this. ' +
-      'After memory search, follow `.claude/guidance/shipped/moflo-subagents.md` protocol.',
-  },
-};
-
-process.stdout.write(JSON.stringify(output));
-process.exit(0);
+#!/usr/bin/env node
+/**
+ * SubagentStart Hook — injects a directive into every subagent's context
+ * telling it to read the subagent protocol guidance before doing any work.
+ *
+ * Output format: JSON with additionalContext (Claude Code hook protocol).
+ * Exit 0 = allow (SubagentStart cannot block).
+ *
+ * Source of truth: ./subagent-bootstrap.json (sibling). The TS export at
+ * `src/cli/services/subagent-bootstrap.ts` reads the same file so future
+ * agent_spawn surfaces (epic #798 stories 3 + 9) inject byte-identical text.
+ *
+ * Inline FALLBACK keeps the hook functional if the JSON sibling is ever
+ * missing — a SubagentStart that emits nothing leaves the memory-first gate
+ * un-announced and silently regresses subagent behavior.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Defense-in-depth copy of the canonical directive in subagent-bootstrap.json.
+// Kept as a single-line literal so the parity test in tests/bin/subagent-start.test.ts
+// can verify it matches the JSON via plain substring containment.
+const FALLBACK_DIRECTIVE = 'MANDATORY FIRST ACTION: Your very first tool call MUST be mcp__moflo__memory_search (any query, any namespace). The memory-first gate WILL BLOCK all Glob, Grep, and Read calls until you do this. After memory search, follow `.claude/guidance/shipped/moflo-subagents.md` protocol.';
+
+function loadDirective() {
+  const jsonPath = path.join(__dirname, 'subagent-bootstrap.json');
+  let raw;
+  try {
+    raw = fs.readFileSync(jsonPath, 'utf8');
+  } catch (err) {
+    if (err && err.code !== 'ENOENT') {
+      process.stderr.write(`[subagent-start] read failed: ${err.message} — using inline fallback\n`);
+    }
+    return FALLBACK_DIRECTIVE;
+  }
+  try {
+    const data = JSON.parse(raw);
+    if (typeof data.directive === 'string' && data.directive.length > 0) {
+      return data.directive;
+    }
+    process.stderr.write('[subagent-start] subagent-bootstrap.json missing string `directive` — using inline fallback\n');
+  } catch (err) {
+    process.stderr.write(`[subagent-start] subagent-bootstrap.json parse failed: ${err.message} — using inline fallback\n`);
+  }
+  return FALLBACK_DIRECTIVE;
+}
+
+const output = {
+  hookSpecificOutput: {
+    hookEventName: 'SubagentStart',
+    additionalContext: loadDirective(),
+  },
+};
+
+process.stdout.write(JSON.stringify(output));
+process.exit(0);