muonroi-cli 1.8.1 → 1.8.4

package/dist/src/council/__tests__/clarifier-options.test.js

@@ -1,54 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildClarifyOptions } from "../clarifier.js";
-describe("buildClarifyOptions", () => {
-    it("converts non-empty suggestions into choice options", () => {
-        const { options } = buildClarifyOptions(["A", "B", "C"]);
-        const choices = options.filter((o) => o.kind === "choice");
-        expect(choices.map((o) => o.label)).toEqual(["A", "B", "C"]);
-        expect(choices.map((o) => o.value)).toEqual(["A", "B", "C"]);
-    });
-    it("appends Type something + Chat about this escape options", () => {
-        const { options } = buildClarifyOptions(["Pick me"]);
-        const kinds = options.map((o) => o.kind);
-        expect(kinds).toEqual(["choice", "freetext", "chat"]);
-        expect(options[1].label).toBe("Type something");
-        expect(options[2].label).toBe("Chat about this");
-    });
-    it("filters blank or non-string suggestions", () => {
-        const { options } = buildClarifyOptions(["", "  ", "real"]);
-        const choices = options.filter((o) => o.kind === "choice");
-        expect(choices.map((o) => o.label)).toEqual(["real"]);
-    });
-    it("works with undefined suggestions (only escape hatches remain)", () => {
-        const { options } = buildClarifyOptions(undefined);
-        expect(options.length).toBe(2);
-        expect(options[0].kind).toBe("freetext");
-        expect(options[1].kind).toBe("chat");
-    });
-    it("trims whitespace from labels and values", () => {
-        const { options } = buildClarifyOptions(["  spaced  "]);
-        expect(options[0].label).toBe("spaced");
-        expect(options[0].value).toBe("spaced");
-    });
-    it("omits defaultIndex when no recommendation provided", () => {
-        const { defaultIndex } = buildClarifyOptions(["A", "B"]);
-        expect(defaultIndex).toBeUndefined();
-    });
-    it("omits defaultIndex when recommended does not match any suggestion", () => {
-        const { defaultIndex } = buildClarifyOptions(["A", "B"], "C");
-        expect(defaultIndex).toBeUndefined();
-    });
-    it("omits defaultIndex when recommended is blank", () => {
-        const { defaultIndex } = buildClarifyOptions(["A", "B"], "  ");
-        expect(defaultIndex).toBeUndefined();
-    });
-    it("sets defaultIndex to recommended position when it matches a suggestion", () => {
-        const { defaultIndex } = buildClarifyOptions(["A", "B", "C"], "B");
-        expect(defaultIndex).toBe(1);
-    });
-    it("matches recommended case-insensitively", () => {
-        const { defaultIndex } = buildClarifyOptions(["Postgres", "MySQL"], "postgres");
-        expect(defaultIndex).toBe(0);
-    });
-});
-//# sourceMappingURL=clarifier-options.test.js.map

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

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

package/dist/src/council/__tests__/clarifier-ready-gate.test.js

@@ -1,265 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { judgeReadiness, MAX_CLARIFY_ROUNDS, runClarification } from "../clarifier.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Drain the generator and return the final ClarifiedSpec. */
-async function _drain(gen) {
-    let result;
-    let done = false;
-    while (!done) {
-        const next = await gen.next();
-        if (next.done) {
-            result = next.value;
-            done = true;
-        }
-    }
-    return result;
-}
-/** Count "clarification_round active" phase events emitted by the generator. */
-async function countRounds(gen) {
-    let rounds = 0;
-    let spec;
-    let done = false;
-    while (!done) {
-        const next = await gen.next();
-        if (next.done) {
-            spec = next.value;
-            done = true;
-        }
-        else if (next.value.type === "council_phase" &&
-            next.value.councilPhase?.kind === "clarification_round" &&
-            next.value.councilPhase?.state === "active") {
-            rounds++;
-        }
-    }
-    return { rounds, spec: spec };
-}
-// ---------------------------------------------------------------------------
-// Shared mock responder — always answers "some answer"
-// ---------------------------------------------------------------------------
-const alwaysAnswer = vi.fn().mockResolvedValue("some answer");
-// ---------------------------------------------------------------------------
-// Test A: judgeReadiness returns ready=true after round 1 → loop exits early
-// ---------------------------------------------------------------------------
-describe("P5 ready-gate: Test A — judge ready after round 1", () => {
-    it("exits loop after 1 round and populates spec.ready + spec.confidenceScore", async () => {
-        // First call: returns a clarification question
-        // Second call (judgeReadiness): returns ready=true
-        // Spec synthesis call: returns a valid spec JSON
-        let callCount = 0;
-        const mockLLM = {
-            generate: vi.fn().mockImplementation(async () => {
-                callCount++;
-                if (callCount === 1) {
-                    // clarify_questions round 1
-                    return JSON.stringify([{ question: "What is the target platform?", why: "Scope clarity", isRequired: true }]);
-                }
-                if (callCount === 2) {
-                    // judgeReadiness verdict — ready after round 1
-                    return JSON.stringify({ ready: true, confidence: 0.9, gaps: [] });
-                }
-                // spec_synthesis
-                return JSON.stringify({
-                    problemStatement: "Build a todo app",
-                    constraints: ["web only"],
-                    successCriteria: ["User can add tasks", "User can mark done"],
-                    scope: "Single user, local storage",
-                });
-            }),
-        };
-        const gen = runClarification("Build a todo app", "leader-model", "", alwaysAnswer, mockLLM);
-        const { rounds, spec } = await countRounds(gen);
-        expect(rounds).toBe(1);
-        expect(spec.ready).toBe(true);
-        expect(spec.confidenceScore).toBeGreaterThan(0);
-        expect(spec.clarifyHistory).toHaveLength(1);
-        expect(spec.remainingGaps).toEqual([]);
-    });
-});
-// ---------------------------------------------------------------------------
-// Test B: judge returns ready=false for 3 rounds, then ready=true on round 4
-// ---------------------------------------------------------------------------
-describe("P5 ready-gate: Test B — judge ready at round 4", () => {
-    it("runs 4 rounds and history has 4 entries", async () => {
-        let callCount = 0;
-        const mockLLM = {
-            generate: vi.fn().mockImplementation(async () => {
-                callCount++;
-                // Pattern: clarify_q → judge → clarify_q → judge → ... (interleaved)
-                // Calls: 1=q1, 2=judge1(not ready), 3=q2, 4=judge2(not ready),
-                //        5=q3, 6=judge3(not ready), 7=q4, 8=judge4(ready), 9=synthesis
-                const judgeCallNums = [2, 4, 6, 8];
-                if (judgeCallNums.includes(callCount)) {
-                    const isLastJudge = callCount === 8;
-                    return JSON.stringify({
-                        ready: isLastJudge,
-                        confidence: isLastJudge ? 0.85 : 0.4,
-                        gaps: isLastJudge ? [] : ["Target platform not specified.", "Authentication method unclear."],
-                    });
-                }
-                if (callCount === 9) {
-                    // spec synthesis
-                    return JSON.stringify({
-                        problemStatement: "Build a todo app",
-                        constraints: [],
-                        successCriteria: ["Tasks can be added"],
-                        scope: "Web app",
-                    });
-                }
-                // clarify_questions
-                return JSON.stringify([{ question: `Question ${callCount}`, why: "Gap", isRequired: true }]);
-            }),
-        };
-        const gen = runClarification("Build a todo app", "leader-model", "", alwaysAnswer, mockLLM);
-        const { rounds, spec } = await countRounds(gen);
-        expect(rounds).toBe(4);
-        expect(spec.clarifyHistory).toHaveLength(4);
-        expect(spec.ready).toBe(true);
-    });
-});
-// ---------------------------------------------------------------------------
-// Test C: judge always returns ready=false → loop caps at MAX_CLARIFY_ROUNDS
-// ---------------------------------------------------------------------------
-describe("P5 ready-gate: Test C — hard cap at MAX_CLARIFY_ROUNDS", () => {
-    it(`caps at ${MAX_CLARIFY_ROUNDS} rounds, spec.ready=false, remainingGaps non-empty`, async () => {
-        const mockLLM = {
-            generate: vi.fn().mockImplementation(async (_modelId, system) => {
-                // Distinguish clarify prompt (system contains "clarification questions")
-                // from judge prompt (system contains "debate facilitator")
-                // from synthesis prompt (system contains "synthesizing")
-                if (system.includes("debate facilitator")) {
-                    return JSON.stringify({ ready: false, confidence: 0.2, gaps: ["Gap A.", "Gap B."] });
-                }
-                if (system.includes("synthesizing") || system.includes("extracting")) {
-                    return JSON.stringify({
-                        problemStatement: "Build something",
-                        constraints: [],
-                        successCriteria: ["Something works"],
-                        scope: "TBD",
-                    });
-                }
-                // clarify_questions
-                return JSON.stringify([{ question: "Some question?", why: "Gap", isRequired: true }]);
-            }),
-        };
-        const gen = runClarification("Build something vague", "leader-model", "", alwaysAnswer, mockLLM);
-        const { rounds, spec } = await countRounds(gen);
-        expect(rounds).toBe(MAX_CLARIFY_ROUNDS);
-        expect(spec.ready).toBe(false);
-        expect(spec.remainingGaps?.length ?? 0).toBeGreaterThan(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// Test E: clarifier asks ZERO questions → spec.ready=true, judge NOT called
-// (de-robotized prompt now commonly returns [] — the gate must reflect that,
-//  not stay at its not-ready default, and must not pay for a judge LLM call.)
-// ---------------------------------------------------------------------------
-describe("P5 ready-gate: Test E — zero questions ⇒ ready without a judge call", () => {
-    it("marks spec.ready=true and skips the readiness judge when the clarifier asks nothing", async () => {
-        let callCount = 0;
-        const generate = vi.fn().mockImplementation(async () => {
-            callCount++;
-            if (callCount === 1)
-                return "[]"; // clarify round 0: nothing to ask
-            // spec synthesis (if reached) — no judge call should occur on this path
-            return JSON.stringify({
-                problemStatement: "Add a retry to the EE bridge",
-                constraints: [],
-                successCriteria: ["Retries once on transient failure"],
-                scope: "EE bridge only",
-            });
-        });
-        const mockLLM = { generate };
-        const gen = runClarification("Add a retry to the EE bridge", "leader-model", "## Current Project\nTypeScript CLI", alwaysAnswer, mockLLM);
-        const spec = await _drain(gen);
-        expect(spec.ready).toBe(true);
-        expect(spec.confidenceScore).toBe(1);
-        expect(spec.remainingGaps).toEqual([]);
-        expect(spec.clarifyHistory).toEqual([]);
-        // The readiness judge ("debate facilitator" system prompt) must NOT fire.
-        const judgeCalled = generate.mock.calls.some(([, system]) => typeof system === "string" && system.includes("debate facilitator"));
-        expect(judgeCalled).toBe(false);
-    });
-});
-// ---------------------------------------------------------------------------
-// Test D: judgeReadiness unit tests
-// ---------------------------------------------------------------------------
-describe("P5 ready-gate: Test D — judgeReadiness unit", () => {
-    const baseSpec = {
-        problemStatement: "Build a REST API for a todo app",
-        constraints: ["TypeScript only"],
-        successCriteria: ["CRUD endpoints work", "Auth required"],
-        scope: "Backend only, no UI",
-        rawQA: [],
-    };
-    it("returns ready=true when LLM says so with detailed Q&A", async () => {
-        const mockLLM = {
-            generate: vi.fn().mockResolvedValue(JSON.stringify({ ready: true, confidence: 0.95, gaps: [] })),
-        };
-        const qa = [
-            { question: "What platform?", answer: "Web — Node.js backend" },
-            { question: "Auth method?", answer: "JWT" },
-            { question: "Database?", answer: "PostgreSQL" },
-        ];
-        const result = await judgeReadiness(baseSpec, "Build a REST API", qa, mockLLM, "leader-model", false);
-        expect(result.ready).toBe(true);
-        expect(result.confidence).toBeGreaterThan(0.8);
-        expect(result.gaps).toHaveLength(0);
-    });
-    it("returns ready=false when topic only, no Q&A", async () => {
-        const mockLLM = {
-            generate: vi.fn().mockResolvedValue(JSON.stringify({
-                ready: false,
-                confidence: 0.15,
-                gaps: ["Deployment target not specified.", "Auth approach unknown."],
-            })),
-        };
-        const partialSpec = {
-            problemStatement: "todo app",
-            constraints: [],
-            successCriteria: [],
-            scope: "",
-            rawQA: [],
-        };
-        const result = await judgeReadiness(partialSpec, "todo app", [], mockLLM, "leader-model", false);
-        expect(result.ready).toBe(false);
-        expect(result.gaps.length).toBeGreaterThan(0);
-    });
-    it("clamps confidence to [0, 1]", async () => {
-        const mockLLM = {
-            generate: vi
-                .fn()
-                .mockResolvedValue(JSON.stringify({ ready: false, confidence: 1.8, gaps: ["Something missing."] })),
-        };
-        const result = await judgeReadiness(baseSpec, "topic", [], mockLLM, "model", false);
-        expect(result.confidence).toBeLessThanOrEqual(1);
-        expect(result.confidence).toBeGreaterThanOrEqual(0);
-    });
-    it("forces gaps=[] when ready=true regardless of LLM output", async () => {
-        const mockLLM = {
-            generate: vi.fn().mockResolvedValue(
-            // LLM contradicts itself: ready=true but also provides gaps
-            JSON.stringify({ ready: true, confidence: 0.9, gaps: ["Some gap that shouldn't be here."] })),
-        };
-        const result = await judgeReadiness(baseSpec, "topic", [], mockLLM, "model", false);
-        expect(result.ready).toBe(true);
-        expect(result.gaps).toHaveLength(0);
-    });
-    it("handles LLM failure gracefully — returns ready=false, confidence=0", async () => {
-        const mockLLM = {
-            generate: vi.fn().mockRejectedValue(new Error("network error")),
-        };
-        const result = await judgeReadiness(baseSpec, "topic", [], mockLLM, "model", false);
-        expect(result.ready).toBe(false);
-        expect(result.confidence).toBe(0);
-    });
-    it("handles malformed JSON from LLM — returns ready=false", async () => {
-        const mockLLM = {
-            generate: vi.fn().mockResolvedValue("not json at all"),
-        };
-        const result = await judgeReadiness(baseSpec, "topic", [], mockLLM, "model", false);
-        expect(result.ready).toBe(false);
-    });
-});
-//# sourceMappingURL=clarifier-ready-gate.test.js.map

package/dist/src/council/__tests__/cost-aware.test.d.ts

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

package/dist/src/council/__tests__/cost-aware.test.js

@@ -1,49 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import * as registry from "../../models/registry.js";
-import * as runtime from "../../providers/runtime.js";
-import { pickCouncilTaskModel } from "../leader.js";
-const catalog = [
-    { id: "premium-x", provider: "anthropic", tier: "premium" },
-    { id: "balanced-x", provider: "anthropic", tier: "balanced" },
-    { id: "fast-x", provider: "anthropic", tier: "fast" },
-    { id: "fast-y", provider: "openai", tier: "fast" },
-];
-describe("pickCouncilTaskModel", () => {
-    beforeEach(() => {
-        vi.spyOn(registry, "getModelInfo").mockImplementation((id) => catalog.find((m) => m.id === id));
-        vi.spyOn(registry, "getModelByTier").mockImplementation((tier, prefer) => {
-            const onPrefer = catalog.find((m) => m.tier === tier && m.provider === prefer);
-            return onPrefer ?? catalog.find((m) => m.tier === tier);
-        });
-        vi.spyOn(runtime, "detectProviderForModel").mockImplementation((id) => {
-            const m = catalog.find((x) => x.id === id);
-            return (m?.provider ?? "anthropic");
-        });
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it("returns leader unchanged when costAware=false", () => {
-        expect(pickCouncilTaskModel("research_need", "premium-x", false)).toBe("premium-x");
-    });
-    it("downshifts to fast tier for trivial classifier (research_need)", () => {
-        expect(pickCouncilTaskModel("research_need", "premium-x", true)).toBe("fast-x");
-    });
-    it("downshifts to balanced tier for evaluate_round", () => {
-        expect(pickCouncilTaskModel("evaluate_round", "premium-x", true)).toBe("balanced-x");
-    });
-    it("does not switch providers (leader anthropic, no anthropic-fast → falls back)", () => {
-        vi.spyOn(registry, "getModelByTier").mockImplementation((tier) => tier === "fast" ? catalog.find((m) => m.id === "fast-y") : undefined);
-        // fast-y is openai — must NOT be selected; fall back to leader.
-        expect(pickCouncilTaskModel("research_need", "premium-x", true)).toBe("premium-x");
-    });
-    it("does not downshift when leader is already at or below target tier", () => {
-        expect(pickCouncilTaskModel("evaluate_round", "balanced-x", true)).toBe("balanced-x");
-        expect(pickCouncilTaskModel("evaluate_round", "fast-x", true)).toBe("fast-x");
-    });
-    it("falls back to leader when target tier has no model anywhere", () => {
-        vi.spyOn(registry, "getModelByTier").mockReturnValue(undefined);
-        expect(pickCouncilTaskModel("research_need", "premium-x", true)).toBe("premium-x");
-    });
-});
-//# sourceMappingURL=cost-aware.test.js.map

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

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

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

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

package/dist/src/council/__tests__/debate-planner-structured.test.d.ts

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