muonroi-cli 1.8.4 → 1.9.0

package/dist/src/product-loop/index.js

@@ -1,21 +1,23 @@
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
+import { readDebateCheckpoint } from "../council/debate-checkpoint.js";
 import { resolveLeaderModel } from "../council/leader.js";
 import { routeModel as eeRouteModel } from "../ee/bridge.js";
 import { fireAndForgetPhaseOutcome } from "../ee/phase-outcome.js";
 import { readArtifact } from "../flow/artifact-io.js";
+import { parseResumeDigest, readSprintOutcomes } from "../flow/run-artifacts.js";
 import { createRun, loadRun } from "../flow/run-manager.js";
 import { getModelsForProvider } from "../models/registry.js";
 import { loadKeyForProvider } from "../providers/keychain.js";
 import { ALL_PROVIDER_IDS } from "../providers/types.js";
 import { defaultResolveChannelId, maybeAutoFire } from "../reporter/auto-fire.js";
+import { clearWorkspaceFocus, setWorkspaceFocus } from "../state/active-run.js";
 import { logInteraction, logUIInteraction } from "../storage/index.js";
-import { activeRunStore } from "../ui/state/active-run.js";
 import { markIterationCrashed, readIterations, readManifest, writeManifest } from "./artifact-io.js";
 import { buildBacklog } from "./backlog-builder.js";
 import { readBacklog, writeBacklog } from "./backlog-store.js";
 import { formatCostPreview, previewRunCost } from "./cost-preview.js";
-import { extractRunToEE } from "./cross-run-memory.js";
+import { composeRunTranscript, extractRunToEE } from "./cross-run-memory.js";
 import { buildContinueFeedback } from "./feedback-routing.js";
 import { runLoopDriver } from "./loop-driver.js";
 import { resolveRoles } from "./role-registry.js";
@@ -38,6 +40,8 @@ export async function* runProductLoop(opts) {
     switch (sub) {
         case "status":
             return yield* runStatus(opts);
+        case "review":
+            return yield* runReview(opts);
         case "resume":
             return yield* runResume(opts);
         case "abort":
@@ -46,14 +50,30 @@ export async function* runProductLoop(opts) {
             return yield* runShip(opts);
         default: {
             // Mode C dispatch — see .planning/MAINTAIN-MODE.md "Trigger mechanism".
-            //   1. Explicit --maintain   → Mode C
-            //   2. Explicit --new        → Mode A (current behavior, skip detection)
-            //   3. Auto-detect: verify recipe present in cwd → Mode C
-            //   4. Otherwise             → Mode A
+            //   1. Explicit --maintain     → Mode C (strongest signal; wins over --force-council)
+            //   2. Explicit --new          → Mode A (skip recipe detection)
+            //   3. --force-council         → Mode A (user explicitly wants the full Council/loop)
+            //   4. Auto-detect: verify recipe present in cwd → Mode C
+            //   5. Otherwise               → Mode A
             if (opts.mode === "maintain") {
                 return yield* runMaintain(opts);
             }
-            if (opts.mode !== "new" && opts.detectVerifyRecipe) {
+            // `--force-council` must bypass the recipe auto-detect. Without this,
+            // ANY recipe-bearing repo (package.json/*.csproj/…) routes to runMaintain
+            // here — BEFORE the forceCouncil checks below (:189 / :197) are ever
+            // reached — so `/ideal --force-council` in an existing project was silently
+            // downgraded to maint-edit (observed: route-decision forceCouncil:false,
+            // path:maintain). Explicit --maintain above still wins over --force-council.
+            //
+            // complexity==="high" ALSO bypasses the recipe auto-detect. An
+            // architectural change (migration, SDK removal, subsystem rewrite) in a
+            // recipe-bearing repo must still earn the full Council — the very intent
+            // the complexity gate at :196-207 (and comment :188-195) documents. Before
+            // this guard, that gate was dead code for any repo with a verify recipe
+            // (real orchestrator ALWAYS wires detectVerifyRecipe), so a high-complexity
+            // /ideal was silently downgraded to maint-edit and jumped straight to Edit
+            // with no debate (observed: route-decision complexity:high path:maintain).
+            if (opts.mode !== "new" && !opts.flags.forceCouncil && opts.complexity !== "high" && opts.detectVerifyRecipe) {
                 try {
                     const recipe = await opts.detectVerifyRecipe();
                     if (recipe) {
@@ -86,10 +106,18 @@ export async function* runProductLoop(opts) {
                 };
                 return yield* runStart(forcedOpts);
             }
-            // Existing repo + complexity≠high → hot-path. The leader can grep
-            // the source instead of interviewing the user. Only architectural
-            // changes (complexity=high) still warrant the full Council debate.
-            if (existingRepoBypass && opts.complexity !== "high" && !opts.flags.forceCouncil) {
+            // Existing repo + complexity≠high + well-specified → hot-path. The leader
+            // can grep the source instead of interviewing the user. Two things still
+            // warrant the full Council/interview path: an architectural change
+            // (complexity=high / heavy), OR a request the model flagged as
+            // UNDERSPECIFIED (needsClarification) — a standard task missing a target
+            // or design decision must be clarified before code. A `quick`
+            // (complexity=low) task always hot-paths (handled below) even when
+            // underspecified: a trivial ask never earns an interview.
+            if (existingRepoBypass &&
+                opts.complexity !== "high" &&
+                !(opts.needsClarification && opts.complexity !== "low") &&
+                !opts.flags.forceCouncil) {
                 return yield* runHotPath(opts);
             }
             if (opts.complexity === "low" && !opts.flags.forceCouncil) {
@@ -148,6 +176,22 @@ async function* runHotPath(opts) {
         stack: flags.stack,
         createdAt: new Date(),
     });
+    if (opts.cwd) {
+        try {
+            const { isGsdNativeEnabled } = await import("../gsd/flags.js");
+            if (isGsdNativeEnabled()) {
+                const { ensureProductPlanningWorkspace } = await import("../gsd/product-workspace.js");
+                ensureProductPlanningWorkspace(opts.cwd, {
+                    idea,
+                    sessionModelId: opts.sessionModelId,
+                    runId,
+                });
+            }
+        }
+        catch (err) {
+            console.error(`[ideal/hot-path] gsd product workspace bootstrap failed: ${err.message}`);
+        }
+    }
     yield {
         type: "content",
         content: "\n> hot-path: complexity=low → single sprint, no council debate\n",
@@ -160,6 +204,7 @@ async function* runHotPath(opts) {
             kind: "route-decision",
             path: "hot-path",
             complexity: opts.complexity ?? "low",
+            underspecified: !!opts.needsClarification,
             forceCouncil: false,
             runId,
         });
@@ -201,7 +246,7 @@ async function* runHotPath(opts) {
     try {
         const { productSlug: deriveSlug } = await import("./product-identity.js");
         const slug = deriveSlug(idea);
-        activeRunStore.setActiveRun(runId, flowDir, slug);
+        await setWorkspaceFocus(flowDir, { runId, productSlug: slug, reason: "sprint-plan-committed" });
         fireAutoReport("sprint-plan-committed", { runId, flowDir, productSlug: slug, sprintCount: 1 });
     }
     catch {
@@ -233,6 +278,7 @@ async function* runHotPath(opts) {
         cwd: opts.cwd,
         sessionId: opts.sessionId,
         processMessageFn: opts.processMessageFn,
+        runIsolatedTask: opts.runIsolatedTask,
         detectVerifyRecipe: opts.detectVerifyRecipe,
         skipPriorContext: opts.skipPriorContext,
         sufficiencyMissing: opts.sufficiencyMissing,
@@ -556,6 +602,22 @@ async function* runStart(opts) {
         stack: flags.stack,
         createdAt: new Date(),
     });
+    if (opts.cwd) {
+        try {
+            const { isGsdNativeEnabled } = await import("../gsd/flags.js");
+            if (isGsdNativeEnabled()) {
+                const { ensureProductPlanningWorkspace } = await import("../gsd/product-workspace.js");
+                ensureProductPlanningWorkspace(opts.cwd, {
+                    idea,
+                    sessionModelId: opts.sessionModelId,
+                    runId,
+                });
+            }
+        }
+        catch (err) {
+            console.error(`[ideal] gsd product workspace bootstrap failed: ${err.message}`);
+        }
+    }
     // Surface a cost-vs-cap preview before the loop kicks off so $50 isn't
     // an arbitrary number — show predicted spend per sprint × max-sprints
     // against the configured cap, with a recommended max-sprints if it
@@ -574,6 +636,7 @@ async function* runStart(opts) {
             kind: "route-decision",
             path: "council",
             complexity: opts.complexity ?? "unknown",
+            underspecified: !!opts.needsClarification,
             forceCouncil: !!opts.flags.forceCouncil,
             sufficiencyMissing: opts.sufficiencyMissing ?? [],
             runId,
@@ -604,6 +667,7 @@ async function* runStart(opts) {
         cwd: opts.cwd,
         sessionId: opts.sessionId,
         processMessageFn: opts.processMessageFn,
+        runIsolatedTask: opts.runIsolatedTask,
         detectVerifyRecipe: opts.detectVerifyRecipe,
         skipPriorContext: opts.skipPriorContext,
         sufficiencyMissing: opts.sufficiencyMissing,
@@ -688,7 +752,7 @@ async function* runStart(opts) {
     try {
         const { productSlug: deriveSlug } = await import("./product-identity.js");
         const slug = deriveSlug(idea);
-        activeRunStore.setActiveRun(runId, flowDir, slug);
+        await setWorkspaceFocus(flowDir, { runId, productSlug: slug, reason: "sprint-plan-committed" });
         fireAutoReport("sprint-plan-committed", { runId, flowDir, productSlug: slug, sprintCount });
     }
     catch {
@@ -880,7 +944,7 @@ async function* drainSprints(args) {
                         const { productSlug: deriveSlug } = await import("./product-identity.js");
                         const slug = deriveSlug(productSpec.idea);
                         fireAutoReport("sprint-halt", { runId: ctx.runId, flowDir: ctx.flowDir, productSlug: slug, haltReason });
-                        activeRunStore.clearActiveRun();
+                        clearWorkspaceFocus();
                     }
                     catch {
                         /* best-effort */
@@ -934,7 +998,7 @@ async function* drainSprints(args) {
                 const { productSlug: deriveSlug } = await import("./product-identity.js");
                 const slug = deriveSlug(productSpec.idea);
                 fireAutoReport("sprint-halt", { runId: ctx.runId, flowDir: ctx.flowDir, productSlug: slug, haltReason: msg });
-                activeRunStore.clearActiveRun();
+                clearWorkspaceFocus();
             }
             catch {
                 /* best-effort */
@@ -1028,7 +1092,7 @@ async function* drainSprints(args) {
                 }
             }
             // B1: clear active-run on successful ship.
-            activeRunStore.clearActiveRun();
+            clearWorkspaceFocus();
             return {
                 runId: ctx.runId,
                 stage: "approved",
@@ -1052,7 +1116,7 @@ async function* drainSprints(args) {
         content: `\n> Reached max-sprints (${flags.maxSprints}) without satisfying Definition-of-Done.\n`,
     };
     // B1: clear active-run when max-sprints reached.
-    activeRunStore.clearActiveRun();
+    clearWorkspaceFocus();
     return {
         runId: ctx.runId,
         stage: "halted",
@@ -1140,6 +1204,12 @@ async function* runPhasesPath(args) {
             currentPhaseId = sc.phaseId ?? null;
             sprintHistory = [];
         }
+        // Carry the previous sprint's failure focus (unmet criteria / verify failures
+        // / residual plan deviations) into this sprint so each iteration continues the
+        // specific risky parts instead of restarting blind — parity with the legacy
+        // drainSprints path. Without this the phase-orchestrated loop dropped the
+        // feedback-routing focus between sprints.
+        const prevSprint = sprintHistory[sprintHistory.length - 1];
         const inner = runSprint({
             sprintN: sc.sprintN,
             ctx,
@@ -1147,6 +1217,7 @@ async function* runPhasesPath(args) {
             roleAssignments,
             history: [...sprintHistory],
             phaseScope: sc.phaseScope,
+            carryOver: prevSprint?.nextFocus ? { focus: prevSprint.nextFocus } : undefined,
         });
         let result;
         while (true) {
@@ -1247,6 +1318,8 @@ async function* runPhasesPath(args) {
         remainingUsd: async () => Math.max(0, manifest.capUsd - (await getProductSpentUsd(ctx.runId))),
         awaitCustomerVerdict,
         sprintRunner,
+        projectCwd: ctx.cwd,
+        idea: ctx.idea,
     });
     let phaseOutcome = { pass: false };
     while (true) {
@@ -1384,12 +1457,27 @@ async function* runStatus(opts) {
             return { runId: opts.runId, stage: "error", success: false, reason: "not_found" };
         }
         const iters = await readIterations(opts.flowDir, opts.runId);
-        yield {
-            type: "content",
-            content: `Run ${opts.runId}: ${m.idea}\n` +
-                `Cap: $${m.capUsd}  MaxSprints: ${m.maxSprints}  DoneThreshold: ${m.doneThreshold}\n` +
-                `Iterations: ${iters.length}  Aborted: ${m.aborted ?? false}  DoneAt: ${m.doneAt?.toISOString() ?? "—"}\n`,
-        };
+        const digest = await readResumeDigest(opts.flowDir, opts.runId);
+        const outcomes = await readSprintOutcomes(opts.flowDir, opts.runId).catch(() => []);
+        const lines = [
+            `Run ${opts.runId}: ${m.idea}`,
+            `Cap: $${m.capUsd}  MaxSprints: ${m.maxSprints}  DoneThreshold: ${m.doneThreshold}`,
+            `Iterations: ${iters.length}  Aborted: ${m.aborted ?? false}  DoneAt: ${m.doneAt?.toISOString() ?? "—"}`,
+        ];
+        if (digest) {
+            lines.push("", "Resume Digest:", `  Stage: ${digest.stage}` +
+                (typeof digest.sprintN === "number" ? `  Sprint: ${digest.sprintN}` : "") +
+                (typeof digest.score === "number" ? `  Score: ${digest.score.toFixed(2)}` : "") +
+                (digest.verify ? `  Verify: ${digest.verify}` : ""), `  Next: ${digest.nextAction || "—"}`);
+        }
+        if (outcomes.length > 0) {
+            lines.push("", "Sprints:");
+            for (const o of outcomes) {
+                lines.push(`  #${o.sprintN}  ${o.pass ? "✓ pass" : "✗ fail"}  score=${o.score.toFixed(2)}  verify=${o.verify}` +
+                    (o.failedCondition ? `  (${o.failedCondition})` : ""));
+            }
+        }
+        yield { type: "content", content: `${lines.join("\n")}\n` };
         return { runId: opts.runId, stage: "approved", success: true };
     }
     const lines = [`Active runs (${entries.length}):`];
@@ -1398,26 +1486,108 @@ async function* runStatus(opts) {
         const iters = await readIterations(opts.flowDir, id).catch(() => []);
         if (!m)
             continue;
-        lines.push(`  ${id}  ${m.idea.slice(0, 60)}  sprints=${iters.length}  aborted=${m.aborted ?? false}`);
+        const digest = await readResumeDigest(opts.flowDir, id).catch(() => null);
+        const stagePart = digest ? `  stage=${digest.stage}` : "";
+        lines.push(`  ${id}  ${m.idea.slice(0, 60)}  sprints=${iters.length}${stagePart}  aborted=${m.aborted ?? false}`);
     }
     yield { type: "content", content: `${lines.join("\n")}\n` };
     return { runId: "", stage: "approved", success: true };
 }
+/**
+ * Read + parse the structured Resume Digest from a run's top-level state.md.
+ * Returns null when the run has no digest yet (or only a legacy one-liner).
+ */
+async function readResumeDigest(flowDir, runId) {
+    const run = await loadRun(flowDir, runId).catch(() => null);
+    if (!run)
+        return null;
+    return parseResumeDigest(run.state.sections.get("Resume Digest"));
+}
+/**
+ * `/ideal review [runId]` — render a run's composed transcript plus a scored
+ * sprint table. Read-only. With no runId, reviews the most recent run (any
+ * status — review is a post-hoc lens, not restricted to incomplete runs).
+ */
+async function* runReview(opts) {
+    let resolvedRunId = opts.runId;
+    if (!resolvedRunId) {
+        const runsRoot = path.join(opts.flowDir, "runs");
+        let entries = [];
+        try {
+            entries = await fs.readdir(runsRoot);
+        }
+        catch {
+            yield { type: "content", content: "No runs to review.\n" };
+            return { runId: "", stage: "error", success: false, reason: "no_runs" };
+        }
+        const dated = [];
+        for (const id of entries) {
+            const m = await readManifest(opts.flowDir, id).catch(() => null);
+            if (!m)
+                continue;
+            const createdAt = m.createdAt instanceof Date && !Number.isNaN(m.createdAt.getTime()) ? m.createdAt.getTime() : 0;
+            dated.push({ id, createdAt });
+        }
+        if (dated.length === 0) {
+            yield { type: "content", content: "No runs to review.\n" };
+            return { runId: "", stage: "error", success: false, reason: "no_runs" };
+        }
+        dated.sort((a, b) => b.createdAt - a.createdAt);
+        resolvedRunId = dated[0].id;
+    }
+    const manifest = await readManifest(opts.flowDir, resolvedRunId);
+    if (!manifest) {
+        yield { type: "content", content: `Run not found: ${resolvedRunId}\n` };
+        return { runId: resolvedRunId, stage: "error", success: false, reason: "not_found" };
+    }
+    const header = [
+        `# Review — run ${resolvedRunId}`,
+        "",
+        `Idea: ${manifest.idea}`,
+        `Aborted: ${manifest.aborted ?? false}  DoneAt: ${manifest.doneAt?.toISOString() ?? "—"}`,
+    ];
+    const digest = await readResumeDigest(opts.flowDir, resolvedRunId);
+    if (digest) {
+        header.push(`Last stage: ${digest.stage} — ${digest.nextAction || "—"}`);
+    }
+    const outcomes = await readSprintOutcomes(opts.flowDir, resolvedRunId).catch(() => []);
+    if (outcomes.length > 0) {
+        header.push("", "## Sprint scores", "", "| Sprint | Result | Score | Verify | Failed condition |", "|---|---|---|---|---|");
+        for (const o of outcomes) {
+            header.push(`| ${o.sprintN} | ${o.pass ? "pass" : "fail"} | ${o.score.toFixed(2)} | ${o.verify} | ${o.failedCondition ?? "—"} |`);
+        }
+    }
+    yield { type: "content", content: `${header.join("\n")}\n` };
+    // The composed transcript (manifest/roadmap/delegations/gray-areas) rounds out
+    // the review with the actual debate + spec text. Bounded to 32KB by the composer.
+    const transcript = await composeRunTranscript(opts.flowDir, resolvedRunId).catch(() => "");
+    if (transcript.trim()) {
+        yield { type: "content", content: `\n## Transcript\n${transcript}\n` };
+    }
+    return { runId: resolvedRunId, stage: "approved", success: true };
+}
 async function* runAbort(opts) {
-    if (!opts.runId) {
-        yield { type: "content", content: "error: abort requires a runId\n" };
-        return { runId: "", stage: "error", success: false, reason: "missing_runId" };
+    // A/B — bare `/ideal abort` (no runId, e.g. the recovery card's Abort option):
+    // auto-detect the newest incomplete run, mirroring resume.
+    let resolvedRunId = opts.runId;
+    if (!resolvedRunId) {
+        const latest = await findLatestIncompleteRun(opts.flowDir);
+        if (!latest) {
+            yield { type: "content", content: "No incomplete run to abort.\n" };
+            return { runId: "", stage: "error", success: false, reason: "no_incomplete_run" };
+        }
+        resolvedRunId = latest.id;
     }
-    const m = await readManifest(opts.flowDir, opts.runId);
+    const m = await readManifest(opts.flowDir, resolvedRunId);
     if (!m) {
-        yield { type: "content", content: `Run not found: ${opts.runId}\n` };
-        return { runId: opts.runId, stage: "error", success: false, reason: "not_found" };
+        yield { type: "content", content: `Run not found: ${resolvedRunId}\n` };
+        return { runId: resolvedRunId, stage: "error", success: false, reason: "not_found" };
     }
-    await writeManifest(opts.flowDir, opts.runId, { ...m, aborted: true, doneAt: new Date() });
+    await writeManifest(opts.flowDir, resolvedRunId, { ...m, aborted: true, doneAt: new Date() });
     // Fire-and-forget EE phase-outcome=aborted (extension landed in 13-05).
     try {
         fireAndForgetPhaseOutcome({
-            sessionId: opts.runId,
+            sessionId: resolvedRunId,
             phaseName: "product-loop",
             outcome: "aborted",
         });
@@ -1431,9 +1601,9 @@ async function* runAbort(opts) {
     // EE client is non-fatal (offline queue absorbs transport failures).
     // P1.6: log telemetry for the extract outcome.
     {
-        const eeResult = await extractRunToEE(opts.flowDir, opts.runId, opts.cwd ?? process.cwd());
+        const eeResult = await extractRunToEE(opts.flowDir, resolvedRunId, opts.cwd ?? process.cwd());
         try {
-            logInteraction(opts.sessionId ?? opts.runId ?? "abort", "ee_injection", {
+            logInteraction(opts.sessionId ?? resolvedRunId ?? "abort", "ee_injection", {
                 eventSubtype: "extract",
                 durationMs: Math.round(eeResult.durationMs),
                 data: {
@@ -1447,39 +1617,106 @@ async function* runAbort(opts) {
             // DB errors must not break /ideal
         }
     }
-    yield { type: "content", content: `Aborted run ${opts.runId}.\n` };
-    return { runId: opts.runId, stage: "halted", success: false, reason: "aborted" };
+    yield { type: "content", content: `Aborted run ${resolvedRunId}.\n` };
+    return { runId: resolvedRunId, stage: "halted", success: false, reason: "aborted" };
+}
+/**
+ * B — Auto-detect the newest resumable run.
+ *
+ * "Resumable" = a run that has a manifest (early pre-manifest crashes are not
+ * replayable) AND is neither aborted nor terminal (`doneAt` is set on done-gate
+ * pass / ship / abort). Sorted by manifest `createdAt` descending so a bare
+ * `/ideal resume` continues the most recent incomplete run without the user
+ * having to remember (or type) the runId.
+ */
+async function findLatestIncompleteRun(flowDir) {
+    const runsRoot = path.join(flowDir, "runs");
+    let entries;
+    try {
+        entries = await fs.readdir(runsRoot);
+    }
+    catch (err) {
+        // No runs directory yet → nothing to resume. Not an error worth surfacing.
+        if (err?.code !== "ENOENT") {
+            console.error(`[product-loop] findLatestIncompleteRun: readdir failed: ${err?.message}`);
+        }
+        return null;
+    }
+    const candidates = [];
+    for (const id of entries) {
+        const m = await readManifest(flowDir, id).catch((e) => {
+            console.error(`[product-loop] findLatestIncompleteRun: manifest read failed for ${id}: ${e?.message}`);
+            return null;
+        });
+        if (!m)
+            continue; // no manifest → not resumable
+        if (m.aborted)
+            continue; // hard-killed
+        if (m.doneAt)
+            continue; // terminal (done / shipped)
+        const createdAt = m.createdAt instanceof Date && !Number.isNaN(m.createdAt.getTime()) ? m.createdAt.getTime() : 0;
+        candidates.push({ id, idea: m.idea, createdAt });
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => b.createdAt - a.createdAt);
+    const top = candidates[0];
+    return { id: top.id, idea: top.idea };
 }
 async function* runResume(opts) {
-    if (!opts.runId) {
-        yield { type: "content", content: "error: resume requires a runId\n" };
-        return { runId: "", stage: "error", success: false, reason: "missing_runId" };
+    // B — bare `/ideal resume` (no runId): auto-detect the newest incomplete run.
+    let resolvedRunId = opts.runId;
+    if (!resolvedRunId) {
+        const latest = await findLatestIncompleteRun(opts.flowDir);
+        if (!latest) {
+            yield {
+                type: "content",
+                content: 'No incomplete run to resume. Start one with /ideal "<idea>".\n',
+            };
+            return { runId: "", stage: "error", success: false, reason: "no_incomplete_run" };
+        }
+        resolvedRunId = latest.id;
+        yield {
+            type: "content",
+            content: `Resuming latest incomplete run ${resolvedRunId}: ${latest.idea.slice(0, 60)}\n`,
+        };
     }
-    const run = await loadRun(opts.flowDir, opts.runId);
+    const run = await loadRun(opts.flowDir, resolvedRunId);
     if (!run) {
-        yield { type: "content", content: `Run not found: ${opts.runId}\n` };
-        return { runId: opts.runId, stage: "error", success: false, reason: "not_found" };
+        yield { type: "content", content: `Run not found: ${resolvedRunId}\n` };
+        return { runId: resolvedRunId, stage: "error", success: false, reason: "not_found" };
     }
-    const manifest = await readManifest(opts.flowDir, opts.runId);
+    const manifest = await readManifest(opts.flowDir, resolvedRunId);
     if (!manifest) {
-        yield { type: "content", content: `Manifest missing for ${opts.runId}\n` };
-        return { runId: opts.runId, stage: "error", success: false, reason: "manifest_missing" };
+        yield { type: "content", content: `Manifest missing for ${resolvedRunId}\n` };
+        return { runId: resolvedRunId, stage: "error", success: false, reason: "manifest_missing" };
     }
     if (manifest.aborted) {
-        yield { type: "content", content: `Run ${opts.runId} was aborted; cannot resume.\n` };
-        return { runId: opts.runId, stage: "halted", success: false, reason: "aborted" };
+        yield { type: "content", content: `Run ${resolvedRunId} was aborted; cannot resume.\n` };
+        return { runId: resolvedRunId, stage: "halted", success: false, reason: "aborted" };
+    }
+    // Surface the Resume Digest so the user sees where the run stopped and what
+    // resuming will do — the whole point of giving the digest real content.
+    {
+        const digest = parseResumeDigest(run.state.sections.get("Resume Digest"));
+        if (digest) {
+            yield {
+                type: "content",
+                content: `> Resume Digest — stage: ${digest.stage}${typeof digest.sprintN === "number" ? ` (sprint ${digest.sprintN})` : ""} · next: ${digest.nextAction || "—"}\n`,
+            };
+        }
     }
     // Detect crashed in-flight sprint: an iterations.md entry without a closing
     // Verify line is treated as crashed. Our schema always writes the Verify line
     // before returning, so an iteration is "in-flight" iff the file has a Sprint
     // heading but no matching Verify field. readIterations skips malformed
     // entries — so we mark the highest sprint number as crashed regardless.
-    const iters = await readIterations(opts.flowDir, opts.runId);
+    const iters = await readIterations(opts.flowDir, resolvedRunId);
     let nextSprint = iters.length + 1;
     if (iters.length > 0) {
         const last = iters[iters.length - 1];
         if (!last.lastVerifyResult || last.lastVerifyResult === "UNKNOWN") {
-            await markIterationCrashed(opts.flowDir, opts.runId, last.sprintN);
+            await markIterationCrashed(opts.flowDir, resolvedRunId, last.sprintN);
             nextSprint = last.sprintN; // retry with retryOf metadata
             yield {
                 type: "content",
@@ -1490,7 +1727,7 @@ async function* runResume(opts) {
     // Fire EE phase-outcome=resumed (extension landed in 13-05).
     try {
         fireAndForgetPhaseOutcome({
-            sessionId: opts.runId,
+            sessionId: resolvedRunId,
             phaseName: `sprint-${Math.max(1, nextSprint - 1)}`,
             outcome: "resumed",
         });
@@ -1499,9 +1736,8 @@ async function* runResume(opts) {
         /* non-fatal */
     }
     // Resume into sprint loop with reconstructed history + manifest flags.
-    const productSpec = await loadProductSpec(opts.flowDir, opts.runId, manifest.idea, manifest.stack);
     const ctx = {
-        runId: opts.runId,
+        runId: resolvedRunId,
         flowDir: opts.flowDir,
         idea: manifest.idea,
         sessionModelId: opts.sessionModelId,
@@ -1512,8 +1748,60 @@ async function* runResume(opts) {
         cwd: opts.cwd,
         sessionId: opts.sessionId,
         processMessageFn: opts.processMessageFn,
+        runIsolatedTask: opts.runIsolatedTask,
         detectVerifyRecipe: opts.detectVerifyRecipe,
     };
+    // C-v2 cross-session debate resume — a persisted debate checkpoint means the
+    // council debate was interrupted before it ever produced a spec, so the run
+    // cannot go straight to sprints (loadProductSpec would return an empty stub).
+    // Re-run the council FSM: loop-driver's resume entry skips discovery + the
+    // interview and restores the debate from its checkpoint, then scoping writes
+    // the spec. This mirrors runStart's phase-1 → phase-2 handoff.
+    const runDir = path.join(opts.flowDir, "runs", resolvedRunId);
+    const interruptedDebate = await readDebateCheckpoint(runDir);
+    if (interruptedDebate) {
+        yield {
+            type: "content",
+            content: `\n> Detected an interrupted council debate (round ${interruptedDebate.roundCount + 1}); resuming it before sprints.\n`,
+        };
+        const driverGen = runLoopDriver(ctx);
+        let driverResult;
+        try {
+            while (true) {
+                const { value, done } = await driverGen.next();
+                if (done) {
+                    driverResult = value;
+                    break;
+                }
+                yield value;
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            yield { type: "error", error: true, content: msg };
+            return { runId: resolvedRunId, stage: "error", success: false, reason: msg };
+        }
+        if (!driverResult?.success || driverResult.stage !== "approved") {
+            return { ...driverResult, runId: resolvedRunId };
+        }
+        // Build the sprint plan now that the spec exists (idempotent — skips when
+        // backlog.json / sprint-plan.json already exist).
+        const resumedSpec = await loadProductSpec(opts.flowDir, resolvedRunId, manifest.idea, manifest.stack);
+        const { sprintCount } = await buildBacklogAndSprintPlan({
+            flowDir: opts.flowDir,
+            runId: resolvedRunId,
+            productSpec: resumedSpec,
+            ctx,
+            sessionModelId: opts.sessionModelId,
+            maxSprints: opts.flags.maxSprints,
+            onChunk: (chunk) => void chunk,
+        });
+        yield {
+            type: "content",
+            content: `\n> Committed: ${sprintCount} sprint${sprintCount === 1 ? "" : "s"} planned. Sprint 1 active.\n`,
+        };
+    }
+    const productSpec = await loadProductSpec(opts.flowDir, resolvedRunId, manifest.idea, manifest.stack);
     const roleAssignments = opts.roleAssignments ?? (await resolveRoleAssignments(opts.sessionModelId));
     // Subsystem E: phase-orchestrated path (default ON; set MUONROI_PHASE_MODE=0 for legacy).
     if (process.env.MUONROI_PHASE_MODE !== "0") {

package/dist/src/product-loop/loop-driver.d.ts

@@ -1,4 +1,11 @@
 import type { StreamChunk } from "../types/index.js";
 import type { DriverContext, DriverResult, Stage } from "./types.js";
+/**
+ * Clamp a title for the milestone/phase index (F12): truncate at a word
+ * boundary when possible and strip trailing punctuation/whitespace so a raw
+ * slice can't leave a dangling "(" or a half word. Falls back to a hard slice
+ * for a single long token.
+ */
+export declare function clampTitle(raw: string, max: number): string;
 export declare function runLoopDriver(ctx: DriverContext): AsyncGenerator<StreamChunk, DriverResult, unknown>;
 export type { DriverContext, DriverResult, Stage };