muonroi-cli 1.7.2 → 1.8.1

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

@@ -1,10 +1,31 @@
 import type { ModelMessage } from "ai";
 import type { StreamChunk } from "../types/index.js";
 import type { CouncilLLM, CouncilStats, PreflightResponder, QuestionResponder } from "./types.js";
+/**
+ * Wrap a CouncilLLM so every `generate` call inherits the council-wide abort
+ * signal. The whole generate-based call path (clarifier, research-need eval,
+ * leader round-eval, opening statements, round summary, spec/plan synthesis,
+ * and the debate-planner retry) calls `llm.generate(...)` with NO signal arg —
+ * none of those sites thread one. Injecting it here in ONE place makes them all
+ * cancellable without touching each signature. `debate`/`research` already get
+ * `config.signal` explicitly, so they pass through unchanged.
+ *
+ * An explicit per-call signal (none exist today, but the param is there) wins
+ * over the injected one. Returns the original llm untouched when no signal is
+ * configured (e.g. the sprint-planner path, which has no user-abort signal).
+ */
+export declare function withCouncilSignal(llm: CouncilLLM, signal: AbortSignal | undefined): CouncilLLM;
 export interface RunCouncilOptions {
     skipClarification?: boolean;
     userModelMessage?: ModelMessage;
     signal?: AbortSignal;
+    /**
+     * Hard cap on clarification rounds for the explicit /council path. Defaults to
+     * EXPLICIT_COUNCIL_CLARIFY_ROUNDS (1). Callers that genuinely want the full
+     * multi-round ready-gate can raise it; auto-council/sprint pass
+     * skipClarification:true and never reach the clarifier regardless.
+     */
+    clarifyMaxRounds?: number;
     /** Working directory used to resolve the "current project" snapshot. */
     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). */
@@ -15,8 +36,32 @@ export interface RunCouncilOptions {
      */
     runDir?: string;
 }
+export type PostDebateAction = "save_exit" | "generate_plan" | "refine" | "ask_followup" | "retry_synthesis";
+/**
+ * Decide the DEFAULT post-debate action surfaced as the recommended option.
+ * Extracted as a pure function so the policy is unit-testable.
+ *
+ * Issue #3 (post-debate default mismatch): when synthesis succeeded and no plan
+ * exists yet, only an `implementation_plan`-shaped debate should default to
+ * "generate_plan" (Lock plan & execute Sprint 1). For a `decision`, `evaluation`,
+ * `investigation`, or `exploration` debate the synthesis IS the deliverable — the
+ * user asked a question, not for code — so the default is `save_exit`. The
+ * generate_plan OPTION is still offered downstream; it's just no longer the
+ * pre-selected default for non-build topics.
+ */
+export declare function pickPostDebateRecommendation(input: {
+    synthesisFailed: boolean;
+    hasEmptySections: boolean;
+    refinementTopics: string[];
+    confidenceLevel: "high" | "medium" | "low";
+    hasPlan: boolean;
+    outputKind: string;
+}): {
+    value: PostDebateAction;
+    reason: string;
+};
 export declare function runCouncil(topic: string, sessionModelId: string, messages: Array<{
     role: string;
     content: string | unknown;
-}>, sessionId: string | undefined, llm: CouncilLLM, respondToQuestion: QuestionResponder, respondToPreflight: PreflightResponder, processMessageFn: (message: string) => AsyncGenerator<StreamChunk, void, unknown>, options?: RunCouncilOptions): AsyncGenerator<StreamChunk, string | null, unknown>;
+}>, sessionId: string | undefined, rawLlm: CouncilLLM, respondToQuestion: QuestionResponder, respondToPreflight: PreflightResponder, processMessageFn: (message: string) => AsyncGenerator<StreamChunk, void, unknown>, options?: RunCouncilOptions): AsyncGenerator<StreamChunk, string | null, unknown>;
 export type { ClarifiedSpec, CouncilLLM, CouncilParticipant, CouncilStats } from "./types.js";

package/dist/src/council/index.js

@@ -15,9 +15,91 @@ import { resolveLeaderModelDetailed, resolveParticipants } from "./leader.js";
 import { phaseDone, phaseStart } from "./phase-events.js";
 import { runPlanning } from "./planner.js";
 import { runPreflight } from "./preflight.js";
-export async function* runCouncil(topic, sessionModelId, messages, sessionId, llm, respondToQuestion, respondToPreflight, processMessageFn, options) {
+/**
+ * Wrap a CouncilLLM so every `generate` call inherits the council-wide abort
+ * signal. The whole generate-based call path (clarifier, research-need eval,
+ * leader round-eval, opening statements, round summary, spec/plan synthesis,
+ * and the debate-planner retry) calls `llm.generate(...)` with NO signal arg —
+ * none of those sites thread one. Injecting it here in ONE place makes them all
+ * cancellable without touching each signature. `debate`/`research` already get
+ * `config.signal` explicitly, so they pass through unchanged.
+ *
+ * An explicit per-call signal (none exist today, but the param is there) wins
+ * over the injected one. Returns the original llm untouched when no signal is
+ * configured (e.g. the sprint-planner path, which has no user-abort signal).
+ */
+export function withCouncilSignal(llm, signal) {
+    if (!signal)
+        return llm;
+    return {
+        ...llm,
+        generate: (modelId, system, prompt, maxTokens, onUsage, sig) => llm.generate(modelId, system, prompt, maxTokens, onUsage, sig ?? signal),
+    };
+}
+/**
+ * Explicit `/council …` is the ONLY caller that runs the clarifier — auto-council
+ * (message-processor) and the sprint-planner both pass `skipClarification: true`.
+ * Capping it to a single round (down from the ready-gate's MAX_CLARIFY_ROUNDS=12)
+ * stops the 2-3 rounds of follow-up askcards users hit on already-detailed topics
+ * (see project-council-subsystem memory). The per-round ready-gate has no
+ * production behavioural effect anyway — `spec.ready`/`confidenceScore`/
+ * `remainingGaps` are write-only — so its only real cost is the extra rounds.
+ * Round 0 still runs, so the user is asked the key questions exactly once.
+ */
+const EXPLICIT_COUNCIL_CLARIFY_ROUNDS = 1;
+/**
+ * Decide the DEFAULT post-debate action surfaced as the recommended option.
+ * Extracted as a pure function so the policy is unit-testable.
+ *
+ * Issue #3 (post-debate default mismatch): when synthesis succeeded and no plan
+ * exists yet, only an `implementation_plan`-shaped debate should default to
+ * "generate_plan" (Lock plan & execute Sprint 1). For a `decision`, `evaluation`,
+ * `investigation`, or `exploration` debate the synthesis IS the deliverable — the
+ * user asked a question, not for code — so the default is `save_exit`. The
+ * generate_plan OPTION is still offered downstream; it's just no longer the
+ * pre-selected default for non-build topics.
+ */
+export function pickPostDebateRecommendation(input) {
+    if (input.synthesisFailed) {
+        return {
+            value: "retry_synthesis",
+            reason: "Re-run synthesis with a compact prompt — usually clears provider-timeout failures.",
+        };
+    }
+    if (input.hasEmptySections) {
+        return { value: "refine", reason: `Fill in ${input.refinementTopics.length} section(s) the debate left empty.` };
+    }
+    if (input.confidenceLevel === "low") {
+        return {
+            value: "ask_followup",
+            reason: "Press the council on the weakest claims rather than accepting a thin synthesis.",
+        };
+    }
+    if (!input.hasPlan) {
+        return input.outputKind === "implementation_plan"
+            ? { value: "generate_plan", reason: "Convert the agreed outcome into concrete steps." }
+            : {
+                value: "save_exit",
+                reason: `This was a ${input.outputKind} debate — the synthesis above is the deliverable; save it.`,
+            };
+    }
+    return { value: "save_exit", reason: "Outcome looks solid — save and move on." };
+}
+export async function* runCouncil(topic, sessionModelId, messages, sessionId, rawLlm, respondToQuestion, respondToPreflight, processMessageFn, options) {
     const stats = options?.councilStats ?? { calls: 0, startMs: Date.now(), phases: [] };
     const costAware = isCouncilCostAware();
+    // Inject the user-abort signal into every generate-based sub-call (clarify,
+    // research-need, leader-eval, opening, summary, synthesis, debate-plan retry).
+    // No-op passthrough when options.signal is undefined.
+    const llm = withCouncilSignal(rawLlm, options?.signal);
+    // Hard-stop guard. Threading the signal into LLM calls makes them abortable,
+    // but every council sub-phase wraps its work in fail-open try/catch that
+    // swallows the resulting AbortError and returns normally — so without an
+    // explicit check at each phase boundary the loop would march on to the next
+    // phase after a cancel. `userAborted()` is checked between phases; when true
+    // the run stops cleanly rather than burning the remaining (debate, synthesis)
+    // LLM budget. Cancellation latency is bounded by one in-flight sub-call.
+    const userAborted = () => options?.signal?.aborted === true;
     // ── Resolve models ──────────────────────────────────────────────────────────
     const leaderResolution = await resolveLeaderModelDetailed(sessionModelId);
     const leaderModelId = leaderResolution.modelId;
@@ -50,6 +132,11 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
         : baseContext;
     const internetFirst = projectInfo.isEmpty;
     const active = participants.map((p) => ({ ...p, position: "" }));
+    if (userAborted()) {
+        yield { type: "content", content: "\n> Council cancelled by user.\n" };
+        yield { type: "done" };
+        return null;
+    }
     // ── Phase A + B loop: Clarify → Confirm ─────────────────────────────────────
     let spec = buildSpecFromTopic(topic, conversationContext);
     let approved = false;
@@ -76,7 +163,7 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
                     content: `\n> Clarification seeded by PIL (${pilSeed.length} gray-area question${pilSeed.length === 1 ? "" : "s"}).\n`,
                 };
             }
-            const clarifyGen = runClarification(topic, leaderModelId, conversationContext, respondToQuestion, llm, options?.signal, pilSeed, undefined, undefined, costAware);
+            const clarifyGen = runClarification(topic, leaderModelId, conversationContext, respondToQuestion, llm, options?.signal, pilSeed, options?.clarifyMaxRounds ?? EXPLICIT_COUNCIL_CLARIFY_ROUNDS, undefined, costAware);
             let clarifyResult;
             do {
                 clarifyResult = await clarifyGen.next();
@@ -90,6 +177,9 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
             spec = buildSpecFromTopic(topic, conversationContext);
             yield { type: "content", content: `\n> Auto-council: skipping clarification (PIL pre-classified).\n` };
         }
+        // Cancelled during clarification — don't pop the preflight approval card.
+        if (userAborted())
+            break;
         const researchNeeded = true;
         const preflightGen = runPreflight(spec, participants, researchNeeded, respondToPreflight, {
             repoEmpty: internetFirst,
@@ -105,6 +195,11 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
         approved = preflightResult.value;
     }
     stats.phases.push({ name: "clarify+preflight", durationMs: Date.now() - phaseAStart });
+    if (userAborted()) {
+        yield { type: "content", content: "\n> Council cancelled by user.\n" };
+        yield { type: "done" };
+        return null;
+    }
     // ── Research-need check + user override ────────────────────────────────────
     // Leader-LLM decides if research is required. If yes, give the user a chance
     // to skip — research is the slowest part of council and trivial questions
@@ -171,6 +266,11 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
             content: `\n> [Experience] ${eeResult.warnings.length} past warning(s) loaded — Experience Auditor will calibrate debate.\n`,
         };
     }
+    if (userAborted()) {
+        yield { type: "content", content: "\n> Council cancelled by user.\n" };
+        yield { type: "done" };
+        return null;
+    }
     // ── Phase B.5: Leader plans the debate (stances + output shape) ─────────────
     const planStartMs = Date.now();
     yield phaseStart({
@@ -179,7 +279,7 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
         label: "Debate plan",
         detail: "stances + output shape",
     });
-    const planGenerator = planDebate(spec, leaderModelId, llm, eeResult.warnings, experienceMode, pilCtx?.taskType ?? undefined, pilCtx?.complexityTier ?? undefined);
+    const planGenerator = planDebate(spec, leaderModelId, llm, eeResult.warnings, experienceMode, pilCtx?.taskType ?? undefined, pilCtx?.complexityTier ?? undefined, options?.signal);
     let planStep;
     do {
         planStep = await planGenerator.next();
@@ -222,6 +322,11 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
         active.length = debatePlan.stances.length;
     }
     stats.phases.push({ name: "plan_debate", durationMs: Date.now() - planStartMs });
+    if (userAborted()) {
+        yield { type: "content", content: "\n> Council cancelled by user.\n" };
+        yield { type: "done" };
+        return null;
+    }
     // ── Phase C: Dynamic Debate ─────────────────────────────────────────────────
     const debateStart = Date.now();
     const debateGen = runDebate(spec, {
@@ -235,6 +340,7 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
         leaderNeedsResearch,
         internetFirst,
         costAware,
+        runId: sessionId,
     }, llm);
     let debateResult;
     do {
@@ -270,6 +376,11 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
         durationMs: Date.now() - debateStart,
         data: { topic, roundCount: debateState.roundCount },
     });
+    if (userAborted()) {
+        yield { type: "content", content: "\n> Council cancelled by user — skipping synthesis.\n" };
+        yield { type: "done" };
+        return null;
+    }
     // ── Phase D: Plan ───────────────────────────────────────────────────────────
     const planStart = Date.now();
     const planGen = runPlanning(debateState, spec, debateState.active, leaderModelId, respondToPreflight, llm, debatePlan, pilCtx?.outputStyle ?? undefined);
@@ -338,22 +449,17 @@ export async function* runCouncil(topic, sessionModelId, messages, sessionId, ll
                     : confidenceLevel === "medium"
                         ? `⚠ Medium confidence (evidence density ${evidenceDensity.toFixed(2)})`
                         : `⚠ Low confidence (evidence density ${evidenceDensity.toFixed(2)})`;
-            // Recommendation surfaced to the user as the default action.
-            const recommendation = synthesisFailed
-                ? {
-                    value: "retry_synthesis",
-                    reason: "Re-run synthesis with a compact prompt — usually clears provider-timeout failures.",
-                }
-                : hasEmptySections
-                    ? { value: "refine", reason: `Fill in ${refinementTopics.length} section(s) the debate left empty.` }
-                    : confidenceLevel === "low"
-                        ? {
-                            value: "ask_followup",
-                            reason: "Press the council on the weakest claims rather than accepting a thin synthesis.",
-                        }
-                        : !hasPlan
-                            ? { value: "generate_plan", reason: "Convert the agreed outcome into concrete steps." }
-                            : { value: "save_exit", reason: "Outcome looks solid — save and move on." };
+            // Recommendation surfaced to the user as the default action. The
+            // implementation_plan-vs-decision/evaluation split lives in
+            // pickPostDebateRecommendation (issue #3 — see its doc comment).
+            const recommendation = pickPostDebateRecommendation({
+                synthesisFailed,
+                hasEmptySections,
+                refinementTopics,
+                confidenceLevel,
+                hasPlan: !!hasPlan,
+                outputKind: debatePlan.outputShape.kind,
+            });
             const baseOptions = [];
             if (synthesisFailed) {
                 baseOptions.push({

package/dist/src/council/llm.js

@@ -4,8 +4,8 @@ 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 { loadKeyForProvider, ProviderKeyMissingError } from "../providers/keychain.js";
+import { createProviderFactoryAsync, 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";
@@ -13,6 +13,33 @@ 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";
+/**
+ * Resolve a provider factory for a council sub-call, OAuth-aware.
+ *
+ * The council reachability gate (`isProviderReachable` in leader.ts) counts
+ * OAuth-authenticated providers as usable (via `getConfiguredProviders`), so a
+ * multi-provider roster can route a stance to an OAuth-only provider such as
+ * xai/grok. `loadKeyForProvider` is API-key-only and throws
+ * `ProviderKeyMissingError` for those — which previously surfaced as
+ * "[Error: No API key found for provider 'xai'.]" on every call of that stance,
+ * even though the provider was fully authenticated. Mirror the main
+ * orchestrator path: fall back to `createProviderFactoryAsync`, which loads +
+ * refreshes the stored OAuth bearer token. Only the expected missing-key case
+ * is swallowed; unexpected errors propagate.
+ */
+async function resolveCouncilFactory(providerId) {
+    let apiKey;
+    try {
+        apiKey = await loadKeyForProvider(providerId);
+    }
+    catch (err) {
+        if (!(err instanceof ProviderKeyMissingError))
+            throw err;
+        // OAuth-only provider — createProviderFactoryAsync injects the bearer token.
+    }
+    const { factory } = await createProviderFactoryAsync(providerId, apiKey ? { apiKey } : {});
+    return factory;
+}
 function getDebugLogPath() {
     const p = process.env.MUONROI_COUNCIL_DEBUG_LOG;
     return p && p.length > 0 ? p : null;
@@ -184,7 +211,7 @@ const COUNCIL_LLM_TIMEOUT_MS = (() => {
 // implementation. Imported at the top of this file.
 export function createCouncilLLM(bash, mode, sessionId, stats) {
     return {
-        async generate(modelId, system, prompt, maxTokens = 4096, onUsage) {
+        async generate(modelId, system, prompt, maxTokens = 4096, onUsage, signal) {
             const mock = getMockLlm();
             if (mock) {
                 stats.calls++;
@@ -192,11 +219,14 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
                 return result.text;
             }
             const providerId = detectProviderForModel(modelId);
-            const key = await loadKeyForProvider(providerId);
-            const { factory } = createProviderFactory(providerId, { apiKey: key });
+            const factory = await resolveCouncilFactory(providerId);
             const runtime = resolveModelRuntime(factory, modelId);
             const t0 = Date.now();
-            const { signal: timedSignal, cleanup: cleanupTimeout } = withTimeoutSignal(undefined, COUNCIL_LLM_TIMEOUT_MS);
+            // Combine the user-abort signal (when threaded from runCouncil) with the
+            // per-call wall-clock deadline. Without the parent signal, an Esc/Ctrl-C
+            // during the longest generate calls (8192-token synthesis, clarify, leader
+            // eval) was a no-op — the call ran to completion or hit the 5-min timeout.
+            const { signal: timedSignal, cleanup: cleanupTimeout } = withTimeoutSignal(signal, COUNCIL_LLM_TIMEOUT_MS);
             try {
                 const result = await withDeadlineRace(() => withVisibleRetry(() => generateText({
                     model: runtime.model,
@@ -211,7 +241,7 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
                     maxRetries: 0,
                     ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
                     abortSignal: timedSignal,
-                }), { label: "council.generate" }), COUNCIL_LLM_TIMEOUT_MS + 5_000, "council.generate");
+                }), { label: "council.generate" }), COUNCIL_LLM_TIMEOUT_MS + 5_000, "council.generate", signal);
                 cleanupTimeout();
                 stats.calls++;
                 const durMs = Date.now() - t0;
@@ -273,8 +303,7 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
                 return { text: result.text, toolCalls: [] };
             }
             const providerId = detectProviderForModel(modelId);
-            const key = await loadKeyForProvider(providerId);
-            const { factory } = createProviderFactory(providerId, { apiKey: key });
+            const factory = await resolveCouncilFactory(providerId);
             const runtime = resolveModelRuntime(factory, modelId);
             // Verification tools — re-introduced after the no-tools fix (session
             // a7a5690d2049). The original failure was stepCountIs(4) + full toolset
@@ -352,7 +381,7 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
                     maxRetries: 0,
                     ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
                     abortSignal: timedSignal,
-                }), { label: "council.debate" }), COUNCIL_LLM_TIMEOUT_MS + 5_000, "council.debate");
+                }), { label: "council.debate" }), COUNCIL_LLM_TIMEOUT_MS + 5_000, "council.debate", signal);
                 cleanupTimeout();
                 stats.calls++;
                 // No tool calls expected, but the AI SDK shape still has the field —
@@ -430,8 +459,7 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
                 return result.text;
             }
             const providerId = detectProviderForModel(modelId);
-            const key = await loadKeyForProvider(providerId);
-            const { factory } = createProviderFactory(providerId, { apiKey: key });
+            const factory = await resolveCouncilFactory(providerId);
             const runtime = resolveModelRuntime(factory, modelId);
             const builtinTools = createTools(bash, mode);
             // CQ-03: Lazy MCP bundle per research call — fail-open so builtins remain available
@@ -488,7 +516,7 @@ export function createCouncilLLM(bash, mode, sessionId, stats) {
                     maxRetries: 0,
                     ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
                     abortSignal: timedSignal,
-                }), { label: "council.research" }), researchTimeoutMs + 5_000, "council.research");
+                }), { label: "council.research" }), researchTimeoutMs + 5_000, "council.research", signal);
                 cleanupTimeout();
                 const researchUsage = logCouncilCost({
                     callsite: "council.research",

package/dist/src/council/prompts.js

@@ -28,6 +28,11 @@ export function buildClarificationPrompt(topic, conversationContext, previousQA)
             `the project IS the one described in the "## Current Project" section of the context. DO NOT ask which project.\n` +
             `- Only ask about project identity when the topic mentions multiple distinct projects or external products.\n` +
             `- Use the project's package.json name and description as implicit context for follow-up questions.\n\n` +
+            `## Language Rule (mandatory)\n` +
+            `Write the "question", "why", and every "suggestions"/"recommended" option in the SAME ` +
+            `language the user used in the Topic below — detect it; if the user wrote Vietnamese, write ` +
+            `Vietnamese; if English, English. The user reads and answers these on a card, so they must ` +
+            `NOT default to English. Keep code identifiers, file paths, tech/product names, and JSON keys in English.\n\n` +
             `Output ONLY a JSON array (no markdown, no preamble):\n` +
             `[{"question": "...", "why": "why this matters for a focused discussion", "suggestions": ["option A", "option B"], "recommended": "option A", "isRequired": true}]\n\n` +
             `Rules for "recommended" (be decisive — the user should never face an unranked list):\n` +
@@ -49,7 +54,15 @@ export function buildSpecSynthesisPrompt(topic, conversationContext, qa) {
             `  "constraints": ["constraint 1", "constraint 2"],\n` +
             `  "successCriteria": ["criterion 1", "criterion 2"],\n` +
             `  "scope": "what is in and out of scope"\n` +
-            `}`,
+            `}\n\n` +
+            `## Language Rule (mandatory)\n` +
+            `Write EVERY field (problemStatement, constraints, successCriteria, scope) in the SAME ` +
+            `language the user used — detect it from the Original Topic and Clarification Q&A below. ` +
+            `If the user wrote Vietnamese, write Vietnamese; if English, English. Do NOT default to ` +
+            `English. This brief is shown to the user on the approval card AND the final synthesis ` +
+            `detects its output language from this problemStatement, so writing it in the wrong ` +
+            `language drags the whole council's output off the user's language. Keep code identifiers, ` +
+            `tech/product names, and JSON keys in English.`,
         prompt: `## Original Topic\n${topic}\n\n` +
             (conversationContext ? `## Context\n${conversationContext}\n\n` : "") +
             `## Clarification Q&A\n${qa.map((qa) => `Q: ${qa.question}\nA: ${qa.answer}`).join("\n\n")}`,
@@ -146,6 +159,25 @@ const EVIDENCE_RULE_FOLLOWUP = `\n## Evidence Rule\n` +
     `- Most follow-up turns will not need any tool call.\n` +
     `Tag verified results: \`[CONFIRMED via <tool>:<evidence>]\` or \`[REFUTED via <tool>:<evidence>]\`.\n` +
     `Uncited numbers you cannot verify: \`[UNVERIFIED: <claim>]\`.\n`;
+/**
+ * Length discipline injected into every debate turn (F13 token-thrift). The
+ * debate-turn ceilings are generous (4096-6144 maxTokens) and reasoning models
+ * left unbounded emit ~400-600 words/turn — ~17 turns/debate is token-heavy and
+ * directly fights the "tiết kiệm token" goal. A concrete word cap + "density
+ * over length" cuts filler / preamble / brief-restating while keeping the
+ * analytical core (position, reasoning bullets, the cross-question). This does
+ * NOT lower maxTokens: reasoning models need that headroom to think without
+ * empty-turn truncation (see llm.ts) — the saving comes from the model writing
+ * less, not from a hard output ceiling. The text deliberately contains none of
+ * the prompt substrings the council mocks route on (e.g. "responding to",
+ * "continuing a discussion", "team lead", "Summarize this discussion").
+ */
+function concisenessRule(maxWords) {
+    return (`\n## Length (be token-thrifty)\n` +
+        `Keep this turn under ~${maxWords} words. Open with your position in one line, ` +
+        `then 2-4 bullets of your strongest reasoning. No preamble, no restating the ` +
+        `brief, no filler — density over length. A tight argument beats a long one.\n`);
+}
 /** Resolve the persona label used inside debate prompts. Stance wins; role is fallback. */
 function personaOf(role, stance) {
     if (stance) {
@@ -171,6 +203,7 @@ export function buildOpeningPrompt(ctx) {
             focusLine +
             ENGLISH_ONLY_RULE +
             EVIDENCE_RULE_OPENING +
+            concisenessRule(220) +
             (stackLock ? `\n${stackLock}\n` : "") +
             guardrails +
             (ctx.conversationContext ? `\n## Conversation Context\n${ctx.conversationContext}\n\n---\n\n` : "\n") +
@@ -192,6 +225,7 @@ export function buildResponsePrompt(ctx) {
         system: `You are the "${me.label}" (lens: ${me.lens}) responding to the "${them.label}" (lens: ${them.lens}).\n` +
             ENGLISH_ONLY_RULE +
             EVIDENCE_RULE_RESPONSE +
+            concisenessRule(160) +
             (stackLock ? `\n${stackLock}\n` : "") +
             `\n## Discussion Brief\n` +
             `Problem: ${ctx.spec.problemStatement}\n` +
@@ -216,6 +250,7 @@ export function buildFollowupPrompt(ctx) {
         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 +
+            concisenessRule(140) +
             (stackLock ? `\n${stackLock}\n` : "") +
             `\n` +
             (ctx.runningSummary

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

@@ -211,6 +211,13 @@ export interface CouncilConfig {
     internetFirst?: boolean;
     /** When true, leader sub-tasks downshift to cheaper tier models on the same provider. */
     costAware?: boolean;
+    /**
+     * Enclosing council run id (= sessionId). Used only as the correlationId on the
+     * observe-only `council-turn-length` harness event so per-turn length samples can
+     * be grouped by run. Optional: direct callers/tests may omit it (falls back to a
+     * stable literal); has no effect on debate behaviour.
+     */
+    runId?: string;
 }
 /**
  * JSON shape persisted as `[Council Memory] {...}` in the session messages.
@@ -270,7 +277,13 @@ export interface CouncilCallUsage {
 }
 export type UsageCallback = (usage: CouncilCallUsage) => void;
 export interface CouncilLLM {
-    generate(modelId: string, system: string, prompt: string, maxTokens?: number, onUsage?: UsageCallback): Promise<string>;
+    generate(modelId: string, system: string, prompt: string, maxTokens?: number, onUsage?: UsageCallback, 
+    /**
+     * User-abort signal. Threaded so a mid-council cancel (Esc/Ctrl-C) aborts
+     * the in-flight generate call. Trailing+optional for back-compat — existing
+     * positional callers/mocks are unaffected. See withCouncilSignal in index.ts.
+     */
+    signal?: AbortSignal): Promise<string>;
     research(modelId: string, topic: string, conversationContext: string, signal?: AbortSignal, persistTrace?: ToolTraceEmitter, options?: {
         internetFirst?: boolean;
     }, onUsage?: UsageCallback): Promise<string>;

package/dist/src/ee/__tests__/export-transcripts.test.js

@@ -49,7 +49,7 @@ function bootstrapDb(sessions) {
     db.close();
 }
 beforeEach(() => {
-    tmpHome = join(tmpdir(), "muonroi-test-export-" + Date.now());
+    tmpHome = join(tmpdir(), `muonroi-test-export-${Date.now()}`);
     const muonroiDir = join(tmpHome, ".muonroi-cli");
     const experienceDir = join(tmpHome, ".experience");
     mkdirSync(muonroiDir, { recursive: true });

package/dist/src/ee/bridge.d.ts

@@ -1,4 +1,6 @@
 import { type PilContextResponse } from "../pil/schema.js";
+export type { WhoAmIDim, WhoAmIDimName, WhoAmIProfile } from "./who-am-i.js";
+export { getWhoAmIProfile, outputStyleFromProfile, resetWhoAmICache } from "./who-am-i.js";
 interface EEPoint {
     id: string | number;
     score?: number;
@@ -37,7 +39,7 @@ export type { EEPoint, EERouteResult, EERouteTaskResult };
  *   2. Fat clients (local experience-core.js present) → in-process call.
  *   3. Otherwise → null (caller falls back to regex/keyword paths).
  */
-export declare function classifyViaBrain(prompt: string, timeoutMs?: number): Promise<string | null>;
+export declare function classifyViaBrain(prompt: string, timeoutMs?: number, options?: import("./types.js").BrainProxyOptions): Promise<string | null>;
 /**
  * Search a named Qdrant collection by embedding vector.
  * Falls back to FileStore inside experience-core.js if Qdrant is unavailable.

package/dist/src/ee/bridge.js

@@ -11,6 +11,12 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { PilContextResponseSchema } from "../pil/schema.js";
 import { classifyEeError, logEeFailure, readTimeoutEnv, withEeTimeout } from "../utils/ee-logger.js";
+// "Who Am I" v4.0 profile access. Re-exported through the bridge so PIL layers
+// reach it via the single sanctioned EE entry point (see the no-network-in-pil
+// arch guard: layer1/types may import `../ee/bridge` only). The provider is
+// local-only (no network), cached, and fail-open — the same contract as the rest
+// of this bridge.
+export { getWhoAmIProfile, outputStyleFromProfile, resetWhoAmICache } from "./who-am-i.js";
 /**
  * Phase 21.5 — `routeModel` / `routeTask` budget. EE server unreachability used
  * to hang `/ideal` for the OS-level fetch connect timeout (~5 min on Windows).
@@ -82,7 +88,7 @@ async function silentCall(fn) {
  *   2. Fat clients (local experience-core.js present) → in-process call.
  *   3. Otherwise → null (caller falls back to regex/keyword paths).
  */
-export async function classifyViaBrain(prompt, timeoutMs = 5000) {
+export async function classifyViaBrain(prompt, timeoutMs = 5000, options) {
     // Thin-client HTTP path — required for CLIs without local experience-core.js.
     try {
         const { getCachedEEClientMode } = await import("./client-mode.js");
@@ -92,7 +98,7 @@ export async function classifyViaBrain(prompt, timeoutMs = 5000) {
             : !!(await import("./auth.js")).getCachedServerBaseUrl();
         if (useRemote) {
             const { getDefaultEEClient } = await import("./intercept.js");
-            const result = await getDefaultEEClient().brainProxy(prompt, timeoutMs);
+            const result = await getDefaultEEClient().brainProxy(prompt, timeoutMs, options);
             if (typeof result === "string")
                 return result;
             // Server unreachable — fall through to in-process path so a fat-client
@@ -110,7 +116,7 @@ export async function classifyViaBrain(prompt, timeoutMs = 5000) {
     try {
         // Race the in-process call against `timeoutMs + 200ms` so a buggy core that
         // ignores its own timeout argument cannot hang the host CLI.
-        return await withEeTimeout(silentCall(() => core.classifyViaBrain(prompt, timeoutMs)), timeoutMs + 200);
+        return await withEeTimeout(silentCall(() => core.classifyViaBrain(prompt, timeoutMs, options)), timeoutMs + 200);
     }
     catch (err) {
         logEeFailure("bridge.classifyViaBrain", classifyEeError(err), err, {

package/dist/src/ee/bridge.test.js

@@ -52,7 +52,7 @@ describe("bridge — loaded core", () => {
     it("Test 1: classifyViaBrain returns classification string when core loaded", async () => {
         const result = await classifyViaBrain("write a function to sort an array");
         expect(result).toBe("generate");
-        expect(mockCore.classifyViaBrain).toHaveBeenCalledWith("write a function to sort an array", 5000);
+        expect(mockCore.classifyViaBrain).toHaveBeenCalledWith("write a function to sort an array", 5000, undefined);
     });
     it("Test 2: searchCollection returns EEPoint[] when core loaded", async () => {
         const vector = [0.1, 0.2, 0.3];
@@ -210,7 +210,6 @@ describe("bridge — config isolation (BRIDGE-03)", () => {
         const _validCall = () => classifyViaBrain("prompt");
         const _validCallWithTimeout = () => classifyViaBrain("prompt", 3000);
         // These would cause @ts-expect-error if uncommented:
-        // @ts-expect-error — qdrantUrl is not a valid parameter
         const _invalidCall = () => classifyViaBrain("prompt", 3000, "http://localhost:6333");
         expect(_validCall).toBeDefined();
         expect(_validCallWithTimeout).toBeDefined();

package/dist/src/ee/client.js

@@ -568,7 +568,7 @@ export function createEEClient(opts = {}) {
                 return null;
             }
         },
-        async brainProxy(prompt, timeoutMs = 2000) {
+        async brainProxy(prompt, timeoutMs = 2000, options) {
             try {
                 // Tight client-side ceiling (~150ms grace over caller's intent budget)
                 // so we never wait longer than the PIL pipeline can use the result.
@@ -576,10 +576,23 @@ export function createEEClient(opts = {}) {
                 // we forward in the body — both ends abort together.
                 const ctrl = new AbortController();
                 const t = setTimeout(() => ctrl.abort(), timeoutMs + 150);
+                const body = { prompt, timeoutMs };
+                if (options) {
+                    if (options.systemPrompt)
+                        body.systemPrompt = options.systemPrompt;
+                    if (options.responseFormat)
+                        body.responseFormat = options.responseFormat;
+                    if (options.model)
+                        body.model = options.model;
+                    if (options.maxTokens != null)
+                        body.maxTokens = options.maxTokens;
+                    if (options.provider)
+                        body.provider = options.provider;
+                }
                 const resp = await f(`${baseUrl}/api/brain`, {
                     method: "POST",
                     headers: headers(),
-                    body: JSON.stringify({ prompt, timeoutMs }),
+                    body: JSON.stringify(body),
                     signal: ctrl.signal,
                 });
                 clearTimeout(t);