muonroi-cli 1.3.4 → 1.4.1

package/dist/src/council/debate-planner.js

@@ -2,6 +2,8 @@ import { generateObject } from "ai";
 import { z } from "zod";
 import { loadKeyForProvider } from "../providers/keychain.js";
 import { createProviderFactory, detectProviderForModel, resolveModelRuntime } from "../providers/runtime.js";
+import { withDeadlineRace, withTimeoutSignal } from "../utils/llm-deadline.js";
+import { getProviderStallTimeoutMs } from "../utils/settings.js";
 import { tracedGenerate } from "./llm.js";
 import { buildDebatePlanPrompt } from "./prompts.js";
 const FALLBACK_PLAN = {
@@ -43,6 +45,32 @@ const DebatePlanSchema = z.object({
     plannedRounds: z.number().int().min(1).max(5).optional(),
 });
 // ── planDebate ────────────────────────────────────────────────────────────────
+/**
+ * Helper: for implementation_plan debates, guarantee at least one Product/User-side
+ * voice in the roster. Engineering-only rosters (Architect/Cost/Skeptic/Researcher)
+ * historically inflate scope — see session f1cec5324716 where "tạo todo app"
+ * became a multi-tenant SaaS plan. The system prompt already asks the planner to
+ * include such a stance, but we still post-check in case the planner ignored it.
+ */
+const PRODUCT_VOICE_PATTERNS = /(product\s*owner|user\s*advocate|customer|mvp\s*skeptic|user\s*proxy)/i;
+const PRODUCT_LENS_PATTERNS = /(user\s+need|scope|v1|over[-\s]?build|day\s*1|would.*pay|ship.*tomorrow)/i;
+function hasProductStance(stances) {
+    return stances.some((s) => PRODUCT_VOICE_PATTERNS.test(s.name) || PRODUCT_LENS_PATTERNS.test(s.lens));
+}
+function ensureProductStance(plan) {
+    if (plan.outputShape.kind !== "implementation_plan")
+        return plan;
+    if (hasProductStance(plan.stances))
+        return plan;
+    const productStance = {
+        name: "Product Owner",
+        lens: "What does the user actually need on day 1, and what are we over-building? " +
+            "Challenge every actionItem that doesn't directly serve the user's stated prompt; " +
+            "push enterprise/multi-tenant/scalability work to v2 unless the prompt explicitly requires it.",
+        focus: "scope discipline & MVP cut-line",
+    };
+    return { ...plan, stances: [...plan.stances, productStance] };
+}
 /** Helper: inject Experience Auditor stance into a plan, depending on mode. */
 function injectAuditorStance(plan, eeWarnings, experienceMode) {
     // CQ-14: Auto-add Experience Auditor stance when EE returns >= 1 warning and mode != off
@@ -88,8 +116,8 @@ complexityTier) {
     // Ecosystem framing — stances + output sections should center on optimal
     // use of existing BB / Muonroi.* packages, not greenfield analysis.
     try {
-        const { isEcosystemBiasEnabled, buildEcosystemDebateContext } = await import("../product-loop/discovery-ecosystem.js");
-        if (isEcosystemBiasEnabled()) {
+        const { shouldApplyEcosystemBias, buildEcosystemDebateContext } = await import("../product-loop/discovery-ecosystem.js");
+        if (shouldApplyEcosystemBias({ cwd: process.cwd() })) {
             system += `\n\n${buildEcosystemDebateContext()}`;
         }
     }
@@ -102,13 +130,18 @@ complexityTier) {
         const key = await loadKeyForProvider(providerId);
         const { factory } = createProviderFactory(providerId, { apiKey: key });
         const runtime = resolveModelRuntime(factory, leaderModelId);
-        const { object } = await generateObject({
+        // Bound attempt-1: a wedged provider response here would freeze the whole
+        // council/loop silently (no streamText stall watchdog covers generateObject).
+        // On timeout this rejects → caught below → retry (guarded) → fallback plan.
+        const { signal: timedSignal, cleanup: cleanupTimeout } = withTimeoutSignal(undefined, getProviderStallTimeoutMs());
+        const { object } = await withDeadlineRace(() => generateObject({
             model: runtime.model,
             schema: DebatePlanSchema,
             system,
             prompt,
+            abortSignal: timedSignal,
             ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
-        });
+        }), getProviderStallTimeoutMs() + 5_000, "plan_debate").finally(() => cleanupTimeout());
         // Validate with existing sanitize helpers for normalization
         const stances = sanitizeStances(object.stances);
         const outputShape = sanitizeShape(object.outputShape);
@@ -123,7 +156,7 @@ complexityTier) {
                 outputShape,
                 plannedRounds,
             };
-            return injectAuditorStance(plan, eeWarnings, experienceMode);
+            return ensureProductStance(injectAuditorStance(plan, eeWarnings, experienceMode));
         }
         // Invalid even with schema — fall through to retry with a sanitize-failure message
         throw new Error("Sanitize check failed: stances.length < 2 or outputShape is null");
@@ -145,7 +178,7 @@ complexityTier) {
             });
             const retryParsed = parsePlan(retryRaw);
             if (retryParsed)
-                return injectAuditorStance(retryParsed, eeWarnings, experienceMode);
+                return ensureProductStance(injectAuditorStance(retryParsed, eeWarnings, experienceMode));
         }
         catch (retryErr) {
             yield {
@@ -155,7 +188,7 @@ complexityTier) {
         }
     }
     // All attempts exhausted — return fallback
-    return injectAuditorStance(FALLBACK_PLAN, eeWarnings, experienceMode);
+    return ensureProductStance(injectAuditorStance(FALLBACK_PLAN, eeWarnings, experienceMode));
 }
 function parsePlan(raw) {
     try {

package/dist/src/council/debate.js

@@ -38,7 +38,7 @@ const ARCHIVE_EXCERPT_CHARS = 400;
 function makeExcerpt(text) {
     const trimmed = text.trim();
     return {
-        excerpt: trimmed.length > ARCHIVE_EXCERPT_CHARS ? trimmed.slice(0, ARCHIVE_EXCERPT_CHARS) + "…" : trimmed,
+        excerpt: trimmed.length > ARCHIVE_EXCERPT_CHARS ? `${trimmed.slice(0, ARCHIVE_EXCERPT_CHARS)}…` : trimmed,
         length: trimmed.length,
     };
 }

package/dist/src/council/decisions-lock.d.ts

@@ -0,0 +1,76 @@
+/**
+ * src/council/decisions-lock.ts
+ *
+ * C2: Persist council_summary decisions to .planning/runs/<runId>/decisions.lock.md
+ * after council synthesis, and read them back in sprint-runner before implementation.
+ *
+ * The lock file is pure string formatting — no LLM calls are made here.
+ * Values come from the structured councilSummary artifact + ClarifiedSpec.
+ */
+import type { ClarifiedSpec, DebateStance } from "./types.js";
+export interface DecisionsLockInput {
+    runId: string;
+    /** The run directory, typically <flowDir>/runs/<runId> */
+    runDir: string;
+    spec: ClarifiedSpec;
+    /** ISO timestamp from the synthesis step */
+    timestamp: string;
+    /** Final positions array from debateState.active */
+    participants: Array<{
+        role: string;
+        stance?: DebateStance;
+        position: string;
+    }>;
+    /** Readable summary from the synthesizer */
+    synthesisExcerpt: string;
+    /**
+     * If the Leader flagged any out-of-stack proposals, list them here
+     * so they appear in the REJECTED section of the lock file.
+     */
+    rejectedProposals?: string[];
+}
+/**
+ * Extract stack-related values from the ClarifiedSpec constraints + scope
+ * as well as free-text analysis. Returns null when stack is genuinely unknown
+ * (greenfield / no scaffold chosen yet).
+ */
+export interface ExtractedStack {
+    backend: string | null;
+    frontend: string | null;
+    database: string | null;
+    license: string | null;
+}
+export declare function extractStackFromSpec(spec: ClarifiedSpec): ExtractedStack | null;
+/**
+ * Build the STACK LOCK section for council system prompts.
+ *
+ * Returns an empty string when the spec has no committed scaffold target
+ * (greenfield — no lock should be injected).
+ *
+ * The returned text is pre-formatted for inclusion directly inside a system
+ * prompt. It is intentionally verbose/assertive so the model treats the
+ * constraints as hard rails, not suggestions.
+ */
+export declare function buildStackLockSection(spec: ClarifiedSpec): string;
+export declare function detectOutOfStackProposals(synthesisText: string, spec: ClarifiedSpec): string[];
+/**
+ * Render the decisions.lock.md content from structured inputs.
+ * Pure string formatting — no I/O or LLM calls.
+ */
+export declare function renderDecisionsLock(input: DecisionsLockInput): string;
+/**
+ * Write decisions.lock.md to the run directory.
+ * Fails gracefully — returns false on error, true on success.
+ * Caller (council index) is responsible for error logging.
+ */
+export declare function writeDecisionsLock(input: DecisionsLockInput): Promise<boolean>;
+/**
+ * Read decisions.lock.md from the run directory.
+ * Returns null when the file does not exist (no lock file = no-op pass-through).
+ */
+export declare function readDecisionsLock(runDir: string): Promise<string | null>;
+/**
+ * Prepend the decisions lock content to an implementation prompt.
+ * Returns the original prompt unchanged if lockContent is null/empty.
+ */
+export declare function prependDecisionsLock(prompt: string, lockContent: string | null): string;

package/dist/src/council/decisions-lock.js

@@ -0,0 +1,239 @@
+/**
+ * src/council/decisions-lock.ts
+ *
+ * C2: Persist council_summary decisions to .planning/runs/<runId>/decisions.lock.md
+ * after council synthesis, and read them back in sprint-runner before implementation.
+ *
+ * The lock file is pure string formatting — no LLM calls are made here.
+ * Values come from the structured councilSummary artifact + ClarifiedSpec.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { atomicWriteText } from "../storage/atomic-io.js";
+// ── Stack lock extraction helpers ─────────────────────────────────────────────
+/**
+ * Known stack values that indicate a committed scaffold target.
+ * Extend as new scaffold frameworks are added.
+ */
+const BB_BACKEND_KEYWORDS = ["muonroi", "basetemplate", "base-template", "building-block", "bb"];
+const REACT_FE_KEYWORDS = ["react", "vite-react"];
+function _isCommittedBackend(val) {
+    if (!val)
+        return false;
+    const lower = val.toLowerCase();
+    return BB_BACKEND_KEYWORDS.some((kw) => lower.includes(kw));
+}
+function _isCommittedFrontend(val) {
+    if (!val)
+        return false;
+    const lower = val.toLowerCase();
+    return REACT_FE_KEYWORDS.some((kw) => lower.includes(kw));
+}
+export function extractStackFromSpec(spec) {
+    const all = [spec.problemStatement, ...spec.constraints, spec.scope].filter(Boolean).join(" ").toLowerCase();
+    const backendMatch = all.includes("muonroi.basetemplate") ||
+        all.includes("muonroi basetemplate") ||
+        all.includes("basetemplate") ||
+        all.includes("building-block") ||
+        all.includes("mediatр") ||
+        all.includes("mediatр")
+        ? "Muonroi.BaseTemplate (.NET 9, CQRS/MediatR, MEntity/MRepository pattern)"
+        : null;
+    const frontendMatch = all.includes("react") && (all.includes("vite") || all.includes("css module"))
+        ? "React 18 + Vite + plain CSS modules (NO shadcn, NO Radix, NO Tailwind unless explicitly listed)"
+        : all.includes("react")
+            ? "React 18"
+            : null;
+    const dbMatch = all.includes("postgresql") || all.includes("postgres")
+        ? "PostgreSQL"
+        : all.includes("sqlite")
+            ? "SQLite (default, PostgreSQL upgrade path)"
+            : null;
+    const licenseMatch = all.includes("muonroi") ? "Muonroi commercial license required" : null;
+    // Only return a non-null ExtractedStack when at least one field is committed.
+    if (!backendMatch && !frontendMatch && !dbMatch && !licenseMatch)
+        return null;
+    return {
+        backend: backendMatch,
+        frontend: frontendMatch,
+        database: dbMatch,
+        license: licenseMatch,
+    };
+}
+// ── STACK LOCK section builder (C1) ───────────────────────────────────────────
+/**
+ * Build the STACK LOCK section for council system prompts.
+ *
+ * Returns an empty string when the spec has no committed scaffold target
+ * (greenfield — no lock should be injected).
+ *
+ * The returned text is pre-formatted for inclusion directly inside a system
+ * prompt. It is intentionally verbose/assertive so the model treats the
+ * constraints as hard rails, not suggestions.
+ */
+export function buildStackLockSection(spec) {
+    const stack = extractStackFromSpec(spec);
+    if (!stack)
+        return "";
+    const lines = ["## STACK LOCK (NON-NEGOTIABLE)"];
+    if (stack.backend) {
+        lines.push(`- Backend: ${stack.backend}`);
+    }
+    if (stack.frontend) {
+        lines.push(`- Frontend: ${stack.frontend}`);
+    }
+    if (stack.database) {
+        lines.push(`- Database: ${stack.database}`);
+    }
+    if (stack.license) {
+        lines.push(`- License: ${stack.license}`);
+    }
+    lines.push("", "Your debate MUST stay within this stack. You may discuss tradeoffs WITHIN the locked stack " +
+        "(e.g. which BB modules to enable, .NET 9 vs .NET 8 within Muonroi compatibility) " +
+        "but you MUST NOT propose alternative frameworks. " +
+        'Proposals like "use Next.js" or "use shadcn" are out of scope — ' +
+        "flag them as scope violations and redirect.", "");
+    return lines.join("\n");
+}
+// ── Out-of-stack detector for Leader synthesis ─────────────────────────────────
+/**
+ * Scan the synthesis text for mentions of out-of-stack technologies.
+ * Returns the list of flagged tech names found in the synthesis.
+ * Used by Leader synthesis check to mark consensus as partial when drift occurs.
+ *
+ * Only runs when a committed stack exists in the spec.
+ */
+const OUT_OF_STACK_PATTERNS = [
+    { pattern: /\bnext\.?js\b/i, name: "Next.js" },
+    { pattern: /\bshadcn\b/i, name: "shadcn" },
+    { pattern: /\bradix[\s-]ui\b/i, name: "Radix UI" },
+    { pattern: /\btailwind(css)?\b/i, name: "Tailwind CSS" },
+    { pattern: /\bnestjs\b|\bnest\.js\b/i, name: "NestJS" },
+    { pattern: /\bexpress\.?js\b|\bexpress\s+framework\b/i, name: "Express.js" },
+    { pattern: /\bdjango\b/i, name: "Django" },
+    { pattern: /\bruby on rails\b|\brails\b/i, name: "Ruby on Rails" },
+    { pattern: /\blaravel\b/i, name: "Laravel" },
+    { pattern: /\bspring boot\b/i, name: "Spring Boot" },
+];
+export function detectOutOfStackProposals(synthesisText, spec) {
+    const stack = extractStackFromSpec(spec);
+    if (!stack)
+        return []; // No committed stack — nothing to enforce
+    const found = [];
+    for (const { pattern, name } of OUT_OF_STACK_PATTERNS) {
+        if (pattern.test(synthesisText)) {
+            found.push(name);
+        }
+    }
+    return found;
+}
+// ── C2: Write decisions.lock.md ───────────────────────────────────────────────
+/**
+ * Render the decisions.lock.md content from structured inputs.
+ * Pure string formatting — no I/O or LLM calls.
+ */
+export function renderDecisionsLock(input) {
+    const stack = extractStackFromSpec(input.spec);
+    const stackSection = stack
+        ? [
+            "## Stack",
+            stack.backend ? `- Backend: ${stack.backend}` : null,
+            stack.frontend ? `- Frontend: ${stack.frontend}` : null,
+            stack.database ? `- Database: ${stack.database}` : null,
+            stack.license ? `- License: ${stack.license}` : null,
+        ]
+            .filter((l) => l !== null)
+            .join("\n")
+        : "## Stack\n_(Greenfield — no scaffold target committed)_";
+    // Architecture decisions from synthesis excerpt
+    const archSection = input.synthesisExcerpt.trim()
+        ? `## Architecture Decisions\n${input.synthesisExcerpt
+            .split(/\n+/)
+            .filter((l) => l.trim().length > 0)
+            .slice(0, 10)
+            .map((l) => (l.startsWith("-") ? l : `- ${l}`))
+            .join("\n")}`
+        : "## Architecture Decisions\n_(No synthesis excerpt provided)_";
+    // Per-role sections
+    const costController = input.participants.find((p) => p.role === "verify" || p.stance?.name?.toLowerCase().includes("cost"));
+    const skeptic = input.participants.find((p) => p.stance?.name?.toLowerCase().includes("skeptic") || p.stance?.name?.toLowerCase().includes("risk"));
+    const architect = input.participants.find((p) => p.role === "implement" || p.stance?.name?.toLowerCase().includes("architect"));
+    function roleSection(heading, p) {
+        if (!p?.position?.trim()) {
+            return `## ${heading}\n_(No position recorded)_`;
+        }
+        const bullets = p.position
+            .split(/\n+/)
+            .filter((l) => l.trim().length > 0)
+            .slice(0, 5)
+            .map((l) => (l.startsWith("-") ? l : `- ${l}`))
+            .join("\n");
+        return `## ${heading}\n${bullets}`;
+    }
+    const rejectedSection = input.rejectedProposals && input.rejectedProposals.length > 0
+        ? `## Out-of-stack proposals (REJECTED)\n${input.rejectedProposals.map((r) => `- ${r}`).join("\n")}`
+        : "## Out-of-stack proposals (REJECTED)\n_(None flagged)_";
+    return [
+        `# Locked Decisions — Run ${input.runId}`,
+        `> Generated from council_summary at ${input.timestamp}`,
+        "",
+        stackSection,
+        "",
+        archSection,
+        "",
+        roleSection("Tradeoffs (Cost-Controller)", costController),
+        "",
+        roleSection("Risks (Skeptic)", skeptic),
+        "",
+        roleSection("Architecture (Architect)", architect),
+        "",
+        rejectedSection,
+        "",
+    ].join("\n");
+}
+/**
+ * Write decisions.lock.md to the run directory.
+ * Fails gracefully — returns false on error, true on success.
+ * Caller (council index) is responsible for error logging.
+ */
+export async function writeDecisionsLock(input) {
+    try {
+        const content = renderDecisionsLock(input);
+        const filePath = path.join(input.runDir, "decisions.lock.md");
+        await atomicWriteText(filePath, content);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── C2: Read decisions.lock.md ────────────────────────────────────────────────
+/**
+ * Read decisions.lock.md from the run directory.
+ * Returns null when the file does not exist (no lock file = no-op pass-through).
+ */
+export async function readDecisionsLock(runDir) {
+    const filePath = path.join(runDir, "decisions.lock.md");
+    try {
+        return await fs.promises.readFile(filePath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        return null; // Fail-open — missing lock file is not an error
+    }
+}
+/**
+ * Prepend the decisions lock content to an implementation prompt.
+ * Returns the original prompt unchanged if lockContent is null/empty.
+ */
+export function prependDecisionsLock(prompt, lockContent) {
+    if (!lockContent?.trim())
+        return prompt;
+    return (`## Locked decisions you MUST follow\n\n` +
+        `${lockContent.trim()}\n\n` +
+        `---\n\n` +
+        `## Sprint task\n\n` +
+        `${prompt}`);
+}
+//# sourceMappingURL=decisions-lock.js.map

package/dist/src/council/index.d.ts

@@ -9,6 +9,11 @@ export interface RunCouncilOptions {
     cwd?: string;
     /** Shared stats object from orchestrator — when provided, runCouncil uses it instead of a local one so stats.calls is accurate (Phase 14 CQ-01). */
     councilStats?: CouncilStats;
+    /**
+     * C2: Run directory for writing decisions.lock.md after synthesis.
+     * Typically <flowDir>/runs/<runId>. When absent the lock file is skipped.
+     */
+    runDir?: string;
 }
 export declare function runCouncil(topic: string, sessionModelId: string, messages: Array<{
     role: string;

package/dist/src/council/index.js

@@ -9,6 +9,7 @@ import { buildSpecFromTopic, runClarification } from "./clarifier.js";
 import { buildCouncilContext, buildProjectSnapshot } from "./context.js";
 import { evaluateResearchNeed, runDebate } from "./debate.js";
 import { planDebate } from "./debate-planner.js";
+import { detectOutOfStackProposals, writeDecisionsLock } from "./decisions-lock.js";
 import { runExecution } from "./executor.js";
 import { resolveLeaderModelDetailed, resolveParticipants } from "./leader.js";
 import { phaseDone, phaseStart } from "./phase-events.js";
@@ -367,8 +368,8 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
             });
             if (!hasPlan && !synthesisFailed) {
                 baseOptions.push({
-                    label: "Generate Action Plan",
-                    description: "Create a detailed implementation plan from the debate outcome",
+                    label: "Lock plan and execute Sprint 1",
+                    description: "Commit the council outcome as the sprint plan and hand control to the sprint runner (planning → implementation → verification → judgment). Does NOT exit to /gsd.",
                     value: "generate_plan",
                     kind: "choice",
                 });
@@ -464,14 +465,15 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
                 synthesisText = refineResult.value.synthesisText;
             }
             else if (answer === "generate_plan") {
-                // P7: skip re-synthesis when the first synthesis already produced
-                // structured action items. Session 1a8fb4be3bc3 showed the first
-                // synthesis under implementation_plan shape emits a full
-                // sections.actionItems objectList (11 entries with owner / time /
-                // depends_on), but clicking generate_plan still re-ran the entire
-                // synthesizer to produce a near-identical second copy — ~128s
-                // wasted. If actionItems already exist with ≥3 entries, lift them
-                // into plan.steps directly and skip the re-run.
+                // A1 FIX: "Lock plan and execute Sprint 1" — stay within sprint-runner.
+                //
+                // Previously this branch called runExecution(plan, processMessageFn) which
+                // bypassed sprint-runner's verification/judgment/done-gate stages entirely.
+                // The correct behavior: synthesize the plan (if not already done), then
+                // return synthesisText to the sprint-runner caller so it can proceed with
+                // Step 4 (implementation), Step 5 (verification), Step 6 (judgment), etc.
+                //
+                // P7 optimization: skip re-synthesis when action items already exist.
                 const existingActionItems = pickActionItemsFromOutcome(outcome);
                 if (existingActionItems.length >= 3) {
                     const synthesizedPlan = synthesizePlanFromActionItems(existingActionItems);
@@ -482,16 +484,17 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
                     }
                     yield {
                         type: "content",
-                        content: `\n> Plan reused: ${existingActionItems.length} action items already present in the synthesis above — ` +
-                            `lifted into the executable plan without re-running the synthesizer (~${SYNTH_RERUN_COST_SECONDS}s saved).\n`,
+                        content: `\n> Plan locked: ${existingActionItems.length} action items committed — ` +
+                            `sprint runner will execute planning → implementation → verification → judgment.\n`,
                     };
-                    yield { type: "content", content: "\n### Action Plan (from synthesis)\n" };
-                    for (const step of synthesizedPlan.steps) {
-                        yield { type: "content", content: `- [${step.priority}] ${step.description}\n` };
-                    }
+                    // Serialize the plan steps into synthesisText so sprint-runner's
+                    // processMessageFn receives a human-readable implementation prompt.
+                    synthesisText =
+                        `Sprint plan locked (${existingActionItems.length} steps):\n` +
+                            synthesizedPlan.steps.map((s) => `- [${s.priority}] ${s.description}`).join("\n");
                 }
                 else {
-                    yield { type: "content", content: "\n> Re-running planning with action plan focus...\n" };
+                    yield { type: "content", content: "\n> Synthesizing sprint plan...\n" };
                     const refineGen = runPlanning(debateState, spec, debateState.active, leaderModelId, respondToPreflight, llm, debatePlan, pilCtx?.outputStyle ?? undefined, undefined, true);
                     // biome-ignore lint/suspicious/noImplicitAnyLet: shape inferred from runPlanning generator
                     let refineResult;
@@ -503,7 +506,16 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
                     outcome = refineResult.value.outcome;
                     plan = refineResult.value.plan;
                     synthesisText = refineResult.value.synthesisText;
+                    yield {
+                        type: "content",
+                        content: "\n> Plan locked — sprint runner will execute planning → implementation → verification → judgment.\n",
+                    };
                 }
+                // Do NOT call runExecution here. Return synthesisText to the sprint-runner
+                // caller so it drives the full sprint lifecycle (Step 4–8 in sprint-runner.ts).
+                // Clear plan so Phase E's runExecution guard below does not fire — the plan
+                // content has already been serialized into synthesisText above.
+                plan = null;
             }
             else if (answer === "refine" && hasEmptySections) {
                 yield { type: "content", content: "\n> Let's clarify the unresolved aspects...\n" };
@@ -614,6 +626,26 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
                     agreedCount: outcome?.agreed?.length ?? 0,
                 },
             });
+            // C2: Persist decisions.lock.md to the run directory so sprint-runner
+            // can inject locked decisions into the implementation prompt.
+            if (options?.runDir) {
+                const rejectedProposals = detectOutOfStackProposals(synthesisText, spec);
+                await writeDecisionsLock({
+                    runId: sessionId,
+                    runDir: options.runDir,
+                    spec,
+                    timestamp: new Date().toISOString(),
+                    participants: debateState.active.map((a) => ({
+                        role: a.role,
+                        stance: a.stance,
+                        position: a.position,
+                    })),
+                    synthesisExcerpt: synthesisText.slice(0, 2000),
+                    rejectedProposals: rejectedProposals.length > 0 ? rejectedProposals : undefined,
+                }).catch(() => {
+                    /* non-critical — lock file write failure must never break the council */
+                });
+            }
         }
         catch {
             /* non-critical */
@@ -677,7 +709,7 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
 // identical second copy — ~128s wasted. These helpers lift existing action
 // items into an ActionPlan locally instead of re-running synthesis.
 /** Rough cost (seconds) of a re-synthesis call. Used in the UX note. */
-const SYNTH_RERUN_COST_SECONDS = 120;
+const _SYNTH_RERUN_COST_SECONDS = 120;
 /**
  * Extract action items from an outcome regardless of which shape produced
  * them. Order of precedence:

package/dist/src/council/leader.d.ts

@@ -7,7 +7,7 @@ import { type ModelRole } from "../utils/settings.js";
  * Keep this table in one place — it's the policy. Anything not listed here
  * MUST keep using the leader model (final synthesis, debate planning).
  */
-export type CouncilSubTask = "research_need" | "evaluate_round" | "round_summary" | "clarify_questions" | "spec_synthesis";
+export type CouncilSubTask = "research_need" | "evaluate_round" | "round_summary" | "clarify_questions" | "spec_synthesis" | "readiness_judge" | "effort_estimate" | "sprint_goal" | "reporter_qa" | "maintain_design" | "maintain_review" | "pr_body";
 /**
  * Pick a cheaper model for a council sub-task on the leader's provider,
  * with fallback to the leader model itself when no cheaper model is

package/dist/src/council/leader.js

@@ -13,6 +13,13 @@ const SUB_TASK_TIER = {
     round_summary: "fast",
     clarify_questions: "balanced",
     spec_synthesis: "balanced",
+    readiness_judge: "balanced",
+    effort_estimate: "fast",
+    sprint_goal: "fast",
+    reporter_qa: "fast",
+    maintain_design: "balanced",
+    maintain_review: "fast",
+    pr_body: "fast",
 };
 /**
  * Pick a cheaper model for a council sub-task on the leader's provider,
@@ -37,7 +44,13 @@ export function pickCouncilTaskModel(task, leaderModelId, costAware) {
     if (leaderTier && TIER_RANK[leaderTier] <= TIER_RANK[targetTier]) {
         return leaderModelId;
     }
-    const leaderProvider = detectProviderForModel(leaderModelId);
+    let leaderProvider;
+    try {
+        leaderProvider = detectProviderForModel(leaderModelId);
+    }
+    catch {
+        return leaderModelId;
+    }
     const candidate = getModelByTier(targetTier, leaderProvider);
     // Only accept a candidate that's on the same provider as the leader.
     // getModelByTier may fall back to "any provider" — reject that to avoid