muonroi-cli 1.8.4 → 1.9.0

package/dist/src/council/index.js

@@ -1,7 +1,9 @@
 import { queryExperience } from "../ee/council-bridge.js";
 import { judgeCouncilOutcome } from "../ee/judge.js";
 import { recordCouncilOutcome } from "../ee/phase-outcome.js";
+import { isTaskAwarePanelEnabled } from "../gsd/flags.js";
 import { runPipeline } from "../pil/pipeline.js";
+import { idealTrace } from "../product-loop/ideal-trace.js";
 import { appendSystemMessage, logInteraction } from "../storage/index.js";
 import { SessionStore } from "../storage/sessions.js";
 import { getCouncilExperienceMode, isCouncilCostAware, isCouncilMultiProviderPreferred } from "../utils/settings.js";
@@ -11,7 +13,8 @@ import { evaluateResearchNeed, runDebate } from "./debate.js";
 import { planDebate } from "./debate-planner.js";
 import { detectOutOfStackProposals, writeDecisionsLock } from "./decisions-lock.js";
 import { runExecution } from "./executor.js";
-import { resolveLeaderModelDetailed, resolveParticipants } from "./leader.js";
+import { buildCouncilCandidatePool, resolveLeaderModelDetailed, resolveParticipants } from "./leader.js";
+import { selectTaskAwarePanel } from "./panel-select.js";
 import { phaseDone, phaseStart } from "./phase-events.js";
 import { runPlanning } from "./planner.js";
 import { runPreflight } from "./preflight.js";
@@ -59,6 +62,22 @@ const EXPLICIT_COUNCIL_CLARIFY_ROUNDS = 1;
  * generate_plan OPTION is still offered downstream; it's just no longer the
  * pre-selected default for non-build topics.
  */
+/**
+ * F1 — summarize how the debate did against its PINNED success criteria, so the
+ * post-debate card can distinguish "the criteria were actually met" from "the
+ * synthesis reads confidently" (evidence density). `metFlags` is index-aligned
+ * to `pinned` (from DebateState.finalCriteriaMet); a missing/short array treats
+ * the unmapped criteria as not-met. `inconclusive` is true when the spec had
+ * pinned criteria and at least one is still open — the caller ANDs this with
+ * `!synthesisFailed` before reframing the card.
+ */
+export function summarizeCriteriaOutcome(pinned, metFlags) {
+    const flags = metFlags ?? [];
+    const total = pinned.length;
+    const metCount = pinned.filter((_, i) => flags[i] === true).length;
+    const unmetLabels = pinned.filter((_, i) => flags[i] !== true);
+    return { total, metCount, unmetLabels, inconclusive: total > 0 && unmetLabels.length > 0 };
+}
 export function pickPostDebateRecommendation(input) {
     if (input.synthesisFailed) {
         return {
@@ -66,6 +85,13 @@ export function pickPostDebateRecommendation(input) {
             reason: "Re-run synthesis with a compact prompt — usually clears provider-timeout failures.",
         };
     }
+    if (input.criteriaUnmet && input.criteriaUnmet > 0) {
+        const n = input.criteriaUnmet;
+        return {
+            value: "ask_followup",
+            reason: `${n} success criteri${n === 1 ? "on" : "a"} still unmet — press the council to close ${n === 1 ? "it" : "them"} before treating this as settled.`,
+        };
+    }
     if (input.hasEmptySections) {
         return { value: "refine", reason: `Fill in ${input.refinementTopics.length} section(s) the debate left empty.` };
     }
@@ -85,6 +111,96 @@ export function pickPostDebateRecommendation(input) {
     }
     return { value: "save_exit", reason: "Outcome looks solid — save and move on." };
 }
+/**
+ * Decide whether — and with what prompt — the agent session should keep working
+ * after the post-debate askcard, given the action the user chose.
+ *
+ * Single source of truth for BOTH continuation callers (the `/council` slash path
+ * in orchestrator.runCouncilV2 and the auto-council path in tool-engine), which
+ * previously diverged: the slash path only continued on `continue_session`, while
+ * auto-council continued UNCONDITIONALLY with a fixed "Proceed with the recommended
+ * action items" prompt — meaningless for an evaluation/decision debate that has no
+ * action items, so the chosen action was effectively ignored.
+ *
+ * Returns the re-entry prompt to feed back into processMessage, or `null` to stop
+ * at the composer (the synthesis IS the deliverable).
+ *   - continue_session → carry the conclusion forward on the ORIGINAL task, but
+ *     ONLY for an implementation-shaped debate. For an analysis/evaluation debate
+ *     the conclusion IS the deliverable, so re-enter WITHOUT an implementation
+ *     mandate (session 578b2eae7099: "Continue the original task using this
+ *     conclusion" on an evaluation made the model invent phantom Phase-1..7 todos
+ *     and start editing files, then the rogue turn wedged the UI).
+ *   - generate_plan / implement → execute the recommended action items.
+ *   - save_exit / refine / retry_synthesis / follow-up / undefined → stop (those
+ *     either already re-synthesized inside runCouncil or are terminal by intent).
+ */
+const IMPLEMENTATION_OUTPUT_KINDS = new Set(["implementation_plan"]);
+/** Recover the output-shape kind the synthesis was produced under (```json { "type": … }). */
+function synthesisOutputKind(synthesis) {
+    const m = synthesis.match(/"type"\s*:\s*"([^"]+)"/);
+    return m?.[1];
+}
+export function postDebateContinuation(action, synthesis, outputKind) {
+    if (!synthesis || !action)
+        return null;
+    // IMPLEMENT — the user decided there is enough to build. Load the council
+    // conclusion back as the approved spec and carry it out through the normal
+    // workflow (the native GSD depth pipeline plans → executes → verifies). Works
+    // for ANY output kind: an analysis/decision synthesis is itself a sufficient
+    // spec, so this no longer needs a separate plan artifact. Scoped so the agent
+    // builds exactly what was decided and cannot balloon into phantom phases.
+    if (action === "generate_plan" || action === "implement") {
+        return (`Council debate completed. Approved conclusion:\n\n${synthesis}\n\n` +
+            `Implement this now. Treat the council conclusion above as the approved spec ` +
+            `— load it as your working context and carry it out through your normal ` +
+            `workflow: plan the concrete steps, make the changes in the smallest correct ` +
+            `increments, and verify (build/tests) as you go. Do NOT re-litigate the ` +
+            `decision or expand scope beyond it. If a required detail is genuinely ` +
+            `ambiguous, ask ONE focused question before editing.`);
+    }
+    if (action === "continue_session") {
+        const kind = outputKind ?? synthesisOutputKind(synthesis);
+        // Only an implementation-shaped debate has an "original task" left to build
+        // (the /ideal build flow relies on this carry-forward — do NOT null it out).
+        if (kind && IMPLEMENTATION_OUTPUT_KINDS.has(kind)) {
+            return `Council debate completed. Conclusion:\n\n${synthesis}\n\nContinue the original task using this conclusion.`;
+        }
+        // Analysis/evaluation/decision/investigation (or unknown → analysis): the
+        // user chose to KEEP THE SESSION GOING without implementing. Stop at the
+        // composer — the synthesis was already shown on the debate card and is
+        // persisted as [Council Decision]/[Council Memory] system messages, so the
+        // user's NEXT message inherits the full council context automatically
+        // (buildCouncilContextBundle surfaces it under "Key Decisions"). Returning
+        // null avoids the wasteful re-present turn AND the old forbid lecture, while
+        // still preventing the phantom-implementation drift (nothing runs). To
+        // actually build, the user picks Implement above; to keep discussing, they
+        // just type — that turn inherits the council context.
+        return null;
+    }
+    return null;
+}
+/**
+ * Neutral post-council continuation. Used by the auto-council path (tool-engine)
+ * and the `/council` slash path (runCouncilV2) once they run with
+ * `convenePath: true` — the hardcoded post-debate option card is suppressed, so
+ * there is no `chosenAction` to branch on. Instead of the CLI deciding the next
+ * step, we hand the synthesis back to a normal agent turn with a NON-BINDING
+ * nudge and let the agent's own intent drive the follow-up (respond / ask_user /
+ * implement). Returns "" for an empty synthesis so the caller skips re-entry.
+ */
+export function buildNeutralPostCouncilContinuation(synthesis) {
+    if (!synthesis || !synthesis.trim())
+        return "";
+    return (`Council debate completed. Conclusion:\n\n${synthesis}\n\n` +
+        `You now decide the next step based on the user's original request — do not ` +
+        `stop without doing one of these:\n` +
+        `  • If the conclusion IS the deliverable (analysis/evaluation/decision), ` +
+        `respond to the user with it.\n` +
+        `  • If a choice genuinely needs the human before proceeding, call ask_user.\n` +
+        `  • If the task calls for building and the conclusion is a sufficient spec, ` +
+        `implement it now through your normal workflow — do NOT re-litigate the ` +
+        `decision or expand scope beyond it.`);
+}
 export async function* runCouncil(topic, sessionModelId, messages, sessionId, rawLlm, respondToQuestion, respondToPreflight, processMessageFn, options) {
     const stats = options?.councilStats ?? { calls: 0, startMs: Date.now(), phases: [] };
     const costAware = isCouncilCostAware();
@@ -103,7 +219,21 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
     // ── Resolve models ──────────────────────────────────────────────────────────
     const leaderResolution = await resolveLeaderModelDetailed(sessionModelId);
     const leaderModelId = leaderResolution.modelId;
-    const participants = await resolveParticipants(sessionModelId, isCouncilMultiProviderPreferred());
+    let participants = await resolveParticipants(sessionModelId, isCouncilMultiProviderPreferred());
+    // U3 — task-aware panel: let the leader read the task and pick which reachable
+    // models should debate it, instead of the prompt-blind capability roster.
+    // Fails open to the default roster on any provider/parse failure.
+    if (participants.length >= 2 && isTaskAwarePanelEnabled()) {
+        try {
+            const pool = await buildCouncilCandidatePool(participants);
+            const taskAware = yield* selectTaskAwarePanel({ topic, pool, leaderModelId, llm });
+            if (taskAware && taskAware.length >= 2)
+                participants = taskAware;
+        }
+        catch {
+            /* fail-open — keep the default roster */
+        }
+    }
     if (participants.length < 2) {
         yield {
             type: "content",
@@ -112,21 +242,48 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
         yield { type: "done" };
         return null;
     }
-    if (leaderResolution.promotedFrom) {
+    // When the TUI Context Rail is active it renders the leader/panel/cost data as
+    // ambient sidebar rows from the council_meta patch below, so emitting the same
+    // data inline would both duplicate it AND read as a roster "decided" before any
+    // task assessment. Railless sinks (headless, telegram) keep the inline summary.
+    const suppressInlineMeta = options?.suppressInlineMeta === true;
+    if (!suppressInlineMeta) {
+        if (leaderResolution.promotedFrom) {
+            yield {
+                type: "content",
+                content: `\n> Leader auto-promoted within session provider: \`${leaderResolution.promotedFrom.modelId}\`` +
+                    `${leaderResolution.promotedFrom.tier ? ` (${leaderResolution.promotedFrom.tier})` : ""}` +
+                    ` → \`${leaderModelId}\`. Synthesis benefits from the highest tier available on the same provider. ` +
+                    `Set \`roleModels.leader\` to override.\n`,
+            };
+        }
         yield {
             type: "content",
-            content: `\n> Leader auto-promoted within session provider: \`${leaderResolution.promotedFrom.modelId}\`` +
-                `${leaderResolution.promotedFrom.tier ? ` (${leaderResolution.promotedFrom.tier})` : ""}` +
-                ` → \`${leaderModelId}\`. Synthesis benefits from the highest tier available on the same provider. ` +
-                `Set \`roleModels.leader\` to override.\n`,
+            // Show models only — the `implement/verify/research` roles are internal
+            // cost-tier routing slots, NOT debate personas (those are task-adaptive and
+            // shown in the Debate Plan card once assigned). Printing the slot names here
+            // misleadingly implied implementation intent on analysis/decision topics.
+            content: `\n> Leader: \`${leaderModelId}\` · Panel: ${participants.map((p) => `\`${p.model}\``).join(", ")}${costAware ? " · Cost-aware sub-tasks: ON" : ""}\n`,
         };
     }
+    // P3 — mirror the leader/panel/cost metadata as a structured council_meta patch
+    // so the context rail can show it as rows instead of transcript spam. The round
+    // budget/ceiling arrive later from inside runDebate (locals unavailable here).
     yield {
-        type: "content",
-        content: `\n> Leader: \`${leaderModelId}\` · Participants: ${participants.map((p) => `\`${p.role}:${p.model}\``).join(", ")}${costAware ? " · Cost-aware sub-tasks: ON" : ""}\n`,
+        type: "council_meta",
+        councilMeta: {
+            topic,
+            leader: leaderModelId,
+            panel: participants.map((p) => p.model),
+            costAware,
+        },
     };
     const baseContext = buildCouncilContext(messages);
-    const projectInfo = options?.cwd ? await buildProjectSnapshot(options.cwd) : { snapshot: "", isEmpty: true };
+    // Fall back to process.cwd() when the caller omits cwd. The old default of
+    // { isEmpty: true } forced internet-first research (and skipped codebase-first
+    // analysis) even when the council was invoked inside a real repo.
+    const projectCwd = options?.cwd ?? process.cwd();
+    const projectInfo = await buildProjectSnapshot(projectCwd);
     const conversationContext = projectInfo.snapshot
         ? `## Current Project\n${projectInfo.snapshot}\n\n---\n\n${baseContext}`
         : baseContext;
@@ -163,7 +320,7 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
                     content: `\n> Clarification seeded by PIL (${pilSeed.length} gray-area question${pilSeed.length === 1 ? "" : "s"}).\n`,
                 };
             }
-            const clarifyGen = runClarification(topic, leaderModelId, conversationContext, respondToQuestion, llm, options?.signal, pilSeed, options?.clarifyMaxRounds ?? EXPLICIT_COUNCIL_CLARIFY_ROUNDS, undefined, costAware);
+            const clarifyGen = runClarification(topic, leaderModelId, conversationContext, respondToQuestion, llm, options?.signal, pilSeed, options?.clarifyMaxRounds ?? EXPLICIT_COUNCIL_CLARIFY_ROUNDS, undefined, costAware, participants.map((p) => p.model));
             let clarifyResult;
             do {
                 clarifyResult = await clarifyGen.next();
@@ -177,13 +334,48 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
             spec = buildSpecFromTopic(topic, conversationContext);
             yield { type: "content", content: `\n> Auto-council: skipping clarification (PIL pre-classified).\n` };
         }
+        // Guarantee context continuity on BOTH paths: the explicit `/council`
+        // clarifier (synthesizeSpec / inferSpecFromTopicOnly) does not always set
+        // parentContext, and the skip path sets it via buildSpecFromTopic. Attach it
+        // centrally here so every downstream debate stage sees the ongoing task
+        // context regardless of how the council was triggered.
+        if (!spec.parentContext) {
+            spec.parentContext = conversationContext?.trim() || undefined;
+        }
+        // B2: pin the outcome criteria into the Context Rail so the user SEES what
+        // the debate is graded against (not a leader-improvised per-round criterion).
+        // Emitted once here; per-round met/pending arrives via later council_meta
+        // patches from debate.ts. Only emit when there is something meaningful (skip
+        // the single "Address the topic" auto-fallback).
+        if (spec.successCriteria.length > 0) {
+            // Emit a count-matched all-false criteriaMet ALONGSIDE successCriteria so
+            // the rail's Outcome block starts at 0/N. councilMeta is upsert-merged
+            // ({...prev, ...patch}); without this reset a previous council's
+            // criteriaMet array bleeds through (e.g. after an Esc-interrupt that
+            // skipped clearLiveTurnUi) and paints stale ✓ / a wrong "N/N met" counter
+            // before this debate has graded anything. debate.ts overwrites it post-eval.
+            yield {
+                type: "council_meta",
+                councilMeta: {
+                    successCriteria: spec.successCriteria,
+                    criteriaMet: spec.successCriteria.map(() => false),
+                },
+            };
+        }
         // Cancelled during clarification — don't pop the preflight approval card.
         if (userAborted())
             break;
         const researchNeeded = true;
+        // ROI: when the clarifier judged the spec ready (high confidence, no gaps),
+        // the approve card is a rubber-stamp — auto-approve after showing the brief.
         const preflightGen = runPreflight(spec, participants, researchNeeded, respondToPreflight, {
             repoEmpty: internetFirst,
             researchOverridable: true,
+            // convenePath auto-approves the pre-debate plan card too: the agent
+            // already decided to convene, so re-gating the discussion plan is a
+            // redundant interruption of the autonomous tool call (same rationale as
+            // sprintPlanningMode). The brief is still shown; it just isn't blocking.
+            autoApprove: spec.ready === true || options?.autoApprovePreflight === true || options?.convenePath === true,
         });
         let preflightResult;
         do {
@@ -204,59 +396,47 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
     // Leader-LLM decides if research is required. If yes, give the user a chance
     // to skip — research is the slowest part of council and trivial questions
     // (e.g. "what did we just decide?") should not pay that cost.
-    let researchSkipOverride = false;
+    // When the caller (sprint-planning) already has product-level research from
+    // CB-1, skip the second research pass entirely: force researchSkipOverride so
+    // runDebate does not re-run it, and short-circuit leaderNeedsResearch to false.
+    const researchSkipOverride = options?.skipResearch === true;
     // Hoisted so the leader's research decision can be reused by runDebate instead
     // of re-running the classifier LLM call (see CouncilConfig.leaderNeedsResearch).
     // Stays undefined if the classifier throws — fail-open: runDebate re-evaluates.
     let leaderNeedsResearch;
-    try {
-        const needGen = evaluateResearchNeed(spec, leaderModelId, conversationContext, llm, costAware);
-        let needStep;
-        do {
-            needStep = await needGen.next();
-            if (!needStep.done && needStep.value)
-                yield needStep.value;
-        } while (!needStep.done);
-        leaderNeedsResearch = needStep.value;
-        if (leaderNeedsResearch) {
-            const { randomUUID } = await import("crypto");
-            const overrideId = randomUUID();
-            yield {
-                type: "council_question",
-                content: `\n## Research decision\nLeader recommends a research phase before debate` +
-                    (internetFirst ? " (internet-first — empty workspace)" : " (codebase-first)") +
-                    `. Want to skip it?`,
-                councilQuestion: {
-                    questionId: overrideId,
-                    phase: "post-debate",
-                    question: "Skip the research phase?",
-                    context: internetFirst
-                        ? "Workspace is empty — research will search the internet. Skip if you already have the answer."
-                        : "Research will grep/read the codebase. Skip for trivial topics that don't need code evidence.",
-                    isRequired: false,
-                    options: [
-                        {
-                            label: "No — run research (recommended)",
-                            description: "Leader thinks evidence is needed.",
-                            value: "no",
-                            kind: "choice",
-                        },
-                        { label: "Yes — skip research", description: "Go straight to debate.", value: "yes", kind: "choice" },
-                    ],
-                    defaultIndex: 0,
-                },
-            };
-            const overrideAnswer = await respondToQuestion(overrideId);
-            researchSkipOverride = overrideAnswer === "yes";
-            yield {
-                type: "content",
-                content: `\n  ↳ ${researchSkipOverride ? "Skipping research per user override." : "Running research."}\n`,
-            };
-        }
+    if (options?.skipResearch) {
+        leaderNeedsResearch = false;
+        yield { type: "council_meta", councilMeta: { researchMode: false } };
     }
-    catch (err) {
-        // fail-open — leaderNeedsResearch stays undefined so runDebate re-evaluates.
-        console.error(`[council] research-need pre-check failed (fail-open): ${err?.message}`);
+    else {
+        try {
+            const needGen = evaluateResearchNeed(spec, leaderModelId, conversationContext, llm, costAware);
+            let needStep;
+            do {
+                needStep = await needGen.next();
+                if (!needStep.done && needStep.value)
+                    yield needStep.value;
+            } while (!needStep.done);
+            leaderNeedsResearch = needStep.value;
+            if (leaderNeedsResearch !== undefined) {
+                yield { type: "council_meta", councilMeta: { researchMode: leaderNeedsResearch } };
+            }
+            // ROI: the leader already decided research is needed and the card's default
+            // was always "run research" — asking the user to confirm is a rubber-stamp
+            // (measured 0 information at real cost). Auto-proceed with research; the
+            // leaderNeedsResearch signal still flows to runDebate. researchSkipOverride
+            // stays false. (Deliberately no card — see council-UX ROI pass.)
+            if (leaderNeedsResearch) {
+                yield {
+                    type: "content",
+                    content: `\n  ↳ Leader recommends research${internetFirst ? " (internet-first — empty workspace)" : " (codebase-first)"} — running it.\n`,
+                };
+            }
+        }
+        catch (err) {
+            // fail-open — leaderNeedsResearch stays undefined so runDebate re-evaluates.
+            console.error(`[council] research-need pre-check failed (fail-open): ${err?.message}`);
+        }
     }
     // Await EE pre-fetch (started in parallel with clarifier — latency already hidden)
     const eeResult = await eePromise;
@@ -341,6 +521,17 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
         internetFirst,
         costAware,
         runId: sessionId,
+        // #2 — isolated research bridge; when wired, runDebate runs research in a
+        // budget-capped explore sub-agent instead of an in-process 15-step call.
+        runIsolatedTask: options?.runIsolatedTask,
+        // B4 interactive escalation — same responder the clarifier + post-debate
+        // askcards use. When the debate is about to stop with pinned criteria
+        // unmet, runDebate asks the user (extend / accept / rescope) instead of
+        // silently synthesizing a partial outcome.
+        respondToQuestion,
+        // convene_council path — auto-accept escalation (no blocking card) since
+        // the council runs autonomously mid-agent-turn with no interactive user.
+        convenePath: options?.convenePath,
     }, llm);
     let debateResult;
     do {
@@ -393,6 +584,10 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
     } while (!planResult.done);
     let { outcome, plan, synthesisText } = planResult.value;
     const synthesisFailReason = planResult.value.synthesisFailReason;
+    // Post-debate action the user picked (hoisted so the completed-status guard +
+    // the caller's auto-continue can both read it). Undefined until the card is
+    // answered.
+    let postDebateAction;
     stats.phases.push({ name: "planning", durationMs: Date.now() - planStart });
     // Log interaction: synthesis
     logInteraction(sessionId ?? "unknown", "council", {
@@ -402,7 +597,13 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
         data: { topic, roundCount: debateState.roundCount, participantCount: debateState.active.length },
     });
     // ── Post-Debate AskCard: What next? ─────────────────────────────────────────
-    if (sessionId) {
+    // convenePath skips this ENTIRE interactive block (recommendation, option set,
+    // card, respondToQuestion, postDebateAction, onPostDebateAction, and the whole
+    // routing tree). On that path the agent that called `convene_council` decides
+    // what happens next — the CLI must not hardcode a post-council pick. The
+    // persistence block below still runs (audit trail, not a decision), and the
+    // function returns synthesisText as usual.
+    if (sessionId && !options?.convenePath) {
         try {
             const { randomUUID } = await import("crypto");
             const refinementTopics = [];
@@ -422,7 +623,19 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
             const hasEmptySections = refinementTopics.length > 0;
             // ── Confidence badge (CQ-6) ──────────────────────────────────────────
             const evidenceDensity = debateState.finalEvidenceDensity ?? 0;
+            const taggedClaims = debateState.finalTaggedClaims ?? 0;
             const synthesisFailed = !!synthesisFailReason || !outcome || synthesisText.trim().length < 20;
+            // "Not measured" ≠ "0%". When the debate emitted zero tagged claims the
+            // density formula returns 0 by convention, but that means grounding was
+            // never measured — not that every claim was refuted. Surfacing "Low 0%"
+            // there reads as a scoring failure on debates that are actually fine
+            // (session de4bafe5ecb7). Only applies when synthesis itself succeeded.
+            // Also treat a genuine 0 density (tags emitted but none resolved to a
+            // citation) as "not measured" rather than a literal "Low 0%" score — a
+            // bare 0% reads as a scoring failure on debates that were degraded (e.g.
+            // the debate model tripped the tool-verification circuit breaker and ran
+            // tool-free, so no claims could be grounded). Session 65b66c99ed36.
+            const confidenceNotMeasured = !synthesisFailed && (taggedClaims === 0 || evidenceDensity === 0);
             const confidenceLevel = synthesisFailed
                 ? "low"
                 : evidenceDensity >= 0.6
@@ -437,18 +650,29 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
             const confidenceReason = synthesisFailed
                 ? (synthesisFailReason ??
                     "The synthesizer produced no usable output. The debate exchanges above are still readable, but no structured outcome could be extracted.")
-                : confidenceLevel === "low"
-                    ? `Only ${(evidenceDensity * 100).toFixed(0)}% of claims in the final round carried citations or were resolved — most positions remained asserted without backing evidence.`
-                    : confidenceLevel === "medium"
-                        ? `${(evidenceDensity * 100).toFixed(0)}% of claims carried citations or were resolved — some open points remain.`
-                        : `${(evidenceDensity * 100).toFixed(0)}% of claims were cited or resolved.`;
+                : confidenceNotMeasured
+                    ? "The debate produced no explicitly tagged claims ([CONFIRMED]/[REFUTED]/[UNVERIFIED]), so evidence grounding could not be measured — this is NOT a 0% score. The exchanges above may still be substantive; read them directly, or re-run with research enabled to force citations."
+                    : confidenceLevel === "low"
+                        ? `Only ${(evidenceDensity * 100).toFixed(0)}% of claims in the final round carried citations or were resolved — most positions remained asserted without backing evidence.`
+                        : confidenceLevel === "medium"
+                            ? `${(evidenceDensity * 100).toFixed(0)}% of claims carried citations or were resolved — some open points remain.`
+                            : `${(evidenceDensity * 100).toFixed(0)}% of claims were cited or resolved.`;
             const confidenceBadge = synthesisFailed
                 ? `❌ Synthesis failed — confidence cannot be computed`
-                : confidenceLevel === "high"
-                    ? `✅ High confidence (evidence density ${evidenceDensity.toFixed(2)})`
-                    : confidenceLevel === "medium"
-                        ? `⚠ Medium confidence (evidence density ${evidenceDensity.toFixed(2)})`
-                        : `⚠ Low confidence (evidence density ${evidenceDensity.toFixed(2)})`;
+                : confidenceNotMeasured
+                    ? `◐ Confidence not measured — the debate emitted no tagged claims`
+                    : confidenceLevel === "high"
+                        ? `✅ High confidence (evidence density ${evidenceDensity.toFixed(2)})`
+                        : confidenceLevel === "medium"
+                            ? `⚠ Medium confidence (evidence density ${evidenceDensity.toFixed(2)})`
+                            : `⚠ Low confidence (evidence density ${evidenceDensity.toFixed(2)})`;
+            // F1 — did the debate actually satisfy its PINNED success criteria? This is
+            // distinct from evidence density (a confidently-worded synthesis can still
+            // leave every criterion open). When criteria remain unmet on a successful
+            // synthesis the outcome is provisional, and the card must not recommend
+            // committing (implement/plan/save) as if it were settled.
+            const critOutcome = summarizeCriteriaOutcome(spec.successCriteria ?? [], debateState.finalCriteriaMet);
+            const inconclusive = !synthesisFailed && critOutcome.inconclusive;
             // Recommendation surfaced to the user as the default action. The
             // implementation_plan-vs-decision/evaluation split lives in
             // pickPostDebateRecommendation (issue #3 — see its doc comment).
@@ -459,83 +683,282 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
                 confidenceLevel,
                 hasPlan: !!hasPlan,
                 outputKind: debatePlan.outputShape.kind,
+                criteriaUnmet: inconclusive ? critOutcome.unmetLabels.length : 0,
             });
             const baseOptions = [];
-            if (synthesisFailed) {
+            // Model-first post-debate options. The leader synthesis picks intent-fit
+            // next actions (a bug investigation, evaluation, plan, and pure discussion
+            // each warrant different follow-ups — the old fixed "accept / research /
+            // apply" menu was wrong regardless of intent). Fall back to the
+            // deterministic set on synthesis failure or when the model emitted none.
+            const modelActions = !synthesisFailed && outcome?.nextActions && outcome.nextActions.length > 0 ? outcome.nextActions : null;
+            if (modelActions) {
+                for (const a of modelActions) {
+                    // "implement" no longer needs a separate plan artifact — an analysis /
+                    // decision synthesis IS the spec (postDebateContinuation loads it and
+                    // runs the normal plan→change→verify workflow). The old `!hasPlan` drop
+                    // is why a decision-to-change-code debate had NO build path and the
+                    // user's "implement"-labelled pick did nothing (session 8191ecaee149).
+                    baseOptions.push({
+                        label: a.label,
+                        // Description is the model's own `reason` (model-first — no hardcoded
+                        // per-action prose). If the model was terse and omitted it, repeat
+                        // the label rather than inventing system copy.
+                        description: a.reason && a.reason.length > 0 ? a.reason : a.label,
+                        value: a.action,
+                        kind: a.action === "ask_followup" ? "freetext" : "choice",
+                    });
+                }
+                // Context-only option the model doesn't own — surfaced when the debate
+                // left shape sections empty.
+                if (hasEmptySections) {
+                    baseOptions.push({
+                        label: `Refine: ${refinementTopics.join(", ")}`,
+                        description: `Answer questions about ${refinementTopics.length} unresolved aspect(s)`,
+                        value: "refine",
+                        kind: "choice",
+                    });
+                }
+                // Guarantee an escape hatch even if the model omitted one.
+                if (!baseOptions.some((o) => o.value === "save_exit" || o.value === "continue_session")) {
+                    baseOptions.push({
+                        label: "Save & Exit",
+                        description: "Save the debate outcome and finish",
+                        value: "save_exit",
+                        kind: "choice",
+                    });
+                }
+            }
+            else {
+                // ── Fallback: deterministic option set ──────────────────────────────
+                if (synthesisFailed) {
+                    baseOptions.push({
+                        label: "Retry Synthesis (compact)",
+                        description: "Re-synthesize from final positions only (drop full exchange history). Fastest recovery from provider timeouts.",
+                        value: "retry_synthesis",
+                        kind: "choice",
+                    });
+                }
                 baseOptions.push({
-                    label: "Retry Synthesis (compact)",
-                    description: "Re-synthesize from final positions only (drop full exchange history). Fastest recovery from provider timeouts.",
-                    value: "retry_synthesis",
+                    label: "Save & Exit",
+                    description: synthesisFailed
+                        ? "Save raw debate exchanges as-is; no structured outcome will be persisted"
+                        : "Save the debate outcome and finish",
+                    value: "save_exit",
                     kind: "choice",
                 });
-            }
-            baseOptions.push({
-                label: "Save & Exit",
-                description: synthesisFailed
-                    ? "Save raw debate exchanges as-is; no structured outcome will be persisted"
-                    : "Save the debate outcome and finish",
-                value: "save_exit",
-                kind: "choice",
-            });
-            if (!hasPlan && !synthesisFailed) {
+                if (!hasPlan && !synthesisFailed) {
+                    baseOptions.push({
+                        label: "Lock plan and execute Sprint 1",
+                        description: "Commit the council outcome as the sprint plan and hand control to the sprint runner (planning → implementation → verification → judgment). Does NOT exit to /gsd.",
+                        value: "generate_plan",
+                        kind: "choice",
+                    });
+                }
+                if (hasEmptySections && !synthesisFailed) {
+                    baseOptions.push({
+                        label: `Refine: ${refinementTopics.join(", ")}`,
+                        description: `Answer questions about ${refinementTopics.length} unresolved aspect(s)`,
+                        value: "refine",
+                        kind: "choice",
+                    });
+                }
+                // CQ-3: free-text follow-up to the council on the same debate context.
                 baseOptions.push({
-                    label: "Lock plan and execute Sprint 1",
-                    description: "Commit the council outcome as the sprint plan and hand control to the sprint runner (planning → implementation → verification → judgment). Does NOT exit to /gsd.",
-                    value: "generate_plan",
-                    kind: "choice",
+                    label: "Ask Council a follow-up",
+                    description: "Pose a new question that re-uses this debate's context (no new clarification).",
+                    value: "ask_followup",
+                    kind: "freetext",
                 });
+                if (!synthesisFailed) {
+                    baseOptions.push({
+                        label: "Start Implementation",
+                        description: "Load the council conclusion as the spec and build it (plan → change → verify)",
+                        value: "implement",
+                        kind: "choice",
+                    });
+                }
             }
-            if (hasEmptySections && !synthesisFailed) {
-                baseOptions.push({
-                    label: `Refine: ${refinementTopics.join(", ")}`,
-                    description: `Answer questions about ${refinementTopics.length} unresolved aspect(s)`,
-                    value: "refine",
+            // Canonicalize the post-analysis choices to the user's mental model:
+            // IMPLEMENT / CONTINUE / SAVE (session 8191ecaee149 redesign).
+            //   (a) "ask a follow-up" and "continue with council context" are the same
+            //       thing to the user (both = keep the session going with the debate as
+            //       context), so collapse a generic ask_followup into continue_session.
+            //       A pinned criteria-recovery follow-up is added LATER (inconclusive /
+            //       lowGrounding) and is intentionally distinct, so this only affects
+            //       the base set built above.
+            //   (b) guarantee a CONTINUE option exists.
+            //   (c) offer IMPLEMENT whenever the synthesis is substantive (grounded &
+            //       conclusive) — the conclusion IS the spec, no plan artifact needed.
+            if (!options?.sprintPlanningMode) {
+                const CONTINUE_OPT = {
+                    label: "Continue with council context",
+                    description: "Return to the composer — your next message keeps this debate's conclusion as context.",
+                    value: "continue_session",
                     kind: "choice",
+                };
+                const hasContinue = baseOptions.some((o) => o.value === "continue_session");
+                for (let i = baseOptions.length - 1; i >= 0; i--) {
+                    if (baseOptions[i].value !== "ask_followup")
+                        continue;
+                    if (hasContinue)
+                        baseOptions.splice(i, 1); // merged away — continue already covers it
+                    else
+                        baseOptions[i] = { ...CONTINUE_OPT }; // convert the lone follow-up into continue
+                }
+                if (!baseOptions.some((o) => o.value === "continue_session"))
+                    baseOptions.push({ ...CONTINUE_OPT });
+                if (!synthesisFailed && !inconclusive && !baseOptions.some((o) => o.value === "implement")) {
+                    // Insert at index 1, NOT 0 — the model's own best-first pick stays the
+                    // default (defaultIndex is 0 for model-first). We only GUARANTEE the
+                    // build path is present + prominent; we don't override the model's
+                    // judgment that building wasn't the recommended next move.
+                    baseOptions.splice(1, 0, {
+                        label: "Start Implementation",
+                        description: "Load the council conclusion as the spec and build it (plan → change → verify)",
+                        value: "implement",
+                        kind: "choice",
+                    });
+                }
+            }
+            // F1 — when the pinned criteria were not met, the model's best-first action
+            // (or the deterministic default) may be a commit/hand-back-the-decision step
+            // that treats the outcome as settled. Pin a criteria-aware "keep working"
+            // option at the front and make it the default so the recommended next move
+            // is honest about the unmet bar. Reuses ask_followup routing (freetext,
+            // re-runs on this debate's context) — no new downstream action. Deduped so
+            // the list never shows two ask_followup rows.
+            if (inconclusive) {
+                const openList = critOutcome.unmetLabels.join("; ");
+                const n = critOutcome.unmetLabels.length;
+                for (let i = baseOptions.length - 1; i >= 0; i--) {
+                    if (baseOptions[i].value === "ask_followup")
+                        baseOptions.splice(i, 1);
+                }
+                baseOptions.unshift({
+                    label: `Keep working the ${n} unmet criteri${n === 1 ? "on" : "a"}`,
+                    description: `Still open: ${openList}. Pose a targeted follow-up to close ${n === 1 ? "it" : "them"} before committing.`,
+                    value: "ask_followup",
+                    kind: "freetext",
                 });
             }
-            // CQ-3: free-text follow-up to the council on the same debate context.
-            baseOptions.push({
-                label: "Ask Council a follow-up",
-                description: "Pose a new question that re-uses this debate's context (no new clarification).",
-                value: "ask_followup",
-                kind: "freetext",
-            });
-            if (hasPlan) {
-                baseOptions.push({
-                    label: "Start Implementation",
-                    description: "Execute the action plan now",
-                    value: "implement",
-                    kind: "choice",
+            // A2 — synthesis succeeded but grounding is weak (density 0 / low /
+            // "not measured"). The honest next move is to RAISE confidence, not to
+            // commit or to ask a blind clarification — the user reported the askcard
+            // asked "clarify more?" without saying WHAT would help. Pin a guided
+            // follow-up that names the concrete confidence-raising ask (make the
+            // council cite/verify its weakest claims) and make it the default.
+            // Reuses ask_followup routing (freetext, re-runs on this debate's
+            // context) — no new downstream action. Skipped when `inconclusive`
+            // already pinned a criteria-aware follow-up, or when synthesis failed
+            // (the retry_synthesis path owns that recovery).
+            const lowGrounding = !synthesisFailed && !inconclusive && (confidenceNotMeasured || confidenceLevel === "low");
+            if (lowGrounding) {
+                for (let i = baseOptions.length - 1; i >= 0; i--) {
+                    if (baseOptions[i].value === "ask_followup")
+                        baseOptions.splice(i, 1);
+                }
+                baseOptions.unshift({
+                    label: "Raise confidence — have the council cite & verify",
+                    description: "Grounding is weak: no claims were cited or resolved, so evidence density stayed at 0. Pose a follow-up that forces the council to back its weakest claims against the codebase or sources — that lifts confidence instead of committing on thin evidence.",
+                    value: "ask_followup",
+                    kind: "freetext",
                 });
             }
-            const defaultIndex = Math.max(0, baseOptions.findIndex((o) => o.value === recommendation.value));
-            const heading = synthesisFailed ? "## Debate Synthesis Failed" : "## Debate Synthesis Complete";
-            const recommendLine = `**Recommended:** ${baseOptions[defaultIndex]?.label ?? recommendation.value} — ${recommendation.reason}`;
-            const headerBlock = `${heading}\n\n> ${confidenceBadge}\n>\n> **Why:** ${confidenceReason}\n\n${recommendLine}\n\nLeader: \`${leaderModelId}\`. What would you like to do next?`;
-            yield {
-                type: "council_question",
-                content: headerBlock,
-                councilQuestion: {
-                    questionId,
-                    phase: "post-debate",
-                    question: synthesisFailed
-                        ? "Synthesis did not produce a structured outcome. How do you want to recover?"
-                        : hasEmptySections
-                            ? `The debate left ${refinementTopics.length} area(s) unresolved. Refine them or save the current outcome?`
-                            : "What would you like to do next?",
-                    context: `${confidenceBadge}\n${confidenceReason}` +
-                        (hasEmptySections ? `\nUnresolved areas: ${refinementTopics.join(", ")}` : "") +
-                        `\n→ ${recommendation.reason}`,
-                    isRequired: false,
-                    options: baseOptions,
-                    defaultIndex,
-                },
-            };
-            const answer = await respondToQuestion(questionId);
-            yield { type: "content", content: `\n  ↳ ${answer}\n` };
+            // Model orders actions best-first (index 0 = recommended default); the
+            // fallback set uses the deterministic recommendation. When inconclusive,
+            // the pinned criteria option at index 0 is the honest default regardless of
+            // path.
+            const defaultIndex = inconclusive || lowGrounding
+                ? 0
+                : modelActions
+                    ? 0
+                    : Math.max(0, baseOptions.findIndex((o) => o.value === recommendation.value));
+            const recommendReason = inconclusive || lowGrounding
+                ? (baseOptions[0]?.description ?? recommendation.reason)
+                : modelActions
+                    ? (baseOptions[0]?.description ?? recommendation.reason)
+                    : recommendation.reason;
+            const heading = synthesisFailed
+                ? "## Debate Synthesis Failed"
+                : inconclusive
+                    ? `## Debate Synthesis — Inconclusive (${critOutcome.metCount}/${critOutcome.total} criteria met)`
+                    : "## Debate Synthesis Complete";
+            // F1 — an explicit provisional-outcome line so the user sees the unmet bar
+            // even if they skim past the recommendation.
+            const outcomeLine = inconclusive
+                ? `\n\n⚠ Outcome: ${critOutcome.metCount}/${critOutcome.total} criteria met. Unmet: ${critOutcome.unmetLabels.join("; ")}. Treat the synthesis as provisional — not a settled decision.`
+                : "";
+            const recommendLine = `**Recommended:** ${baseOptions[defaultIndex]?.label ?? recommendation.value} — ${recommendReason}`;
+            // B — the live per-round transcript is cleared from the view at turn end
+            // (it renders as a bottom block decoupled from the timeline, so keeping it
+            // would mis-order later messages). The full exchange IS persisted though —
+            // point the user at it so the rounds aren't "lost" (user report: after a
+            // debate the rounds vanish with no way to re-read them). `/council inspect`
+            // is a registered slash command that replays [Council Round N] / [Council
+            // Memory] from the DB.
+            const roundsArchivedLine = debateState.roundCount > 0
+                ? `\n\n📋 All ${debateState.roundCount} debate round(s) are archived — run \`/council inspect ${sessionId}\` to re-read the full exchange.`
+                : "";
+            const headerBlock = `${heading}\n\n> ${confidenceBadge}\n>\n> **Why:** ${confidenceReason}${outcomeLine}\n\n${recommendLine}${roundsArchivedLine}\n\nLeader: \`${leaderModelId}\`. What would you like to do next?`;
+            let answer;
+            if (options?.sprintPlanningMode) {
+                // Blocker 4/5 fix: no interactive post-debate menu inside automated
+                // per-sprint planning. Presenting it stranded the sprint before
+                // implementation — picking "Save & Exit" ended the run with no Sprint
+                // Implementation, and "Refine" (the default) looped back into more
+                // debate. Auto-lock the synthesized plan (== "Lock plan and execute
+                // Sprint 1") and hand control back to the sprint runner.
+                answer = "generate_plan";
+                idealTrace("council.postDebate.autoLock", { sessionId });
+                yield {
+                    type: "content",
+                    content: "\n> Sprint plan synthesized — auto-locked and handed to the sprint runner " +
+                        "(the product plan was already approved at the /ideal preflight).\n",
+                };
+            }
+            else {
+                yield {
+                    type: "council_question",
+                    content: headerBlock,
+                    councilQuestion: {
+                        questionId,
+                        phase: "post-debate",
+                        question: synthesisFailed
+                            ? "Synthesis did not produce a structured outcome. How do you want to recover?"
+                            : inconclusive
+                                ? `${critOutcome.metCount}/${critOutcome.total} success criteria met — the outcome is provisional. Keep working the unmet criteria, or save it as-is?`
+                                : hasEmptySections
+                                    ? `The debate left ${refinementTopics.length} area(s) unresolved. Refine them or save the current outcome?`
+                                    : "What would you like to do next?",
+                        context: `${confidenceBadge}\n${confidenceReason}` +
+                            (inconclusive ? `\nUnmet criteria: ${critOutcome.unmetLabels.join("; ")}` : "") +
+                            (hasEmptySections ? `\nUnresolved areas: ${refinementTopics.join(", ")}` : "") +
+                            `\n→ ${recommendation.reason}`,
+                        isRequired: false,
+                        options: baseOptions,
+                        defaultIndex,
+                    },
+                };
+                answer = await respondToQuestion(questionId);
+            }
+            postDebateAction = answer;
+            idealTrace("council.postDebate.answer", { sessionId, answer });
+            options?.onPostDebateAction?.(answer);
+            // Echo the human-readable option label, never the raw action id
+            // (`continue_session`, `save_exit`, …) — the id is an internal routing
+            // token users should never see. Free-text follow-ups (no matching option)
+            // echo verbatim.
+            const answeredLabel = baseOptions.find((o) => o.value === answer)?.label ?? answer;
+            // No "↳ choice" echo in sprint-planning mode — there was no user choice to
+            // echo (the plan was auto-locked above with its own status line).
+            if (!options?.sprintPlanningMode) {
+                yield { type: "content", content: `\n  ↳ ${answeredLabel}\n` };
+            }
             // Treat any non-empty answer that doesn't match a known choice value as a follow-up question.
             const knownValues = new Set([
                 "save_exit",
+                "continue_session",
                 "generate_plan",
                 "refine",
                 "ask_followup",
@@ -603,6 +1026,10 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
                     synthesisText =
                         `Sprint plan locked (${existingActionItems.length} steps):\n` +
                             synthesizedPlan.steps.map((s) => `- [${s.priority}] ${s.description}`).join("\n");
+                    idealTrace("council.generatePlan.locked.fast", {
+                        sessionId,
+                        actionItems: existingActionItems.length,
+                    });
                 }
                 else {
                     yield { type: "content", content: "\n> Synthesizing sprint plan...\n" };
@@ -621,6 +1048,10 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
                         type: "content",
                         content: "\n> Plan locked — sprint runner will execute planning → implementation → verification → judgment.\n",
                     };
+                    idealTrace("council.generatePlan.locked.synth", {
+                        sessionId,
+                        synthesisLen: synthesisText?.length ?? 0,
+                    });
                 }
                 // Do NOT call runExecution here. Return synthesisText to the sprint-runner
                 // caller so it drives the full sprint lifecycle (Step 4–8 in sprint-runner.ts).
@@ -655,7 +1086,13 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
                     };
                     const ans = await respondToQuestion(sqId);
                     refinedAnswers.push({ section: label, answer: ans });
-                    yield { type: "content", content: `\n  ↳ ${ans}\n` };
+                    // Only echo sections the user actually filled. "Skip — leave as-is"
+                    // returns an empty value; echoing it emits a blank "↳ " bubble per
+                    // section (6 skips = 6 empty rows of transcript garbage). Prefix the
+                    // section label so a real answer reads as "↳ <section>: <answer>".
+                    if (ans.trim().length > 0) {
+                        yield { type: "content", content: `\n  ↳ ${label}: ${ans}\n` };
+                    }
                 }
                 // Build refineContext string from user answers
                 const refineCtx = refinedAnswers
@@ -678,69 +1115,85 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
             }
             // "save_exit" and "implement" fall through to normal persistence
         }
-        catch {
-            /* non-critical */
+        catch (err) {
+            // Post-debate interaction (menu, follow-up re-synthesis, refine) is
+            // non-critical to the persisted outcome, so we swallow — but NEVER
+            // silently: a throw here previously vanished, hiding a "generate_plan
+            // stalled" root cause. Log it and breadcrumb it so blocker-5 forensics
+            // can see whether the tail was reached via an exception.
+            console.error(`[council] post-debate interaction failed: ${err?.message}`);
+            idealTrace("council.postDebate.threw", { sessionId, err: err?.message });
         }
     }
+    idealTrace("council.persist.start", { sessionId, hasOutcome: !!outcome, postDebateAction });
     // ── Persist outcome ─────────────────────────────────────────────────────────
     if (sessionId) {
         try {
-            if (outcome) {
-                const agreedLine = outcome.agreed?.length ? `\nAgreed: ${outcome.agreed.join("; ")}` : "";
-                const recLine = outcome.recommendation ? `\nRecommendation: ${outcome.recommendation}` : "";
-                appendSystemMessage(sessionId, `[Council Decision]\nTopic: ${topic}\n${outcome.summary}${agreedLine}${recLine}`);
-                appendSystemMessage(sessionId, `[Council Outcome]\n${JSON.stringify(outcome)}`);
-            }
-            const evidenceDensityPersist = debateState.finalEvidenceDensity ?? 0;
-            const confidenceLevelPersist = evidenceDensityPersist >= 0.6 ? "high" : evidenceDensityPersist >= 0.3 ? "medium" : "low";
-            const councilRecord = {
-                topic,
-                spec,
-                debatePlan,
-                leaderModel: leaderModelId,
-                participants: debateState.active.map((a) => ({ role: a.role, model: a.model, stance: a.stance })),
-                finalPositions: debateState.active.map((a) => ({ role: a.role, position: a.position })),
-                archive: debateState.archive ?? [],
-                synthesis: synthesisText,
-                confidence: {
-                    level: confidenceLevelPersist,
-                    evidenceDensity: evidenceDensityPersist,
-                    rounds: debateState.roundCount,
-                },
-                stats: { calls: stats.calls, durationMs: Date.now() - stats.startMs, phases: stats.phases },
-                timestamp: new Date().toISOString(),
-            };
-            appendSystemMessage(sessionId, `[Council Memory] ${JSON.stringify(councilRecord)}`);
-            // Forensics-friendly summary row in interaction_logs. The full
-            // [Council Memory] system message above is great for context replay but
-            // can't be queried — `usage forensics` reads interaction_logs only.
-            // Excerpts are capped to keep metadata_json small (~2-4KB per run).
-            const stancesForLog = debateState.active.slice(0, 8).map((a) => ({
-                role: a.role,
-                model: a.model,
-                stanceName: a.stance?.name,
-                finalPositionExcerpt: (a.position ?? "").slice(0, 400),
-            }));
-            logInteraction(sessionId, "council", {
-                eventSubtype: "council_summary",
-                model: leaderModelId,
-                durationMs: Date.now() - stats.startMs,
-                data: {
+            // Skip session-scoped persistence in sprintPlanningMode: messages /
+            // interaction_logs FK-reference sessions(id), but the sprint-planning caller
+            // passes the product-RUN id (no session row) → "FOREIGN KEY constraint
+            // failed" on the FIRST write, which under the catch below previously aborted
+            // the whole block — silently taking writeDecisionsLock down with it. The
+            // file-based decisions.lock still writes below (outside this guard).
+            if (!options?.sprintPlanningMode) {
+                if (outcome) {
+                    const agreedLine = outcome.agreed?.length ? `\nAgreed: ${outcome.agreed.join("; ")}` : "";
+                    const recLine = outcome.recommendation ? `\nRecommendation: ${outcome.recommendation}` : "";
+                    appendSystemMessage(sessionId, `[Council Decision]\nTopic: ${topic}\n${outcome.summary}${agreedLine}${recLine}`);
+                    appendSystemMessage(sessionId, `[Council Outcome]\n${JSON.stringify(outcome)}`);
+                }
+                const evidenceDensityPersist = debateState.finalEvidenceDensity ?? 0;
+                const confidenceLevelPersist = evidenceDensityPersist >= 0.6 ? "high" : evidenceDensityPersist >= 0.3 ? "medium" : "low";
+                const councilRecord = {
                     topic,
-                    roundCount: debateState.roundCount,
-                    participantCount: debateState.active.length,
-                    stances: stancesForLog,
-                    synthesisExcerpt: synthesisText.slice(0, 1500),
-                    evidenceDensity: evidenceDensityPersist,
-                    confidenceLevel: confidenceLevelPersist,
-                    recommendation: outcome?.recommendation?.slice(0, 400) ?? null,
-                    agreedCount: outcome?.agreed?.length ?? 0,
-                },
-            });
+                    spec,
+                    debatePlan,
+                    leaderModel: leaderModelId,
+                    participants: debateState.active.map((a) => ({ role: a.role, model: a.model, stance: a.stance })),
+                    finalPositions: debateState.active.map((a) => ({ role: a.role, position: a.position })),
+                    archive: debateState.archive ?? [],
+                    synthesis: synthesisText,
+                    confidence: {
+                        level: confidenceLevelPersist,
+                        evidenceDensity: evidenceDensityPersist,
+                        rounds: debateState.roundCount,
+                    },
+                    stats: { calls: stats.calls, durationMs: Date.now() - stats.startMs, phases: stats.phases },
+                    timestamp: new Date().toISOString(),
+                };
+                appendSystemMessage(sessionId, `[Council Memory] ${JSON.stringify(councilRecord)}`);
+                // Forensics-friendly summary row in interaction_logs. The full
+                // [Council Memory] system message above is great for context replay but
+                // can't be queried — `usage forensics` reads interaction_logs only.
+                // Excerpts are capped to keep metadata_json small (~2-4KB per run).
+                const stancesForLog = debateState.active.slice(0, 8).map((a) => ({
+                    role: a.role,
+                    model: a.model,
+                    stanceName: a.stance?.name,
+                    finalPositionExcerpt: (a.position ?? "").slice(0, 400),
+                }));
+                logInteraction(sessionId, "council", {
+                    eventSubtype: "council_summary",
+                    model: leaderModelId,
+                    durationMs: Date.now() - stats.startMs,
+                    data: {
+                        topic,
+                        roundCount: debateState.roundCount,
+                        participantCount: debateState.active.length,
+                        stances: stancesForLog,
+                        synthesisExcerpt: synthesisText.slice(0, 1500),
+                        evidenceDensity: evidenceDensityPersist,
+                        confidenceLevel: confidenceLevelPersist,
+                        recommendation: outcome?.recommendation?.slice(0, 400) ?? null,
+                        agreedCount: outcome?.agreed?.length ?? 0,
+                    },
+                });
+            }
             // C2: Persist decisions.lock.md to the run directory so sprint-runner
             // can inject locked decisions into the implementation prompt.
             if (options?.runDir) {
                 const rejectedProposals = detectOutOfStackProposals(synthesisText, spec);
+                idealTrace("council.persist.writeDecisionsLock.before", { sessionId, runDir: options.runDir });
                 await writeDecisionsLock({
                     runId: sessionId,
                     runDir: options.runDir,
@@ -758,14 +1211,22 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
                     // only fires on an unexpected throw — log it (No-Silent-Catch), never break council.
                     console.error(`[council] decisions.lock write guard caught: ${err?.message}`);
                 });
+                idealTrace("council.persist.writeDecisionsLock.after", { sessionId });
             }
         }
-        catch {
-            /* non-critical */
+        catch (err) {
+            // Persistence is best-effort (session-message / interaction-log writes),
+            // but log so a storage fault is not mistaken for a hang in blocker-5
+            // forensics.
+            console.error(`[council] outcome persistence failed: ${err?.message}`);
+            idealTrace("council.persist.threw", { sessionId, err: err?.message });
         }
     }
-    // Update session status to completed
-    if (sessionId) {
+    idealTrace("council.persist.done", { sessionId });
+    // Update session status to completed — EXCEPT when the user chose
+    // "continue_session", where the agent keeps working in this session; marking
+    // it completed here is what dropped it from the resume picker.
+    if (sessionId && postDebateAction !== "continue_session") {
         try {
             new SessionStore(options?.cwd ?? process.cwd()).setStatus(sessionId, "completed");
         }
@@ -802,15 +1263,27 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ra
         stats.phases.push({ name: "execution", durationMs: Date.now() - execStart });
     }
     // ── Stats ───────────────────────────────────────────────────────────────────
+    idealTrace("council.stats", { sessionId });
     const totalMs = Date.now() - stats.startMs;
-    yield {
-        type: "content",
-        content: `\n---\n` +
-            `> Council stats: ${stats.calls} API calls, ${(totalMs / 1000).toFixed(1)}s total, ` +
-            `${active.length} participants, ${debateState.roundCount} rounds\n` +
-            `> Phases: ${stats.phases.map((p) => `${p.name}=${(p.durationMs / 1000).toFixed(1)}s`).join(", ")}\n`,
-    };
-    yield { type: "done" };
+    // Blocker-5 root cause: in sprintPlanningMode this runCouncil is a SUB-STEP of
+    // runSprint, not a standalone turn. The terminal `{type:"done"}` chunk (and the
+    // stats banner) are turn-terminal signals — forwarded verbatim by sprint-runner
+    // they made the app's stream consumer STOP pulling right here, so the generator
+    // suspended at these yields and never returned. sprint-runner's `planGen.next()`
+    // therefore never saw `done`, and the Sprint Implementation stage never ran
+    // (idle at the composer, no error). A sub-step must not emit them: skip both so
+    // the generator returns cleanly and the sprint runner proceeds to implementation.
+    if (!options?.sprintPlanningMode) {
+        yield {
+            type: "content",
+            content: `\n---\n` +
+                `> Council stats: ${stats.calls} API calls, ${(totalMs / 1000).toFixed(1)}s total, ` +
+                `${active.length} participants, ${debateState.roundCount} rounds\n` +
+                `> Phases: ${stats.phases.map((p) => `${p.name}=${(p.durationMs / 1000).toFixed(1)}s`).join(", ")}\n`,
+        };
+        yield { type: "done" };
+    }
+    idealTrace("council.return", { sessionId, synthesisLen: (synthesisText || "").length });
     return synthesisText || null;
 }
 // ── P7: action-item reuse helpers ─────────────────────────────────────────────