muonroi-cli 1.8.1 → 1.8.4

package/dist/src/council/__tests__/post-debate-recommendation.test.js

@@ -1,58 +0,0 @@
-/**
- * Issue #3 — post-debate default mismatch.
- *
- * Before the fix, `runCouncil`'s post-debate AskCard recommended "generate_plan"
- * (Lock plan & execute Sprint 1) for ANY successful synthesis with no plan yet —
- * ignoring `debatePlan.outputShape.kind`. For a pure decision/evaluation topic the
- * user wanted a decision, not to build, so defaulting to "kick off a sprint" was
- * the wrong next step. `pickPostDebateRecommendation` now only defaults to
- * generate_plan for `implementation_plan`-shaped debates; everything else defaults
- * to `save_exit` (the synthesis IS the deliverable). The generate_plan OPTION is
- * still offered — only the pre-selected default changed.
- */
-import { describe, expect, it } from "vitest";
-import { pickPostDebateRecommendation } from "../index.js";
-const base = {
-    synthesisFailed: false,
-    hasEmptySections: false,
-    refinementTopics: [],
-    confidenceLevel: "high",
-    hasPlan: false,
-};
-describe("pickPostDebateRecommendation — issue #3 default", () => {
-    it("defaults implementation_plan (no plan yet) to generate_plan", () => {
-        const r = pickPostDebateRecommendation({ ...base, outputKind: "implementation_plan" });
-        expect(r.value).toBe("generate_plan");
-    });
-    for (const kind of ["decision", "evaluation", "investigation", "exploration", "other"]) {
-        it(`defaults ${kind} (no plan) to save_exit, not generate_plan`, () => {
-            const r = pickPostDebateRecommendation({ ...base, outputKind: kind });
-            expect(r.value).toBe("save_exit");
-            // Reason names the shape so the card explains WHY save is the default.
-            expect(r.reason).toContain(kind);
-        });
-    }
-    it("retry_synthesis wins on synthesis failure regardless of kind", () => {
-        const r = pickPostDebateRecommendation({ ...base, synthesisFailed: true, outputKind: "decision" });
-        expect(r.value).toBe("retry_synthesis");
-    });
-    it("refine wins when the debate left sections empty", () => {
-        const r = pickPostDebateRecommendation({
-            ...base,
-            hasEmptySections: true,
-            refinementTopics: ["Risks", "Trade-offs"],
-            outputKind: "implementation_plan",
-        });
-        expect(r.value).toBe("refine");
-        expect(r.reason).toContain("2");
-    });
-    it("low confidence routes to ask_followup before the kind split", () => {
-        const r = pickPostDebateRecommendation({ ...base, confidenceLevel: "low", outputKind: "implementation_plan" });
-        expect(r.value).toBe("ask_followup");
-    });
-    it("an existing plan always defaults to save_exit", () => {
-        const r = pickPostDebateRecommendation({ ...base, hasPlan: true, outputKind: "implementation_plan" });
-        expect(r.value).toBe("save_exit");
-    });
-});
-//# sourceMappingURL=post-debate-recommendation.test.js.map

package/dist/src/council/__tests__/research-tools.test.d.ts

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

package/dist/src/council/__tests__/research-tools.test.js

@@ -1,214 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { buildResearchSystemPrompt } from "../prompts.js";
-// ── CQ-05: buildResearchSystemPrompt pure-function tests ─────────────────────
-describe("CQ-05: buildResearchSystemPrompt", () => {
-    it("contains all 3 required section headings", () => {
-        const prompt = buildResearchSystemPrompt(false);
-        expect(prompt).toContain("## Source Code Findings");
-        expect(prompt).toContain("## Internet Findings");
-        expect(prompt).toContain("## Frontend Findings (live)");
-    });
-    it("injects URL Research Requirement when hasUrl=true", () => {
-        const prompt = buildResearchSystemPrompt(true);
-        expect(prompt).toContain("URL Research Requirement");
-        expect(prompt).toContain("Playwright or Chrome-DevTools");
-    });
-    it("does NOT inject URL instruction when hasUrl=false", () => {
-        const prompt = buildResearchSystemPrompt(false);
-        expect(prompt).not.toContain("URL Research Requirement");
-    });
-    it("contains citation format instructions for all 3 sections", () => {
-        const prompt = buildResearchSystemPrompt(false);
-        // Source Code Findings citation format
-        expect(prompt).toContain("[file:line]");
-        // Internet Findings citation format
-        expect(prompt).toContain("[url]");
-        // Frontend Findings citation format
-        expect(prompt).toContain("[snapshot:uid]");
-    });
-});
-// ── CQ-04 + CQ-03: createCouncilLLM.research() integration-style tests ──────
-describe("CQ-04: research() URL detection and gap annotation", () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    it("appends gap annotation when topic contains URL but no browser tool invoked", async () => {
-        // Mock ai generateText to return result with no browser tool calls
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockResolvedValue({
-                text: "## Source Code Findings\nFound nothing.\n\n## Internet Findings\nFound nothing.\n\n## Frontend Findings (live)\nNot performed.",
-                toolCalls: [],
-                steps: [],
-            }),
-            stepCountIs: vi.fn().mockReturnValue({}),
-        }));
-        // Mock provider/key dependencies so createCouncilLLM doesn't require real keys
-        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,
-            }),
-        }));
-        vi.doMock("../../tools/registry.js", () => ({
-            createBuiltinTools: vi.fn().mockReturnValue({}),
-        }));
-        vi.doMock("../../mcp/runtime.js", () => ({
-            buildMcpToolSet: vi.fn().mockResolvedValue({
-                tools: {},
-                errors: [],
-                close: vi.fn().mockResolvedValue(undefined),
-            }),
-        }));
-        vi.doMock("../../utils/settings.js", () => ({
-            loadMcpServers: vi.fn().mockReturnValue([]),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        // bash and mode are not used in the mocked code paths
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        const result = await llm.research("gpt-4o", "Check https://example.com for issues", "", undefined);
-        expect(result).toContain("## Research Gap");
-        expect(result).toContain("no browser tool was invoked");
-        expect(stats.calls).toBe(1);
-    });
-    it("does NOT append gap annotation when topic has no URL", async () => {
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockResolvedValue({
-                text: "## Source Code Findings\nFound something.\n\n## Internet Findings\nNone.\n\n## Frontend Findings (live)\nNone.",
-                toolCalls: [],
-                steps: [],
-            }),
-            stepCountIs: vi.fn().mockReturnValue({}),
-        }));
-        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 }),
-        }));
-        vi.doMock("../../tools/registry.js", () => ({
-            createBuiltinTools: vi.fn().mockReturnValue({}),
-        }));
-        vi.doMock("../../mcp/runtime.js", () => ({
-            buildMcpToolSet: vi.fn().mockResolvedValue({
-                tools: {},
-                errors: [],
-                close: vi.fn().mockResolvedValue(undefined),
-            }),
-        }));
-        vi.doMock("../../utils/settings.js", () => ({
-            loadMcpServers: vi.fn().mockReturnValue([]),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        const result = await llm.research("gpt-4o", "What is the council architecture?", "", undefined);
-        expect(result).not.toContain("## Research Gap");
-        expect(stats.calls).toBe(1);
-    });
-});
-describe("CQ-03: research() MCP tool merge", () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    it("merges MCP tools with builtin tools when buildMcpToolSet returns a bundle", async () => {
-        const capturedTools = {};
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockImplementation(async (args) => {
-                if (args.tools) {
-                    Object.assign(capturedTools, args.tools);
-                }
-                return {
-                    text: "## Source Code Findings\nNone.\n\n## Internet Findings\nNone.\n\n## Frontend Findings (live)\nNone.",
-                    toolCalls: [],
-                    steps: [],
-                };
-            }),
-            stepCountIs: vi.fn().mockReturnValue({}),
-        }));
-        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 }),
-        }));
-        vi.doMock("../../tools/registry.js", () => ({
-            createBuiltinTools: vi.fn().mockReturnValue({ builtin_bash: {} }),
-        }));
-        vi.doMock("../../mcp/runtime.js", () => ({
-            buildMcpToolSet: vi.fn().mockResolvedValue({
-                tools: { mcp_tavily__search: {} },
-                errors: [],
-                close: vi.fn().mockResolvedValue(undefined),
-            }),
-        }));
-        vi.doMock("../../utils/settings.js", () => ({
-            loadMcpServers: vi.fn().mockReturnValue([{ id: "tavily", enabled: true }]),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        await llm.research("gpt-4o", "What are best practices for TypeScript?", "", undefined);
-        // Both builtin and MCP tools must be present in the generateText call
-        expect(capturedTools).toHaveProperty("builtin_bash");
-        expect(capturedTools).toHaveProperty("mcp_tavily__search");
-    });
-    it("falls back to builtin tools only when MCP spawn fails", async () => {
-        const capturedTools = {};
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockImplementation(async (args) => {
-                if (args.tools) {
-                    Object.assign(capturedTools, args.tools);
-                }
-                return {
-                    text: "## Source Code Findings\nNone.\n\n## Internet Findings\nNone.\n\n## Frontend Findings (live)\nNone.",
-                    toolCalls: [],
-                    steps: [],
-                };
-            }),
-            stepCountIs: vi.fn().mockReturnValue({}),
-        }));
-        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 }),
-        }));
-        vi.doMock("../../tools/registry.js", () => ({
-            createBuiltinTools: vi.fn().mockReturnValue({ builtin_bash: {} }),
-        }));
-        vi.doMock("../../mcp/runtime.js", () => ({
-            buildMcpToolSet: vi.fn().mockRejectedValue(new Error("MCP spawn failed")),
-        }));
-        vi.doMock("../../utils/settings.js", () => ({
-            loadMcpServers: vi.fn().mockReturnValue([{ id: "tavily", enabled: true }]),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        // Should not throw; falls back to builtins
-        const result = await llm.research("gpt-4o", "Some topic", "", undefined);
-        expect(result).not.toContain("Research failed");
-        expect(capturedTools).toHaveProperty("builtin_bash");
-        expect(capturedTools).not.toHaveProperty("mcp_tavily__search");
-        expect(stats.calls).toBe(1);
-    });
-});
-//# sourceMappingURL=research-tools.test.js.map

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

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

package/dist/src/council/__tests__/round-tools.test.js

@@ -1,306 +0,0 @@
-/**
- * Debate-call shape contracts.
- *
- * History:
- *  - CQ-06 required tools + stepCountIs(4) for evidence verification.
- *  - Session a7a5690d2049 (DeepSeek V4 on SiliconFlow): 4/4 Round-1 turns
- *    empty because reasoning models burned step budget on tool chains and
- *    returned finishReason="tool-calls" text="".
- *  - First fix removed tools entirely → debate worked but lost evidence
- *    verification (training-data citations only — session f83c278f2162).
- *  - Current: verification tools available ONLY when
- *    options.enableVerificationTools=true, capped at stepCountIs(2)
- *    (1 verification call + final text). The caller (debate.ts) only enables
- *    it for balanced/premium tier; fast-tier reasoning models stay tool-free.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-describe("debate() call shape — tools off by default, on with explicit opt-in", () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    it("does NOT pass tools to generateText when enableVerificationTools is absent", async () => {
-        const capturedArgs = [];
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockImplementation(async (args) => {
-                capturedArgs.push(args);
-                return { text: "debate response", toolCalls: [], steps: [] };
-            }),
-            stepCountIs: vi.fn().mockReturnValue({ __stepCountIs: 2 }),
-        }));
-        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 }),
-        }));
-        vi.doMock("../prompts.js", () => ({
-            buildResearchSystemPrompt: vi.fn().mockReturnValue("research system prompt"),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        await llm.debate("gpt-4o", "system prompt", "user prompt", undefined);
-        expect(capturedArgs).toHaveLength(1);
-        const args = capturedArgs[0];
-        expect(args.tools).toBeUndefined();
-        expect(args.stopWhen).toBeUndefined();
-    });
-    it("passes tools + stopWhen=stepCountIs(2) when enableVerificationTools=true", async () => {
-        const capturedArgs = [];
-        const stepCountIsMock = vi.fn().mockReturnValue({ __stepCountIs: 2 });
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockImplementation(async (args) => {
-                capturedArgs.push(args);
-                return { text: "verified response", toolCalls: [], steps: [] };
-            }),
-            stepCountIs: stepCountIsMock,
-        }));
-        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 }),
-        }));
-        // Builtin tools — must contain grep+read_file so the filter keeps something
-        vi.doMock("../../tools/registry.js", () => ({
-            createBuiltinTools: vi.fn().mockReturnValue({
-                grep: { execute: async () => "ok" },
-                read_file: { execute: async () => "ok" },
-                bash: { execute: async () => "ok" }, // must be filtered out
-            }),
-        }));
-        vi.doMock("../../mcp/runtime.js", () => ({
-            buildMcpToolSet: vi.fn().mockResolvedValue({
-                tools: {},
-                errors: [],
-                close: vi.fn().mockResolvedValue(undefined),
-            }),
-        }));
-        vi.doMock("../../utils/settings.js", () => ({
-            loadMcpServers: vi.fn().mockReturnValue([]),
-        }));
-        vi.doMock("../prompts.js", () => ({
-            buildResearchSystemPrompt: vi.fn().mockReturnValue("research system prompt"),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        await llm.debate("gpt-4o", "system", "prompt", undefined, undefined, { enableVerificationTools: true });
-        expect(capturedArgs).toHaveLength(1);
-        const args = capturedArgs[0];
-        expect(args.tools).toBeDefined();
-        // Allowlist: only grep + read_file pass through; bash is filtered out
-        expect(Object.keys(args.tools).sort()).toEqual(["grep", "read_file"]);
-        expect(args.stopWhen).toEqual({ __stepCountIs: 2 });
-        expect(stepCountIsMock).toHaveBeenCalledWith(2);
-    });
-    it("uses temperature 0.7 and maxOutputTokens 6144", async () => {
-        let capturedArgs = {};
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockImplementation(async (args) => {
-                capturedArgs = args;
-                return { text: "response", toolCalls: [], steps: [] };
-            }),
-            stepCountIs: vi.fn().mockReturnValue({}),
-        }));
-        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 }),
-        }));
-        vi.doMock("../../tools/registry.js", () => ({
-            createBuiltinTools: vi.fn().mockReturnValue({}),
-        }));
-        vi.doMock("../../mcp/runtime.js", () => ({
-            buildMcpToolSet: vi.fn().mockResolvedValue({
-                tools: {},
-                errors: [],
-                close: vi.fn().mockResolvedValue(undefined),
-            }),
-        }));
-        vi.doMock("../../utils/settings.js", () => ({
-            loadMcpServers: vi.fn().mockReturnValue([]),
-        }));
-        vi.doMock("../prompts.js", () => ({
-            buildResearchSystemPrompt: vi.fn().mockReturnValue("research system prompt"),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        await llm.debate("gpt-4o", "system", "prompt");
-        expect(capturedArgs.temperature).toBe(0.7);
-        // Reasoning models share output budget with reasoning_tokens — e2e showed
-        // 2048 truncated debate turns mid-thought (finishReason=length). Raised to
-        // 6144 so reasoning models still have ~4K text-token headroom.
-        expect(capturedArgs.maxOutputTokens).toBe(6144);
-    });
-});
-// ── CQ-07: debate() returns { text, toolCalls } object ───────────────────────
-describe("CQ-07: debate() returns { text, toolCalls } — not bare string", () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    it("returns an object with text and toolCalls array", async () => {
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockResolvedValue({
-                text: "debate answer",
-                toolCalls: [{ toolName: "bash", result: "ls output" }, { toolName: "grep" }],
-                steps: [],
-            }),
-            stepCountIs: vi.fn().mockReturnValue({}),
-        }));
-        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 }),
-        }));
-        vi.doMock("../../tools/registry.js", () => ({
-            createBuiltinTools: vi.fn().mockReturnValue({}),
-        }));
-        vi.doMock("../../mcp/runtime.js", () => ({
-            buildMcpToolSet: vi.fn().mockResolvedValue({
-                tools: {},
-                errors: [],
-                close: vi.fn().mockResolvedValue(undefined),
-            }),
-        }));
-        vi.doMock("../../utils/settings.js", () => ({
-            loadMcpServers: vi.fn().mockReturnValue([]),
-        }));
-        vi.doMock("../prompts.js", () => ({
-            buildResearchSystemPrompt: vi.fn().mockReturnValue("research system prompt"),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        const result = await llm.debate("gpt-4o", "system", "prompt");
-        // Must be an object, not a string
-        expect(typeof result).toBe("object");
-        expect(result).toHaveProperty("text");
-        expect(result).toHaveProperty("toolCalls");
-        expect(result.text).toBe("debate answer");
-        expect(Array.isArray(result.toolCalls)).toBe(true);
-        expect(result.toolCalls).toHaveLength(2);
-        expect(result.toolCalls[0].toolName).toBe("bash");
-        expect(result.toolCalls[1].toolName).toBe("grep");
-    });
-    it("returns empty toolCalls array when generateText returns no toolCalls", async () => {
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockResolvedValue({
-                text: "answer without tools",
-                toolCalls: undefined,
-                steps: [],
-            }),
-            stepCountIs: vi.fn().mockReturnValue({}),
-        }));
-        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 }),
-        }));
-        vi.doMock("../../tools/registry.js", () => ({
-            createBuiltinTools: vi.fn().mockReturnValue({}),
-        }));
-        vi.doMock("../../mcp/runtime.js", () => ({
-            buildMcpToolSet: vi.fn().mockResolvedValue({
-                tools: {},
-                errors: [],
-                close: vi.fn().mockResolvedValue(undefined),
-            }),
-        }));
-        vi.doMock("../../utils/settings.js", () => ({
-            loadMcpServers: vi.fn().mockReturnValue([]),
-        }));
-        vi.doMock("../prompts.js", () => ({
-            buildResearchSystemPrompt: vi.fn().mockReturnValue("research system prompt"),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        const result = await llm.debate("gpt-4o", "system", "prompt");
-        expect(result.toolCalls).toEqual([]);
-    });
-    it("increments stats.calls after a successful debate() call", async () => {
-        vi.doMock("ai", () => ({
-            generateText: vi.fn().mockResolvedValue({ text: "ok", toolCalls: [], steps: [] }),
-            stepCountIs: vi.fn().mockReturnValue({}),
-        }));
-        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 }),
-        }));
-        vi.doMock("../../tools/registry.js", () => ({
-            createBuiltinTools: vi.fn().mockReturnValue({}),
-        }));
-        vi.doMock("../../mcp/runtime.js", () => ({
-            buildMcpToolSet: vi.fn().mockResolvedValue({
-                tools: {},
-                errors: [],
-                close: vi.fn().mockResolvedValue(undefined),
-            }),
-        }));
-        vi.doMock("../../utils/settings.js", () => ({
-            loadMcpServers: vi.fn().mockReturnValue([]),
-        }));
-        vi.doMock("../prompts.js", () => ({
-            buildResearchSystemPrompt: vi.fn().mockReturnValue("research system prompt"),
-        }));
-        const { createCouncilLLM } = await import("../llm.js");
-        const stats = { calls: 0, startMs: Date.now(), phases: [] };
-        const llm = createCouncilLLM({}, "agent", undefined, stats);
-        expect(stats.calls).toBe(0);
-        await llm.debate("gpt-4o", "system", "prompt");
-        expect(stats.calls).toBe(1);
-    });
-});
-// ── CQ-09: Per-round persistence text contains "[Council Round N]" ────────────
-describe("CQ-09: Per-round persistence output format", () => {
-    it("roundPersistText contains literal '[Council Round' followed by round number", () => {
-        // Test the persistence text format directly — pure function behavior
-        // The debate.ts code builds: `[Council Round ${round}]\n${roundSummaryText}`
-        // We validate the expected string format that gets emitted as council_status content
-        const round = 1;
-        const exampleSummaryText = "[primary] → [secondary]: response text";
-        const roundPersistText = `[Council Round ${round}]\n${exampleSummaryText}`;
-        expect(roundPersistText).toMatch(/^\[Council Round \d+\]/);
-        expect(roundPersistText).toContain("[Council Round 1]");
-    });
-    it("round persistence text format works for multiple round numbers", () => {
-        for (const round of [1, 2, 3, 8]) {
-            const persistText = `[Council Round ${round}]\nsome exchange text`;
-            expect(persistText).toContain(`[Council Round ${round}]`);
-            expect(persistText).toMatch(/\[Council Round \d+\]/);
-        }
-    });
-    it("persistence text includes tool usage suffix when toolCalls present", () => {
-        // Validate the suffix format: "[tools: bash, grep]"
-        const toolCalls = [{ toolName: "bash" }, { toolName: "grep" }];
-        const toolSuffix = toolCalls.length ? ` [tools: ${toolCalls.map((t) => t.toolName).join(", ")}]` : "";
-        const chunkText = `some response${toolSuffix}`;
-        expect(chunkText).toContain("[tools: bash, grep]");
-    });
-});
-//# sourceMappingURL=round-tools.test.js.map

package/dist/src/council/__tests__/tool-trace.test.d.ts

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