muonroi-cli 1.8.1 → 1.8.4

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

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

@@ -1,71 +0,0 @@
-import { describe, expect, it } from "vitest";
-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
-// (c) carry no existing-repo grounding → generic greenfield questions on a
-// brownfield repo. These assertions lock in the fixed behaviour so a future
-// edit can't silently regress it.
-describe("buildClarificationPrompt — de-robotized askcard", () => {
-    const { system } = buildClarificationPrompt("Add a retry to the EE bridge call", "## Current Project\nmuonroi-cli — TypeScript CLI. Stack: bun, vitest.\n");
-    it("does NOT force a minimum question quota", () => {
-        expect(system).not.toMatch(/AT LEAST 2 questions/i);
-        expect(system).not.toMatch(/MUST ask AT LEAST/i);
-        expect(system).not.toMatch(/Minimum-question rule/i);
-    });
-    it("explicitly allows zero questions / returning []", () => {
-        expect(system).toMatch(/return \[\]/i);
-        expect(system).toMatch(/ZERO questions/i);
-    });
-    it("makes a recommendation MANDATORY (decisive), not optional", () => {
-        expect(system).toMatch(/ALWAYS include "recommended"/);
-        // The old "OMIT the field entirely" default must be gone.
-        expect(system).not.toMatch(/OMIT the field entirely/i);
-        expect(system).toMatch(/never face an unranked list/i);
-    });
-    it("grounds questions in the existing repo, not greenfield", () => {
-        expect(system).toMatch(/Current Project/);
-        expect(system).toMatch(/EXISTING repository/);
-        expect(system).toMatch(/do NOT ask generic greenfield/i);
-    });
-    it("still emits the structured JSON contract (question/suggestions/recommended)", () => {
-        expect(system).toMatch(/"suggestions"/);
-        expect(system).toMatch(/"recommended"/);
-        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",
-        constraints: [],
-        successCriteria: ["c"],
-        scope: "s",
-    });
-    it("does not leak JS concatenation syntax into the prompt text", () => {
-        // Was: `...means "probably " +\n  "ready but some ambiguity remains"` — the
-        // `" +` and the leading `  "` leaked verbatim into the model-facing string.
-        expect(system).not.toContain('" +');
-        expect(system).toContain("probably ready but some ambiguity remains");
-    });
-});
-//# sourceMappingURL=clarification-prompt.test.js.map

package/dist/src/council/__tests__/clarifier-max-rounds.test.d.ts

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

package/dist/src/council/__tests__/clarifier-max-rounds.test.js

@@ -1,46 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { MAX_CLARIFY_ROUNDS, runClarification } from "../clarifier.js";
-describe("runClarification maxRounds parameterization", () => {
-    const mockLLM = {
-        generate: vi.fn().mockResolvedValue('["Next question?"]'),
-    };
-    const mockResponder = vi.fn().mockResolvedValue("answer");
-    it("respects maxRounds=6 when provided", async () => {
-        const rounds = [];
-        const gen = runClarification("topic", "model", "context", mockResponder, mockLLM, undefined, undefined, 6);
-        for await (const chunk of gen) {
-            if (chunk.type === "council_phase" &&
-                chunk.councilPhase?.kind === "clarification_round" &&
-                chunk.councilPhase.state === "active") {
-                rounds.push(chunk.councilPhase.phaseId);
-            }
-        }
-        // Since mockLLM always returns a question, it should iterate exactly maxRounds times
-        expect(rounds.length).toBe(6);
-    });
-    it("defaults to MAX_CLARIFY_ROUNDS when maxRounds is not provided", async () => {
-        const rounds = [];
-        const gen = runClarification("topic", "model", "context", mockResponder, mockLLM, undefined, undefined);
-        for await (const chunk of gen) {
-            if (chunk.type === "council_phase" &&
-                chunk.councilPhase?.kind === "clarification_round" &&
-                chunk.councilPhase.state === "active") {
-                rounds.push(chunk.councilPhase.phaseId);
-            }
-        }
-        expect(rounds.length).toBe(MAX_CLARIFY_ROUNDS);
-    });
-    it("falls back to MAX_CLARIFY_ROUNDS when maxRounds is non-positive", async () => {
-        const rounds = [];
-        const gen = runClarification("topic", "model", "context", mockResponder, mockLLM, undefined, undefined, -1);
-        for await (const chunk of gen) {
-            if (chunk.type === "council_phase" &&
-                chunk.councilPhase?.kind === "clarification_round" &&
-                chunk.councilPhase.state === "active") {
-                rounds.push(chunk.councilPhase.phaseId);
-            }
-        }
-        expect(rounds.length).toBe(MAX_CLARIFY_ROUNDS);
-    });
-});
-//# sourceMappingURL=clarifier-max-rounds.test.js.map

package/dist/src/council/__tests__/clarifier-options.test.d.ts

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