muonroi-cli 1.7.1 → 1.8.0

package/dist/src/agent-harness/mock-model.js

@@ -22,6 +22,7 @@
  *   const calls = handle.calls; // LanguageModelV3CallOptions[]
  *   expect(calls[0].maxOutputTokens).toBeUndefined();
  */
+import { APICallError } from "@ai-sdk/provider";
 import { simulateReadableStream } from "ai";
 import { MockLanguageModelV3 } from "ai/test";
 function isNestedArray(v) {
@@ -71,7 +72,7 @@ export function createMockModel(fx) {
             const text = generates.length > 0 ? generates[Math.min(genIdx, generates.length - 1)] : "{}";
             genIdx += 1;
             if (process.env.MUONROI_DEBUG_MOCK_MODEL === "1") {
-                process.stderr.write(`[mock-model] doGenerate #${genIdx} → ${text.length} chars\n`);
+                process.stderr.write(`[mock-model] doGenerate #${genIdx} → ${text.length} chars\nCALLER:\n${new Error().stack}\n`);
             }
             return {
                 content: [{ type: "text", text }],
@@ -201,12 +202,40 @@ function normalizeStreamChunks(chunks) {
     return chunks.map((c) => {
         if (c && c.type === "error") {
             const raw = c.error;
-            const err = raw instanceof Error ? raw : new Error(typeof raw === "string" ? raw : "mock LLM error");
-            return { ...c, error: err };
+            return { ...c, error: buildFixtureError(raw) };
         }
         return c;
     });
 }
+/**
+ * Turn a fixture `error` payload into the right runtime shape:
+ * - an `APICallError` when the payload is an object carrying a `statusCode`
+ *   (or `apiCallError: true`), so harness specs can exercise the orchestrator's
+ *   status-aware paths (humanizeApiError 5xx canned text, summarizeApiErrorForLog
+ *   forensics, retry classifier). `APICallError.isInstance` duck-types on a
+ *   shared marker, so constructing it here satisfies the `isInstance` checks in
+ *   error-utils.ts. A pure JSON fixture cannot otherwise build one (it would
+ *   arrive as a plain string).
+ * - a plain `Error` for string payloads (the common transient-message case).
+ */
+function buildFixtureError(raw) {
+    if (raw instanceof Error)
+        return raw;
+    if (raw && typeof raw === "object") {
+        const o = raw;
+        if (o.apiCallError === true || typeof o.statusCode === "number") {
+            return new APICallError({
+                message: o.message ?? `mock API error${o.statusCode ? ` (HTTP ${o.statusCode})` : ""}`,
+                url: o.url ?? "https://mock.invalid/v1/chat/completions",
+                requestBodyValues: {},
+                statusCode: o.statusCode,
+                responseBody: o.responseBody,
+                isRetryable: o.isRetryable,
+            });
+        }
+    }
+    return new Error(typeof raw === "string" ? raw : "mock LLM error");
+}
 export async function loadMockModelFromDir(dir) {
     // Diagnostic logging path. Without these messages, every failure mode
     // (directory missing, no .json files, malformed JSON, no `model` block)

package/dist/src/agent-harness/test-spawn.js

@@ -131,7 +131,9 @@ async function spawnWindows(args, opts) {
         await waitForHandshake(outSocket, timeoutMs);
     }
     catch (err) {
-        proc.kill();
+        if (proc && typeof proc.kill === "function") {
+            proc.kill();
+        }
         inServer.close();
         outServer.close();
         throw err;

package/dist/src/chat/chat-keychain.js

@@ -86,7 +86,15 @@ export async function deleteChatSecret(id) {
     const kt = await loadKeytar();
     if (!kt?.deletePassword)
         return false;
-    return kt.deletePassword(KEYCHAIN_SERVICE, ACCOUNT_BY_CHAT[id]);
+    try {
+        return await kt.deletePassword(KEYCHAIN_SERVICE, ACCOUNT_BY_CHAT[id]);
+    }
+    catch (err) {
+        if (process.env.DEBUG || process.env.MUONROI_DEBUG_KEYCHAIN) {
+            console.error(`[chat-keychain] deletePassword backend error for ${id}:`, err?.message || err);
+        }
+        return false;
+    }
 }
 /**
  * List all stored chat secret IDs.

package/dist/src/cli/cost-forensics.js

@@ -43,21 +43,21 @@ export function collectCostForensics(sessionId) {
     if (!session)
         throw new Error(`Session not found: ${sessionId}`);
     const rows = db
-        .prepare(`
-    SELECT id, source, model, message_seq, input_tokens, output_tokens,
-           cache_read_tokens, cache_creation_tokens, cost_micros, created_at,
-           provider_options_shape
-    FROM usage_events
-    WHERE session_id = ?
-    ORDER BY id ASC
+        .prepare(`
+    SELECT id, source, model, message_seq, input_tokens, output_tokens,
+           cache_read_tokens, cache_creation_tokens, cost_micros, created_at,
+           provider_options_shape
+    FROM usage_events
+    WHERE session_id = ?
+    ORDER BY id ASC
   `)
         .all(sessionId);
     const counts = db
-        .prepare(`
-    SELECT event_type, COUNT(*) AS c
-    FROM interaction_logs
-    WHERE session_id = ?
-    GROUP BY event_type
+        .prepare(`
+    SELECT event_type, COUNT(*) AS c
+    FROM interaction_logs
+    WHERE session_id = ?
+    GROUP BY event_type
   `)
         .all(sessionId);
     const countMap = new Map(counts.map((r) => [r.event_type, r.c]));

package/dist/src/cli/keys.d.ts

@@ -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 { type ChatSecretId } from "../chat/chat-keychain.js";
 export interface KeysSetOptions {

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 {};