muonroi-cli 1.3.4 → 1.4.1

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

@@ -1,344 +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.js", () => ({
-  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<typeof import("../../utils/settings.js")>();
-  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: AsyncGenerator<unknown, unknown, unknown>): Promise<unknown[]> {
-  const chunks: unknown[] = [];
-  let step = await gen.next();
-  while (!step.done) {
-    chunks.push(step.value);
-    step = await gen.next();
-  }
-  return chunks;
-}
-
-// ── Tests ────────────────────────────────────────────────────────────────────
-
-describe("audit-replay", () => {
-  let capturedMessages: Array<{ sessionId: string; content: string }>;
-
-  beforeEach(() => {
-    capturedMessages = [];
-    (appendSystemMessage as ReturnType<typeof vi.fn>).mockImplementation((sessionId: string, content: string) => {
-      capturedMessages.push({ sessionId, content });
-    });
-    (logInteraction as ReturnType<typeof vi.fn>).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: string = 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 as ReturnType<typeof vi.fn>).mock.calls;
-    const summaryCall = calls.find(
-      (args) =>
-        args[1] === "council" && (args[2] as { eventSubtype?: string } | undefined)?.eventSubtype === "council_summary",
-    );
-    expect(summaryCall).toBeDefined();
-    expect(summaryCall![0]).toBe("test-session-summary");
-
-    const data = (summaryCall![2] as { data: Record<string, unknown> }).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 as string).length).toBeLessThanOrEqual(1500);
-    expect(["high", "medium", "low"]).toContain(data.confidenceLevel);
-  });
-});

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

@@ -1,91 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { StreamChunk } from "../../types/index.js";
-import { runClarification } from "../clarifier.js";
-import type { CouncilLLM, QuestionResponder } from "../types.js";
-
-describe("runClarification maxRounds parameterization", () => {
-  const mockLLM: CouncilLLM = {
-    generate: vi.fn().mockResolvedValue('["Next question?"]'),
-  } as any;
-
-  const mockResponder: QuestionResponder = vi.fn().mockResolvedValue("answer");
-
-  it("respects maxRounds=6 when provided", async () => {
-    const rounds: string[] = [];
-    const gen = runClarification(
-      "topic",
-      "model",
-      "context",
-      mockResponder,
-      mockLLM,
-      undefined,
-      undefined,
-      6, // maxRounds
-    );
-
-    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 3 rounds when maxRounds is not provided", async () => {
-    const rounds: string[] = [];
-    const gen = runClarification(
-      "topic",
-      "model",
-      "context",
-      mockResponder,
-      mockLLM,
-      undefined,
-      undefined,
-      // maxRounds omitted
-    );
-
-    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(3);
-  });
-
-  it("falls back to 3 rounds when maxRounds is non-positive", async () => {
-    const rounds: string[] = [];
-    const gen = runClarification(
-      "topic",
-      "model",
-      "context",
-      mockResponder,
-      mockLLM,
-      undefined,
-      undefined,
-      -1, // invalid maxRounds
-    );
-
-    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(3);
-  });
-});

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

@@ -1,63 +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);
-  });
-});

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

@@ -1,60 +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 type { ModelInfo } from "../../types/index.js";
-import { pickCouncilTaskModel } from "../leader.js";
-
-const catalog: ModelInfo[] = [
-  { id: "premium-x", provider: "anthropic", tier: "premium" } as ModelInfo,
-  { id: "balanced-x", provider: "anthropic", tier: "balanced" } as ModelInfo,
-  { id: "fast-x", provider: "anthropic", tier: "fast" } as ModelInfo,
-  { id: "fast-y", provider: "openai", tier: "fast" } as ModelInfo,
-];
-
-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") as ReturnType<typeof runtime.detectProviderForModel>;
-    });
-  });
-
-  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");
-  });
-});