muonroi-cli 1.3.4 → 1.4.1

package/dist/src/council/llm.js

@@ -3,11 +3,13 @@ import { generateText, stepCountIs } from "ai";
 import { getDefaultEEClient } from "../ee/intercept.js";
 import { emitMatches } from "../ee/render.js";
 import { buildMcpToolSet } from "../mcp/runtime.js";
+import { getProviderCapabilities } from "../providers/capabilities.js";
 import { loadKeyForProvider } from "../providers/keychain.js";
 import { createProviderFactory, detectProviderForModel, resolveModelRuntime } from "../providers/runtime.js";
 import { createBuiltinTools as createTools } from "../tools/registry.js";
 import { appendCostLog } from "../usage/cost-log.js";
 import { projectCostUSD } from "../usage/estimator.js";
+import { withDeadlineRace, withTimeoutSignal } from "../utils/llm-deadline.js";
 import { loadMcpServers } from "../utils/settings.js";
 import { withVisibleRetry } from "../utils/visible-retry.js";
 import { buildResearchSystemPrompt } from "./prompts.js";
@@ -20,7 +22,7 @@ function writeDebugRecord(rec) {
     if (!path)
         return;
     try {
-        fs.appendFileSync(path, JSON.stringify(rec) + "\n", "utf-8");
+        fs.appendFileSync(path, `${JSON.stringify(rec)}\n`, "utf-8");
     }
     catch {
         // Logging must never break the council run.
@@ -28,13 +30,13 @@ function writeDebugRecord(rec) {
 }
 function head(s, n = 300) {
     const str = typeof s === "string" ? s : s == null ? "" : String(s);
-    return str.length > n ? str.slice(0, n) + "…" : str;
+    return str.length > n ? `${str.slice(0, n)}…` : str;
 }
 // ── Tool trace helpers (CQ-22) ────────────────────────────────────────────────
 const TRACE_ARG_LIMIT = 2048;
 function truncate(value) {
     const s = typeof value === "string" ? value : (JSON.stringify(value) ?? "");
-    return s.length > TRACE_ARG_LIMIT ? s.slice(0, TRACE_ARG_LIMIT) + "…[truncated]" : s;
+    return s.length > TRACE_ARG_LIMIT ? `${s.slice(0, TRACE_ARG_LIMIT)}…[truncated]` : s;
 }
 function emitToolTrace(toolName, args, result, persistTrace) {
     if (!persistTrace)
@@ -73,7 +75,7 @@ function capToolResult(result) {
         return {
             _truncated: true,
             _originalSize: serialized.length,
-            preview: serialized.slice(0, TOOL_RESULT_CAP_CHARS) + "…",
+            preview: `${serialized.slice(0, TOOL_RESULT_CAP_CHARS)}…`,
         };
     }
     catch {
@@ -177,62 +179,9 @@ const COUNCIL_LLM_TIMEOUT_MS = (() => {
         return raw;
     return 300_000;
 })();
-/**
- * Combine an optional parent AbortSignal with a wall-clock deadline. Returns
- * the merged signal plus a `cleanup` thunk the caller must invoke once the
- * underlying request settles so the timeout timer doesn't keep the process
- * alive past the call.
- */
-function withTimeoutSignal(parent, timeoutMs) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => {
-        controller.abort(new Error(`council LLM call exceeded ${timeoutMs}ms deadline (timeout)`));
-    }, timeoutMs);
-    let parentListener = null;
-    if (parent) {
-        if (parent.aborted) {
-            clearTimeout(timer);
-            controller.abort(parent.reason);
-        }
-        else {
-            parentListener = () => controller.abort(parent.reason);
-            parent.addEventListener("abort", parentListener, { once: true });
-        }
-    }
-    return {
-        signal: controller.signal,
-        cleanup: () => {
-            clearTimeout(timer);
-            if (parent && parentListener)
-                parent.removeEventListener("abort", parentListener);
-        },
-    };
-}
-/**
- * Race a promise against a wall-clock deadline. AI SDK occasionally fails to
- * honour `abortSignal` mid-tool-execution (observed: deepseek-v4-flash with
- * MCP verification tools sitting on a stuck firecrawl HTTP request, the
- * controller.abort fires but generateText keeps awaiting the tool result).
- * This race guarantees the surrounding code receives an Error within
- * `deadlineMs`, regardless of what the SDK does internally. The in-flight
- * request is still aborted via `controller.abort` for cleanup; this layer
- * just ensures the caller is not blocked past the deadline.
- */
-async function withDeadlineRace(fn, deadlineMs, label) {
-    let timer = null;
-    const deadline = new Promise((_, reject) => {
-        timer = setTimeout(() => {
-            reject(new Error(`${label} exceeded ${deadlineMs}ms deadline (timeout)`));
-        }, deadlineMs);
-    });
-    try {
-        return await Promise.race([fn(), deadline]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
+// withTimeoutSignal + withDeadlineRace moved to ../utils/llm-deadline.js so all
+// pre-flight LLM call sites (council, debate-planner, scope-ceiling) share one
+// implementation. Imported at the top of this file.
 export function createCouncilLLM(bash, mode, sessionId, stats) {
     return {
         async generate(modelId, system, prompt, maxTokens = 4096, onUsage) {
@@ -366,6 +315,10 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
                     /* fail-open: no tools */
                 }
             }
+            // sanitizeHistory is identity for every provider (kept as a hook for
+            // future provider-specific quirks). Reasoning round-trips natively —
+            // see src/providers/__tests__/reasoning-roundtrip.test.ts.
+            const debateCaps = getProviderCapabilities(providerId);
             const t0 = Date.now();
             const { signal: timedSignal, cleanup: cleanupTimeout } = withTimeoutSignal(signal, COUNCIL_LLM_TIMEOUT_MS);
             try {
@@ -374,7 +327,16 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
                     system,
                     prompt,
                     ...(verificationTools && Object.keys(verificationTools).length > 0
-                        ? { tools: verificationTools, stopWhen: stepCountIs(2) }
+                        ? {
+                            tools: verificationTools,
+                            stopWhen: stepCountIs(2),
+                            prepareStep: ({ stepNumber, messages }) => {
+                                if (stepNumber < 1)
+                                    return {};
+                                const stripped = debateCaps.sanitizeHistory(messages);
+                                return stripped === messages ? {} : { messages: stripped };
+                            },
+                        }
                         : {}),
                     // Reasoning models (deepseek-v4-*, anthropic thinking) consume part
                     // of this budget on reasoning_tokens before producing user-visible
@@ -496,6 +458,10 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
             const userPrompt = conversationContext
                 ? `## Context\n${conversationContext}\n\n---\n\n## Research Topic\n${topic}\n\nInvestigate and report findings.`
                 : `## Research Topic\n${topic}\n\nInvestigate and report findings.`;
+            // sanitizeHistory hook (identity today) preserved for symmetry with
+            // debate(). Reasoning round-trips natively across all 15 chained tool
+            // steps — see src/providers/__tests__/reasoning-roundtrip.test.ts.
+            const researchCaps = getProviderCapabilities(providerId);
             const t0 = Date.now();
             // Research is multi-step tool-using so give it 2x the standard deadline.
             const researchTimeoutMs = Math.min(COUNCIL_LLM_TIMEOUT_MS * 2, 1_800_000);
@@ -507,6 +473,12 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
                     prompt: userPrompt,
                     tools: allTools,
                     stopWhen: stepCountIs(15),
+                    prepareStep: ({ stepNumber, messages }) => {
+                        if (stepNumber < 1)
+                            return {};
+                        const stripped = researchCaps.sanitizeHistory(messages);
+                        return stripped === messages ? {} : { messages: stripped };
+                    },
                     maxOutputTokens: 4096,
                     temperature: 0.3,
                     // Visible retry (src/utils/visible-retry.ts) replaces SDK's silent

package/dist/src/council/phase-events.d.ts

@@ -9,6 +9,11 @@ export declare function phaseStart(opts: {
     kind: CouncilPhaseKind;
     label: string;
     detail?: string;
+    /**
+     * Override for the start timestamp. Defaults to Date.now(). Tests pass an
+     * explicit value to keep the chunk deterministic; production callers omit.
+     */
+    startedAt?: number;
 }): StreamChunk;
 export declare function phaseDone(opts: {
     phaseId: string;

package/dist/src/council/phase-events.js

@@ -12,6 +12,7 @@ export function phaseStart(opts) {
         state: "active",
         label: opts.label,
         detail: opts.detail,
+        startedAt: opts.startedAt ?? Date.now(),
     });
 }
 export function phaseDone(opts) {

package/dist/src/council/planner.js

@@ -186,7 +186,7 @@ function shapeFallback(synthesisText, debatePlan) {
         let found = false;
         for (const line of synthesisText.split("\n")) {
             const trimmed = line.trim();
-            if (trimmed.match(new RegExp("^#{1,3}s+" + heading.replace(/\s+/g, "s+"), "i"))) {
+            if (trimmed.match(new RegExp(`^#{1,3}s+${heading.replace(/\s+/g, "s+")}`, "i"))) {
                 found = true;
                 continue;
             }

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

@@ -13,6 +13,30 @@ export declare function buildSpecSynthesisPrompt(topic: string, conversationCont
     system: string;
     prompt: string;
 };
+/**
+ * Build system + prompt for the ready-gate judge.
+ *
+ * The judge receives the topic, all Q&A so far, and the current partial spec,
+ * then decides whether enough context exists to start a productive debate or
+ * whether there are still critical gaps.
+ *
+ * Output shape: { ready: boolean, confidence: number, gaps: string[] }
+ *   - ready: true when a debate can start without blind spots
+ *   - confidence: 0.0–1.0 (1.0 = judge is certain, 0.0 = major unknowns)
+ *   - gaps: 1-line descriptions of WHAT is still missing (empty when ready)
+ */
+export declare function buildReadinessJudgePrompt(topic: string, qa: Array<{
+    question: string;
+    answer: string;
+}>, spec: {
+    problemStatement: string;
+    constraints: string[];
+    successCriteria: string[];
+    scope: string;
+}): {
+    system: string;
+    prompt: string;
+};
 export declare function buildOpeningPrompt(ctx: {
     speakerRole: string;
     partnerRole: string;

package/dist/src/council/prompts.js

@@ -1,3 +1,4 @@
+import { buildStackLockSection } from "./decisions-lock.js";
 // ── Clarification prompts ────────────────────────────────────────────────────
 export function buildClarificationPrompt(topic, conversationContext, previousQA) {
     const qaSection = previousQA?.length
@@ -55,6 +56,50 @@ export function buildSpecSynthesisPrompt(topic, conversationContext, qa) {
             `## Clarification Q&A\n${qa.map((qa) => `Q: ${qa.question}\nA: ${qa.answer}`).join("\n\n")}`,
     };
 }
+// ── P5: Readiness judge prompt ───────────────────────────────────────────────
+/**
+ * Build system + prompt for the ready-gate judge.
+ *
+ * The judge receives the topic, all Q&A so far, and the current partial spec,
+ * then decides whether enough context exists to start a productive debate or
+ * whether there are still critical gaps.
+ *
+ * Output shape: { ready: boolean, confidence: number, gaps: string[] }
+ *   - ready: true when a debate can start without blind spots
+ *   - confidence: 0.0–1.0 (1.0 = judge is certain, 0.0 = major unknowns)
+ *   - gaps: 1-line descriptions of WHAT is still missing (empty when ready)
+ */
+export function buildReadinessJudgePrompt(topic, qa, spec) {
+    return {
+        system: `You are a senior debate facilitator deciding whether a clarification session has collected ` +
+            `enough context for a productive multi-expert debate.\n\n` +
+            `A debate can start when ALL of the following are true:\n` +
+            `1. The problem statement is specific enough that experts won't derail into "what are we solving?"\n` +
+            `2. At least one success criterion is measurable/observable.\n` +
+            `3. Any hard constraints (platform, budget, tech stack) are either stated or provably irrelevant.\n` +
+            `4. Scope boundaries are clear enough that debate stays focused.\n\n` +
+            `Output ONLY a JSON object (no markdown, no preamble):\n` +
+            `{ "ready": true|false, "confidence": 0.0-1.0, "gaps": ["gap 1", "gap 2"] }\n\n` +
+            `Rules:\n` +
+            `- "gaps" MUST be empty when "ready" is true.\n` +
+            `- Each gap is a single sentence starting with a noun: what info is missing (not a question).\n` +
+            `  Example: "Target platform (web, mobile, or both) not specified."\n` +
+            `- "confidence" reflects how sure you are; a ready=true with confidence=0.6 means "probably " +\n` +
+            `  "ready but some ambiguity remains". confidence=1.0 means zero remaining blind spots.\n` +
+            `- When the topic is a simple one-answer technical question (no design/scope), set ready=true, ` +
+            `  confidence=1.0, gaps=[].`,
+        prompt: `## Topic\n${topic}\n\n` +
+            `## Current Spec\n` +
+            `Problem: ${spec.problemStatement}\n` +
+            `Constraints: ${spec.constraints.length > 0 ? spec.constraints.join("; ") : "(none)"}\n` +
+            `Success Criteria: ${spec.successCriteria.join("; ")}\n` +
+            `Scope: ${spec.scope || "(unspecified)"}\n\n` +
+            (qa.length > 0
+                ? `## Clarification Q&A So Far\n${qa.map((item) => `Q: ${item.question}\nA: ${item.answer}`).join("\n\n")}\n\n`
+                : "## Clarification Q&A So Far\n(none — topic only)\n\n") +
+            `Is this sufficient to start a focused, productive debate? Respond with JSON only.`,
+    };
+}
 // ── Debate prompts ───────────────────────────────────────────────────────────
 /**
  * Hard-language rule injected into every internal debate/evaluation/summary
@@ -122,12 +167,14 @@ export function buildOpeningPrompt(ctx) {
         ? `\nGuardrails for this discussion:\n${ctx.outputShape.guardrails.map((g) => `- ${g}`).join("\n")}\n`
         : "";
     const focusLine = me.focus ? `\nYour specific focus: ${me.focus}\n` : "";
+    const stackLock = buildStackLockSection(ctx.spec);
     return {
         system: `You are the "${me.label}". Your lens: ${me.lens}.\n` +
             `You are entering a discussion with the "${them.label}" (${them.lens}).\n` +
             focusLine +
             ENGLISH_ONLY_RULE +
             EVIDENCE_RULE_OPENING +
+            (stackLock ? `\n${stackLock}\n` : "") +
             guardrails +
             (ctx.conversationContext ? `\n## Conversation Context\n${ctx.conversationContext}\n\n---\n\n` : "\n") +
             `## Discussion Brief\n` +
@@ -143,10 +190,12 @@ export function buildOpeningPrompt(ctx) {
 export function buildResponsePrompt(ctx) {
     const me = personaOf(ctx.speakerRole, ctx.speakerStance);
     const them = personaOf(ctx.partnerRole, ctx.partnerStance);
+    const stackLock = buildStackLockSection(ctx.spec);
     return {
         system: `You are the "${me.label}" (lens: ${me.lens}) responding to the "${them.label}" (lens: ${them.lens}).\n` +
             ENGLISH_ONLY_RULE +
             EVIDENCE_RULE_RESPONSE +
+            (stackLock ? `\n${stackLock}\n` : "") +
             `\n## Discussion Brief\n` +
             `Problem: ${ctx.spec.problemStatement}\n` +
             `Success Criteria: ${ctx.spec.successCriteria.join("; ")}\n\n` +
@@ -165,10 +214,12 @@ export function buildResponsePrompt(ctx) {
 export function buildFollowupPrompt(ctx) {
     const me = personaOf(ctx.speakerRole, ctx.speakerStance);
     const them = personaOf(ctx.partnerRole, ctx.partnerStance);
+    const stackLock = buildStackLockSection(ctx.spec);
     return {
         system: `You are the "${me.label}" (lens: ${me.lens}) continuing a discussion (round ${ctx.round}) with the "${them.label}" (lens: ${them.lens}).\n` +
             ENGLISH_ONLY_RULE +
             EVIDENCE_RULE_FOLLOWUP +
+            (stackLock ? `\n${stackLock}\n` : "") +
             `\n` +
             (ctx.runningSummary
                 ? `## Discussion State So Far\n${ctx.runningSummary}\n\nFocus on UNRESOLVED points only. Do not repeat agreed positions.\n\n`
@@ -191,9 +242,18 @@ export function buildFollowupPrompt(ctx) {
 }
 // ── Leader evaluation prompt (replaces convergence-check) ────────────────────
 export function buildLeaderEvaluationPrompt(ctx) {
+    const stackLock = buildStackLockSection(ctx.spec);
+    const outOfStackCheck = stackLock
+        ? `\n## Out-of-stack enforcement\n` +
+            `Scan the final positions for proposals that cite frameworks or technologies NOT in the STACK LOCK above.\n` +
+            `If any participant's final position cites an out-of-stack technology (e.g. Next.js, shadcn, NestJS), ` +
+            `set "outOfStackViolations" to the list of offending tech names and set "consensusQuality" to "partial". ` +
+            `When all positions stay within the locked stack, set "consensusQuality" to "full".\n\n`
+        : "";
     return {
         system: `You are the discussion moderator evaluating whether a multi-expert debate has produced sufficient results.\n` +
             ENGLISH_ONLY_RULE +
+            (stackLock ? `\n${stackLock}\n` : "") +
             `\n## Success Criteria to Evaluate\n` +
             ctx.spec.successCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n") +
             `\n\n` +
@@ -207,6 +267,7 @@ export function buildLeaderEvaluationPrompt(ctx) {
             `- The remaining disagreements are minor wording, not substantive trade-offs\n` +
             `- The next round would mostly repeat already-stated positions\n` +
             `Continuing past convergence wastes ~120-150s per round and adds no new content. Prefer to stop early — the user can always /ask-followup to clarify a specific point.\n\n` +
+            outOfStackCheck +
             `Output ONLY a JSON object (no markdown):\n` +
             `{\n` +
             `  "allCriteriaMet": true/false,\n` +
@@ -219,6 +280,10 @@ export function buildLeaderEvaluationPrompt(ctx) {
             `  "evidenceDensity": 0.0,  // citations / total claims ratio (0.0–1.0)\n` +
             `  "disagreementResolved": 0,  // count of [REFUTED] + [CONFIRMED] tags and explicit concessions\n` +
             `  "extendRounds": 0  // set to 1-3 ONLY when this is the last planned round AND one critical point is genuinely close to resolving but not yet there. 0 otherwise.\n` +
+            (stackLock
+                ? `  ,\n  "consensusQuality": "full",  // "full" when all positions stay within locked stack; "partial" when out-of-stack violations found\n` +
+                    `  "outOfStackViolations": []  // list of out-of-stack tech names cited by participants (empty when none)\n`
+                : "") +
             `}`,
         prompt: `## Debate (Round ${ctx.round})\n${ctx.exchangeLogs}`,
     };
@@ -257,6 +322,11 @@ export function buildDebatePlanPrompt(spec) {
             `1. \`stances\`: 2-3 specialists tailored to THIS topic. Each has a distinct lens that produces ` +
             `productive disagreement. Avoid overlap. Stances should fit the topic, NOT generic ` +
             `"implement/verify/research" labels.\n` +
+            `   **When \`outputShape.kind === "implementation_plan"\`, AT LEAST ONE stance MUST be a Product/User-side voice** — ` +
+            `e.g. "Product Owner", "User Advocate", "Customer Proxy", "MVP Skeptic". Its lens MUST challenge scope: ` +
+            `"what does the user actually need on day 1?", "what are we over-building?", "would the user pay for this if it shipped tomorrow?". ` +
+            `This counter-balances engineering stances (Architect/Cost/Skeptic) that historically inflate scope ` +
+            `(e.g. proposing multi-tenant SaaS for a 5-word "todo app" prompt). Engineering-only rosters are REJECTED.\n` +
             `2. \`outputShape\`: the JSON sections the synthesis should produce. ` +
             `Pick keys/headings that match what the user actually wants to receive. ` +
             `Be specific to the topic.\n` +
@@ -268,11 +338,23 @@ export function buildDebatePlanPrompt(spec) {
             `  - recommendation: text — decisive verdict\n` +
             `\n**implementation_plan** — building/changing something:\n` +
             `  - agreed_architecture: text — what the design IS, in prose\n` +
+            `  - entities: objectList of {name, fields, relationships} — the domain model. ` +
+            `\`fields\` is a CSV of \`name:type[?]\` (e.g. "id:uuid, title:string, completed:bool, createdAt:timestamp"). ` +
+            `\`relationships\` lists FK/nav properties (e.g. "userId → User(id)"). REQUIRED for any topic that involves persistence; ` +
+            `omit only when the change is pure-refactor with zero schema impact.\n` +
+            `  - endpoints: objectList of {method, path, request_body, response_body, auth_required} — the HTTP/RPC surface. ` +
+            `Use concrete names (e.g. \`POST /todos\` not "create endpoint"). REQUIRED for any topic that exposes an API.\n` +
+            `  - acceptance_criteria: list of Gherkin-style "Given X / When Y / Then Z" assertions OR ` +
+            `concrete pass/fail predicates ("User can create a todo and see it in the list within 1s"). ` +
+            `These are what the verify step uses to score Done. REQUIRED — at least 3.\n` +
             `  - tradeoffs: objectList of {decision, option_a, option_b, chosen, why}\n` +
             `  - risks: objectList of {description, severity: "High"|"Medium"|"Low", mitigation}\n` +
             `  - actionItems: objectList of {step, owner_lens, time_estimate, depends_on, acceptance_criteria}\n` +
             `  - dissenting_notes: list — minority opinions NOT to lose in synthesis (e.g. "X argued for B over A; if assumption Y fails, revisit")\n` +
-            `  - mvp_definition: text — explicit v1 cut-line\n` +
+            `  - mvp_definition: objectList of {feature, included_in_v1: "yes"|"no", reason} — ` +
+            `EVERY major feature must appear here with an explicit v1-include decision and a one-line reason. ` +
+            `This forces the council to make scope decisions instead of writing fluff like "lean MVP". ` +
+            `Features marked "no" must still appear, with the deferral reason.\n` +
             `  Order actionItems by dependency — predecessors before dependents.\n` +
             `\n**decision** — choose between options:\n` +
             `  - options: objectList of {name, pros, cons, cost_estimate}\n` +
@@ -290,7 +372,13 @@ export function buildDebatePlanPrompt(spec) {
             `  - kill_criteria: list — conditions under which the idea is NOT worth pursuing\n` +
             `  - recommendation: text — go / no-go / scoped pilot\n` +
             `3. \`guardrails\`: behavioral rules participants must obey. ` +
-            `Examples: "cite sources for numbers", "do not propose code changes", "stay within YYYY constraint".\n\n` +
+            `Examples: "cite sources for numbers", "do not propose code changes", "stay within YYYY constraint".\n` +
+            `   For \`implementation_plan\` debates, ALWAYS include this scope-drift guardrail verbatim: ` +
+            `"If any actionItem, entity, or endpoint requires multi-tenancy, enterprise auth-as-a-service, ` +
+            `org/team hierarchy, or other enterprise infrastructure when the user's original prompt is < 25 words ` +
+            `AND mentions none of those words explicitly, move it to \`dissenting_notes\` with reason 'scope inflation beyond user prompt'. ` +
+            `Default to single-user / personal scope unless the prompt says otherwise." ` +
+            `This counters the historical pattern where a 5-word prompt like 'tạo todo app' produced a multi-tenant SaaS plan.\n\n` +
             `4. \`plannedRounds\`: 1-5. How many discussion rounds you expect this topic to need. ` +
             `Simple yes/no decisions: 1-2. Multi-faceted design or trade-off analysis: 3. ` +
             `Deep architecture / multi-system debate: 4-5. The leader can extend this ` +
@@ -379,12 +467,14 @@ export function buildSynthesisPrompt(ctx) {
                     ? "Be thorough. Include rationale and evidence for each point."
                     : "Balance clarity with completeness.") // balanced (default)
         : "";
+    const stackLockForSynth = buildStackLockSection(ctx.spec);
     let system = `You are the team lead synthesizing a multi-specialist discussion.\n\n` +
         `## Original Brief\n` +
         `Problem: ${ctx.spec.problemStatement}\n` +
         `Constraints: ${ctx.spec.constraints.join("; ")}\n` +
         `Success Criteria: ${ctx.spec.successCriteria.join("; ")}\n` +
         intent +
+        (stackLockForSynth ? `\n${stackLockForSynth}\n` : "") +
         guardrailBlock +
         `\nProduce the answer the user requested — do NOT default to an implementation plan ` +
         `unless the output shape explicitly asks for actionItems/plan. ` +
@@ -417,33 +507,33 @@ export function buildSynthesisPrompt(ctx) {
     }
     let extraContext = "";
     if (ctx.refineContext) {
-        extraContext += `
-## User Refinements
-${ctx.refineContext}
+        extraContext += `
+## User Refinements
+${ctx.refineContext}
 `;
     }
     if (ctx.planEmphasis) {
-        extraContext += `
-## Additional Instruction
-The user has requested a concrete action plan with executable steps. Each action item MUST be an object with these fields:
-  {
-    "step": "<imperative action>",
-    "owner_lens": "<which stance owns this — frontend / backend / architecture / etc>",
-    "time_estimate": "<rough — e.g. '2h', '1d', '~30min'>",
-    "depends_on": ["<step keys this requires>"] or [],
-    "acceptance_criteria": "<how we know it's done>"
-  }
-Order action items by dependency: predecessors first, dependents after.
-Risks MUST be objects with: {"description", "severity": "High|Medium|Low", "mitigation"}.
-Do NOT emit loose strings for these fields — the user needs structured plan output.
+        extraContext += `
+## Additional Instruction
+The user has requested a concrete action plan with executable steps. Each action item MUST be an object with these fields:
+  {
+    "step": "<imperative action>",
+    "owner_lens": "<which stance owns this — frontend / backend / architecture / etc>",
+    "time_estimate": "<rough — e.g. '2h', '1d', '~30min'>",
+    "depends_on": ["<step keys this requires>"] or [],
+    "acceptance_criteria": "<how we know it's done>"
+  }
+Order action items by dependency: predecessors first, dependents after.
+Risks MUST be objects with: {"description", "severity": "High|Medium|Low", "mitigation"}.
+Do NOT emit loose strings for these fields — the user needs structured plan output.
 `;
     }
     return {
         system,
-        prompt: `Final positions:
-${ctx.finalPositions}
-
-Full discussion:
+        prompt: `Final positions:
+${ctx.finalPositions}
+
+Full discussion:
 ${ctx.allExchanges}${extraContext}`,
     };
 }

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

@@ -19,6 +19,24 @@ export interface ClarifiedSpec {
     }>;
     /** Maps dimension IDs to their resolution status. Used by Product Loop. */
     resolved?: Record<string, "answered" | "unspecified" | "skipped">;
+    /** Self-judged confidence score (0–1) that the spec is ready for debate. */
+    confidenceScore?: number;
+    /** Outstanding gaps the agent identified; empty when ready === true. */
+    remainingGaps?: string[];
+    /**
+     * True when the ready-gate judge decided the spec is sufficient.
+     * Invariant: ready === (remainingGaps?.length ?? 1) === 0
+     */
+    ready?: boolean;
+    /** Full Q&A history including gap-driven follow-up rounds. */
+    clarifyHistory?: Array<{
+        question: string;
+        answer: string;
+        /** ISO timestamp of when the answer was recorded. */
+        ts: string;
+    }>;
+    /** Populated by P6 when the spec is converted to a Backlog. */
+    backlogId?: string;
 }
 export interface CouncilPreflight {
     preflightId: string;

package/dist/src/ee/__tests__/export-transcripts.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * export-transcripts.test.ts
+ *
+ * Unit tests for exportTranscripts() — SQLite → JSONL transcript export.
+ *
+ * Strategy: redirect USERPROFILE (Windows) / HOME (POSIX) to a temp dir,
+ * create a real SQLite DB at `~/.muonroi-cli/muonroi.db`, and call the
+ * function.  Also creates `~/.experience/config.json` so the emit sidecar
+ * (transcript-emit) does not gate-return null.
+ */
+export {};