muonroi-cli 1.7.2 → 1.8.1

package/dist/src/cli/keys.js

@@ -15,8 +15,8 @@
  *   keys delete <provider>        — remove a stored key
  *   keys import-bw [providers]    — pull from Bitwarden vault, store in keychain
  *   keys cleanup-settings         — strip plaintext keys from user-settings.json
- *   keys login <provider>         — OAuth login (openai, google)
- *   keys logout <provider>        — OAuth logout (openai, google)
+ *   keys login <provider>         — OAuth login (openai, google/agy)
+ *   keys logout <provider>        — OAuth logout (openai, google/agy)
  */
 import { spawnSync } from "node:child_process";
 import { promises as fs } from "node:fs";
@@ -49,8 +49,17 @@ function maskKey(key) {
         return "***";
     return `${key.slice(0, 6)}…${key.slice(-4)}`;
 }
-function isValidProvider(p) {
-    return KEYCHAIN_PROVIDER_IDS.includes(p);
+function normalizeProvider(p) {
+    const lower = p.toLowerCase();
+    if (lower === "agy")
+        return "google"; // agy is alias for google (OAuth + key)
+    if (KEYCHAIN_PROVIDER_IDS.includes(lower)) {
+        return lower;
+    }
+    return null;
+}
+function _isValidProvider(p) {
+    return normalizeProvider(p) !== null;
 }
 async function promptHidden(question) {
     // ASCII control codes used during raw-mode capture.
@@ -104,8 +113,9 @@ async function promptHidden(question) {
     });
 }
 export async function runKeysSet(provider, options = {}) {
-    if (!isValidProvider(provider)) {
-        console.error(`Unknown provider '${provider}'. Valid: ${KEYCHAIN_PROVIDER_IDS.join(", ")}`);
+    const norm = normalizeProvider(provider);
+    if (!norm) {
+        console.error(`Unknown provider '${provider}'. Valid: ${KEYCHAIN_PROVIDER_IDS.join(", ")} (agy is alias for google)`);
         process.exit(1);
     }
     const key = (await promptHidden(`Paste ${provider} API key (hidden): `)).trim();
@@ -124,7 +134,7 @@ export async function runKeysSet(provider, options = {}) {
         console.log(`Bitwarden vault: ${res.action} '${itemName}'.`);
     }
     try {
-        const ok = await setKeyForProvider(provider, key);
+        const ok = await setKeyForProvider(norm, key);
         if (!ok) {
             console.error("OS keychain unavailable (keytar failed to load or secret service backend unavailable).");
             console.error("Common on Linux: install the runtime library, e.g.");
@@ -184,13 +194,35 @@ export async function runKeysList() {
     const chatStored = await listChatSecrets();
     // Load OAuth tokens for supported providers
     const { loadTokens } = await import("../providers/auth/token-store.js");
+    const { getOAuthProviderConfig } = await import("../providers/auth/registry.js");
     const oauthRows = [];
     const oauthIds = await getOAuthProviderIds();
     for (const p of oauthIds) {
         try {
-            const tokens = await loadTokens(p);
+            let tokens = await loadTokens(p);
+            if (!tokens && p === "google") {
+                // Import from agy storage only for fresh (non-expired) tokens.
+                // Stale agy tokens should be cleaned by running `keys logout google` + removing old .gemini file.
+                const { loadAgyTokensWithRefresh } = await import("../providers/auth/gemini-oauth.js");
+                const agyTokens = await loadAgyTokensWithRefresh();
+                if (agyTokens && Date.now() < agyTokens.expiresAt) {
+                    tokens = agyTokens;
+                }
+            }
             if (tokens) {
-                oauthRows.push({ provider: p, email: tokens.email, expiresAt: tokens.expiresAt });
+                if (Date.now() < tokens.expiresAt) {
+                    const cfg = await getOAuthProviderConfig(p);
+                    const display = cfg?.displayName ?? p;
+                    oauthRows.push({ provider: p, display, email: tokens.email, expiresAt: tokens.expiresAt });
+                }
+                else if (p === "google") {
+                    // auto-clean stale Agy token from our store (imported from old ~/.gemini)
+                    try {
+                        const { deleteTokens } = await import("../providers/auth/token-store.js");
+                        await deleteTokens("google");
+                    }
+                    catch { }
+                }
             }
         }
         catch {
@@ -202,7 +234,7 @@ export async function runKeysList() {
         console.log("No keys stored in OS keychain.");
         console.log("Run 'muonroi-cli keys set <provider>' or 'muonroi-cli keys import-bw' to add some.");
         console.log("Run 'muonroi-cli keys login openai' to log in with your OpenAI subscription.");
-        console.log("Run 'muonroi-cli keys login google' to log in with your Google account.");
+        console.log("Run 'muonroi-cli keys login google' or 'keys login agy' to log in with Agy (Google OAuth).");
         console.log("Run 'muonroi-cli keys login xai' to log in with your SuperGrok / X Premium+ subscription.");
         return;
     }
@@ -215,7 +247,7 @@ export async function runKeysList() {
             const account = row.email ?? "(no email)";
             const expiry = new Date(row.expiresAt).toLocaleString();
             const expired = Date.now() > row.expiresAt ? " [EXPIRED]" : "";
-            console.log(`${row.provider.padEnd(12)} ${account.padEnd(26)} ${expiry}${expired}`);
+            console.log(`${row.display.padEnd(12)} ${account.padEnd(26)} ${expiry}${expired}`);
         }
         console.log("");
     }
@@ -254,12 +286,37 @@ export async function runKeysList() {
     }
 }
 export async function runKeysDelete(provider) {
-    if (!isValidProvider(provider)) {
-        console.error(`Unknown provider '${provider}'. Valid: ${KEYCHAIN_PROVIDER_IDS.join(", ")}`);
+    const norm = normalizeProvider(provider);
+    if (!norm) {
+        console.error(`Unknown provider '${provider}'. Valid: ${KEYCHAIN_PROVIDER_IDS.join(", ")} (agy is alias for google)`);
         process.exit(1);
     }
-    const ok = await deleteKeyForProvider(provider);
+    const ok = await deleteKeyForProvider(norm);
     console.log(ok ? `Deleted ${provider} key from keychain.` : `No ${provider} key was stored.`);
+    // If deleting google/agy, also clean the OAuth token (Agy uses the google slot for its OAuth)
+    if (norm === "google") {
+        try {
+            const { loadTokens, deleteTokens } = await import("../providers/auth/token-store.js");
+            const { getOAuthProviderConfig } = await import("../providers/auth/registry.js");
+            const tokens = await loadTokens("google");
+            if (tokens) {
+                const cfg = await getOAuthProviderConfig("google");
+                if (cfg?.provider) {
+                    try {
+                        await cfg.provider.revoke(tokens);
+                    }
+                    catch {
+                        // best effort
+                    }
+                }
+                await deleteTokens("google");
+                console.log(`Also cleared Agy/Google OAuth token.`);
+            }
+        }
+        catch {
+            // ignore secondary errors
+        }
+    }
 }
 export async function runKeysExport(filePath) {
     const providers = {};
@@ -330,13 +387,14 @@ export async function runKeysImport(filePath) {
     let imported = 0;
     let skipped = 0;
     for (const [provider, key] of entries) {
-        if (!isValidProvider(provider)) {
+        const norm = normalizeProvider(provider);
+        if (!norm) {
             console.warn(`Skipping unknown provider '${provider}' in bundle.`);
             skipped++;
             continue;
         }
         try {
-            const ok = await setKeyForProvider(provider, key);
+            const ok = await setKeyForProvider(norm, key);
             if (ok) {
                 imported++;
                 console.log(`✓ ${provider} → keychain (${maskKey(key)})`);
@@ -388,7 +446,8 @@ export async function runKeysImportBw(opts = {}) {
     let imported = 0;
     let skipped = 0;
     for (const provider of requested) {
-        if (!isValidProvider(provider)) {
+        const norm = normalizeProvider(provider);
+        if (!norm) {
             console.warn(`Skip unknown provider: ${provider}`);
             skipped++;
             continue;
@@ -407,7 +466,7 @@ export async function runKeysImportBw(opts = {}) {
             continue;
         }
         try {
-            const ok = await setKeyForProvider(provider, key);
+            const ok = await setKeyForProvider(norm, key);
             if (!ok) {
                 console.warn(`! ${provider} — OS keychain unavailable (keytar or secret service backend).`);
                 console.warn("  Linux fix: sudo dnf install libsecret   (Fedora)  or  sudo apt-get install libsecret-1-0 (Ubuntu)");
@@ -620,18 +679,36 @@ export async function runChatImportBw(opts = {}) {
  */
 export async function runKeysLogin(provider) {
     const oauthIds = await getOAuthProviderIds();
-    if (!oauthIds.includes(provider)) {
-        console.error(`OAuth login not supported for '${provider}'. Supported: ${oauthIds.join(", ")}`);
+    const norm = provider.toLowerCase() === "agy" ? "google" : provider;
+    if (!oauthIds.includes(norm)) {
+        const supported = oauthIds.map((id) => (id === "google" ? "google (or agy)" : id)).join(", ");
+        console.error(`OAuth login not supported for '${provider}'. Supported: ${supported}`);
         process.exit(1);
     }
     const { getOAuthProviderConfig } = await import("../providers/auth/registry.js");
     const { saveTokens } = await import("../providers/auth/token-store.js");
-    const cfg = await getOAuthProviderConfig(provider);
+    const cfg = await getOAuthProviderConfig(norm);
     if (!cfg) {
         console.error(`OAuth provider '${provider}' is registered but failed to load.`);
         process.exit(1);
     }
     const name = cfg.displayName;
+    // Special handling for google: prefer importing/reusing token from agy local config
+    // (~/.gemini/oauth_creds.json) so existing agy login "just works" without browser.
+    if (provider === "google") {
+        const { loadAgyTokensWithRefresh } = await import("../providers/auth/gemini-oauth.js");
+        const existing = await loadAgyTokensWithRefresh();
+        if (existing?.accessToken) {
+            console.log(`Found existing agy token for ${existing.email || "(no email)"}.`);
+            console.log("Reusing it (refreshed if near expiry). No browser needed.");
+            const expiry = new Date(existing.expiresAt).toLocaleString();
+            const isExpired = Date.now() > existing.expiresAt;
+            console.log(`Token expires: ${expiry}${isExpired ? " (was expired, refresh attempted)" : ""}`);
+            console.log("Run 'muonroi-cli keys list' to verify.");
+            return;
+        }
+        // No existing agy token — fall through to normal browser flow (using agy client)
+    }
     console.log(`Logging in to ${name} via OAuth...`);
     console.log("A browser window will open. Complete the sign-in to continue.");
     const tokens = await cfg.provider.login({
@@ -646,12 +723,12 @@ export async function runKeysLogin(provider) {
                 console.log(`  User code: ${codeOrUrl}`);
             }
             console.log("\n  Waiting for authorization...");
-            if (provider === "xai") {
+            if (norm === "xai") {
                 console.log("  (If the xAI page shows a code instead of redirecting, paste it when the terminal prompts.)");
             }
         },
     });
-    await saveTokens(provider, tokens);
+    await saveTokens(norm, tokens);
     const emailDisplay = tokens.email ? ` (${tokens.email})` : "";
     const expiry = new Date(tokens.expiresAt).toLocaleString();
     console.log(`\nLogged in to ${name}${emailDisplay}. Token expires: ${expiry}`);
@@ -665,22 +742,24 @@ export async function runKeysLogin(provider) {
  */
 export async function runKeysLogout(provider) {
     const oauthIds = await getOAuthProviderIds();
-    if (!oauthIds.includes(provider)) {
-        console.error(`OAuth logout not supported for '${provider}'. Supported: ${oauthIds.join(", ")}`);
+    const norm = provider.toLowerCase() === "agy" ? "google" : provider;
+    if (!oauthIds.includes(norm)) {
+        const supported = oauthIds.map((id) => (id === "google" ? "google (or agy)" : id)).join(", ");
+        console.error(`OAuth logout not supported for '${provider}'. Supported: ${supported}`);
         process.exit(1);
     }
     const { getOAuthProviderConfig } = await import("../providers/auth/registry.js");
     const { loadTokens, deleteTokens } = await import("../providers/auth/token-store.js");
-    const tokens = await loadTokens(provider);
+    const tokens = await loadTokens(norm);
     if (!tokens) {
         console.log(`No OAuth tokens stored for '${provider}'.`);
         return;
     }
-    const cfg = await getOAuthProviderConfig(provider);
+    const cfg = await getOAuthProviderConfig(norm);
     if (cfg) {
         await cfg.provider.revoke(tokens); // best-effort
     }
-    await deleteTokens(provider);
+    await deleteTokens(norm);
     const name = cfg?.displayName ?? provider;
     console.log(`Logged out of ${name}. OAuth tokens revoked and deleted.`);
 }

package/dist/src/cli/usage-report.js

@@ -8,8 +8,8 @@ import { promises as fs } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { readCostLog } from "../usage/cost-log.js";
-import { readProductLedger } from "../usage/product-ledger.js";
 import { listDecisionLogDates, readDecisionLog } from "../usage/decision-log.js";
+import { readProductLedger } from "../usage/product-ledger.js";
 function muonroiHome(homeOverride) {
     return homeOverride ?? process.env.MUONROI_CLI_HOME ?? path.join(os.homedir(), ".muonroi-cli");
 }
@@ -284,7 +284,7 @@ export async function runSecurityAudit(opts = {}) {
     const highRiskCmds = overrides
         .map((d) => {
         const ctx = d.meta?.context || {};
-        let cmd = ctx.command ? String(ctx.command) : (ctx.shuru ? "[shuru]" : "");
+        let cmd = ctx.command ? String(ctx.command) : ctx.shuru ? "[shuru]" : "";
         if (cmd && cmd !== "[shuru]") {
             cmd = cmd.replace(/((?:key|token|secret|pwd|pass|auth|AWS_)[^=]*=)[^\s]+/gi, "$1[REDACTED]");
             cmd = cmd.replace(/https?:\/\/\S*?(?:key|token|secret)=\S+/gi, "[REDACTED_URL]");

package/dist/src/council/__tests__/abort-threading.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/council/__tests__/abort-threading.test.js

@@ -0,0 +1,193 @@
+/**
+ * Abort-signal threading contract for the council subsystem.
+ *
+ * Bug this guards: a user-abort signal that reaches `runCouncil(options.signal)`
+ * was never forwarded to the `generate`-based call path (clarify, research-need,
+ * leader-eval, opening statements, round summary, synthesis, debate planning).
+ * `llm.generate` had no `signal` parameter at all and `withTimeoutSignal(undefined,…)`
+ * was hard-coded — so pressing Esc/Ctrl-C mid-council did nothing and the run
+ * continued making LLM calls to completion.
+ *
+ * The fix:
+ *  1. `CouncilLLM.generate` accepts a trailing `signal?` and threads it into the
+ *     SDK call via `withTimeoutSignal(signal, …)`.
+ *  2. `runCouncil` wraps the injected `llm` with `withCouncilSignal(llm, signal)`
+ *     so EVERY generate call site (none of which pass a signal) inherits it.
+ *  3. `planDebate` forwards the signal to its direct `generateObject` attempt.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { withCouncilSignal } from "../index.js";
+/** Recording fake — captures the `signal` argument each method received. */
+function recordingLlm(generateReply = () => "{}") {
+    const calls = [];
+    const llm = {
+        generate: async (_modelId, _system, prompt, _maxTokens, _onUsage, signal) => {
+            calls.push({ kind: "generate", signal });
+            return generateReply(prompt);
+        },
+        debate: async (_modelId, _system, _prompt, signal) => {
+            calls.push({ kind: "debate", signal });
+            return { text: "ok", toolCalls: [] };
+        },
+        research: async (_modelId, _topic, _ctx, signal) => {
+            calls.push({ kind: "research", signal });
+            return "findings";
+        },
+    };
+    return { llm, calls };
+}
+describe("withCouncilSignal — injects the council abort signal into generate", () => {
+    it("forwards the wrapper signal when the caller passes none", async () => {
+        const { llm, calls } = recordingLlm();
+        const ac = new AbortController();
+        const wrapped = withCouncilSignal(llm, ac.signal);
+        // tracedGenerate / openingWithRetry / judgeReadiness all call generate with
+        // <= 4 positional args — i.e. no signal. The wrapper must inject ours.
+        await wrapped.generate("m", "sys", "prompt", 256);
+        expect(calls).toHaveLength(1);
+        expect(calls[0].signal).toBe(ac.signal);
+    });
+    it("lets an explicit caller signal win over the injected one", async () => {
+        const { llm, calls } = recordingLlm();
+        const injected = new AbortController().signal;
+        const explicit = new AbortController().signal;
+        const wrapped = withCouncilSignal(llm, injected);
+        await wrapped.generate("m", "sys", "prompt", 256, undefined, explicit);
+        expect(calls[0].signal).toBe(explicit);
+    });
+    it("is a no-op passthrough when no signal is configured (sprint path)", () => {
+        const { llm } = recordingLlm();
+        expect(withCouncilSignal(llm, undefined)).toBe(llm);
+    });
+});
+describe("createCouncilLLM.generate — honours the parent abort signal", () => {
+    beforeEach(() => vi.resetModules());
+    it("propagates an already-aborted parent into the SDK abortSignal", async () => {
+        const captured = [];
+        vi.doMock("ai", () => ({
+            generateText: vi.fn().mockImplementation(async (args) => {
+                captured.push(args);
+                return { text: "done", usage: { inputTokens: 1, outputTokens: 1 }, finishReason: "stop" };
+            }),
+            stepCountIs: vi.fn().mockReturnValue({ __step: 1 }),
+        }));
+        vi.doMock("../../providers/keychain.js", () => ({
+            loadKeyForProvider: vi.fn().mockResolvedValue("test-key"),
+        }));
+        vi.doMock("../../providers/runtime.js", () => ({
+            detectProviderForModel: vi.fn().mockReturnValue("openai"),
+            createProviderFactory: vi.fn().mockReturnValue({ factory: {} }),
+            createProviderFactoryAsync: vi.fn().mockResolvedValue({ factory: {} }),
+            resolveModelRuntime: vi.fn().mockReturnValue({ model: {}, providerOptions: undefined }),
+        }));
+        const { createCouncilLLM } = await import("../llm.js");
+        const stats = { calls: 0, startMs: Date.now(), phases: [] };
+        const llm = createCouncilLLM({}, "agent", undefined, stats);
+        const ac = new AbortController();
+        ac.abort(new Error("user pressed Esc"));
+        await llm.generate("gpt-4o", "sys", "prompt", 256, undefined, ac.signal);
+        expect(captured).toHaveLength(1);
+        const sig = captured[0].abortSignal;
+        expect(sig).toBeDefined();
+        expect(sig?.aborted).toBe(true);
+    });
+    it("does NOT abort the SDK call when the parent is live", async () => {
+        const captured = [];
+        vi.doMock("ai", () => ({
+            generateText: vi.fn().mockImplementation(async (args) => {
+                captured.push(args);
+                return { text: "done", usage: { inputTokens: 1, outputTokens: 1 }, finishReason: "stop" };
+            }),
+            stepCountIs: vi.fn().mockReturnValue({ __step: 1 }),
+        }));
+        vi.doMock("../../providers/keychain.js", () => ({
+            loadKeyForProvider: vi.fn().mockResolvedValue("test-key"),
+        }));
+        vi.doMock("../../providers/runtime.js", () => ({
+            detectProviderForModel: vi.fn().mockReturnValue("openai"),
+            createProviderFactory: vi.fn().mockReturnValue({ factory: {} }),
+            createProviderFactoryAsync: vi.fn().mockResolvedValue({ factory: {} }),
+            resolveModelRuntime: vi.fn().mockReturnValue({ model: {}, providerOptions: undefined }),
+        }));
+        const { createCouncilLLM } = await import("../llm.js");
+        const stats = { calls: 0, startMs: Date.now(), phases: [] };
+        const llm = createCouncilLLM({}, "agent", undefined, stats);
+        const ac = new AbortController();
+        await llm.generate("gpt-4o", "sys", "prompt", 256, undefined, ac.signal);
+        const sig = captured[0].abortSignal;
+        expect(sig?.aborted).toBe(false);
+    });
+});
+describe("evaluateResearchNeed — generate call inherits the wrapped signal", () => {
+    it("records the council signal on the underlying generate call", async () => {
+        const { evaluateResearchNeed } = await import("../debate.js");
+        const { llm, calls } = recordingLlm(() => '{"needsResearch": false}');
+        const ac = new AbortController();
+        const wrapped = withCouncilSignal(llm, ac.signal);
+        const spec = {
+            problemStatement: "x",
+            constraints: [],
+            successCriteria: [],
+            scope: "",
+            rawQA: [],
+        };
+        const gen = evaluateResearchNeed(spec, "leader-model", "ctx", wrapped, false);
+        let step = await gen.next();
+        while (!step.done)
+            step = await gen.next();
+        const genCalls = calls.filter((c) => c.kind === "generate");
+        expect(genCalls.length).toBeGreaterThan(0);
+        for (const c of genCalls)
+            expect(c.signal).toBe(ac.signal);
+    });
+});
+describe("planDebate — forwards signal to the direct generateObject attempt", () => {
+    beforeEach(() => vi.resetModules());
+    it("passes an abort-linked signal to generateObject", async () => {
+        const captured = [];
+        vi.doMock("ai", () => ({
+            generateObject: vi.fn().mockImplementation(async (args) => {
+                captured.push(args);
+                return {
+                    object: {
+                        intentSummary: "s",
+                        stances: [
+                            { name: "A", lens: "l1" },
+                            { name: "B", lens: "l2" },
+                        ],
+                        outputShape: { kind: "decision", sections: [{ key: "k", heading: "H", shape: "list" }], guardrails: [] },
+                    },
+                };
+            }),
+        }));
+        vi.doMock("../../providers/keychain.js", () => ({
+            loadKeyForProvider: vi.fn().mockResolvedValue("test-key"),
+        }));
+        vi.doMock("../../providers/runtime.js", () => ({
+            detectProviderForModel: vi.fn().mockReturnValue("openai"),
+            createProviderFactory: vi.fn().mockReturnValue({ factory: {} }),
+            createProviderFactoryAsync: vi.fn().mockResolvedValue({ factory: {} }),
+            resolveModelRuntime: vi.fn().mockReturnValue({ model: {}, providerOptions: undefined }),
+        }));
+        const { planDebate } = await import("../debate-planner.js");
+        const spec = {
+            problemStatement: "x",
+            constraints: [],
+            successCriteria: [],
+            scope: "",
+            rawQA: [],
+        };
+        const ac = new AbortController();
+        ac.abort(new Error("user pressed Esc"));
+        const { llm } = recordingLlm();
+        const gen = planDebate(spec, "leader-model", llm, undefined, undefined, undefined, undefined, ac.signal);
+        let step = await gen.next();
+        while (!step.done)
+            step = await gen.next();
+        expect(captured).toHaveLength(1);
+        const sig = captured[0].abortSignal;
+        expect(sig).toBeDefined();
+        expect(sig?.aborted).toBe(true);
+    });
+});
+//# sourceMappingURL=abort-threading.test.js.map

package/dist/src/council/__tests__/clarification-prompt.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { buildClarificationPrompt, buildReadinessJudgePrompt } from "../prompts.js";
+import { buildClarificationPrompt, buildReadinessJudgePrompt, buildSpecSynthesisPrompt } from "../prompts.js";
 // Guards the de-robotized askcard contract (2026-06-14). The council clarifier
 // used to (a) force "AT LEAST 2 questions" → rambling/over-asking, (b) tell the
 // model to OMIT a recommendation unless certain → unranked option lists, and
@@ -34,6 +34,26 @@ describe("buildClarificationPrompt — de-robotized askcard", () => {
         expect(system).toMatch(/Output ONLY a JSON array/);
     });
 });
+// Issue A — language drift. buildSpecSynthesisPrompt had NO language rule, so
+// DeepSeek defaulted the brief to English even for a Vietnamese topic. Because
+// the final synthesis detects its output language FROM this problemStatement,
+// an English brief dragged the whole council off the user's language. The fix
+// adds a mandatory "use the user's language" rule. These lock it in.
+describe("buildSpecSynthesisPrompt — user-language rule (issue A)", () => {
+    const { system } = buildSpecSynthesisPrompt("Xây dựng REST API quản lý todo", "", [
+        { question: "Auth?", answer: "Không cần" },
+    ]);
+    it("instructs writing every field in the user's language, not defaulting to English", () => {
+        expect(system).toMatch(/Language Rule/i);
+        expect(system).toMatch(/SAME[\s\S]*language the user used/i);
+        expect(system).toMatch(/Do NOT default to[\s\S]*English/i);
+    });
+    it("keeps the mock-router substring so council-e2e fixtures still match", () => {
+        // tests/council/council-e2e.ts routes the spec-synthesis mock on this exact
+        // phrase — changing it silently diverges the e2e flow. Guard it.
+        expect(system).toContain("synthesizing a discussion brief");
+    });
+});
 describe("buildReadinessJudgePrompt — no JS string-concat leak", () => {
     const { system } = buildReadinessJudgePrompt("Optimize queries", [], {
         problemStatement: "p",

package/dist/src/council/__tests__/council-turn-length-emit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/council/__tests__/council-turn-length-emit.test.js

@@ -0,0 +1,130 @@
+/**
+ * council-turn-length emit contract (G2-b).
+ *
+ * Drives the REAL `runDebate` generator with a recording CouncilLLM and a
+ * capturing `globalThis.__muonroiAgentRuntime`, then asserts the observe-only
+ * `council-turn-length` harness event fires for each fully-assembled speaker
+ * turn — opening statements (round 0) and discussion turns (round 1+) — carrying
+ * the right charCount / wordCount / round / model / correlationId.
+ *
+ * This exercises the production emit path in src/council/debate.ts end-to-end
+ * (not a mocked re-implementation). The MCP harness tool surface only exposes
+ * toast/stream.delta via tui_last_event, so this generator-level drive is the
+ * faithful wire-level proof that the event fires during a real council run.
+ */
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { runDebate } from "../debate.js";
+const OPENING = "Opening alpha beta gamma."; // 25 chars, 4 words
+const ROUND = "Round response one two three."; // round-turn text
+function recordingLlm() {
+    return {
+        // openingWithRetry + leader-eval + summaries all go through generate. Opening
+        // statements use the returned text verbatim → that drives the round-0 emit.
+        generate: async () => OPENING,
+        // debateWithRetry (discussion turns) is the ONLY caller of debate → drives the
+        // round-1+ emit with a known, non-failure string.
+        debate: async () => ({ text: ROUND, toolCalls: [] }),
+        research: async () => "findings",
+    };
+}
+function makeParticipants() {
+    return [
+        { role: "architect", model: "model-arch", position: "", stance: { name: "architect", lens: "design" } },
+        { role: "qa", model: "model-qa", position: "", stance: { name: "qa", lens: "risk" } },
+    ];
+}
+function makeSpec() {
+    return {
+        problemStatement: "Decide X vs Y for a small service.",
+        constraints: [],
+        successCriteria: [],
+        scope: "",
+        rawQA: [],
+    };
+}
+function makeConfig(participants) {
+    return {
+        topic: "X vs Y",
+        conversationContext: "",
+        leaderModelId: "model-leader",
+        participants,
+        debatePlan: {
+            intentSummary: "Pick the better option.",
+            stances: [
+                { name: "architect", lens: "design" },
+                { name: "qa", lens: "risk" },
+            ],
+            outputShape: {
+                kind: "decision",
+                sections: [{ key: "rec", heading: "Recommendation", shape: "list" }],
+                guardrails: [],
+            },
+            plannedRounds: 1,
+        },
+        // Skip research so the flow goes straight to opening statements deterministically.
+        researchSkipOverride: true,
+        runId: "sess-turnlen-test",
+    };
+}
+describe("council-turn-length emit (real runDebate)", () => {
+    let captured;
+    let prevRuntime;
+    beforeEach(() => {
+        captured = [];
+        const g = globalThis;
+        prevRuntime = g.__muonroiAgentRuntime;
+        g.__muonroiAgentRuntime = { emitEvent: (e) => captured.push(e) };
+    });
+    afterEach(() => {
+        globalThis.__muonroiAgentRuntime = prevRuntime;
+    });
+    function turnLengthEvents() {
+        return captured.filter((e) => e.t === "event" && e.kind === "council-turn-length");
+    }
+    it("emits a round-0 event per opening speaker with correct counts + correlationId", async () => {
+        const participants = makeParticipants();
+        const gen = runDebate(makeSpec(), makeConfig(participants), recordingLlm());
+        let step = await gen.next();
+        while (!step.done)
+            step = await gen.next();
+        const opening = turnLengthEvents().filter((e) => e.round === 0);
+        // One opening statement per participant.
+        expect(opening.length).toBe(2);
+        for (const e of opening) {
+            expect(e.charCount).toBe(OPENING.length);
+            expect(e.wordCount).toBe(4);
+            expect(e.correlationId).toBe("sess-turnlen-test");
+            expect(typeof e.model).toBe("string");
+            expect(e.model.length).toBeGreaterThan(0);
+        }
+        // Roles are the participant stance names / roles.
+        const roles = opening.map((e) => e.role);
+        expect(roles).toContain("architect");
+        expect(roles).toContain("qa");
+    });
+    it("emits round-1 discussion-turn events with the discussion text's counts", async () => {
+        const gen = runDebate(makeSpec(), makeConfig(makeParticipants()), recordingLlm());
+        let step = await gen.next();
+        while (!step.done)
+            step = await gen.next();
+        const round1 = turnLengthEvents().filter((e) => e.round === 1);
+        expect(round1.length).toBeGreaterThanOrEqual(1);
+        for (const e of round1) {
+            expect(e.charCount).toBe(ROUND.trim().length);
+            expect(e.wordCount).toBe(ROUND.trim().split(/\s+/).filter(Boolean).length);
+            expect(e.correlationId).toBe("sess-turnlen-test");
+        }
+    });
+    it("does not emit when no agent runtime is installed (normal user mode)", async () => {
+        globalThis.__muonroiAgentRuntime = undefined;
+        const localCaptured = [];
+        // Re-install a capturer AFTER clearing to prove the helper truly no-ops when
+        // the runtime is absent: here it's absent, so localCaptured stays empty.
+        const gen = runDebate(makeSpec(), makeConfig(makeParticipants()), recordingLlm());
+        let step = await gen.next();
+        while (!step.done)
+            step = await gen.next();
+        expect(localCaptured.length).toBe(0);
+    });
+});
+//# sourceMappingURL=council-turn-length-emit.test.js.map

package/dist/src/council/__tests__/debate-round-budget.test.d.ts

@@ -0,0 +1 @@
+export {};