muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/__tests__/batch-turn-runner.test.ts

@@ -1,186 +0,0 @@
-// Phase 12.5-03 — BatchTurnRunner unit tests.
-//
-// Focused smoke: confirms the DI surface (BatchTurnRunnerDeps) is wired
-// correctly and that the abort + retry invariants hold without exercising
-// the (stub) batch API. The Phase 0 batch stubs throw, so every successful
-// path through `run()` here goes via the catch-block — that's exactly what
-// we want to assert (transient retry + abort + recordUsage guard).
-
-import type { ModelMessage, ToolSet } from "ai";
-import { beforeAll, describe, expect, it } from "vitest";
-import { getTestModels, getTestProviders } from "../../__test-helpers__/catalog-fixtures.js";
-import { loadCatalog } from "../../models/registry.js";
-import type { BashTool } from "../../tools/bash";
-import type { ToolCall, ToolResult } from "../../types/index";
-import type { ProcessMessageObserver } from "../agent-options";
-import { BatchTurnRunner, type BatchTurnRunnerDeps } from "../batch-turn-runner.js";
-import type { CompactionSettings } from "../compaction";
-
-beforeAll(async () => {
-  await loadCatalog();
-});
-
-function makeBashStub(): BashTool {
-  return {
-    getCwd: () => process.cwd(),
-    getSandboxMode: () => "off",
-    getSandboxSettings: () => ({}),
-  } as unknown as BashTool;
-}
-
-type Counters = {
-  appendCompletedTurn: number;
-  discardAbortedTurn: number;
-  recordUsage: number;
-  compactedFlags: boolean[];
-};
-
-function makeDeps(overrides: Partial<BatchTurnRunnerDeps> = {}): {
-  deps: BatchTurnRunnerDeps;
-  counters: Counters;
-} {
-  const messages: ModelMessage[] = [];
-  let compactedThisTurn = false;
-  const counters: Counters = {
-    appendCompletedTurn: 0,
-    discardAbortedTurn: 0,
-    recordUsage: 0,
-    compactedFlags: [],
-  };
-  const deps: BatchTurnRunnerDeps = {
-    messages,
-    bash: makeBashStub(),
-    mode: "agent",
-    maxToolRounds: 50,
-    maxTokens: 16_384,
-    schedules: {} as unknown as BatchTurnRunnerDeps["schedules"],
-    sendTelegramFile: null,
-    getSessionId: () => null,
-    getCompactedThisTurn: () => compactedThisTurn,
-    setCompactedThisTurn: (v) => {
-      compactedThisTurn = v;
-      counters.compactedFlags.push(v);
-    },
-    setLastProviderOptionsShape: () => {},
-    getBatchClientOptions: () => ({ apiKey: "test-key" }),
-    getCompactionSettings: (_cw): CompactionSettings =>
-      ({
-        thresholdPct: 0.85,
-        keepRecentTokens: 4096,
-        reserveTokens: 16_384,
-      }) as unknown as CompactionSettings,
-    compactForContext: async () => true,
-    postTurnCompact: async () => {},
-    createTools: () => ({}) as ToolSet,
-    runTask: async () => ({ success: true, output: "" }) as ToolResult,
-    runDelegation: async () => ({ success: true, output: "" }) as ToolResult,
-    readDelegation: async () => ({ success: true, output: "" }) as ToolResult,
-    listDelegations: async () => ({ success: true, output: "" }) as ToolResult,
-    executeBatchToolCall: async (_tools: ToolSet, _call: ToolCall) => ({
-      input: {},
-      result: { success: true, output: "" } as ToolResult,
-    }),
-    appendCompletedTurn: () => {
-      counters.appendCompletedTurn++;
-    },
-    discardAbortedTurn: () => {
-      counters.discardAbortedTurn++;
-    },
-    recordUsage: () => {
-      counters.recordUsage++;
-    },
-    ...overrides,
-  };
-  return { deps, counters };
-}
-
-function makeArgs(signal: AbortSignal, providerStub?: unknown): Parameters<BatchTurnRunner["run"]>[0] {
-  const testModels = getTestModels();
-  const testProviders = getTestProviders();
-  return {
-    userModelMessage: { role: "user", content: "hello" } as ModelMessage,
-    observer: undefined as ProcessMessageObserver | undefined,
-    provider: (providerStub ?? {}) as Parameters<BatchTurnRunner["run"]>[0]["provider"],
-    subagents: [],
-    system: "",
-    runtime: {
-      modelId: testModels.fast,
-      modelInfo: { provider: testProviders.default, contextWindow: 131_072 },
-      model: {} as unknown,
-      providerOptions: {},
-      unsupportedParams: [],
-    } as unknown as Parameters<BatchTurnRunner["run"]>[0]["runtime"],
-    modelInfo: { contextWindow: 131_072 } as Parameters<BatchTurnRunner["run"]>[0]["modelInfo"],
-    signal,
-  };
-}
-
-async function drain(gen: AsyncGenerator<unknown, void, unknown>): Promise<unknown[]> {
-  const out: unknown[] = [];
-  for await (const chunk of gen) out.push(chunk);
-  return out;
-}
-
-describe("BatchTurnRunner DI invariants (12.5-03)", () => {
-  it("constructs with deps and exposes run()", () => {
-    const { deps } = makeDeps();
-    const runner = new BatchTurnRunner(deps);
-    expect(typeof runner.run).toBe("function");
-  });
-
-  it("yields [Cancelled] when signal is already aborted and calls discardAbortedTurn", async () => {
-    // Force compactForContext to throw a non-transient error fast so the
-    // catch-block runs without hitting the retry exponential-backoff sleep.
-    const { deps, counters } = makeDeps({
-      compactForContext: async () => {
-        throw new Error("synthetic compact failure (non-transient)");
-      },
-    });
-    const runner = new BatchTurnRunner(deps);
-    const ctrl = new AbortController();
-    ctrl.abort();
-    const chunks = await drain(runner.run(makeArgs(ctrl.signal)));
-    // catch sees signal.aborted → emits "[Cancelled]" and discards the turn.
-    expect(chunks.some((c) => (c as { content?: string }).content === "\n\n[Cancelled]")).toBe(true);
-    expect(counters.discardAbortedTurn).toBe(1);
-    expect(counters.appendCompletedTurn).toBe(0);
-  });
-
-  it("flips compactedThisTurn to false at the top of every turn", async () => {
-    const { deps, counters } = makeDeps({
-      compactForContext: async () => {
-        throw new Error("synthetic non-transient");
-      },
-    });
-    const runner = new BatchTurnRunner(deps);
-    const ctrl = new AbortController();
-    ctrl.abort(); // skip retry sleep
-    await drain(runner.run(makeArgs(ctrl.signal)));
-    expect(counters.compactedFlags[0]).toBe(false);
-  });
-
-  it("does NOT call recordUsage when totalUsage is empty (hasUsage guard)", async () => {
-    const { deps, counters } = makeDeps({
-      compactForContext: async () => {
-        throw new Error("synthetic non-transient");
-      },
-    });
-    const runner = new BatchTurnRunner(deps);
-    const ctrl = new AbortController();
-    // Pre-abort so we hit the catch's `signal.aborted` early-return: that
-    // path discards the turn (no appendCompletedTurn and no recordUsage).
-    ctrl.abort();
-    await drain(runner.run(makeArgs(ctrl.signal)));
-    expect(counters.recordUsage).toBe(0);
-    expect(counters.appendCompletedTurn).toBe(0);
-    expect(counters.discardAbortedTurn).toBe(1);
-  });
-
-  it("propagates messages array reference (deps.messages mutation visible)", () => {
-    const { deps } = makeDeps();
-    const newMsg: ModelMessage = { role: "assistant", content: "test" };
-    (deps.messages as ModelMessage[]).push(newMsg);
-    expect(deps.messages.length).toBe(1);
-    expect(deps.messages[0]).toBe(newMsg);
-  });
-});

package/src/orchestrator/__tests__/council-manager.test.ts

@@ -1,171 +0,0 @@
-// Phase 12.1-02 — CouncilManager unit tests.
-//
-// Smoke-only: state isolation, resolver registration/buffering lifecycle,
-// outcome parser fallback. Heavy integration is covered by
-// src/council/__tests__/*.test.ts.
-
-import type { ModelMessage } from "ai";
-import { describe, expect, it } from "vitest";
-import type { BashTool } from "../../tools/bash";
-import { CouncilManager, type CouncilManagerDeps } from "../council-manager";
-
-function makeDeps(overrides: Partial<CouncilManagerDeps> = {}): CouncilManagerDeps {
-  return {
-    getModelId: () => "test-model",
-    getSessionId: () => null,
-    hasSessionStore: () => false,
-    getMessages: () => [] as ReadonlyArray<ModelMessage>,
-    getBash: () => ({ getCwd: () => process.cwd() }) as unknown as BashTool,
-    getMode: () => "agent",
-    ...overrides,
-  };
-}
-
-describe("CouncilManager — state isolation", () => {
-  it("each instance owns its own stats", () => {
-    const a = new CouncilManager(makeDeps());
-    const b = new CouncilManager(makeDeps());
-    a.resetStats(1000);
-    b.resetStats(2000);
-    expect(a.stats.startMs).toBe(1000);
-    expect(b.stats.startMs).toBe(2000);
-    // Bump a's calls — b stays at zero.
-    a.stats.calls = 5;
-    expect(b.stats.calls).toBe(0);
-  });
-
-  it("synthesis state is per-instance", () => {
-    const a = new CouncilManager(makeDeps());
-    const b = new CouncilManager(makeDeps());
-    a.setLastSynthesis("from-a");
-    b.setLastSynthesis("from-b");
-    expect(a.lastSynthesis).toBe("from-a");
-    expect(b.lastSynthesis).toBe("from-b");
-  });
-
-  it("continuation flag is per-instance", () => {
-    const a = new CouncilManager(makeDeps());
-    const b = new CouncilManager(makeDeps());
-    a.setContinuation(true);
-    expect(a.isContinuation).toBe(true);
-    expect(b.isContinuation).toBe(false);
-  });
-});
-
-describe("CouncilManager — question resolver lifecycle", () => {
-  it("buffers question answers that arrive before the responder registers", async () => {
-    const m = new CouncilManager(makeDeps());
-    m.respondToQuestion("qid-1", "buffered-answer");
-    const promise = m.createQuestionResponder()("qid-1");
-    await expect(promise).resolves.toBe("buffered-answer");
-  });
-
-  it("resolves a pending question when the answer arrives later", async () => {
-    const m = new CouncilManager(makeDeps());
-    const promise = m.createQuestionResponder()("qid-2");
-    m.respondToQuestion("qid-2", "later-answer");
-    await expect(promise).resolves.toBe("later-answer");
-  });
-
-  it("drains the buffered slot exactly once per question id", async () => {
-    const m = new CouncilManager(makeDeps());
-    m.respondToQuestion("qid-3", "first");
-    await expect(m.createQuestionResponder()("qid-3")).resolves.toBe("first");
-    // Second responder for the same id must wait for a new answer.
-    const stalled = m.createQuestionResponder()("qid-3");
-    let settled = false;
-    void stalled.then(() => {
-      settled = true;
-    });
-    await new Promise((r) => setTimeout(r, 10));
-    expect(settled).toBe(false);
-    m.respondToQuestion("qid-3", "second");
-    await expect(stalled).resolves.toBe("second");
-  });
-});
-
-describe("CouncilManager — preflight resolver lifecycle", () => {
-  it("buffers preflight approvals before the responder registers", async () => {
-    const m = new CouncilManager(makeDeps());
-    m.respondToPreflight("pf-1", false);
-    await expect(m.createPreflightResponder()("pf-1")).resolves.toBe(false);
-  });
-
-  it("resolves pending preflight when approval arrives later", async () => {
-    const m = new CouncilManager(makeDeps());
-    const promise = m.createPreflightResponder()("pf-2");
-    m.respondToPreflight("pf-2", true);
-    await expect(promise).resolves.toBe(true);
-  });
-});
-
-describe("CouncilManager — parseOutcome fallback", () => {
-  it("returns null on non-JSON synthesis", () => {
-    const m = new CouncilManager(makeDeps());
-    expect(m.parseOutcome("no json here", "topic")).toBeNull();
-  });
-
-  it("returns null when required fields are missing", () => {
-    const m = new CouncilManager(makeDeps());
-    expect(m.parseOutcome('{"type":"decision"}', "topic")).toBeNull();
-    expect(m.parseOutcome('{"summary":"only summary"}', "topic")).toBeNull();
-  });
-
-  it("parses a well-formed decision outcome", () => {
-    const m = new CouncilManager(makeDeps());
-    const parsed = m.parseOutcome(
-      '{"type":"decision","summary":"do X","agreed":["a"],"tradeoffs":[],"recommendation":"X"}',
-      "topic",
-    );
-    expect(parsed?.type).toBe("decision");
-    expect(parsed?.summary).toBe("do X");
-    expect(parsed?.agreed).toEqual(["a"]);
-  });
-});
-
-describe("CouncilManager — buildContext", () => {
-  it("returns empty string when there are no messages", () => {
-    const m = new CouncilManager(makeDeps({ getMessages: () => [] }));
-    expect(m.buildContext()).toBe("");
-  });
-
-  it("includes recent user messages", () => {
-    const msgs: ModelMessage[] = [
-      { role: "user", content: "hello world" },
-      { role: "assistant", content: "ack" },
-      { role: "user", content: "second user turn" },
-    ];
-    const m = new CouncilManager(makeDeps({ getMessages: () => msgs }));
-    const ctx = m.buildContext();
-    expect(ctx).toContain("hello world");
-    expect(ctx).toContain("second user turn");
-  });
-
-  it("surfaces previous council memories", () => {
-    const msgs: ModelMessage[] = [
-      { role: "system", content: "[Council Memory] previous outcome" },
-      { role: "user", content: "current ask" },
-    ];
-    const m = new CouncilManager(makeDeps({ getMessages: () => msgs }));
-    const ctx = m.buildContext();
-    expect(ctx).toContain("Previous Council Outcomes");
-    expect(ctx).toContain("previous outcome");
-  });
-});
-
-describe("CouncilManager — hasMultiProviderConfig", () => {
-  it("returns false for single-provider role models", () => {
-    const m = new CouncilManager(makeDeps());
-    expect(m.hasMultiProviderConfig({ implement: "claude-sonnet-4-6", verify: "claude-haiku-4" })).toBe(false);
-  });
-
-  it("returns true when models span multiple providers", () => {
-    const m = new CouncilManager(makeDeps());
-    expect(m.hasMultiProviderConfig({ implement: "claude-sonnet-4-6", verify: "gpt-4o-mini" })).toBe(true);
-  });
-
-  it("returns false for empty config", () => {
-    const m = new CouncilManager(makeDeps());
-    expect(m.hasMultiProviderConfig({})).toBe(false);
-  });
-});

package/src/orchestrator/__tests__/cross-turn-dedup.test.ts

@@ -1,201 +0,0 @@
-import type { ToolSet } from "ai";
-import { afterEach, describe, expect, it } from "vitest";
-
-import { CrossTurnDedup, isCrossTurnDedupEnabled, wrapToolSetWithDedup } from "../cross-turn-dedup.js";
-
-describe("CrossTurnDedup", () => {
-  describe("maybeDedup", () => {
-    it("returns null for the first occurrence and a stub for the second", () => {
-      const dedup = new CrossTurnDedup();
-      dedup.beginTurn();
-      const payload = "x".repeat(2_000);
-
-      // First call: passes through.
-      const first = dedup.maybeDedup("read_file", payload);
-      expect(first).toBeNull();
-
-      // Second user turn — bump counter.
-      dedup.beginTurn();
-      const second = dedup.maybeDedup("read_file", payload);
-      expect(second).not.toBeNull();
-      expect(second).toContain("[dup of");
-      expect(second).toContain("read_file");
-      expect(second).toContain("turn 1");
-    });
-
-    it("distinct large tool outputs do not collide on sha256-16", () => {
-      // Two large strings differing only in last char must produce different
-      // stubs (i.e. no false-positive dedup hit). Regression coverage for the
-      // sha1-12 → sha256-16 upgrade — at 48 bits the birthday bound made this
-      // theoretically plausible; at 64 bits it's astronomically unlikely.
-      const dedup = new CrossTurnDedup({ minChars: 100 });
-      dedup.beginTurn();
-      const a = "A".repeat(2_000);
-      const b = `${"A".repeat(1_999)}B`;
-
-      expect(dedup.maybeDedup("read_file", a)).toBeNull();
-      // Distinct content must NOT hit the cache.
-      expect(dedup.maybeDedup("read_file", b)).toBeNull();
-      // Two distinct payloads → two distinct cache entries (verified via
-      // cache size since the marker no longer embeds the hash post-G3).
-      expect(dedup.getStats().size).toBe(2);
-
-      // Re-emitting either payload now triggers a dedup hit.
-      const stubA = dedup.maybeDedup("read_file", a);
-      const stubB = dedup.maybeDedup("read_file", b);
-      expect(stubA).not.toBeNull();
-      expect(stubB).not.toBeNull();
-      expect(dedup.getStats().hits).toBe(2);
-    });
-
-    it("does not dedup different outputs", () => {
-      const dedup = new CrossTurnDedup();
-      dedup.beginTurn();
-      const a = "a".repeat(1_000);
-      const b = "b".repeat(1_000);
-      expect(dedup.maybeDedup("read_file", a)).toBeNull();
-      expect(dedup.maybeDedup("read_file", b)).toBeNull();
-      // Re-run yields a hit for a, miss for c.
-      expect(dedup.maybeDedup("read_file", a)).not.toBeNull();
-      const c = "c".repeat(1_000);
-      expect(dedup.maybeDedup("read_file", c)).toBeNull();
-    });
-
-    it("skips outputs below the min-chars threshold", () => {
-      const dedup = new CrossTurnDedup({ minChars: 500 });
-      dedup.beginTurn();
-      const small = "y".repeat(100);
-      expect(dedup.maybeDedup("bash", small)).toBeNull();
-      expect(dedup.maybeDedup("bash", small)).toBeNull();
-      expect(dedup.getStats().inserts).toBe(0);
-      expect(dedup.getStats().hits).toBe(0);
-    });
-
-    it("evicts oldest entry after exceeding maxEntries", () => {
-      const dedup = new CrossTurnDedup({ maxEntries: 3, minChars: 10 });
-      dedup.beginTurn();
-      // Insert 4 distinct payloads — first should be evicted.
-      const payloads = ["A", "B", "C", "D"].map((c) => c.repeat(50));
-      for (const p of payloads) expect(dedup.maybeDedup("read_file", p)).toBeNull();
-      expect(dedup.getStats().size).toBe(3);
-
-      // First payload should no longer be cached (evicted) — re-running it
-      // returns null, not a stub.
-      expect(dedup.maybeDedup("read_file", payloads[0]!)).toBeNull();
-      // Latest payload should still be cached — re-running returns a stub.
-      expect(dedup.maybeDedup("read_file", payloads[3]!)).not.toBeNull();
-    });
-
-    it("no-ops when constructed with enabled=false", () => {
-      const dedup = new CrossTurnDedup({ enabled: false });
-      dedup.beginTurn();
-      const payload = "z".repeat(2_000);
-      expect(dedup.maybeDedup("read_file", payload)).toBeNull();
-      expect(dedup.maybeDedup("read_file", payload)).toBeNull();
-      expect(dedup.getStats().inserts).toBe(0);
-      expect(dedup.getStats().hits).toBe(0);
-    });
-  });
-
-  describe("isCrossTurnDedupEnabled", () => {
-    const original = process.env.MUONROI_CROSS_TURN_DEDUP;
-    afterEach(() => {
-      if (original === undefined) delete process.env.MUONROI_CROSS_TURN_DEDUP;
-      else process.env.MUONROI_CROSS_TURN_DEDUP = original;
-    });
-
-    it("defaults to enabled", () => {
-      delete process.env.MUONROI_CROSS_TURN_DEDUP;
-      expect(isCrossTurnDedupEnabled()).toBe(true);
-    });
-
-    it("respects MUONROI_CROSS_TURN_DEDUP=0", () => {
-      process.env.MUONROI_CROSS_TURN_DEDUP = "0";
-      expect(isCrossTurnDedupEnabled()).toBe(false);
-    });
-
-    it("respects MUONROI_CROSS_TURN_DEDUP=false", () => {
-      process.env.MUONROI_CROSS_TURN_DEDUP = "false";
-      expect(isCrossTurnDedupEnabled()).toBe(false);
-    });
-  });
-
-  describe("wrapToolSetWithDedup", () => {
-    function makeTool(returnValue: unknown): ToolSet[string] {
-      return {
-        description: "test tool",
-        inputSchema: { type: "object", properties: {} },
-        execute: async () => returnValue,
-        // biome-ignore lint: minimal AI ToolSet shape used by the wrapper only
-      } as unknown as ToolSet[string];
-    }
-
-    it("returns the same tool set when dedup is null", () => {
-      const tools: ToolSet = { read_file: makeTool("payload") };
-      expect(wrapToolSetWithDedup(tools, null)).toBe(tools);
-    });
-
-    it("dedups string outputs across calls", async () => {
-      const dedup = new CrossTurnDedup({ minChars: 10 });
-      dedup.beginTurn();
-      const payload = "p".repeat(1_000);
-      const tools: ToolSet = { read_file: makeTool(payload) };
-      const wrapped = wrapToolSetWithDedup(tools, dedup);
-      const exec = (wrapped.read_file as unknown as { execute: (i: unknown) => Promise<unknown> }).execute;
-
-      const first = await exec({});
-      expect(first).toBe(payload);
-
-      const second = (await exec({})) as string;
-      expect(second).not.toBe(payload);
-      expect(second).toContain("[dup of");
-    });
-
-    it("dedups the .output field on object-shaped results", async () => {
-      const dedup = new CrossTurnDedup({ minChars: 10 });
-      dedup.beginTurn();
-      const payload = "q".repeat(1_000);
-      const tools: ToolSet = { read_file: makeTool({ success: true, output: payload }) };
-      const wrapped = wrapToolSetWithDedup(tools, dedup);
-      const exec = (wrapped.read_file as unknown as { execute: (i: unknown) => Promise<unknown> }).execute;
-
-      const first = (await exec({})) as { output: string };
-      expect(first.output).toBe(payload);
-
-      const second = (await exec({})) as { output: string };
-      expect(second.output).toContain("[dup of");
-    });
-
-    it("dedups MCP content-array text parts across calls", async () => {
-      // MCP results are { type: "content", value: [{type:"text", text}] } — a
-      // shape the dedup previously ignored, so re-fetching the same MCP payload
-      // (e.g. the same docs page) re-billed full content every turn.
-      const dedup = new CrossTurnDedup({ minChars: 10 });
-      dedup.beginTurn();
-      const payload = "r".repeat(1_000);
-      const tools: ToolSet = {
-        mcp_docs__fetch: makeTool({ type: "content", value: [{ type: "text", text: payload }] }),
-      };
-      const wrapped = wrapToolSetWithDedup(tools, dedup);
-      const exec = (wrapped.mcp_docs__fetch as unknown as { execute: (i: unknown) => Promise<unknown> }).execute;
-
-      const first = (await exec({})) as { value: Array<{ text: string }> };
-      expect(first.value[0]!.text).toBe(payload);
-
-      const second = (await exec({})) as { value: Array<{ text: string }> };
-      expect(second.value[0]!.text).toContain("[dup of");
-    });
-
-    it("leaves non-text MCP content parts (images) untouched", async () => {
-      const dedup = new CrossTurnDedup({ minChars: 10 });
-      dedup.beginTurn();
-      const image = { type: "image", data: "BASE64", mediaType: "image/png" };
-      const tools: ToolSet = { mcp_x__shot: makeTool({ type: "content", value: [image] }) };
-      const wrapped = wrapToolSetWithDedup(tools, dedup);
-      const exec = (wrapped.mcp_x__shot as unknown as { execute: (i: unknown) => Promise<unknown> }).execute;
-
-      const out = (await exec({})) as { value: unknown[] };
-      expect(out.value[0]).toEqual(image);
-    });
-  });
-});