muonroi-cli 1.8.0 → 1.8.3

package/dist/src/cli/keys.test.js

@@ -1,86 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-describe("runKeysCleanupSettings", () => {
-    let tmpHome;
-    let originalHome;
-    let originalUserprofile;
-    beforeEach(async () => {
-        tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-keys-"));
-        await fs.mkdir(path.join(tmpHome, ".muonroi-cli"), { recursive: true });
-        originalHome = process.env.HOME;
-        originalUserprofile = process.env.USERPROFILE;
-        process.env.HOME = tmpHome;
-        process.env.USERPROFILE = tmpHome;
-        vi.resetModules();
-    });
-    afterEach(async () => {
-        if (originalHome === undefined)
-            delete process.env.HOME;
-        else
-            process.env.HOME = originalHome;
-        if (originalUserprofile === undefined)
-            delete process.env.USERPROFILE;
-        else
-            process.env.USERPROFILE = originalUserprofile;
-        await fs.rm(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-        vi.restoreAllMocks();
-    });
-    it("strips top-level apiKey and providers.*.apiKey, drops empty provider blocks", async () => {
-        const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-        await fs.writeFile(settingsPath, JSON.stringify({
-            apiKey: "sk-leaked-top",
-            defaultModel: "deepseek-v4-flash",
-            providers: {
-                deepseek: { apiKey: "sk-leaked-ds" },
-                anthropic: { apiKey: "sk-leaked-an", baseURL: "https://example" },
-            },
-            mcp: { servers: [] },
-        }, null, 2));
-        const { runKeysCleanupSettings } = await import("./keys.js");
-        // Capture stdout — runKeysCleanupSettings writes the backup path which we don't want in test output.
-        const logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        await runKeysCleanupSettings();
-        logSpy.mockRestore();
-        const cleaned = JSON.parse(await fs.readFile(settingsPath, "utf8"));
-        expect(cleaned.apiKey).toBeUndefined();
-        expect(cleaned.providers?.deepseek).toBeUndefined(); // empty block dropped
-        expect(cleaned.providers?.anthropic?.apiKey).toBeUndefined();
-        expect(cleaned.providers?.anthropic?.baseURL).toBe("https://example");
-        expect(cleaned.defaultModel).toBe("deepseek-v4-flash");
-        expect(cleaned.mcp).toBeDefined();
-        // A backup with timestamp suffix should exist.
-        const dirEntries = await fs.readdir(path.join(tmpHome, ".muonroi-cli"));
-        expect(dirEntries.some((f) => f.startsWith("user-settings.json.bak."))).toBe(true);
-    });
-    it("drops the providers map entirely when all provider blocks become empty", async () => {
-        const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-        await fs.writeFile(settingsPath, JSON.stringify({
-            defaultModel: "x",
-            providers: {
-                deepseek: { apiKey: "sk-1234567890123456789012" },
-                anthropic: { apiKey: "sk-ant-1234567890123456789012" },
-            },
-        }));
-        const { runKeysCleanupSettings } = await import("./keys.js");
-        const logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        await runKeysCleanupSettings();
-        logSpy.mockRestore();
-        const cleaned = JSON.parse(await fs.readFile(settingsPath, "utf8"));
-        expect(cleaned.providers).toBeUndefined();
-        expect(cleaned.defaultModel).toBe("x");
-    });
-    it("is a no-op if the settings file is already clean", async () => {
-        const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-        const original = { defaultModel: "y", roleModels: { leader: "y" } };
-        await fs.writeFile(settingsPath, JSON.stringify(original));
-        const { runKeysCleanupSettings } = await import("./keys.js");
-        const logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        await runKeysCleanupSettings();
-        logSpy.mockRestore();
-        const cleaned = JSON.parse(await fs.readFile(settingsPath, "utf8"));
-        expect(cleaned).toEqual(original);
-    });
-});
-//# sourceMappingURL=keys.test.js.map

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

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

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

@@ -1,193 +0,0 @@
-/**
- * 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__/accounting.test.d.ts

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

package/dist/src/council/__tests__/accounting.test.js

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "vitest";
-// ── CQ-01: stats.calls accuracy ─────────────────────────────────────────────
-describe("CQ-01: council stats accounting", () => {
-    it("RunCouncilOptions accepts councilStats field", async () => {
-        // Type-level test: if this compiles, the interface is correct
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const {} = await import("../index.js"); // ensure module resolves
-        const options = {
-            councilStats: stats,
-        };
-        expect(options.councilStats).toBe(stats);
-    });
-    it("shared CouncilStats object is mutated by reference — same object tracks calls", () => {
-        const sharedStats = { calls: 0, startMs: Date.now(), phases: [] };
-        // Simulate what createCouncilLLM.generate does: stats.calls++
-        const simulateLLMCall = (s) => {
-            s.calls++;
-        };
-        simulateLLMCall(sharedStats);
-        simulateLLMCall(sharedStats);
-        expect(sharedStats.calls).toBe(2);
-        // Verify the same ref from options would read the correct count
-        const options = { councilStats: sharedStats };
-        expect(options.councilStats?.calls).toBe(2);
-    });
-});
-// ── CQ-02: finalPositions propagation ───────────────────────────────────────
-describe("CQ-02: finalPositions reflects debate-mutated positions", () => {
-    it("DebateState includes active field with CouncilParticipant array", () => {
-        // Type-level test: verify DebateState.active field exists post Plan-01
-        const fakeActive = [
-            { role: "primary", model: "gpt-4", position: "Position after debate round" },
-            { role: "secondary", model: "claude-3", position: "Counter-position after round" },
-        ];
-        const fakeDebateState = {
-            spec: { problemStatement: "test", constraints: [], successCriteria: [], scope: "", rawQA: [] },
-            exchangeLogs: new Map(),
-            runningSummary: "summary",
-            roundCount: 1,
-            active: fakeActive, // This field must exist — fails if Plan 01 not done
-        };
-        expect(fakeDebateState.active).toHaveLength(2);
-        expect(fakeDebateState.active[0].position).toBe("Position after debate round");
-        expect(fakeDebateState.active[1].position).toBe("Counter-position after round");
-    });
-    it("positions read from debateState.active are non-empty after debate mutations", () => {
-        const active = [{ role: "primary", model: "gpt-4", position: "" }];
-        // Simulate what debate.ts does during rounds
-        active[0].position = "Mutated position from round 1";
-        // Simulate what index.ts SHOULD do after fix (read from debateState.active)
-        const debateState = {
-            spec: { problemStatement: "topic", constraints: [], successCriteria: [], scope: "", rawQA: [] },
-            exchangeLogs: new Map(),
-            runningSummary: "",
-            roundCount: 1,
-            active,
-        };
-        const finalPositions = debateState.active.map((a) => ({
-            role: a.role,
-            position: a.position.slice(0, 1000),
-        }));
-        expect(finalPositions[0].position).toBe("Mutated position from round 1");
-        expect(finalPositions[0].position).not.toBe("");
-    });
-});
-//# sourceMappingURL=accounting.test.js.map

package/dist/src/council/__tests__/audit-replay.test.d.ts

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

package/dist/src/council/__tests__/audit-replay.test.js

@@ -1,241 +0,0 @@
-/**
- * CQ-24: audit-replay — E2E council memory assertions
- *
- * Verifies that after runCouncil completes:
- * 1. A [Council Memory] record is persisted via appendSystemMessage
- * 2. The [Council Memory] JSON is parseable and has required top-level fields
- * 3. stats.calls > 0 after a full run (accounting not broken)
- * 4. synthesis contains evidence signals from research output
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { appendSystemMessage, logInteraction } from "../../storage/index.js";
-// ── Module-level mocks — declared before any dynamic import ─────────────────
-vi.mock("../../storage/index", () => ({
-    appendSystemMessage: vi.fn(),
-    appendMessages: vi.fn(),
-    loadTranscript: vi.fn().mockReturnValue([]),
-    logInteraction: vi.fn(),
-}));
-vi.mock("../../ee/council-bridge.js", () => ({
-    queryExperience: vi.fn().mockResolvedValue({ warnings: [] }),
-}));
-vi.mock("../../ee/judge.js", () => ({
-    judgeCouncilOutcome: vi.fn().mockResolvedValue({ confidence: 0.8, reason: "test" }),
-}));
-vi.mock("../../ee/phase-outcome.js", () => ({
-    recordCouncilOutcome: vi.fn(),
-}));
-vi.mock("../../pil/pipeline.js", () => ({
-    runPipeline: vi.fn().mockResolvedValue({
-        taskType: "research",
-        domain: "backend",
-        outputStyle: "balanced",
-        grayAreas: [],
-    }),
-}));
-vi.mock("../leader.js", () => ({
-    resolveLeaderModelDetailed: vi.fn().mockResolvedValue({ modelId: "mock-leader", promotedFrom: null }),
-    resolveParticipants: vi.fn().mockResolvedValue([
-        { role: "analyst", model: "mock-a", position: "" },
-        { role: "critic", model: "mock-b", position: "" },
-    ]),
-}));
-vi.mock("../debate-planner.js", () => ({
-    // biome-ignore lint/correctness/useYield: mock returns immediately; consumer drains via .next()
-    planDebate: vi.fn().mockImplementation(async function* () {
-        return {
-            intentSummary: "Test debate intent",
-            stances: [
-                { name: "Analyst", lens: "Analyze carefully" },
-                { name: "Critic", lens: "Challenge assumptions" },
-            ],
-            outputShape: {
-                kind: "evaluation",
-                sections: [{ key: "findings", heading: "Findings", prompt: "List key findings", shape: "list" }],
-                guardrails: [],
-            },
-        };
-    }),
-}));
-vi.mock("../context.js", () => ({
-    buildCouncilContext: vi.fn().mockReturnValue("mock context"),
-    buildProjectSnapshot: vi.fn().mockResolvedValue({ snapshot: "", isEmpty: true }),
-}));
-vi.mock("../../utils/settings.js", async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        isCouncilMultiProviderPreferred: vi.fn().mockReturnValue(false),
-        getCouncilExperienceMode: vi.fn().mockReturnValue("advisory"),
-        loadMcpServers: vi.fn().mockReturnValue([]),
-        loadUserSettings: vi.fn().mockReturnValue({
-            apiKey: undefined,
-            defaultModel: "mock-model",
-            providers: {},
-            roleModels: {},
-        }),
-    };
-});
-// ── Helpers ──────────────────────────────────────────────────────────────────
-const SYNTHESIS_JSON = JSON.stringify({
-    type: "evaluation",
-    summary: "Council found strong evidence from docs/Council.md, tavily research, and snapshot:pw-001 of localhost:3010.",
-    findings: [
-        "docs/Council.md:42 shows the flow",
-        "tavily found https://tavily.example.com/results",
-        "snapshot:pw-001 localhost:3010 screenshot confirms UI state",
-    ],
-    plan: { steps: [], estimatedComplexity: "trivial", prerequisites: [] },
-});
-const RESEARCH_OUTPUT = [
-    "## Source Code Findings",
-    "- [docs/Council.md:42] Council flow",
-    "",
-    "## Internet Findings",
-    "- [https://tavily.example.com/results]",
-    "",
-    "## Frontend Findings (live)",
-    "- [snapshot:pw-001] localhost:3010 screenshot",
-].join("\n");
-/** Builds a mock CouncilLLM for the audit-replay tests. */
-function buildMockLLM() {
-    return {
-        generate: vi.fn().mockResolvedValue(SYNTHESIS_JSON),
-        research: vi.fn().mockResolvedValue(RESEARCH_OUTPUT),
-        debate: vi.fn().mockResolvedValue({
-            text: "Position text [CONFIRMED via tavily:https://tavily.example.com]",
-            toolCalls: [{ toolName: "tavily_search", result: "found results" }],
-        }),
-    };
-}
-/** Drains a runCouncil AsyncGenerator and returns all emitted chunks. */
-async function drainCouncil(gen) {
-    const chunks = [];
-    let step = await gen.next();
-    while (!step.done) {
-        chunks.push(step.value);
-        step = await gen.next();
-    }
-    return chunks;
-}
-// ── Tests ────────────────────────────────────────────────────────────────────
-describe("audit-replay", () => {
-    let capturedMessages;
-    beforeEach(() => {
-        capturedMessages = [];
-        appendSystemMessage.mockImplementation((sessionId, content) => {
-            capturedMessages.push({ sessionId, content });
-        });
-        logInteraction.mockClear();
-    });
-    it("persists [Council Memory] after a full run", async () => {
-        const { runCouncil } = await import("../index.js");
-        const mockLLM = buildMockLLM();
-        const respondToQuestion = vi.fn().mockResolvedValue("skip");
-        const respondToPreflight = vi.fn().mockResolvedValue(true);
-        const processMessageFn = vi.fn().mockImplementation(async function* () {
-            yield { type: "done" };
-        });
-        const gen = runCouncil("Should we use gRPC internally?", "mock-model", [], "test-session-001", mockLLM, respondToQuestion, respondToPreflight, processMessageFn, { skipClarification: true });
-        await drainCouncil(gen);
-        const councilMemoryMessages = capturedMessages.filter((m) => m.content.startsWith("[Council Memory]"));
-        expect(councilMemoryMessages).toHaveLength(1);
-        expect(councilMemoryMessages[0].sessionId).toBe("test-session-001");
-    });
-    it("[Council Memory] record is parseable JSON with required fields", async () => {
-        const { runCouncil } = await import("../index.js");
-        const mockLLM = buildMockLLM();
-        const respondToQuestion = vi.fn().mockResolvedValue("skip");
-        const respondToPreflight = vi.fn().mockResolvedValue(true);
-        const processMessageFn = vi.fn().mockImplementation(async function* () {
-            yield { type: "done" };
-        });
-        const gen = runCouncil("Should we use gRPC internally?", "mock-model", [], "test-session-002", mockLLM, respondToQuestion, respondToPreflight, processMessageFn, { skipClarification: true });
-        await drainCouncil(gen);
-        const memMsg = capturedMessages.find((m) => m.content.startsWith("[Council Memory]"));
-        expect(memMsg).toBeDefined();
-        const jsonStr = memMsg.content.slice("[Council Memory] ".length);
-        const record = JSON.parse(jsonStr);
-        expect(record).toHaveProperty("topic");
-        expect(record).toHaveProperty("participants");
-        expect(record).toHaveProperty("finalPositions");
-        expect(record).toHaveProperty("synthesis");
-        expect(record).toHaveProperty("stats");
-    });
-    it("stats.calls > 0 after full run", async () => {
-        const { runCouncil } = await import("../index.js");
-        const sharedStats = { calls: 0, startMs: Date.now(), phases: [] };
-        const mockLLM = buildMockLLM();
-        // Wire stats.calls increments on each generate() call
-        mockLLM.generate.mockImplementation(async () => {
-            sharedStats.calls++;
-            return SYNTHESIS_JSON;
-        });
-        mockLLM.research.mockImplementation(async () => {
-            sharedStats.calls++;
-            return RESEARCH_OUTPUT;
-        });
-        mockLLM.debate.mockImplementation(async () => {
-            sharedStats.calls++;
-            return {
-                text: "Position text [CONFIRMED via tavily:https://tavily.example.com]",
-                toolCalls: [{ toolName: "tavily_search", result: "found results" }],
-            };
-        });
-        const respondToQuestion = vi.fn().mockResolvedValue("skip");
-        const respondToPreflight = vi.fn().mockResolvedValue(true);
-        const processMessageFn = vi.fn().mockImplementation(async function* () {
-            yield { type: "done" };
-        });
-        const gen = runCouncil("Should we use gRPC internally?", "mock-model", [], "test-session-003", mockLLM, respondToQuestion, respondToPreflight, processMessageFn, { skipClarification: true, councilStats: sharedStats });
-        await drainCouncil(gen);
-        expect(sharedStats.calls).toBeGreaterThan(0);
-    });
-    it("synthesis contains evidence signals from research output", async () => {
-        const { runCouncil } = await import("../index.js");
-        const mockLLM = buildMockLLM();
-        const respondToQuestion = vi.fn().mockResolvedValue("skip");
-        const respondToPreflight = vi.fn().mockResolvedValue(true);
-        const processMessageFn = vi.fn().mockImplementation(async function* () {
-            yield { type: "done" };
-        });
-        const gen = runCouncil("Should we use gRPC internally?", "mock-model", [], "test-session-004", mockLLM, respondToQuestion, respondToPreflight, processMessageFn, { skipClarification: true });
-        await drainCouncil(gen);
-        const memMsg = capturedMessages.find((m) => m.content.startsWith("[Council Memory]"));
-        expect(memMsg).toBeDefined();
-        const jsonStr = memMsg.content.slice("[Council Memory] ".length);
-        const record = JSON.parse(jsonStr);
-        // synthesis must contain all three: docs/ reference, tavily citation, snapshot signal
-        const synthesis = record.synthesis ?? "";
-        expect(synthesis).toContain("docs/");
-        expect(synthesis).toContain("tavily");
-        expect(synthesis).toContain("snapshot");
-    });
-    // Issue #4: council_summary row in interaction_logs lets `usage forensics`
-    // surface debate outcomes without parsing the [Council Memory] system
-    // message. The summary must contain enough structure to triage runs.
-    it("persists a council_summary row to interaction_logs (Issue #4)", async () => {
-        const { runCouncil } = await import("../index.js");
-        const mockLLM = buildMockLLM();
-        const respondToQuestion = vi.fn().mockResolvedValue("skip");
-        const respondToPreflight = vi.fn().mockResolvedValue(true);
-        const processMessageFn = vi.fn().mockImplementation(async function* () {
-            yield { type: "done" };
-        });
-        const gen = runCouncil("Should we use gRPC internally?", "mock-model", [], "test-session-summary", mockLLM, respondToQuestion, respondToPreflight, processMessageFn, { skipClarification: true });
-        await drainCouncil(gen);
-        const calls = logInteraction.mock.calls;
-        const summaryCall = calls.find((args) => args[1] === "council" && args[2]?.eventSubtype === "council_summary");
-        expect(summaryCall).toBeDefined();
-        expect(summaryCall[0]).toBe("test-session-summary");
-        const data = summaryCall[2].data;
-        expect(data.topic).toBe("Should we use gRPC internally?");
-        expect(data.roundCount).toBeGreaterThanOrEqual(0);
-        expect(data.participantCount).toBeGreaterThanOrEqual(2);
-        expect(Array.isArray(data.stances)).toBe(true);
-        expect(typeof data.synthesisExcerpt).toBe("string");
-        expect(data.synthesisExcerpt.length).toBeLessThanOrEqual(1500);
-        expect(["high", "medium", "low"]).toContain(data.confidenceLevel);
-    });
-});
-//# sourceMappingURL=audit-replay.test.js.map

package/dist/src/council/__tests__/clarification-prompt.test.d.ts

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