moflo 4.9.0-rc.13 → 4.9.0-rc.15

package/.claude/helpers/statusline.cjs

@@ -382,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'));
@@ -393,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);
   }
 
@@ -423,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)
@@ -484,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;
@@ -601,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 : '',
@@ -623,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)
@@ -784,6 +795,25 @@ function generateDashboard() {
     );
   }
 
+  // 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}`);
+      }
+      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 = [];
@@ -795,7 +825,7 @@ function generateDashboard() {
     }
     if (integration.hasDatabase) parts.push(`${c.brightGreen}\u25C6${c.reset}DB`);
     if (parts.length > 0) {
-      lines.push(`${c.brightCyan}\uD83D\uDCCA MCP${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}  `)}`);
     }
   }
 
@@ -835,7 +865,7 @@ function generateCompactDashboard() {
   pushUpgradeNoticeSegment(lines);
   lines.push(header);
 
-  // Combined swarm + mcp line
+  // Combined swarm + embeddings + mcp line
   const segments = [];
   if (SL_CONFIG.show_swarm) {
     const swarm = getSwarmStatus();
@@ -845,6 +875,18 @@ function generateCompactDashboard() {
       `${c.brightYellow}\uD83E\uDD16${c.reset} ${swarmInd}[${agentsColor}${swarm.activeAgents}${c.reset}/${c.brightWhite}${swarm.maxAgents}${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();
     if (integration.mcpServers.total > 0) {
@@ -863,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);

package/.claude/skills/swarm-advanced/SKILL.md

@@ -33,6 +33,83 @@ mcp__moflo__agent_spawn({ type: "researcher", name: "swarm-advanced" })
 // 3. Orchestrate tasks
 ```
 
+### Dynamic Scaling
+Use `mcp__moflo__swarm_scale` to grow or shrink the agent pool to a target size
+without re-initializing the swarm. Three strategies are available:
+
+```javascript
+// Burst-spawn 8 workers all at once (load test, big batch)
+mcp__moflo__swarm_scale({
+  targetAgents: 8,
+  scaleStrategy: "immediate",
+  agentTypes: ["worker"],
+  reason: "load-test ramp"
+})
+
+// Rate-limited ramp (1 agent / 200ms) — gentler on the coordinator
+mcp__moflo__swarm_scale({
+  targetAgents: 12,
+  scaleStrategy: "gradual",
+  agentTypes: ["coder", "tester"]
+})
+
+// Adaptive: chunks scale with current coordinator load
+mcp__moflo__swarm_scale({ targetAgents: 4, scaleStrategy: "adaptive" })
+```
+
+The tool returns `{ previousAgents, currentAgents, scalingStatus, addedAgents,
+removedAgents }` so callers can verify the swarm reached the target. Scale-down
+prefers idle agents first, then oldest by heartbeat.
+
+### Task Orchestration
+
+The `task_*` family talks to the same UnifiedSwarmCoordinator that
+`swarm_init` / `agent_spawn` use, so tasks created here flow through the
+same scoring scheduler that load-balances across idle agents.
+
+```javascript
+// Single task — coordinator picks the lowest-workload agent automatically
+mcp__moflo__task_create({
+  type: "coding",
+  description: "Implement OAuth refresh flow",
+  priority: "high"
+})
+
+// Direct dispatch to a known agent (skip the scheduler)
+mcp__moflo__task_assign({
+  taskId: "task_swarm-…_3",
+  agentId: "agent-coder-…"
+})
+
+// Domain-routed dispatch (queen / security / core / integration / support)
+mcp__moflo__task_assign({
+  taskId: "task_swarm-…_4",
+  domain: "security"
+})
+
+// Submit a batch — load-balanced across available agents in one call.
+// 5 tasks across 3 idle agents → no agent ends up with more than 2.
+mcp__moflo__task_orchestrate({
+  tasks: [
+    { type: "coding", description: "endpoint A" },
+    { type: "coding", description: "endpoint B" },
+    { type: "testing", description: "tests for A" },
+    { type: "testing", description: "tests for B" },
+    { type: "review",  description: "PR review" }
+  ]
+})
+
+// Mark a task done and record its outcome
+mcp__moflo__task_complete({
+  taskId: "task_swarm-…_3",
+  result: { ok: true, summary: "merged in PR #842" }
+})
+```
+
+`task_orchestrate` returns `{ submitted, assigned, queued, rejected, tasks,
+errors }` — `assigned` is the count whose agents accepted them on submit;
+the rest are queued and will be picked up as agents go idle.
+
 ## Core Concepts
 
 ### Swarm Topologies

package/README.md

@@ -293,16 +293,16 @@ For simple epics with independent stories, `/flo <epic>` is all you need. For co
 `flo epic` is the robust epic runner — it adds persistent state, resume from failure, and per-story auto-merge on top of `/flo`. It takes a GitHub epic issue number:
 
 ```bash
-flo epic run 42                            # Fetch epic #42, run all stories sequentially
-flo epic run 42 --dry-run                  # Preview execution plan without running
-flo epic run 42 --strategy auto-merge      # Per-story PRs with auto-merge between stories
+flo epic 42                                # Fetch epic #42, run all stories sequentially
+flo epic 42 --dry-run                      # Preview execution plan without running
+flo epic 42 --strategy auto-merge          # Per-story PRs with auto-merge between stories
 flo epic status 42                         # Check progress (which stories passed/failed)
 flo epic reset 42                          # Reset state for re-run
 ```
 
-`flo epic` fetches the epic from GitHub, extracts child stories from checklists, numbered references, and `## Stories` / `## Tasks` sections, then runs each through `/flo` with state tracking. If a story fails, you can fix the issue and `flo epic run 42` again — it resumes from where it left off, skipping already-passed stories.
+`flo epic` fetches the epic from GitHub, extracts child stories from checklists, numbered references, and `## Stories` / `## Tasks` sections, then runs each through `/flo` with state tracking. If a story fails, you can fix the issue and re-run `flo epic 42` — it resumes from where it left off, skipping already-passed stories. (`flo epic run 42` is an explicit alias for the same shorthand.)
 
-| | `/flo <epic>` | `flo epic run <epic>` |
+| | `/flo <epic>` | `flo epic <epic>` |
 |---|---|---|
 | **State tracking** | No | Yes (`epic-state` memory namespace) |
 | **Resume from failure** | No | Yes (skips passed stories) |
@@ -583,7 +583,7 @@ flo --version                    # Show version
 
 ### Hooks (enabled OOTB)
 
-Hooks are shell commands that Claude Code runs automatically at specific points in its lifecycle. MoFlo installs 20 hook bindings across 8 lifecycle events. You don't invoke these — they fire automatically.
+Hooks are shell commands that Claude Code runs automatically at specific points in its lifecycle. MoFlo installs 23 hook bindings across 8 lifecycle events. You don't invoke these — they fire automatically.
 
 | Hook Event | What fires | What it does | Enabled OOTB |
 |------------|-----------|-------------|:---:|
@@ -593,9 +593,12 @@ Hooks are shell commands that Claude Code runs automatically at specific points
 | **PreToolUse: Bash** | `flo gate check-dangerous-command` | Safety check on shell commands | Yes |
 | **PreToolUse: Bash** | `flo gate check-before-pr` | Validates PR readiness before `gh pr create` | Yes |
 | **PostToolUse: Write/Edit** | `flo hooks post-edit` | Records edit outcome, optionally trains neural patterns | Yes |
+| **PostToolUse: Write/Edit** | `flo gate reset-edit-gates` | Resets edit-related gate state after the write completes | Yes |
 | **PostToolUse: Agent** | `flo hooks post-task` | Records task completion, feeds outcome into routing learner | Yes |
 | **PostToolUse: TaskCreate** | `flo gate record-task-created` | Records that a task was registered (clears TaskCreate gate) | Yes |
 | **PostToolUse: Bash** | `flo gate check-bash-memory` | Detects memory search commands in Bash (clears memory gate) | Yes |
+| **PostToolUse: Bash** | `flo gate record-test-run` | Records test runs from Bash for the test-output gate | Yes |
+| **PostToolUse: Skill** | `flo gate record-skill-run` | Records that a skill was invoked (clears skill-related gates) | Yes |
 | **PostToolUse: memory_search** | `flo gate record-memory-searched` | Records that memory was searched (clears memory-first gate) | Yes |
 | **PostToolUse: TaskUpdate** | `flo gate check-task-transition` | Validates task state transitions (prevents skipping states) | Yes |
 | **PostToolUse: memory_store** | `flo gate record-learnings-stored` | Records that learnings were persisted to memory | Yes |

package/bin/session-start-launcher.mjs

@@ -63,35 +63,36 @@ let upgradeNoticeContext = null;
 let pendingVersionStampWrite = null;
 
 // 5-min TTL is a safety net for zombie launchers (statusline ignores past-TTL
-// files). The launcher deletes the notice when upgrade work finishes — no
-// "complete" state lingers, see #738.
+// files). The 2-min "completed" TTL lets the user see the post-upgrade badge
+// briefly in the next session render (Claude Code renders the statusline only
+// AFTER the SessionStart hook returns, so the in-progress badge has effectively
+// zero visibility window). The next session-start's section 0-pre wipes any
+// leftover, so a stale completed notice can't linger past one session.
 const UPGRADE_NOTICE_INPROGRESS_TTL_MS = 5 * 60 * 1000;
+const UPGRADE_NOTICE_COMPLETED_TTL_MS = 2 * 60 * 1000;
 const UPGRADE_NOTICE_PATH = () => join(mofloDir(projectRoot), 'upgrade-notice.json');
 
-function writeInProgressUpgradeNotice() {
+function writeUpgradeNotice(status) {
   if (!upgradeNoticeContext) return;
+  const ttlMs = status === 'completed'
+    ? UPGRADE_NOTICE_COMPLETED_TTL_MS
+    : UPGRADE_NOTICE_INPROGRESS_TTL_MS;
   try {
     mkdirSync(mofloDir(projectRoot), { recursive: true });
     const now = Date.now();
     const notice = {
-      status: 'in-progress',
+      status,
       kind: upgradeNoticeContext.kind,
       from: upgradeNoticeContext.from,
       to: upgradeNoticeContext.to,
       at: new Date(now).toISOString(),
-      expiresAt: new Date(now + UPGRADE_NOTICE_INPROGRESS_TTL_MS).toISOString(),
+      expiresAt: new Date(now + ttlMs).toISOString(),
       changes: 0,
     };
     writeFileSync(UPGRADE_NOTICE_PATH(), JSON.stringify(notice, null, 2));
   } catch { /* non-fatal — statusline just won't show the segment */ }
 }
 
-function clearUpgradeNotice() {
-  try {
-    unlinkSync(UPGRADE_NOTICE_PATH());
-  } catch { /* non-fatal — already gone or never existed */ }
-}
-
 // ── 0-pre. Drop any stale upgrade notice (#738, #743) ───────────────────────
 // `upgrade-notice.json` is a transient handshake between launcher and
 // statusline — it should never survive past the launcher run that wrote it.
@@ -313,9 +314,9 @@ try {
       }
       // Surface a transient "(updating…)" badge in the statusline before the
       // long-running upgrade work (manifest sync, daemon recycle, embeddings
-      // migration). See #738 — the launcher clears this file after work
-      // completes, so the badge naturally disappears once the user is unblocked.
-      writeInProgressUpgradeNotice();
+      // migration). See #738 — section 3f flips this to a 2-min "completed"
+      // badge once work finishes (TTL rationale at the constants above).
+      writeUpgradeNotice('in-progress');
       const binDir = resolve(projectRoot, 'node_modules/moflo/bin');
 
       // ── Manifest-based auto-update ──────────────────────────────────────
@@ -415,7 +416,9 @@ try {
           resolve(projectRoot, 'node_modules/moflo/src/cli/.claude/helpers'),
         ];
         const sourceHelperFiles = [
-          'auto-memory-hook.mjs', 'statusline.cjs', 'intelligence.cjs', 'subagent-start.cjs', 'pre-commit', 'post-commit',
+          'auto-memory-hook.mjs', 'statusline.cjs', 'intelligence.cjs',
+          'subagent-start.cjs', 'subagent-bootstrap.json',
+          'pre-commit', 'post-commit',
         ];
         for (const file of sourceHelperFiles) {
           const dest = resolve(helpersDir, file);
@@ -855,12 +858,11 @@ try {
   } catch { /* writing the failure itself must not throw */ }
 }
 
-// ── 3f. Clear the in-progress upgrade notice (#636, #738) ───────────────────
-// Upgrade work is finished; drop the notice so the statusline badge disappears
-// immediately. Change summary is already in stdout emits (Claude's
-// `additionalContext`); a lingering "you upgraded a while ago" badge is noise.
+// ── 3f. Flip the upgrade notice to "completed" (#636, #738) ─────────────────
+// See the TTL rationale at the constants above for why we switch to a
+// short-TTL completed badge instead of clearing the file.
 if (upgradeNoticeContext) {
-  clearUpgradeNotice();
+  writeUpgradeNotice('completed');
 }
 
 // ── 3g. Commit deferred version stamp (#730) ────────────────────────────────

package/dist/src/cli/commands/doctor-checks-deep.js

@@ -23,7 +23,7 @@ import { errorDetail } from '../shared/utils/error-detail.js';
 // Path Resolution
 // ============================================================================
 /** Convert an absolute path to a file:// URL for dynamic import() on Windows. */
-function toImportUrl(absolutePath) {
+export function toImportUrl(absolutePath) {
     return pathToFileURL(absolutePath).href;
 }
 /**
@@ -37,7 +37,7 @@ export function getMofloRoot() {
 /**
  * Find the first existing .js module from paths relative to the moflo root.
  */
-function findModule(...relativePaths) {
+export function findModule(...relativePaths) {
     const root = getMofloRoot();
     if (!root)
         return undefined;
@@ -79,7 +79,10 @@ export async function checkSubagentHealth() {
             priority: 'low',
             metadata: { purpose: 'doctor-health-check' },
         }, {});
-        if (!spawnResult?.agentId || !['active', 'spawned'].includes(spawnResult.status)) {
+        // `idle` is the AgentState status returned by the live coordinator (post
+        // #801); `active`/`spawned` were the legacy literal returns. Accept all
+        // three — matches the status-check enum 13 lines below.
+        if (!spawnResult?.agentId || !['active', 'idle', 'spawned'].includes(spawnResult.status)) {
             return { name: 'Subagent Health', status: 'fail', message: `Spawn returned unexpected result: ${JSON.stringify(spawnResult)}` };
         }
         const agentId = spawnResult.agentId;