muonroi-cli 1.8.4 → 1.9.0

package/dist/src/council/debate.js

@@ -1,6 +1,12 @@
+import { randomUUID } from "node:crypto";
 import { getModelInfo } from "../models/registry.js";
+import { detectProviderForModel } from "../providers/runtime.js";
+import { getIsolatedTaskDeadlineMs, withDeadlineRace } from "../utils/llm-deadline.js";
+import { getCouncilLanguage } from "../utils/settings.js";
+import { buildDebateCheckpoint, checkpointMatches, deleteDebateCheckpoint, restoreExchangeLogs, writeDebateCheckpoint, } from "./debate-checkpoint.js";
+import { resolveDebateSummary } from "./debate-summary.js";
 import { pickCouncilTaskModel } from "./leader.js";
-import { tracedAsync, tracedGenerate } from "./llm.js";
+import { councilStreamLivenessReader, tracedAsync, tracedGenerate } from "./llm.js";
 import { phaseDone, phaseStart } from "./phase-events.js";
 import { buildFollowupPrompt, buildLeaderEvaluationPrompt, buildOpeningPrompt, buildResponsePrompt, buildRoundSummaryPrompt, } from "./prompts.js";
 /**
@@ -220,7 +226,149 @@ async function openingWithRetry(llm, model, system, prompt) {
     }
     return { text: "", attempts: MAX_OPENING_ATTEMPTS, error: lastError };
 }
-async function debateWithRetry(llm, model, system, prompt, signal, traceCb, toolBudget) {
+/**
+ * Pick a debate fallback model on a DIFFERENT provider than `failedModel`.
+ *
+ * When a participant's model fails BOTH same-model attempts (e.g. opencode-go
+ * proxy overload "Upstream request failed", or a param-reject that survives the
+ * adapter-level degrade), retrying the same endpoint just fails again — live
+ * session renders showed the same speaker dropped 3× in a row, silently
+ * shrinking the debate. Falling back to any pooled council model on another
+ * provider keeps that voice in the discussion. Returns undefined when every
+ * pooled model resolves to the same provider (nothing to fall back to).
+ */
+function pickDebateFallbackModel(failedModel, pool) {
+    let failedProvider;
+    try {
+        failedProvider = detectProviderForModel(failedModel);
+    }
+    catch {
+        failedProvider = undefined;
+    }
+    for (const candidate of pool) {
+        if (candidate === failedModel)
+            continue;
+        let candidateProvider;
+        try {
+            candidateProvider = detectProviderForModel(candidate);
+        }
+        catch {
+            continue;
+        }
+        if (candidateProvider && candidateProvider !== failedProvider)
+            return candidate;
+    }
+    return undefined;
+}
+/**
+ * Marker the CouncilLLM.research catch-block embeds in its return string when a
+ * provider crashes (it returns a string, never throws — see llm.ts:737). Used
+ * to detect a failed research pass so we can fall back to another provider.
+ */
+const RESEARCH_FAILED_MARKER = "[Research failed:";
+/**
+ * Runs council research on `primaryModel`; if the provider crashes (the
+ * `[Research failed: …]` marker), retries ONCE on a pooled model resolving to a
+ * DIFFERENT provider before giving up. Mirrors {@link pickDebateFallbackModel}.
+ *
+ * Motivating evidence: session de4bafe5ecb7 routed research to opencode-go
+ * (Console Go "Upstream request failed") with no fallback. Research returned
+ * only the failure marker → participants had zero citations to tag → evidence
+ * density hard-zeroed → the debate scored "Low confidence 0%" despite being
+ * substantive. debateWithRetry already had cross-provider fallback; research
+ * did not.
+ */
+/**
+ * #2 — run the research phase in an ISOLATED explore sub-agent (near-empty
+ * context, budget-capped, independent compaction) instead of the in-process
+ * 15-step generateText that accretes tool clutter into the council thread.
+ * Returns the findings string on success; a `[Research failed: …]` marker string
+ * on failure so `researchWithFallback` transparently falls back to `llm.research`.
+ */
+async function runResearchIsolated(runIsolatedTask, model, topic, conversationContext, traceCb, options) {
+    traceCb(`[research] isolated explore sub-agent via ${model}`);
+    // Keep the child near-empty — pass only the question + a bounded context slice
+    // (the whole point is to NOT inherit the council's growing transcript).
+    const ctxSlice = conversationContext.length > 4000
+        ? `${conversationContext.slice(0, 4000)}\n…[context truncated]`
+        : conversationContext;
+    const sourcePref = options.internetFirst
+        ? "This is a greenfield task with little/no local source: PREFER web + documentation sources (use web_search / fetch tools if available), then any local files."
+        : "PREFER grounding every claim in THIS repo's code — cite concrete file:line. Use web sources only to fill genuine gaps.";
+    const prompt = `You are grounding a council debate with EVIDENCE. Research the question below and return concise, sourced findings.\n\n` +
+        `## Question\n${topic}\n\n` +
+        `## Debate context\n${ctxSlice}\n\n` +
+        `## Instructions\n${sourcePref}\n` +
+        `Return a compact "## Research Findings" section: only the concrete facts that bear on the question, each with its source (file:line or URL). ` +
+        `Be terse and factual — no opinions, no recommendations. If you cannot find solid evidence, say so in one line.`;
+    try {
+        const result = await withDeadlineRace(() => runIsolatedTask({
+            agent: "explore",
+            description: `Council research: ${topic.slice(0, 60)}`,
+            prompt,
+            // Pin the research-role model; bypasses the parent-tier cap in StreamRunner.
+            modelId: model,
+        }), getIsolatedTaskDeadlineMs(), "council-research");
+        if (result.success && result.output?.trim())
+            return result.output.trim();
+        traceCb(`[research] isolated sub-agent produced nothing: ${result.error ?? "no output"}`);
+        return `[Research failed: ${result.error ?? "isolated sub-agent produced no output"}]`;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        traceCb(`[research] isolated sub-agent threw: ${msg}`);
+        return `[Research failed: ${msg}]`;
+    }
+}
+export async function researchWithFallback(llm, primaryModel, topic, conversationContext, signal, traceCb, options, fallbackPool, runIsolatedTask) {
+    // #2 — prefer the isolated explore sub-agent when the orchestrator wired one.
+    // On any failure (marker) we transparently fall through to the legacy
+    // in-process research below, preserving resilience for headless/degraded runs.
+    if (runIsolatedTask && !signal?.aborted) {
+        const iso = await runResearchIsolated(runIsolatedTask, primaryModel, topic, conversationContext, traceCb, options);
+        if (!iso.includes(RESEARCH_FAILED_MARKER))
+            return iso;
+        traceCb("[research] isolated sub-agent unavailable — falling back to in-process research");
+    }
+    const primary = await llm.research(primaryModel, topic, conversationContext, signal, traceCb, options);
+    if (!primary.includes(RESEARCH_FAILED_MARKER) || signal?.aborted)
+        return primary;
+    const fallbackModel = pickDebateFallbackModel(primaryModel, fallbackPool);
+    if (!fallbackModel)
+        return primary;
+    traceCb(`[research] ${primaryModel} failed; retrying via ${fallbackModel} (different provider)`);
+    try {
+        const fb = await llm.research(fallbackModel, topic, conversationContext, signal, traceCb, options);
+        if (!fb.includes(RESEARCH_FAILED_MARKER)) {
+            traceCb(`[research] recovered via fallback ${fallbackModel}`);
+            return fb;
+        }
+        // Both providers failed — surface the primary's marker so the existing
+        // "research produced nothing" rendering still fires.
+        return primary;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        traceCb(`[research] fallback ${fallbackModel} also failed: ${msg}`);
+        return primary;
+    }
+}
+/**
+ * Times every `debateWithRetryInner` exit path — success, retry, fallback and
+ * total failure all cost wall-clock, and a slow FAILING speaker is exactly the
+ * case worth seeing. Wrapping is why `durationMs` cannot drift out of sync with
+ * the four separate returns inside.
+ *
+ * The number is per-SPEAKER. The only timed council rows today are
+ * `debate_complete` (whole debate: 87s..1128s measured) and `council_summary`
+ * — aggregates that cannot name the model responsible.
+ */
+async function debateWithRetry(llm, model, system, prompt, signal, traceCb, toolBudget, fallbackPool = []) {
+    const startedAt = Date.now();
+    const r = await debateWithRetryInner(llm, model, system, prompt, signal, traceCb, toolBudget, fallbackPool);
+    return { ...r, durationMs: Date.now() - startedAt };
+}
+async function debateWithRetryInner(llm, model, system, prompt, signal, traceCb, toolBudget, fallbackPool = []) {
     // Respect the circuit breaker — once a model has tripped, it stays
     // tool-disabled for the rest of this council run.
     const allowTools = debateAllowsTools(model) && !toolBudget.disabled.has(model);
@@ -250,31 +398,69 @@ async function debateWithRetry(llm, model, system, prompt, signal, traceCb, tool
     // Retry once — if first attempt was tool-enabled and came back empty, the
     // reasoning model likely hit the step cap on a tool call without producing
     // text. Retry WITHOUT tools to guarantee analytical output.
+    let retryError;
+    let retryToolCalls = [];
     try {
         const retry = await llm.debate(model, system, prompt, signal, traceCb, { enableVerificationTools: false });
         const text = (retry.text ?? "").trim();
         if (text.length > 0) {
             return { text: retry.text, toolCalls: retry.toolCalls ?? [], attempts: 2 };
         }
-        return {
-            text: "",
-            toolCalls: retry.toolCalls ?? [],
-            failureReason: `provider returned empty completion on both attempts (initial: ${firstError})`,
-            attempts: 2,
-        };
+        retryToolCalls = retry.toolCalls ?? [];
+        retryError = "provider returned empty completion";
     }
     catch (err) {
-        const retryMsg = err instanceof Error ? err.message : String(err);
-        return {
-            text: "",
-            toolCalls: [],
-            failureReason: `both attempts failed — initial: ${firstError}; retry: ${retryMsg}`,
-            attempts: 2,
-        };
+        retryError = err instanceof Error ? err.message : String(err);
+    }
+    // Both same-model attempts failed. Before dropping this speaker from the
+    // debate, try ONE cross-provider fallback — the primary endpoint is either
+    // overloaded (opencode-go "Upstream request failed") or param-rejecting, and
+    // a third same-model hit would just fail identically. Skip when the caller
+    // aborted (user cancellation must not be papered over by a fallback call).
+    if (!signal?.aborted) {
+        const fallbackModel = pickDebateFallbackModel(model, fallbackPool);
+        if (fallbackModel) {
+            try {
+                const fb = await llm.debate(fallbackModel, system, prompt, signal, traceCb, {
+                    enableVerificationTools: false,
+                });
+                const text = (fb.text ?? "").trim();
+                if (text.length > 0) {
+                    traceCb(`[debate] ${model} failed both attempts; recovered via fallback ${fallbackModel}`);
+                    return { text: fb.text, toolCalls: fb.toolCalls ?? [], attempts: 3 };
+                }
+            }
+            catch (err) {
+                const fbMsg = err instanceof Error ? err.message : String(err);
+                traceCb(`[debate] fallback ${fallbackModel} for ${model} also failed: ${fbMsg}`);
+            }
+        }
     }
+    return {
+        text: "",
+        toolCalls: retryToolCalls,
+        failureReason: `both attempts failed — initial: ${firstError}; retry: ${retryError}`,
+        attempts: 2,
+    };
 }
 export async function* runDebate(spec, config, llm) {
     const { leaderModelId, participants, conversationContext, signal, debatePlan } = config;
+    // C — resume from a prior per-round checkpoint when it matches this debate
+    // (same problem statement + panel). On a match we skip research + openings and
+    // the already-completed rounds, restoring the accumulated transcript. On any
+    // mismatch (spec changed, panel re-resolved) we run fresh and let the stale
+    // checkpoint be overwritten by the first new round.
+    const resumeCp = config.resumeCheckpoint &&
+        checkpointMatches(config.resumeCheckpoint, spec.problemStatement, participants.map((p) => p.model))
+        ? config.resumeCheckpoint
+        : undefined;
+    const resumed = resumeCp !== undefined;
+    // Cross-provider fallback pool for debateWithRetry: leader + every
+    // participant model, deduped. When a speaker's model fails both same-model
+    // attempts, debateWithRetry retries once on the first pooled model whose
+    // provider differs, so an overloaded provider (opencode-go) can't silently
+    // drop a voice from the debate.
+    const fallbackPool = Array.from(new Set([leaderModelId, ...participants.map((p) => p.model)]));
     // Correlation id for the observe-only council-turn-length telemetry (groups
     // per-turn length samples by run). sessionId in production; a stable literal
     // for direct callers/tests that omit runId.
@@ -283,6 +469,12 @@ export async function* runDebate(spec, config, llm) {
     const leaderNeedsResearch = config.leaderNeedsResearch;
     const internetFirst = config.internetFirst === true;
     const costAware = config.costAware === true;
+    // Feature B — resolved council debate language. The chosen language IS the
+    // debate language (no translate-back pass). "auto" (default) follows the
+    // user's brief; "english" is the historical behavior; any other value pins
+    // the debate prose to that locale. Threaded into every debate/eval/summary
+    // prompt below. config.debateLanguage lets a caller/test override the setting.
+    const debateLanguage = config.debateLanguage ?? getCouncilLanguage();
     const active = [];
     const exchangeLogs = new Map();
     const archive = [];
@@ -296,13 +488,32 @@ export async function* runDebate(spec, config, llm) {
     // Track which models we've already announced as tool-disabled so we don't
     // emit the same "circuit breaker tripped" message every round.
     const announcedDisabled = new Set();
+    // C — restore accumulated state before any phase runs when resuming.
+    if (resumeCp) {
+        for (const p of resumeCp.active)
+            active.push(p);
+        for (const [k, v] of restoreExchangeLogs(resumeCp))
+            exchangeLogs.set(k, v);
+        for (const a of resumeCp.archive)
+            archive.push(a);
+        runningSummary = resumeCp.runningSummary;
+        researchFindings = resumeCp.researchFindings;
+        yield {
+            type: "content",
+            content: `\n> Resuming debate from round ${resumeCp.roundCount + 1} — restored ${resumeCp.roundCount} completed round(s), ${active.length} participant(s), skipping research + opening statements.\n`,
+        };
+    }
     // ── Leader decides: research needed? (skipped if user overrode upstream) ──
     // Reuse the leader's upstream research decision (computed once in runCouncil)
     // when available; only run the classifier here for direct callers that did not
     // pre-compute it. Avoids a duplicate leader-tier LLM call per council run.
-    const needsResearch = researchSkipOverride
+    // On resume the research phase already ran — never re-run it.
+    const needsResearch = resumed
         ? false
-        : (leaderNeedsResearch ?? (yield* evaluateResearchNeed(spec, leaderModelId, conversationContext, llm, costAware)));
+        : researchSkipOverride
+            ? false
+            : (leaderNeedsResearch ??
+                (yield* evaluateResearchNeed(spec, leaderModelId, conversationContext, llm, costAware)));
     if (researchSkipOverride) {
         yield {
             type: "content",
@@ -319,11 +530,16 @@ export async function* runDebate(spec, config, llm) {
             detail: `via ${researchCandidate.model}`,
         });
         const researchTraces = [];
-        researchFindings = yield* tracedAsync(() => llm.research(researchCandidate.model, spec.problemStatement, conversationContext, signal, (t) => researchTraces.push(t), { internetFirst }), {
+        const researchStartedAt = Date.now();
+        researchFindings = yield* tracedAsync(() => researchWithFallback(llm, researchCandidate.model, spec.problemStatement, conversationContext, signal, (t) => researchTraces.push(t), { internetFirst }, fallbackPool, config.runIsolatedTask), {
             phase: "research",
             label: internetFirst ? "Researching (internet-first)" : "Researching codebase",
             detail: spec.problemStatement.slice(0, 80),
             role: "research",
+            // Research is a single long generateText (up to ~10 min / 15 tool steps)
+            // with a quiet main stream — the phase most easily misread as hung, and
+            // the one whose cost the per-round numbers could not account for.
+            liveness: councilStreamLivenessReader(),
         });
         // CQ-22: emit research tool traces as council_status
         for (const trace of researchTraces) {
@@ -336,105 +552,163 @@ export async function* runDebate(spec, config, llm) {
             startedAt: p0Start,
             detail: `via ${researchCandidate.model}`,
         });
+        // A failed research call returns a "[Research failed: …]" placeholder once
+        // both primary and fallback providers are exhausted. It is a truthy string,
+        // so injecting it verbatim (below) would plant a fake "Research Findings"
+        // block into every opening/round prompt. Detect it and show a clean status
+        // note instead of the raw placeholder.
+        const researchFailed = !!researchFindings && researchFindings.includes(RESEARCH_FAILED_MARKER);
         yield {
             type: "council_message",
             councilMessage: {
                 kind: "research",
                 speaker: { role: researchCandidate.role, model: researchCandidate.model },
-                text: researchFindings ?? "",
+                text: researchFailed
+                    ? "⚠ Research unavailable — both providers failed. The council proceeds on the panel's own knowledge (no external findings injected)."
+                    : (researchFindings ?? ""),
+                // Spans researchWithFallback including any fallback provider attempt.
+                // Measured per-speaker debate turns summed to only ~3.7 min against a
+                // ~507s historical `debate_complete`, so the balance is here.
+                durationMs: Date.now() - researchStartedAt,
             },
         };
     }
-    const enrichedContext = researchFindings
+    // Only enrich when research actually produced findings — never fold the
+    // "[Research failed: …]" placeholder into the debate context.
+    const enrichedContext = researchFindings && !researchFindings.includes(RESEARCH_FAILED_MARKER)
         ? `${conversationContext}\n\n---\n\n## Research Findings\n${researchFindings}`
         : conversationContext;
     // ── Phase 1: Parallel opening statements ───────────────────────────────────
-    const p1Start = Date.now();
-    yield phaseStart({
-        phaseId: "phase:opening",
-        kind: "opening",
-        label: "Opening analysis",
-        detail: `${participants.length} participants in parallel`,
-    });
-    const openingPromises = participants.map((self) => {
-        const partner = participants.find((c) => c.role !== self.role) ?? participants[0];
-        const { system, prompt } = buildOpeningPrompt({
-            speakerRole: self.role,
-            partnerRole: partner.role,
-            speakerStance: self.stance,
-            partnerStance: partner.stance,
-            spec,
-            outputShape: debatePlan?.outputShape,
-            conversationContext: enrichedContext,
+    // Skipped entirely on resume — `active` was restored from the checkpoint so
+    // re-running openings would both waste tokens and reset the debated positions.
+    if (!resumed) {
+        const p1Start = Date.now();
+        yield phaseStart({
+            phaseId: "phase:opening",
+            kind: "opening",
+            label: "Opening analysis",
+            detail: `${participants.length} participants in parallel`,
         });
-        return openingWithRetry(llm, self.model, system, prompt).then((r) => ({
-            role: self.role,
-            model: self.model,
-            stance: self.stance,
-            position: r.text,
-            error: r.text ? null : (r.error ?? "empty completion after retries"),
-            attempts: r.attempts,
-        }));
-    });
-    const openings = yield* tracedAsync(() => Promise.all(openingPromises), {
-        phase: "opening",
-        label: `Generating opening statements (${participants.length} participants in parallel)`,
-        detail: participants.map((p) => p.role).join(", "),
-    });
-    yield { type: "content", content: "\n── Opening Analysis ──\n" };
-    for (const o of openings) {
-        const speakerRole = o.stance?.name ?? o.role;
-        if (o.error) {
-            yield {
-                type: "council_message",
-                councilMessage: {
-                    kind: "debate",
-                    speaker: { role: speakerRole, model: o.model },
-                    round: 0,
-                    text: `[Error: ${o.error}]`,
-                    attempts: o.attempts,
-                    failureReason: o.error,
-                },
-            };
+        // Sprint-2 item 3 — per-stance recall. Fire one stance-weighted recall per
+        // unique role before openings; fold each role's seed into that participant's
+        // opening context so every stance opens grounded in the experience its lens
+        // cares about. Bounded + failure-tolerant inside the injected fn; a null/empty
+        // result leaves openings unchanged.
+        let stanceSeeds = null;
+        if (config.stanceRecall) {
+            try {
+                const roles = Array.from(new Set(participants.map((p) => p.role)));
+                stanceSeeds = await config.stanceRecall(roles, spec.problemStatement);
+            }
+            catch {
+                stanceSeeds = null;
+            }
         }
-        else {
-            active.push({ role: o.role, model: o.model, position: o.position, stance: o.stance });
-            archive.push({
-                round: 0,
-                role: o.role,
-                model: o.model,
-                stanceName: o.stance?.name,
-                ...makeExcerpt(o.position),
+        const openingPromises = participants.map((self) => {
+            const partner = participants.find((c) => c.role !== self.role) ?? participants[0];
+            const seed = stanceSeeds?.get(self.role)?.trim();
+            const selfContext = seed
+                ? `${enrichedContext}\n\n---\n\n## Experience recall — ${self.stance?.name ?? self.role} lens\n${seed}`
+                : enrichedContext;
+            const { system, prompt } = buildOpeningPrompt({
+                speakerRole: self.role,
+                partnerRole: partner.role,
+                speakerStance: self.stance,
+                partnerStance: partner.stance,
+                spec,
+                outputShape: debatePlan?.outputShape,
+                conversationContext: selfContext,
+                language: debateLanguage,
             });
-            yield {
-                type: "council_message",
-                councilMessage: {
-                    kind: "debate",
-                    speaker: { role: speakerRole, model: o.model },
+            const startedAt = Date.now();
+            return openingWithRetry(llm, self.model, system, prompt).then((r) => ({
+                role: self.role,
+                model: self.model,
+                stance: self.stance,
+                position: r.text,
+                error: r.text ? null : (r.error ?? "empty completion after retries"),
+                attempts: r.attempts,
+                durationMs: Date.now() - startedAt,
+            }));
+        });
+        const openings = yield* tracedAsync(() => Promise.all(openingPromises), {
+            phase: "opening",
+            label: `Generating opening statements (${participants.length} participants in parallel)`,
+            // Newline-joined "Name — lens" roster so the composing placeholder shows WHAT
+            // each speaker is tasked to argue (A: live debate preview) instead of a bare
+            // spinner during the atomic generateText window.
+            detail: formatSpeakerRoster(participants),
+            // Promise.all does not pump this generator, so `elapsedMs` freezes while
+            // the openings run. Push-based stream counters keep the heartbeat honest.
+            liveness: councilStreamLivenessReader(),
+        });
+        yield { type: "content", content: "\n── Opening Analysis ──\n" };
+        for (const o of openings) {
+            const speakerRole = o.stance?.name ?? o.role;
+            if (o.error) {
+                yield {
+                    type: "council_message",
+                    councilMessage: {
+                        kind: "debate",
+                        speaker: { role: speakerRole, model: o.model },
+                        round: 0,
+                        text: `[Error: ${o.error}]`,
+                        attempts: o.attempts,
+                        failureReason: o.error,
+                        durationMs: o.durationMs,
+                    },
+                };
+            }
+            else {
+                active.push({ role: o.role, model: o.model, position: o.position, stance: o.stance });
+                archive.push({
+                    round: 0,
+                    role: o.role,
+                    model: o.model,
+                    stanceName: o.stance?.name,
+                    ...makeExcerpt(o.position),
+                });
+                yield {
+                    type: "council_message",
+                    councilMessage: {
+                        kind: "debate",
+                        speaker: { role: speakerRole, model: o.model },
+                        round: 0,
+                        text: o.position,
+                        attempts: o.attempts,
+                        durationMs: o.durationMs,
+                    },
+                };
+                emitCouncilTurnLength({
+                    role: speakerRole,
                     round: 0,
                     text: o.position,
-                    attempts: o.attempts,
-                },
-            };
-            emitCouncilTurnLength({
-                role: speakerRole,
-                round: 0,
-                text: o.position,
-                model: o.model,
-                correlationId: turnCorrelationId,
-            });
+                    model: o.model,
+                    correlationId: turnCorrelationId,
+                });
+            }
         }
+        yield phaseDone({
+            phaseId: "phase:opening",
+            kind: "opening",
+            label: "Opening analysis",
+            startedAt: p1Start,
+            detail: `${active.length}/${participants.length} participants succeeded`,
+        });
     }
-    yield phaseDone({
-        phaseId: "phase:opening",
-        kind: "opening",
-        label: "Opening analysis",
-        startedAt: p1Start,
-        detail: `${active.length}/${participants.length} participants succeeded`,
-    });
     if (active.length < 2) {
         yield { type: "content", content: "\nNot enough successful openings for discussion.\n" };
-        return { spec, exchangeLogs, runningSummary: "", roundCount: 0, researchFindings, active, archive };
+        // Even a single-opening debate is worth persisting (F9) — a deterministic
+        // synthesis of whatever position survived beats an empty research artifact.
+        return {
+            spec,
+            exchangeLogs,
+            runningSummary: resolveDebateSummary({ runningSummary: "", active, archive }),
+            roundCount: 0,
+            researchFindings,
+            active,
+            archive,
+        };
     }
     // ── Phase 2: Dynamic discussion rounds ─────────────────────────────────────
     // Leader-decided round budget: planner proposes an initial value, leader
@@ -458,6 +732,16 @@ export async function* runDebate(spec, config, llm) {
         type: "content",
         content: `\n> Leader-proposed debate budget: ${maxRounds} round${maxRounds === 1 ? "" : "s"}${ceilingNote}.\n`,
     };
+    // P3 — structured budget/ceiling for the context rail. These are locals here,
+    // invisible to the council entrypoint, so they ride a separate council_meta
+    // patch that the UI upsert-merges with the leader/panel patch.
+    yield {
+        type: "council_meta",
+        councilMeta: {
+            roundBudget: maxRounds,
+            roundCeiling: kindCapped ? effectiveCeiling : ABSOLUTE_MAX_ROUNDS,
+        },
+    };
     // Pairs that fail twice in a row are dropped from subsequent rounds so the
     // remaining participants don't keep retrying a broken model and inflating
     // the persistent transcript with failure noise.
@@ -466,7 +750,74 @@ export async function* runDebate(spec, config, llm) {
     // Stop debate entirely after two consecutive rounds where ≥50% of pairs fail
     // — the LLM is clearly under provider stress and more rounds won't help.
     let consecutiveRoundFailures = 0;
-    for (let round = 1; round <= maxRounds; round++) {
+    // P5 — topic carried from the prior round's leader nextRoundFocus, shown as the
+    // next round's heading in the round-grouped transcript.
+    let nextTopic;
+    // B5 — prior round's aligned criteriaMet, so each round's directive/verdict
+    // and the post-debate unmet-flag know what is still open. Empty before round 1
+    // → the round-1 directive treats every criterion as unmet.
+    let lastCriteriaMet = [];
+    // B4 — leader auto-remedy progress tracking. `bestCriteriaMetCount` is the
+    // high-water mark of pinned criteria met; `roundsSinceProgress` counts
+    // consecutive evaluated rounds that produced no NEW met criterion. Auto-extend
+    // fires only while progress is being made; a stuck criterion (no progress for
+    // 2 rounds) stops the budget burn and drops to a diagnostic closing verdict.
+    let bestCriteriaMetCount = 0;
+    let roundsSinceProgress = 0;
+    // B4 interactive escalation — fires at most once per debate. `escalation`
+    // records the user's choice at a stop-with-unmet boundary for the DebateState.
+    let escalated = false;
+    let escalation;
+    // C — restore round-loop continuity from the checkpoint. `maxRounds` takes the
+    // checkpointed budget (which may have been extended past the plan). The within-
+    // run heuristics that reset safely (droppedPairKeys, consecutiveRoundFailures,
+    // consecutivePairFailures, escalated) are intentionally NOT restored — a fresh
+    // start for them at most re-tries a previously-dropped pair, never corrupts
+    // state. The loop start is derived below from `roundCount`.
+    if (resumeCp) {
+        roundCount = resumeCp.roundCount;
+        maxRounds = Math.max(maxRounds, resumeCp.maxRounds);
+        lastCriteriaMet = [...resumeCp.lastCriteriaMet];
+        bestCriteriaMetCount = resumeCp.bestCriteriaMetCount;
+        roundsSinceProgress = resumeCp.roundsSinceProgress;
+        nextTopic = resumeCp.nextTopic;
+    }
+    // Shared applier for the two stop-with-unmet boundaries (leader voluntarily
+    // stopped, or the budget exhausted while stuck/at ceiling). Reassigns the
+    // loop's round budget via closure; returns whether the debate should keep
+    // going. Caller must have already checked the gate (responder wired, flag on,
+    // not yet escalated, criteria unmet).
+    async function* escalateStop(stuck, pinnedUnmet, openList) {
+        escalated = true;
+        // convene_council path: no interactive user is answering mid-tool-call, so a
+        // blocking escalation card would hang the council. Auto-accept (= conclude
+        // with the best synthesis so far) without emitting the card. Mirrors the
+        // "empty/failed answer → accept" fallback runEscalationPrompt already uses.
+        if (config.convenePath) {
+            escalation = { action: "accept" };
+            return "stop";
+        }
+        const dec = yield* runEscalationPrompt({
+            respondToQuestion: config.respondToQuestion,
+            openCriteria: openList,
+            pinnedUnmet,
+            stuck,
+            atAbsoluteMax: maxRounds >= ABSOLUTE_MAX_ROUNDS,
+            currentMax: maxRounds,
+        });
+        escalation = { action: dec.action, grantedRounds: dec.grantedRounds || undefined };
+        if (dec.action === "extend" && dec.grantedRounds > 0) {
+            maxRounds += dec.grantedRounds;
+            roundsSinceProgress = 0;
+            if (!nextTopic)
+                nextTopic = `Close the unmet criteria: ${openList.join("; ")}`;
+            return "extend";
+        }
+        return "stop";
+    }
+    // C — on resume, `roundCount` was seeded to the last completed round so the
+    // loop continues at roundCount+1; a fresh run starts at 1 (roundCount=0).
+    for (let round = roundCount + 1; round <= maxRounds; round++) {
         // User cancelled mid-debate — stop before spending another round of
         // parallel pair LLM calls. The caller (runCouncil) re-checks the signal at
         // its next phase boundary and skips synthesis too.
@@ -475,6 +826,10 @@ export async function* runDebate(spec, config, llm) {
             break;
         }
         roundCount = round;
+        // Set when the user extends the debate at this round's stop boundary (B4
+        // escalation). Guards the convergence-exit below so a user "extend" isn't
+        // immediately overridden by a lock-phrase convergence break.
+        let userExtendedThisRound = false;
         const p2Start = Date.now();
         const roundPhaseId = `phase:round-${round}`;
         yield phaseStart({
@@ -510,6 +865,50 @@ export async function* runDebate(spec, config, llm) {
             roundCount = round - 1;
             break;
         }
+        // P5 — round lifecycle for the grouped transcript. `roundRec` closes over
+        // this round's participants/pairCount/emergent/topic; a running record now,
+        // a guaranteed done record on every exit below.
+        // Surface the task-adaptive persona (or model id), never the internal
+        // implement/verify/research cost-tier slot — that slot is a routing detail
+        // that misleads on analysis/decision topics (observed session dd34c59c63e9:
+        // an "evaluation" debate showed a bogus "implement" member).
+        const roundParticipants = active.map((p) => p.stance?.name ?? p.model);
+        const roundEmergent = round > plannedMaxRounds;
+        const roundTopic = nextTopic;
+        const roundRec = (state, patch = {}) => ({
+            type: "council_round",
+            councilRound: {
+                round,
+                state,
+                topic: roundTopic,
+                participants: roundParticipants,
+                pairCount: pairs.length,
+                emergent: roundEmergent,
+                ...patch,
+            },
+        });
+        yield roundRec("running");
+        // B5 — pre-round leader DIRECTIVE. Before the exchanges run, the leader
+        // states this round's goal and which pinned criteria are still unmet, so it
+        // visibly conducts each round instead of only grading afterwards. Gated on
+        // pinned criteria (nothing to steer toward otherwise) + the conductor flag.
+        // Captured in `roundDirective` so it also lands on the round record's
+        // `directive` field below — durable in the conclusion card, not only the
+        // ephemeral live bubble a user misses if they look away mid-debate.
+        let roundDirective;
+        if (leaderConductorEnabled() && spec.successCriteria.length > 0) {
+            roundDirective = buildLeaderDirective(round, spec.successCriteria, lastCriteriaMet, roundTopic);
+            yield {
+                type: "council_message",
+                councilMessage: {
+                    kind: "leader",
+                    phase: "directive",
+                    speaker: { role: "Leader", model: leaderModelId },
+                    round,
+                    text: roundDirective,
+                },
+            };
+        }
         const pairResults = yield* tracedAsync(() => Promise.all(pairs.map(async ({ a, b, key }) => {
             const log = exchangeLogs.get(key);
             const chunks = [];
@@ -529,9 +928,10 @@ export async function* runDebate(spec, config, llm) {
                         speakerPosition: a.position,
                         partnerPosition: b.position,
                         spec,
+                        language: debateLanguage,
                     });
                     const aTraces = [];
-                    const aResult = await debateWithRetry(llm, a.model, aPrompt.system, aPrompt.prompt, signal, (t) => aTraces.push(t), toolBudget);
+                    const aResult = await debateWithRetry(llm, a.model, aPrompt.system, aPrompt.prompt, signal, (t) => aTraces.push(t), toolBudget, fallbackPool);
                     aResponse = aResult.text;
                     aToolCalls = aResult.toolCalls;
                     log.push(`[${aLabel}]: ${aResponse}`);
@@ -542,6 +942,7 @@ export async function* runDebate(spec, config, llm) {
                         traces: aTraces,
                         failureReason: aResult.failureReason,
                         attempts: aResult.attempts,
+                        durationMs: aResult.durationMs,
                     });
                     const bPrompt = buildResponsePrompt({
                         speakerRole: b.role,
@@ -551,9 +952,10 @@ export async function* runDebate(spec, config, llm) {
                         speakerPosition: b.position,
                         partnerPosition: aResponse,
                         spec,
+                        language: debateLanguage,
                     });
                     const bTraces = [];
-                    const bResult = await debateWithRetry(llm, b.model, bPrompt.system, bPrompt.prompt, signal, (t) => bTraces.push(t), toolBudget);
+                    const bResult = await debateWithRetry(llm, b.model, bPrompt.system, bPrompt.prompt, signal, (t) => bTraces.push(t), toolBudget, fallbackPool);
                     bResponse = bResult.text;
                     bToolCalls = bResult.toolCalls;
                     log.push(`[${bLabel}]: ${bResponse}`);
@@ -564,6 +966,7 @@ export async function* runDebate(spec, config, llm) {
                         traces: bTraces,
                         failureReason: bResult.failureReason,
                         attempts: bResult.attempts,
+                        durationMs: bResult.durationMs,
                     });
                 }
                 else {
@@ -581,9 +984,10 @@ export async function* runDebate(spec, config, llm) {
                         round,
                         runningSummary,
                         spec,
+                        language: debateLanguage,
                     });
                     const aTraces = [];
-                    const aResult = await debateWithRetry(llm, a.model, aPrompt.system, aPrompt.prompt, signal, (t) => aTraces.push(t), toolBudget);
+                    const aResult = await debateWithRetry(llm, a.model, aPrompt.system, aPrompt.prompt, signal, (t) => aTraces.push(t), toolBudget, fallbackPool);
                     aResponse = aResult.text;
                     aToolCalls = aResult.toolCalls;
                     log.push(`[${aLabel}] (round ${round}): ${aResponse}`);
@@ -594,6 +998,7 @@ export async function* runDebate(spec, config, llm) {
                         traces: aTraces,
                         failureReason: aResult.failureReason,
                         attempts: aResult.attempts,
+                        durationMs: aResult.durationMs,
                     });
                     const bPrompt = buildFollowupPrompt({
                         speakerRole: b.role,
@@ -605,9 +1010,10 @@ export async function* runDebate(spec, config, llm) {
                         round,
                         runningSummary,
                         spec,
+                        language: debateLanguage,
                     });
                     const bTraces = [];
-                    const bResult = await debateWithRetry(llm, b.model, bPrompt.system, bPrompt.prompt, signal, (t) => bTraces.push(t), toolBudget);
+                    const bResult = await debateWithRetry(llm, b.model, bPrompt.system, bPrompt.prompt, signal, (t) => bTraces.push(t), toolBudget, fallbackPool);
                     bResponse = bResult.text;
                     bToolCalls = bResult.toolCalls;
                     log.push(`[${bLabel}] (round ${round}): ${bResponse}`);
@@ -618,6 +1024,7 @@ export async function* runDebate(spec, config, llm) {
                         traces: bTraces,
                         failureReason: bResult.failureReason,
                         attempts: bResult.attempts,
+                        durationMs: bResult.durationMs,
                     });
                 }
                 // Only update positions when response is non-empty (avoid clearing on LLM error)
@@ -633,7 +1040,14 @@ export async function* runDebate(spec, config, llm) {
         })), {
             phase: "exchange",
             label: `Discussion round ${round} (${pairs.length} pair${pairs.length === 1 ? "" : "s"})`,
-            detail: pairs.map((p) => `${p.a.role}↔${p.b.role}`).join(", "),
+            // Distinct speakers with their lens (A: live debate preview) — dedup by
+            // formatted line so a speaker appearing in two pairs shows once.
+            detail: formatSpeakerRoster(pairs.flatMap((p) => [p.a, p.b])),
+            // THE case this exists for: each pair turn can run to the 5-min council
+            // ceiling on a reasoning model, and Promise.all never pumps this
+            // generator — `elapsedMs` freezes and a healthy 15-min round looks hung.
+            // These counters come off the token stream, so they keep advancing.
+            liveness: councilStreamLivenessReader(),
         });
         yield { type: "content", content: `\n── Round ${round} ──\n` };
         // Track failures so the circuit breaker can fire after this round.
@@ -698,6 +1112,7 @@ export async function* runDebate(spec, config, llm) {
                             text: chunk.text.trim(),
                             toolCalls: chunk.toolCalls?.map((t) => ({ name: t.toolName })),
                             attempts: chunk.attempts,
+                            durationMs: chunk.durationMs,
                         },
                     };
                     emitCouncilTurnLength({
@@ -769,6 +1184,11 @@ export async function* runDebate(spec, config, llm) {
                     type: "content",
                     content: `\n> Circuit breaker: aborting debate after ${consecutiveRoundFailures} consecutive failure-heavy rounds — proceeding to synthesis with what we have.\n`,
                 };
+                yield roundRec("done", {
+                    leaderDecision: "circuit-break",
+                    leaderReason: "provider stress — circuit breaker",
+                    directive: roundDirective,
+                });
                 break;
             }
         }
@@ -784,13 +1204,67 @@ export async function* runDebate(spec, config, llm) {
             label: `Leader evaluation (round ${round})`,
         });
         const allExchangeText = [...exchangeLogs.values()].flat().slice(-8).join("\n\n");
-        const evaluation = yield* evaluateDebate(spec, allExchangeText, round, leaderModelId, llm, costAware);
+        let evaluation = yield* evaluateDebate(spec, allExchangeText, round, leaderModelId, llm, costAware, undefined, debateLanguage);
+        // Eval robustness: the leader's cost-tier eval model can be on a flaky proxy
+        // (Console Go glm/kimi → "Upstream request failed") while panel models on
+        // other providers stay healthy. Rather than surface "evaluation unavailable"
+        // and lose the round outcome, retry the eval on each healthy model in the
+        // fallback pool before giving up. Bounded (pool is small) and only runs on the
+        // failure path, so successful evals pay nothing.
+        if (!evaluation) {
+            // Which model the primary eval already tried (skip re-hitting it). Defensive
+            // against a partially-mocked leader module in tests — if we can't resolve
+            // it, skip the fallback loop rather than throw.
+            let firstTried = null;
+            try {
+                firstTried = pickCouncilTaskModel("evaluate_round", leaderModelId, costAware);
+            }
+            catch {
+                firstTried = null;
+            }
+            if (firstTried) {
+                for (const fallbackModel of fallbackPool) {
+                    if (fallbackModel === firstTried)
+                        continue;
+                    evaluation = yield* evaluateDebate(spec, allExchangeText, round, leaderModelId, llm, costAware, fallbackModel, debateLanguage);
+                    if (evaluation)
+                        break;
+                }
+            }
+        }
         if (evaluation) {
             if (typeof evaluation.evidenceDensity === "number") {
                 lastEvidenceDensity = evaluation.evidenceDensity;
             }
             const metCount = evaluation.criteriaStatus.filter((c) => c.met).length;
             const total = evaluation.criteriaStatus.length;
+            // B2/B3: project this round's evaluation onto the PINNED spec criteria
+            // (index-aligned, best-effort text match as a fallback) and push it to the
+            // rail so the user sees live ✓/○ against the exact outcome they saw — not
+            // an opaque "N/M". Only when the spec has real pinned criteria.
+            const hasPinned = spec.successCriteria.length > 0;
+            const aligned = hasPinned ? alignCriteriaMet(spec.successCriteria, evaluation.criteriaStatus) : [];
+            // Count of pinned criteria still open this round — used by both auto-remedy
+            // and the interactive escalation boundaries below.
+            const pinnedUnmet = hasPinned ? aligned.filter((m) => !m).length : 0;
+            if (hasPinned) {
+                yield {
+                    type: "council_meta",
+                    councilMeta: { criteriaMet: aligned },
+                };
+                lastCriteriaMet = aligned; // B5: feed next round's directive + final unmet-flag
+                // B4: track progress against the PINNED criteria. A round that meets a new
+                // criterion resets the stuck counter; a round that meets nothing new
+                // increments it. Auto-remedy reads these to decide extend-vs-give-up.
+                const pinnedMetNow = aligned.filter(Boolean).length;
+                if (pinnedMetNow > bestCriteriaMetCount) {
+                    bestCriteriaMetCount = pinnedMetNow;
+                    roundsSinceProgress = 0;
+                }
+                else {
+                    roundsSinceProgress++;
+                }
+            }
             yield phaseDone({
                 phaseId: evalPhaseId,
                 kind: "evaluation",
@@ -798,15 +1272,45 @@ export async function* runDebate(spec, config, llm) {
                 startedAt: evalStart,
                 detail: `${metCount}/${total} criteria met · ${evaluation.reason.slice(0, 80)}`,
             });
+            // B5: post-round VERDICT. With pinned criteria + conductor on, list each
+            // criterion's ✓/○ and the focus handed to the next round; otherwise fall
+            // back to the plain one-line eval (pre-B5 behavior).
+            const verdictText = leaderConductorEnabled() && hasPinned
+                ? buildLeaderVerdict(spec.successCriteria, aligned, evaluation.reason, evaluation.nextRoundFocus)
+                : `${metCount}/${total} criteria met — ${evaluation.reason}`;
             yield {
                 type: "council_message",
                 councilMessage: {
                     kind: "leader",
+                    phase: leaderConductorEnabled() && hasPinned ? "verdict" : undefined,
                     speaker: { role: "Leader", model: leaderModelId },
                     round,
-                    text: `${metCount}/${total} criteria met — ${evaluation.reason}`,
+                    text: verdictText,
+                    // Spans every evaluateDebate attempt including fallback models, so a
+                    // leader that ate the round is attributable rather than hidden inside
+                    // the `debate_complete` aggregate.
+                    durationMs: Date.now() - evalStart,
                 },
             };
+            // P5 — guaranteed done record for this round. Decision reflects the
+            // LEADER's intent (extend / continue / stop); a later code-side convergence
+            // override that stops the loop is a separate mechanism and doesn't rewrite
+            // the leader's stated call. Carry the leader's nextRoundFocus to the next
+            // round's topic.
+            const leaderDecision = typeof evaluation.extendRounds === "number" && evaluation.extendRounds > 0
+                ? "extend"
+                : evaluation.shouldContinue
+                    ? "continue"
+                    : "stop";
+            yield roundRec("done", {
+                criteriaMet: metCount,
+                criteriaTotal: total,
+                leaderReason: evaluation.reason,
+                leaderDecision,
+                nextRoundFocus: evaluation.nextRoundFocus,
+                directive: roundDirective,
+            });
+            nextTopic = evaluation.nextRoundFocus;
             if (evaluation.needsResearch && evaluation.researchQuery) {
                 const midPhaseId = `phase:mid-research-${round}`;
                 const midStart = Date.now();
@@ -818,7 +1322,7 @@ export async function* runDebate(spec, config, llm) {
                 });
                 const researchCandidate = participants.find((c) => c.role === "research") ?? participants[0];
                 const midTraces = [];
-                const findings = yield* tracedAsync(() => llm.research(researchCandidate.model, evaluation.researchQuery, enrichedContext, signal, (t) => midTraces.push(t)), {
+                const findings = yield* tracedAsync(() => researchWithFallback(llm, researchCandidate.model, evaluation.researchQuery, enrichedContext, signal, (t) => midTraces.push(t), {}, fallbackPool, config.runIsolatedTask), {
                     phase: "research",
                     label: "Mid-debate research",
                     detail: evaluation.researchQuery.slice(0, 80),
@@ -855,11 +1359,40 @@ export async function* runDebate(spec, config, llm) {
                 }
             }
             if (!evaluation.shouldContinue) {
-                yield {
-                    type: "content",
-                    content: `\n> Leader decided: debate sufficient at round ${round}.\n`,
-                };
-                break;
+                // B4 escalation site 1 — the leader is declaring the debate done. If
+                // pinned criteria are still unmet and we have an interactive channel,
+                // ask the user before accepting a partial outcome (the "3/5 → stop,
+                // synthesize as if done" gap). An "extend" cancels the stop and runs
+                // more rounds; accept/rescope confirm it.
+                if (config.respondToQuestion &&
+                    leaderEscalationEnabled() &&
+                    !escalated &&
+                    hasPinned &&
+                    pinnedUnmet > 0 &&
+                    // Respect the leader's own verdict: if it declared every criterion met,
+                    // don't second-guess it with the fuzzy per-criterion alignment (which
+                    // can miss a match and show a false unmet). Escalate only on a genuine
+                    // stop-with-unmet the leader itself signalled.
+                    !evaluation.allCriteriaMet) {
+                    const openList = spec.successCriteria.filter((_, i) => !aligned[i]).map((c) => shortCriterion(c, 56));
+                    const outcome = yield* escalateStop(roundsSinceProgress >= 2, pinnedUnmet, openList);
+                    if (outcome === "extend") {
+                        userExtendedThisRound = true;
+                        // Fall through — the loop runs the user-granted rounds. Skip the
+                        // convergence + auto-remedy stop-logic below (both assume a natural
+                        // stop); the inter-round summary still runs.
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    yield {
+                        type: "content",
+                        content: `\n> Leader decided: debate sufficient at round ${round}.\n`,
+                    };
+                    break;
+                }
             }
             // Code-side convergence override. When the latest round had ≥80% of
             // pair-turns containing lock phrases ("everything locked", "fully
@@ -875,7 +1408,9 @@ export async function* runDebate(spec, config, llm) {
             const lockRatio = convergenceRatio(lastRoundTurns);
             const skepticClean = Array.isArray(evaluation.unresolvedPoints) && evaluation.unresolvedPoints.length === 0;
             const canExitEarly = (round >= 2 && lockRatio >= 0.8) || (round === 1 && lockRatio >= 0.8 && skepticClean);
-            if (canExitEarly) {
+            // A user "extend" at this round's stop boundary overrides a convergence
+            // break — the user explicitly asked for more rounds to close open criteria.
+            if (canExitEarly && !userExtendedThisRound) {
                 const reason = round === 1
                     ? `round 1 converged early (lock=${Math.round(lockRatio * 100)}%, no unresolved points)`
                     : `${Math.round(lockRatio * 100)}% of round ${round} turns contained lock phrases`;
@@ -885,24 +1420,60 @@ export async function* runDebate(spec, config, llm) {
                 };
                 break;
             }
-            // Leader asked for more rounds and we still have ceiling headroom.
-            // Both the absolute ceiling AND the kind-specific cap apply — leader
-            // can't override an implementation_plan cap of 3 by asking for 4.
-            if (round === maxRounds &&
-                typeof evaluation.extendRounds === "number" &&
-                evaluation.extendRounds > 0 &&
-                maxRounds < effectiveCeiling) {
-                const requested = Math.max(1, Math.floor(evaluation.extendRounds));
+            // Budget-exhaustion remedy (B4). At the last planned round with ceiling
+            // headroom, two triggers extend the debate:
+            //   1. the leader explicitly asked (extendRounds > 0), OR
+            //   2. auto-remedy — pinned criteria are still unmet AND progress is being
+            //      made (a new criterion was met within the last 2 rounds).
+            // "Done = all pinned criteria met"; the ceiling is a leader-managed budget,
+            // not a give-up at the initial plan. A stuck criterion (no progress for 2
+            // rounds) fails the guard so we don't burn the ceiling chasing it — the
+            // closing verdict below then escalates it as stuck. Both the absolute
+            // ceiling AND the kind cap still apply (leader can't push an
+            // implementation_plan cap of 3 to 4).
+            const leaderAskedExtend = typeof evaluation.extendRounds === "number" && evaluation.extendRounds > 0;
+            const autoRemedy = leaderAutoRemedyEnabled() && autoRemedyWantsExtend(pinnedUnmet, roundsSinceProgress);
+            if (round === maxRounds && maxRounds < effectiveCeiling && (leaderAskedExtend || autoRemedy)) {
+                const requested = leaderAskedExtend ? Math.max(1, Math.floor(evaluation.extendRounds)) : 1;
                 const newMax = Math.min(effectiveCeiling, maxRounds + requested);
                 const grantedExtra = newMax - maxRounds;
                 if (grantedExtra > 0) {
+                    const why = leaderAskedExtend
+                        ? "unresolved points remain"
+                        : `${pinnedUnmet} pinned criteri${pinnedUnmet === 1 ? "on" : "a"} still unmet`;
                     yield {
                         type: "content",
-                        content: `\n> Leader extending debate by ${grantedExtra} round${grantedExtra === 1 ? "" : "s"} (now ${newMax}/${ABSOLUTE_MAX_ROUNDS}) — unresolved points remain.\n`,
+                        content: `\n> Leader extending debate by ${grantedExtra} round${grantedExtra === 1 ? "" : "s"} (now ${newMax}/${ABSOLUTE_MAX_ROUNDS}) — ${why}.\n`,
                     };
                     maxRounds = newMax;
+                    // Steer the extra round at the open criteria when auto-remedy fired and
+                    // the leader set no focus of its own.
+                    if (autoRemedy && !leaderAskedExtend && !nextTopic) {
+                        const openList = spec.successCriteria.filter((_, i) => !aligned[i]).map((c) => shortCriterion(c, 48));
+                        nextTopic = `Close the unmet criteria: ${openList.join("; ")}`;
+                    }
                 }
             }
+            // B4 escalation site 2 — the leader wanted to keep going but we're at the
+            // last round and auto-remedy couldn't extend (stuck, or the ceiling is
+            // reached). Rather than let the loop exit into a diagnostic-only synthesis,
+            // ask the user. An "extend" bumps maxRounds so the loop continues; accept/
+            // rescope let it exit naturally. `!escalated` already prevents a double-ask
+            // if site 1 fired this round.
+            if (round === maxRounds &&
+                config.respondToQuestion &&
+                leaderEscalationEnabled() &&
+                !escalated &&
+                hasPinned &&
+                !evaluation.allCriteriaMet &&
+                escalationWanted({
+                    pinnedUnmet,
+                    stuck: roundsSinceProgress >= 2,
+                    atCeiling: maxRounds >= effectiveCeiling,
+                })) {
+                const openList = spec.successCriteria.filter((_, i) => !aligned[i]).map((c) => shortCriterion(c, 56));
+                yield* escalateStop(roundsSinceProgress >= 2, pinnedUnmet, openList);
+            }
         }
         else {
             yield phaseDone({
@@ -912,6 +1483,33 @@ export async function* runDebate(spec, config, llm) {
                 startedAt: evalStart,
                 detail: "evaluation unavailable — continuing",
             });
+            // P5 — eval parse failed: still close the round with a done record so the
+            // grouped transcript never shows a round stuck "running". Do NOT set
+            // leaderReason here — the "eval-unavailable" DECISION_LABEL already conveys
+            // it, and a redundant reason line rendered the message twice on the card
+            // (observed session dd34c59c63e9).
+            yield roundRec("done", { leaderDecision: "eval-unavailable", directive: roundDirective });
+            nextTopic = undefined;
+            // F2 — final-round eval-unavailable must not silently drop an unmet
+            // outcome. The eval failed to parse even after the cross-provider fallback
+            // loop, so there is no fresh criteria status; fall back to the last
+            // successful round's alignment (lastCriteriaMet), treating an empty history
+            // as all-unmet. If this is the last round and we have an interactive
+            // channel with criteria still open, consult the user (same B4 escalation)
+            // instead of proceeding straight to synthesis. stuck=true: a broken eval
+            // gives no progress signal, so the diagnostic frames the criteria as
+            // needing evidence/rescope rather than "more debate".
+            if (round === maxRounds &&
+                config.respondToQuestion &&
+                leaderEscalationEnabled() &&
+                !escalated &&
+                spec.successCriteria.length > 0) {
+                const unmetIdx = spec.successCriteria.map((_, i) => i).filter((i) => lastCriteriaMet[i] !== true);
+                if (unmetIdx.length > 0) {
+                    const openList = unmetIdx.map((i) => shortCriterion(spec.successCriteria[i], 56));
+                    yield* escalateStop(true, unmetIdx.length, openList);
+                }
+            }
         }
         // Generate inter-round summary
         if (round < maxRounds) {
@@ -924,7 +1522,7 @@ export async function* runDebate(spec, config, llm) {
             });
             try {
                 const allEx = [...exchangeLogs.values()].flat().slice(-6).join("\n\n");
-                const { system, prompt } = buildRoundSummaryPrompt(allEx, spec.problemStatement, round);
+                const { system, prompt } = buildRoundSummaryPrompt(allEx, spec.problemStatement, round, debateLanguage);
                 // Round summary is mechanical condensation — drop to "fast" tier on the leader's
                 // provider when cost-aware. Fall back to the first participant's model otherwise
                 // (matches the pre-cost-aware behavior).
@@ -961,6 +1559,57 @@ export async function* runDebate(spec, config, llm) {
                 });
             }
         }
+        // C — snapshot the fully-completed round (transcript + summary persisted) so
+        // a break before synthesis resumes from round+1 instead of round 1. roundCount
+        // was set to `round` at the top of this iteration. Non-fatal on write failure.
+        if (config.checkpointDir) {
+            await writeDebateCheckpoint(config.checkpointDir, buildDebateCheckpoint({
+                problemStatement: spec.problemStatement,
+                roundCount,
+                maxRounds,
+                exchangeLogs,
+                runningSummary,
+                researchFindings,
+                active,
+                archive,
+                lastCriteriaMet,
+                bestCriteriaMetCount,
+                roundsSinceProgress,
+                nextTopic,
+                savedAt: new Date().toISOString(),
+            }));
+        }
+    }
+    // B4 leader remedy: the debate has ended — via leader stop, convergence, or
+    // budget exhaustion (after auto-remedy exhausted the ceiling). If pinned
+    // criteria remain unmet, the leader emits a visible closing verdict that
+    // DIAGNOSES why it stopped and gives an actionable next move, instead of
+    // letting synthesis proceed as if the outcome were fully achieved (the "3/5 →
+    // stop, synthesize as if done" gap). When the user was consulted (B4
+    // escalation) and chose to accept/rescope, the remedy reflects that decision
+    // instead of a generic "re-run" shrug.
+    if (leaderConductorEnabled() && spec.successCriteria.length > 0) {
+        const unmet = spec.successCriteria.filter((_, i) => !lastCriteriaMet[i]);
+        if (unmet.length > 0) {
+            const atCeiling = maxRounds >= effectiveCeiling;
+            const stuck = roundsSinceProgress >= 2;
+            const remedy = escalation?.action === "accept"
+                ? "you accepted these as open — synthesis proceeds with them noted as unresolved."
+                : escalation?.action === "rescope"
+                    ? "you asked to narrow the scope — re-run the council on just these criteria with a tighter problem statement."
+                    : diagnoseUnmetRemedy({ stuck, atCeiling, effectiveCeiling, roundsSinceProgress });
+            yield {
+                type: "council_message",
+                councilMessage: {
+                    kind: "leader",
+                    phase: "verdict",
+                    speaker: { role: "Leader", model: leaderModelId },
+                    text: `Debate ended with ${unmet.length} of ${spec.successCriteria.length} criteri` +
+                        `${unmet.length === 1 ? "on" : "a"} still unmet: ${unmet.map((c) => shortCriterion(c, 56)).join("; ")}. ` +
+                        `Synthesis notes these as open — ${remedy}`,
+                },
+            };
+        }
     }
     // Compute cumulative evidence density across the WHOLE debate, not just
     // the leader's last per-round evaluation. Citations are concentrated in
@@ -969,12 +1618,112 @@ export async function* runDebate(spec, config, llm) {
     // slice (as lastEvidenceDensity does) reports 0.00 even when the debate
     // actually produced [CONFIRMED via …] tags earlier — that's the bug
     // session ea13da132dec hit despite 2 real web_fetch citations.
-    const fullExchangeText = [...exchangeLogs.values()].flat().join("\n\n");
+    // #3 — grounding-verify. When the debate produced weak evidence density
+    // (debaters barely tagged claims, since each is capped at stepCountIs(2)), run
+    // an isolated explore sub-agent to fact-check the load-bearing claims and emit
+    // authoritative [CONFIRMED]/[REFUTED] tags. Its output is folded into the
+    // density INPUT below (NOT into exchangeLogs, keeping the persisted transcript
+    // clean) and surfaced as a council_message. Fires only when a bridge is wired,
+    // the flag is on, we're not aborting, and grounding is genuinely weak.
+    let groundingVerifyText = "";
+    {
+        const preText = [...exchangeLogs.values()].flat().join("\n\n");
+        if (config.runIsolatedTask &&
+            groundingVerifyEnabled() &&
+            !signal?.aborted &&
+            computeEvidenceDensity(preText) < GROUNDING_VERIFY_THRESHOLD) {
+            const gvStart = Date.now();
+            yield phaseStart({
+                phaseId: "phase:grounding-verify",
+                kind: "grounding_verify",
+                label: "Grounding verification",
+                detail: "verifying claims against evidence",
+            });
+            const gvTraces = [];
+            const gvOut = yield* tracedAsync(() => runGroundingVerify(config.runIsolatedTask, leaderModelId, spec.problemStatement, preText, (t) => gvTraces.push(t)), { phase: "research", label: "Verifying claims against evidence", role: "verify" });
+            for (const t of gvTraces)
+                yield { type: "council_status", content: t };
+            yield phaseDone({
+                phaseId: "phase:grounding-verify",
+                kind: "grounding_verify",
+                label: "Grounding verification",
+                startedAt: gvStart,
+            });
+            // Only fold in when it actually produced verified citations — appending
+            // pure [UNVERIFIED] output would LOWER density, defeating the purpose.
+            if (gvOut && countCitations(gvOut) > 0) {
+                groundingVerifyText = gvOut;
+                yield {
+                    type: "council_message",
+                    councilMessage: {
+                        kind: "research",
+                        speaker: { role: "verify", model: leaderModelId },
+                        text: gvOut,
+                    },
+                };
+            }
+        }
+    }
+    const fullExchangeText = [...exchangeLogs.values()].flat().join("\n\n") + (groundingVerifyText ? `\n\n${groundingVerifyText}` : "");
     const cumulativeDensity = computeEvidenceDensity(fullExchangeText);
     // Prefer cumulative when it exceeds the leader's last-round measurement —
     // we don't want a converged final round (which has fewer fact-claims to
     // tag) to wipe out evidence work done earlier in the debate.
     const finalEvidenceDensity = Math.max(cumulativeDensity, lastEvidenceDensity ?? 0);
+    // Count of claims participants explicitly TAGGED ([CONFIRMED]/[REFUTED]/
+    // [UNVERIFIED]) across the whole debate. Lets the confidence badge tell
+    // "measured 0% grounding" apart from "no tags emitted → not measurable"
+    // (session de4bafe5ecb7: substantive debate, zero tags → misleading 0%).
+    const finalTaggedClaims = countCitations(fullExchangeText) + countUnverified(fullExchangeText);
+    // F9 root fix — `runningSummary` is only produced as an INTER-round summary
+    // (`if (round < maxRounds)` above), so a debate that ends on its final/only
+    // round, or stops early after round 1, returns an empty summary — and the
+    // /ideal research artifacts (research.md, delegations.md) silently lose the
+    // whole debate. Generate a real closing summary from the full exchange when
+    // none exists; if there were no discussion rounds (openings-only) or the
+    // model call fails, fall back to a deterministic synthesis from the
+    // participants' positions so the returned state is never emptily summarized.
+    if (!runningSummary.trim()) {
+        const exchangeTurns = [...exchangeLogs.values()].flat();
+        if (exchangeTurns.length > 0) {
+            const closeId = "phase:summary-final";
+            const closeStart = Date.now();
+            yield phaseStart({ phaseId: closeId, kind: "summary", label: "Closing summary" });
+            try {
+                const { system, prompt } = buildRoundSummaryPrompt(exchangeTurns.slice(-6).join("\n\n"), spec.problemStatement, roundCount, debateLanguage);
+                const summaryModel = pickCouncilTaskModel("round_summary", leaderModelId, costAware);
+                runningSummary = yield* tracedGenerate(llm, {
+                    phase: "summary",
+                    label: "Summarizing the debate",
+                    modelId: costAware ? summaryModel : active[0].model,
+                    system,
+                    prompt,
+                    maxTokens: 512,
+                });
+                yield phaseDone({ phaseId: closeId, kind: "summary", label: "Closing summary", startedAt: closeStart });
+            }
+            catch {
+                yield phaseDone({
+                    phaseId: closeId,
+                    kind: "summary",
+                    label: "Closing summary",
+                    startedAt: closeStart,
+                    detail: "skipped",
+                });
+            }
+        }
+        // Deterministic backstop: openings-only debates (no exchange turns) or a
+        // failed/empty closing-summary call still yield a non-empty summary.
+        if (!runningSummary.trim()) {
+            runningSummary = resolveDebateSummary({ runningSummary, active, archive });
+        }
+    }
+    // C — the debate reached synthesis (normal completion or user-cancel fall-
+    // through), so the checkpoint is obsolete. A mid-round THROW never reaches
+    // here, leaving the checkpoint for the loop-driver retry / resume path.
+    if (config.checkpointDir) {
+        await deleteDebateCheckpoint(config.checkpointDir);
+    }
     return {
         spec,
         exchangeLogs,
@@ -984,6 +1733,12 @@ export async function* runDebate(spec, config, llm) {
         active,
         archive,
         finalEvidenceDensity,
+        finalTaggedClaims,
+        escalation,
+        // F1 — expose the last successful round's criteria alignment so the
+        // post-debate card can frame an unmet outcome as provisional. Undefined when
+        // no round eval ever produced a criteria status (card treats as all-unmet).
+        finalCriteriaMet: lastCriteriaMet.length > 0 ? lastCriteriaMet : undefined,
     };
 }
 export async function* evaluateResearchNeed(spec, leaderModelId, conversationContext, llm, costAware = false) {
@@ -1011,21 +1766,39 @@ export async function* evaluateResearchNeed(spec, leaderModelId, conversationCon
     }
     return true;
 }
-async function* evaluateDebate(spec, exchangeText, round, leaderModelId, llm, costAware = false) {
+async function* evaluateDebate(spec, exchangeText, round, leaderModelId, llm, costAware = false, 
+// When set, evaluate with this exact model instead of the cost-tier pick — used
+// by the call-site fallback loop to re-run a round eval on a healthy panel model
+// after the leader's provider rejected the eval payload (Console Go "Upstream
+// request failed" on glm/kimi; observed session dd34c59c63e9).
+modelOverride, 
+/** Feature B — resolved council debate language (undefined → English). */
+debateLanguage) {
     try {
-        const { system, prompt } = buildLeaderEvaluationPrompt({ spec, exchangeLogs: exchangeText, round });
-        const modelId = pickCouncilTaskModel("evaluate_round", leaderModelId, costAware);
+        const { system, prompt } = buildLeaderEvaluationPrompt({
+            spec,
+            exchangeLogs: exchangeText,
+            round,
+            language: debateLanguage,
+        });
+        const modelId = modelOverride ?? pickCouncilTaskModel("evaluate_round", leaderModelId, costAware);
         const raw = yield* tracedGenerate(llm, {
             phase: "evaluate",
-            label: `Leader evaluating round ${round}`,
+            label: modelOverride
+                ? `Leader evaluating round ${round} (fallback: ${modelOverride})`
+                : `Leader evaluating round ${round}`,
             modelId,
             system,
             prompt,
-            maxTokens: 1024,
+            // Raised from 1024: nextRoundFocus is now the FIRST schema field, and the
+            // whole eval is parsed by a single JSON.parse that returns null on any
+            // truncation — a tight budget could clip the JSON and null the round's
+            // outcome. 1536 keeps the focus line + criteria array intact.
+            maxTokens: 1536,
         });
-        const match = raw.match(/\{[\s\S]*\}/);
-        if (match) {
-            const parsed = JSON.parse(match[0]);
+        const jsonStr = extractEvalJson(raw);
+        if (jsonStr) {
+            const parsed = JSON.parse(jsonStr);
             const citationCount = countCitations(exchangeText);
             const evidenceDensity = computeEvidenceDensity(exchangeText);
             const disagreementResolved = citationCount;
@@ -1053,15 +1826,372 @@ async function* evaluateDebate(spec, exchangeText, round, leaderModelId, llm, co
                 evidenceDensity,
                 disagreementResolved,
                 extendRounds,
+                nextRoundFocus: typeof parsed.nextRoundFocus === "string" &&
+                    parsed.nextRoundFocus.trim()
+                    ? parsed.nextRoundFocus.trim()
+                    : undefined,
             };
         }
+        // F3a — no JSON object found in the model output. Log a diagnosable snippet
+        // (No-Silent-Catch) before falling through to null so eval-unavailable is
+        // never a black box — earlier this returned null silently and the only signal
+        // was the "evaluation unavailable" round label.
+        console.warn(`[council] round-${round} eval: no JSON object in output from ${modelOverride ?? leaderModelId} ` +
+            `(${raw.length} chars): ${raw.slice(0, 160).replace(/\s+/g, " ")}`);
     }
-    catch {
-        // Continue debate if evaluation fails
+    catch (err) {
+        // F3a — parse or generate failure. Log with context instead of swallowing:
+        // which model, which round, the message. The debate still continues (returns
+        // null → eval-unavailable), but the failure is now diagnosable remotely.
+        console.error(`[council] round-${round} eval failed on ${modelOverride ?? leaderModelId}: ${err?.message}`, { round, stack: err?.stack?.split("\n").slice(0, 3) });
     }
     return null;
 }
-function countCitations(text) {
+/**
+ * F3b — robustly extract the leader-evaluation JSON object from a model's raw
+ * output. Replaces a greedy `/\{[\s\S]*\}/` match that could swallow prose,
+ * multiple objects, or a trailing partial object into an unparseable span.
+ *
+ * Strategy: strip code fences, then brace-scan and return the LAST fully
+ * balanced top-level `{…}` object (the eval schema is emitted last, after any
+ * chain-of-thought prose). Returns null only when no balanced object exists.
+ * Deterministic, no LLM call. Braces inside string values are rare in the
+ * machine-emitted eval payload; a real tokenizer would be overkill here.
+ */
+export function extractEvalJson(raw) {
+    if (!raw)
+        return null;
+    const unfenced = raw.replace(/```(?:json)?/gi, "").replace(/```/g, "");
+    let best = null;
+    let depth = 0;
+    let start = -1;
+    for (let i = 0; i < unfenced.length; i++) {
+        const ch = unfenced[i];
+        if (ch === "{") {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (ch === "}") {
+            if (depth > 0) {
+                depth--;
+                if (depth === 0 && start >= 0)
+                    best = unfenced.slice(start, i + 1);
+            }
+        }
+    }
+    return best;
+}
+/**
+ * Format a speaker list as newline-joined "Name — lens" rows for the composing
+ * placeholder (A: live debate preview). Prefers the concrete `focus`, falls back
+ * to the one-sentence `lens`, then to bare name. Dedups identical rows so a
+ * speaker in multiple pairs renders once. Returns undefined when nothing useful
+ * is available so the UI falls back to label-only.
+ */
+/**
+ * Project a leader evaluation's `criteriaStatus` onto the PINNED spec criteria,
+ * returning a boolean[] index-aligned to `pinned` (B2/B3). The eval prompt asks
+ * for one entry per criterion in order, so index alignment is the primary path;
+ * when the model drifts (wrong count/order) we fall back to a case-insensitive
+ * substring match either direction, defaulting unmatched criteria to not-met so
+ * a hallucinated "all met" never silently marks an untouched criterion done.
+ */
+export function alignCriteriaMet(pinned, status) {
+    const aligned = status.length === pinned.length;
+    return pinned.map((crit, i) => {
+        if (aligned)
+            return status[i]?.met === true;
+        const norm = crit.trim().toLowerCase();
+        const hit = status.find((s) => {
+            const sc = (s.criterion ?? "").trim().toLowerCase();
+            return sc.length > 0 && (sc.includes(norm) || norm.includes(sc));
+        });
+        return hit?.met === true;
+    });
+}
+/**
+ * B5 leader-conductor visibility. Default ON; opt out with
+ * MUONROI_LEADER_CONDUCTOR=0 (fallback = pre-B5 behavior, no directive/verdict
+ * messages — keeps headless/legacy transcripts unchanged).
+ */
+export function leaderConductorEnabled() {
+    return process.env.MUONROI_LEADER_CONDUCTOR !== "0";
+}
+/**
+ * B4 leader auto-remedy. When pinned criteria remain unmet at the round budget's
+ * end, the leader auto-extends toward them (up to the hard ceiling) instead of
+ * stopping at the initial plan — "done = all criteria met", ceiling is a managed
+ * budget. Default ON under the conductor; opt out with
+ * MUONROI_COUNCIL_AUTO_REMEDY=0 (fallback = only leader-requested extensions).
+ */
+export function leaderAutoRemedyEnabled() {
+    return leaderConductorEnabled() && process.env.MUONROI_COUNCIL_AUTO_REMEDY !== "0";
+}
+/**
+ * #3 — grounding-verify pass. When a debate ends with weak evidence density
+ * (< GROUNDING_VERIFY_THRESHOLD, i.e. debaters barely tagged any [CONFIRMED]/
+ * [REFUTED] claims — the common case since each debater is capped at
+ * stepCountIs(2)), an isolated explore sub-agent verifies the load-bearing
+ * claims against the codebase and emits authoritative tags that raise the
+ * density metric council uses for confidence. Default ON when an isolated-task
+ * bridge is wired; opt out with MUONROI_COUNCIL_GROUNDING_VERIFY=0.
+ */
+export function groundingVerifyEnabled() {
+    return process.env.MUONROI_COUNCIL_GROUNDING_VERIFY !== "0";
+}
+/** Density below which the grounding-verify pass fires (weak grounding). */
+const GROUNDING_VERIFY_THRESHOLD = 0.3;
+/**
+ * #3 — run an isolated explore sub-agent that fact-checks the debate's
+ * load-bearing claims and emits `[CONFIRMED via file:line]` / `[REFUTED via …]`
+ * tags (the exact shape `countCitations` recognises). Returns the tagged output
+ * on success, or "" on any failure (caller only folds it in when it actually
+ * raised the citation count).
+ */
+export async function runGroundingVerify(runIsolatedTask, model, problemStatement, exchangeText, traceCb) {
+    traceCb(`[grounding-verify] isolated explore sub-agent via ${model}`);
+    const claims = exchangeText.length > 6000 ? `${exchangeText.slice(0, 6000)}\n…[truncated]` : exchangeText;
+    const prompt = `You are grounding-checking a council debate — verify its load-bearing FACTUAL claims against evidence.\n\n` +
+        `## Debate question\n${problemStatement}\n\n` +
+        `## Debaters' claims\n${claims}\n\n` +
+        `## Instructions\n` +
+        `Pick the up-to-5 most decision-relevant factual claims and check EACH against THIS repository's code ` +
+        `(grep/read files) and web sources if available. For every claim you check, emit exactly one inline tag in ` +
+        `this precise format:\n` +
+        `  [CONFIRMED via <file:line or URL>] — evidence supports the claim\n` +
+        `  [REFUTED via <file:line or URL>] — evidence contradicts the claim\n` +
+        `  [UNVERIFIED] — you genuinely could not find evidence\n` +
+        `Return a compact "## Grounding Check" list: one line per checked claim, each restating the claim in ≤15 ` +
+        `words followed by its tag. Do NOT restate the whole debate or add opinions. Prefer [CONFIRMED]/[REFUTED] ` +
+        `with a real citation over [UNVERIFIED].`;
+    try {
+        const result = await withDeadlineRace(() => runIsolatedTask({
+            agent: "explore",
+            description: `Council grounding-verify: ${problemStatement.slice(0, 50)}`,
+            prompt,
+            modelId: model,
+        }), getIsolatedTaskDeadlineMs(), "council-grounding-verify");
+        if (result.success && result.output?.trim())
+            return result.output.trim();
+        traceCb(`[grounding-verify] produced nothing: ${result.error ?? "no output"}`);
+        return "";
+    }
+    catch (err) {
+        traceCb(`[grounding-verify] threw: ${err instanceof Error ? err.message : String(err)}`);
+        return "";
+    }
+}
+/**
+ * B4: does auto-remedy want to extend the budget this round? True while pinned
+ * criteria remain unmet AND progress is still being made (a new criterion was
+ * met within the last 2 rounds). A stuck debate (roundsSinceProgress ≥ 2) returns
+ * false so the ceiling isn't burned chasing a criterion that isn't moving.
+ */
+export function autoRemedyWantsExtend(pinnedUnmet, roundsSinceProgress) {
+    return pinnedUnmet > 0 && roundsSinceProgress < 2;
+}
+/**
+ * B4: the diagnostic closing-remedy line for a debate that ended with unmet
+ * pinned criteria — distinguishes a stuck criterion (needs evidence/rescope)
+ * from a genuine ceiling hit (needs a higher budget) from an ordinary early
+ * stop, so the leader's final word is an actionable next move, not a shrug.
+ */
+export function diagnoseUnmetRemedy(opts) {
+    if (opts.stuck) {
+        return (`these made no progress across the last ${opts.roundsSinceProgress} rounds — ` +
+            `they likely need external evidence (research) or a narrower scope, not more debate.`);
+    }
+    if (opts.atCeiling) {
+        return (`the debate hit its ${opts.effectiveCeiling}-round ceiling with these open — ` +
+            `re-run with a higher round budget or split the scope.`);
+    }
+    return `re-run with an extended round budget or a narrower scope to close them.`;
+}
+/** Extra rounds a user "extend" grants — can push past effectiveCeiling, never past ABSOLUTE_MAX_ROUNDS. */
+const ESCALATION_EXTEND_ROUNDS = 2;
+/**
+ * B4 interactive escalation. When the debate is about to stop with pinned
+ * criteria unmet AND auto-remedy can't help (stuck / at ceiling), hand the
+ * decision to the user instead of silently synthesizing a partial outcome.
+ * Default ON under the conductor; opt out with MUONROI_COUNCIL_ESCALATE=0
+ * (fallback = diagnostic closing verdict only, no askcard).
+ */
+export function leaderEscalationEnabled() {
+    return leaderConductorEnabled() && process.env.MUONROI_COUNCIL_ESCALATE !== "0";
+}
+/**
+ * B4: should we interrupt to ask the user at this stop boundary? True only when
+ * pinned criteria remain unmet AND the leader can no longer self-remedy — it is
+ * stuck (no progress for ≥2 rounds) or has hit the round ceiling. While progress
+ * is still being made under the ceiling, auto-remedy handles it silently and we
+ * don't nag the user.
+ */
+export function escalationWanted(opts) {
+    return opts.pinnedUnmet > 0 && (opts.stuck || opts.atCeiling);
+}
+/**
+ * B4: the three escalation choices. When the debate is already at the absolute
+ * safety ceiling, the "extend" option degrades to a disabled-looking accept
+ * (label says so) — we never let the user push past ABSOLUTE_MAX_ROUNDS.
+ */
+export function buildEscalationOptions(unmetCount, atAbsoluteMax) {
+    const noun = `${unmetCount} unmet criteri${unmetCount === 1 ? "on" : "a"}`;
+    return [
+        atAbsoluteMax
+            ? {
+                label: "Extend (unavailable — at hard ceiling)",
+                description: `The debate already reached the ${ABSOLUTE_MAX_ROUNDS}-round safety ceiling; more rounds aren't allowed. Picking this accepts the outcome as-is.`,
+                value: "escalate_accept",
+                kind: "choice",
+            }
+            : {
+                label: `Extend ${ESCALATION_EXTEND_ROUNDS} more rounds`,
+                description: `Push past the round budget to keep working the ${noun}.`,
+                value: "escalate_extend",
+                kind: "choice",
+            },
+        {
+            label: "Accept as-is",
+            description: `Proceed to synthesis with the ${noun} noted as open.`,
+            value: "escalate_accept",
+            kind: "choice",
+        },
+        {
+            label: "Narrow the scope",
+            description: "Stop and re-scope — synthesis notes the open criteria for a narrower follow-up.",
+            value: "escalate_rescope",
+            kind: "choice",
+        },
+    ];
+}
+/**
+ * B4: emit the escalation askcard and resolve the user's choice. Yields the
+ * council_question chunk (rendered by the same consumer as clarifier/post-debate
+ * askcards), awaits the responder, echoes the choice, and returns the decision.
+ * `grantedRounds` is pre-computed here (bounded by ABSOLUTE_MAX_ROUNDS) so the
+ * caller only mutates loop state. Any unmatched / empty answer is treated as
+ * "accept" — never a silent hang.
+ */
+export async function* runEscalationPrompt(opts) {
+    const { respondToQuestion, openCriteria, pinnedUnmet, stuck, atAbsoluteMax, currentMax } = opts;
+    const noun = `${pinnedUnmet} criteri${pinnedUnmet === 1 ? "on" : "a"}`;
+    const openList = openCriteria.join("; ");
+    const questionId = randomUUID();
+    yield {
+        type: "council_question",
+        content: `**Debate stalled with ${noun} still unmet.**\n> Open: ${openList}`,
+        councilQuestion: {
+            questionId,
+            // Reuse the existing post-debate phase — same askcard renderer, no new UI.
+            phase: "post-debate",
+            question: `The debate reached its ${stuck ? "progress limit" : "round ceiling"} with ${noun} still unmet. ` +
+                `How do you want to proceed?`,
+            context: `Open criteria: ${openList}`,
+            isRequired: false,
+            options: buildEscalationOptions(pinnedUnmet, atAbsoluteMax),
+            defaultIndex: 0,
+        },
+    };
+    let answer = "";
+    try {
+        answer = (await respondToQuestion(questionId))?.trim() ?? "";
+    }
+    catch (err) {
+        // A failed responder must not hang or crash the debate — treat as accept and
+        // log so a broken UI channel is diagnosable (No-Silent-Catch).
+        console.error(`[council] escalation responder failed — accepting outcome as-is: ${err?.message}`, {
+            questionId,
+            stack: err?.stack?.split("\n").slice(0, 3),
+        });
+        answer = "";
+    }
+    if (answer === "escalate_extend" && !atAbsoluteMax) {
+        const newMax = Math.min(ABSOLUTE_MAX_ROUNDS, currentMax + ESCALATION_EXTEND_ROUNDS);
+        const grantedRounds = Math.max(0, newMax - currentMax);
+        if (grantedRounds > 0) {
+            yield {
+                type: "content",
+                content: `\n> User extended debate by ${grantedRounds} round${grantedRounds === 1 ? "" : "s"} (now ${newMax}/${ABSOLUTE_MAX_ROUNDS}) — pushing past the budget to close the open criteria.\n`,
+            };
+            return { action: "extend", grantedRounds };
+        }
+        // No headroom left even though the option showed — fall through to accept.
+    }
+    if (answer === "escalate_rescope") {
+        yield {
+            type: "content",
+            content: `\n  ↳ Narrow the scope — ending the debate; synthesis will note the open criteria for a re-scoped follow-up.\n`,
+        };
+        return { action: "rescope", grantedRounds: 0 };
+    }
+    yield {
+        type: "content",
+        content: `\n  ↳ Accepted the current outcome with ${noun} open.\n`,
+    };
+    return { action: "accept", grantedRounds: 0 };
+}
+/** One-line criterion label for directive/verdict bodies. */
+export function shortCriterion(c, max = 64) {
+    const t = c.trim().replace(/\s+/g, " ");
+    return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+}
+/**
+ * B5: build the leader's pre-round DIRECTIVE body — the round goal plus the
+ * criteria still unmet going into this round. `metSoFar` is the prior round's
+ * aligned criteriaMet (empty before round 1 → everything is unmet).
+ */
+export function buildLeaderDirective(round, criteria, metSoFar, focus) {
+    const pending = criteria.filter((_, i) => !metSoFar[i]);
+    const lines = [];
+    const trimmedFocus = focus?.trim();
+    lines.push(trimmedFocus
+        ? `Focus: ${trimmedFocus}`
+        : round === 1
+            ? "Establish concrete evidence for every outcome criterion."
+            : "Drive the remaining criteria to done.");
+    if (pending.length > 0) {
+        // One criterion per line (bulleted) rather than a single "; "-joined blob.
+        // The joined form produced a ~300-char logical line (5 criteria × ~56 chars)
+        // that word-wrapped into a dense, unreadable block overflowing the round-
+        // summary card and the leader directive bubble — the "loạn/không rõ ràng"
+        // the user reported. A vertical list reads cleanly and wraps per-criterion.
+        lines.push(`Unmet (${pending.length}/${criteria.length}):`);
+        for (const c of pending)
+            lines.push(`  • ${shortCriterion(c, 72)}`);
+    }
+    else {
+        lines.push("All criteria met so far — pressure-test the weakest before closing.");
+    }
+    return lines.join("\n");
+}
+/**
+ * B5: build the leader's post-round VERDICT body — per-criterion ✓/○ against the
+ * pinned outcome, the leader's reason, and the focus it hands to the next round.
+ */
+export function buildLeaderVerdict(criteria, met, reason, nextFocus) {
+    const metCount = met.filter(Boolean).length;
+    const lines = [`${metCount}/${criteria.length} criteria met — ${reason.trim()}`];
+    criteria.forEach((c, i) => {
+        lines.push(`${met[i] ? "✓" : "○"} ${shortCriterion(c, 56)}`);
+    });
+    const nf = nextFocus?.trim();
+    if (nf && metCount < criteria.length)
+        lines.push(`→ Next: ${nf}`);
+    return lines.join("\n");
+}
+export function formatSpeakerRoster(list) {
+    const rows = [];
+    for (const s of list) {
+        const name = s.stance?.name ?? s.model;
+        const angle = s.stance?.focus?.trim() || s.stance?.lens?.trim();
+        const row = angle ? `${name} — ${angle}` : name;
+        if (row && !rows.includes(row))
+            rows.push(row);
+    }
+    return rows.length > 0 ? rows.join("\n") : undefined;
+}
+export function countCitations(text) {
     const matches = text.match(/\[(REFUTED|CONFIRMED) via [^\]]+\]/g);
     return matches?.length ?? 0;
 }
@@ -1087,7 +2217,7 @@ function countUnverified(text) {
  * shown, low confidence is correct. This biases participants (via the
  * EVIDENCE_RULE prompt) to either verify or explicitly mark unverified.
  */
-function computeEvidenceDensity(text) {
+export function computeEvidenceDensity(text) {
     const cited = countCitations(text);
     const unverified = countUnverified(text);
     const totalTagged = cited + unverified;