muonroi-cli 1.8.1 → 1.8.4

package/dist/src/orchestrator/__tests__/usage-normalizer-c1.test.js

@@ -1,155 +0,0 @@
-/**
- * src/orchestrator/__tests__/usage-normalizer-c1.test.ts
- *
- * Phase C1 — DeepSeek cache-token field reading.
- *
- * Before the fix, `getUsage()` and `getBatchUsage()` only consulted
- * `event.usage.cachedInputTokens`, `event.usage.inputTokenDetails.*`, and
- * `event.usage.raw.cache_creation_input_tokens`. DeepSeek goes through
- * `@ai-sdk/openai-compatible`, which exposes its cache split via
- * `providerMetadata.deepseek.{promptCacheHitTokens, promptCacheMissTokens}`
- * (streaming events) or raw `prompt_cache_hit_tokens` / `prompt_cache_miss_tokens`
- * fields (batch responses). Neither path was being read, so every DeepSeek
- * request recorded `cache_read_tokens = 0` — flagged by `usage forensics`
- * as "zero cache_creation across deepseek route — Phase C1 still open".
- *
- * This spec pins the new behavior:
- *   - DeepSeek-shaped batch usage → cacheReadTokens=700, noCacheInputTokens=300
- *   - DeepSeek-shaped streaming event (providerMetadata path) → same
- *   - OpenAI-shaped usage → unchanged (no DeepSeek-specific fields read)
- */
-import { describe, expect, it } from "vitest";
-import { getBatchUsage } from "../batch-utils.js";
-import { getUsage } from "../tool-utils.js";
-describe("C1: DeepSeek cache-token field reading", () => {
-    describe("getBatchUsage (raw API response shape)", () => {
-        it("reads DeepSeek prompt_cache_hit_tokens into cacheReadTokens and prompt_cache_miss_tokens into noCacheInputTokens", () => {
-            const result = getBatchUsage({
-                usage: {
-                    prompt_tokens: 1000,
-                    prompt_cache_hit_tokens: 700,
-                    prompt_cache_miss_tokens: 300,
-                    completion_tokens: 50,
-                },
-            });
-            expect(result.inputTokens).toBe(1000);
-            expect(result.outputTokens).toBe(50);
-            expect(result.cacheReadTokens).toBe(700);
-            expect(result.noCacheInputTokens).toBe(300);
-            // DeepSeek has no explicit cache-creation field — leave undefined, do not
-            // zero-fill (zero would mask a real provider regression).
-            expect(result.cacheCreationTokens).toBeUndefined();
-        });
-        it("control: OpenAI-shaped batch usage is unchanged (no DeepSeek-specific fields)", () => {
-            const result = getBatchUsage({
-                usage: {
-                    prompt_tokens: 1000,
-                    completion_tokens: 50,
-                },
-            });
-            expect(result.inputTokens).toBe(1000);
-            expect(result.outputTokens).toBe(50);
-            expect(result.cacheReadTokens).toBeUndefined();
-            expect(result.cacheCreationTokens).toBeUndefined();
-            expect(result.noCacheInputTokens).toBeUndefined();
-        });
-        it("control: Anthropic-style cache_read_input_tokens still wins over DeepSeek fallback", () => {
-            const result = getBatchUsage({
-                usage: {
-                    input_tokens: 1000,
-                    output_tokens: 50,
-                    cache_read_input_tokens: 800,
-                    cache_creation_input_tokens: 200,
-                },
-            });
-            expect(result.cacheReadTokens).toBe(800);
-            expect(result.cacheCreationTokens).toBe(200);
-            expect(result.noCacheInputTokens).toBeUndefined();
-        });
-    });
-    describe("getUsage (streamText onStepFinish event shape)", () => {
-        it("reads DeepSeek providerMetadata.deepseek.promptCacheHitTokens / promptCacheMissTokens", () => {
-            // Mirrors the shape AI SDK v6 produces for `@ai-sdk/openai-compatible`
-            // pointed at DeepSeek: standardized usage fields PLUS a provider-specific
-            // bucket on `event.providerMetadata`.
-            const event = {
-                finishReason: "stop",
-                usage: {
-                    inputTokens: 1000,
-                    outputTokens: 50,
-                    totalTokens: 1050,
-                },
-                providerMetadata: {
-                    deepseek: {
-                        promptCacheHitTokens: 700,
-                        promptCacheMissTokens: 300,
-                    },
-                },
-            };
-            const result = getUsage(event);
-            expect(result.inputTokens).toBe(1000);
-            expect(result.outputTokens).toBe(50);
-            expect(result.totalTokens).toBe(1050);
-            expect(result.cacheReadTokens).toBe(700);
-            expect(result.noCacheInputTokens).toBe(300);
-            expect(result.cacheCreationTokens).toBeUndefined();
-        });
-        it("falls back to legacy usage.raw shape for batched DeepSeek responses", () => {
-            const event = {
-                usage: {
-                    inputTokens: 1000,
-                    outputTokens: 50,
-                    raw: {
-                        prompt_cache_hit_tokens: 700,
-                        prompt_cache_miss_tokens: 300,
-                    },
-                },
-            };
-            const result = getUsage(event);
-            expect(result.cacheReadTokens).toBe(700);
-            expect(result.noCacheInputTokens).toBe(300);
-        });
-        it("reads OpenAI providerMetadata.openai.cachedPromptTokens for cacheReadTokens", () => {
-            const event = {
-                usage: { inputTokens: 1000, outputTokens: 50 },
-                providerMetadata: {
-                    openai: { cachedPromptTokens: 256 },
-                },
-            };
-            const result = getUsage(event);
-            expect(result.cacheReadTokens).toBe(256);
-            expect(result.noCacheInputTokens).toBeUndefined();
-        });
-        it("control: standardized cachedInputTokens still takes priority over providerMetadata", () => {
-            const event = {
-                usage: {
-                    inputTokens: 1000,
-                    outputTokens: 50,
-                    cachedInputTokens: 900, // standardized field — must win
-                },
-                providerMetadata: {
-                    deepseek: { promptCacheHitTokens: 700 },
-                },
-            };
-            const result = getUsage(event);
-            expect(result.cacheReadTokens).toBe(900);
-        });
-        it("control: OpenAI-shaped event with no DeepSeek fields → no cache metrics", () => {
-            const event = {
-                usage: { inputTokens: 1000, outputTokens: 50, totalTokens: 1050 },
-            };
-            const result = getUsage(event);
-            expect(result.inputTokens).toBe(1000);
-            expect(result.outputTokens).toBe(50);
-            expect(result.cacheReadTokens).toBeUndefined();
-            expect(result.cacheCreationTokens).toBeUndefined();
-            expect(result.noCacheInputTokens).toBeUndefined();
-        });
-        it("handles missing usage gracefully", () => {
-            expect(getUsage(undefined)).toEqual({});
-            expect(getUsage({})).toEqual({});
-            expect(getUsage({ usage: null })).toEqual({});
-        });
-    });
-});
-//# sourceMappingURL=usage-normalizer-c1.test.js.map

package/dist/src/orchestrator/__tests__/usage-shape-threading.test.d.ts

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

package/dist/src/orchestrator/__tests__/usage-shape-threading.test.js

@@ -1,98 +0,0 @@
-/**
- * src/orchestrator/__tests__/usage-shape-threading.test.ts
- *
- * Forensics-accuracy regression: the providerOptions SHAPE recorded on each
- * usage_events row must reflect the call that produced THAT event.
- *
- * The old design stashed the shape in mutable `Agent._lastProviderOptionsShape`
- * and cleared it after the first `source==="message"` event. Two failures fell
- * out of that:
- *   1. Multi-step turns emit one usage event PER step (onStepFinish), but the
- *      clear nulled the shape after step 1 → steps 2+ recorded an EMPTY shape
- *      even though the same streamText config (with promptCacheKey) drove them.
- *   2. A `task` sub-agent running mid-turn overwrote the shared field, so the
- *      message turn's later steps recorded the TASK's shape (interleaving race).
- *
- * The fix threads the shape EXPLICITLY into recordUsage per call, so neither the
- * clear nor an interleaved task can corrupt it. These tests drive the private
- * recordUsage directly with a faked session and a spied recordUsageEvent.
- */
-import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-const recordUsageEventSpy = vi.fn();
-vi.mock("../../storage/index.js", () => ({
-    appendCompaction: vi.fn(),
-    appendMessages: vi.fn(() => []),
-    appendSystemMessage: vi.fn(() => 0),
-    buildChatEntries: vi.fn(() => []),
-    getNextMessageSequence: vi.fn(() => 0),
-    getSessionTotalTokens: vi.fn(() => 0),
-    loadTranscript: vi.fn(() => []),
-    loadTranscriptState: vi.fn(() => ({ messages: [], seqs: [] })),
-    recordUsageEvent: (...args) => recordUsageEventSpy(...args),
-    SessionStore: class {
-        getWorkspace() {
-            return null;
-        }
-        openSession() {
-            return null;
-        }
-        createSession() {
-            return null;
-        }
-        setModel() { }
-        getRequiredSession() {
-            return null;
-        }
-        setMode() { }
-        touchSession() { }
-    },
-}));
-import { loadCatalog } from "../../models/registry.js";
-import { Agent } from "../orchestrator.js";
-// recordUsageEvent(sessionId, source, model, usage, lastSeq, pilActive,
-//                  enrichmentDelta, providerOptionsShape) — shape is the LAST arg.
-const SHAPE_ARG = 7;
-function makeAgentWithSession() {
-    const agent = new Agent(undefined, undefined, undefined, undefined, { persistSession: false });
-    // Fake a live session so recordUsage's `if (this.session)` branch runs.
-    agent.session = { id: "sess-threading-test" };
-    return {
-        recordUsage: (...a) => agent.recordUsage(...a),
-        setLastShape: (s) => {
-            agent._lastProviderOptionsShape = s;
-        },
-    };
-}
-const USAGE = { inputTokens: 100, outputTokens: 50, totalTokens: 150 };
-beforeAll(async () => {
-    await loadCatalog();
-});
-describe("recordUsage threads an explicit providerOptions shape", () => {
-    beforeEach(() => recordUsageEventSpy.mockClear());
-    afterEach(() => recordUsageEventSpy.mockClear());
-    it("records the explicit shape on EVERY message event of a multi-step turn (clear bug)", () => {
-        const a = makeAgentWithSession();
-        const shape = JSON.stringify({ openai: { promptCacheKey: "string", store: "boolean" } });
-        // Two steps of the same turn — both must carry the shape (step 2 used to be
-        // null because the first event cleared the shared field).
-        a.recordUsage(USAGE, "message", "gpt-5.4-mini", shape);
-        a.recordUsage(USAGE, "message", "gpt-5.4-mini", shape);
-        expect(recordUsageEventSpy).toHaveBeenCalledTimes(2);
-        expect(recordUsageEventSpy.mock.calls[0]?.[SHAPE_ARG]).toBe(shape);
-        expect(recordUsageEventSpy.mock.calls[1]?.[SHAPE_ARG]).toBe(shape);
-    });
-    it("records the message shape even when a task call set the shared field (interleaving race)", () => {
-        const a = makeAgentWithSession();
-        // Simulate a task sub-agent having stamped the shared field mid-turn.
-        a.setLastShape(JSON.stringify({ openai: { instructions: "string" } }));
-        const msgShape = JSON.stringify({ openai: { promptCacheKey: "string" } });
-        a.recordUsage(USAGE, "message", "gpt-5.4-mini", msgShape);
-        expect(recordUsageEventSpy.mock.calls[0]?.[SHAPE_ARG]).toBe(msgShape);
-    });
-    it("falls back to null (not stale) when no explicit shape is given for a title/other call", () => {
-        const a = makeAgentWithSession();
-        a.recordUsage(USAGE, "title", "gpt-5.4-mini");
-        expect(recordUsageEventSpy.mock.calls[0]?.[SHAPE_ARG]).toBeNull();
-    });
-});
-//# sourceMappingURL=usage-shape-threading.test.js.map

package/dist/src/orchestrator/__tests__/write-ahead.test.d.ts

@@ -1,20 +0,0 @@
-/**
- * src/orchestrator/__tests__/write-ahead.test.ts
- *
- * Phase A4 — write-ahead persistence for tool_calls.
- *
- * The orchestrator's streamText loop now persists a `pending` row in
- * `tool_calls` the moment the model emits a `tool-call` part — BEFORE
- * the tool executes. If the stream throws between this point and
- * `appendCompletedTurn(...)`, the row remains as `pending`, giving
- * `usage forensics <prefix>` a recoverable trail of what input the model
- * passed (previously this row would never have been written → silent
- * cost-leak forensic gap).
- *
- * Strategy: bun:sqlite is mocked globally for vitest (see
- * src/__test-stubs__/vitest-setup.ts). We mock the storage `db` module to
- * inject a fake SQLiteDatabase that records prepare() calls, then verify
- * `persistToolCallWriteAhead` and `markToolCallErrored` shape their SQL
- * correctly.
- */
-export {};

package/dist/src/orchestrator/__tests__/write-ahead.test.js

@@ -1,134 +0,0 @@
-/**
- * src/orchestrator/__tests__/write-ahead.test.ts
- *
- * Phase A4 — write-ahead persistence for tool_calls.
- *
- * The orchestrator's streamText loop now persists a `pending` row in
- * `tool_calls` the moment the model emits a `tool-call` part — BEFORE
- * the tool executes. If the stream throws between this point and
- * `appendCompletedTurn(...)`, the row remains as `pending`, giving
- * `usage forensics <prefix>` a recoverable trail of what input the model
- * passed (previously this row would never have been written → silent
- * cost-leak forensic gap).
- *
- * Strategy: bun:sqlite is mocked globally for vitest (see
- * src/__test-stubs__/vitest-setup.ts). We mock the storage `db` module to
- * inject a fake SQLiteDatabase that records prepare() calls, then verify
- * `persistToolCallWriteAhead` and `markToolCallErrored` shape their SQL
- * correctly.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-const preparedCalls = [];
-let dbShouldThrow = false;
-vi.mock("../../storage/db", () => {
-    const makeDb = () => ({
-        prepare: (sql) => ({
-            run: (...args) => {
-                preparedCalls.push({ sql, runArgs: args });
-                return undefined;
-            },
-            get: () => undefined,
-            all: () => [],
-        }),
-        exec: () => undefined,
-        pragma: () => undefined,
-        transaction: (fn) => fn,
-        close: () => undefined,
-    });
-    return {
-        getDatabase: () => {
-            if (dbShouldThrow)
-                throw new Error("simulated SQL failure");
-            return makeDb();
-        },
-        withTransaction: (fn) => fn(makeDb()),
-    };
-});
-// Import AFTER the mock so the helper picks up the mocked db module.
-import { markToolCallErrored, persistToolCallWriteAhead } from "../../storage/transcript.js";
-describe("A4: write-ahead tool_calls persistence", () => {
-    beforeEach(() => {
-        preparedCalls.length = 0;
-    });
-    afterEach(() => {
-        preparedCalls.length = 0;
-    });
-    describe("persistToolCallWriteAhead", () => {
-        it("inserts a tool_calls row with status='pending' BEFORE tool execution", () => {
-            persistToolCallWriteAhead("session-xyz", 42, "tool-call-abc", "read_file", JSON.stringify({ path: "/etc/hosts" }));
-            expect(preparedCalls).toHaveLength(1);
-            const call = preparedCalls[0];
-            expect(call.sql).toMatch(/INSERT OR IGNORE INTO tool_calls/);
-            expect(call.sql).toMatch(/'pending'/);
-            // started_at populated, completed_at NULL.
-            expect(call.sql).toMatch(/completed_at/);
-            expect(call.sql).toMatch(/NULL/);
-            // Run args: sessionId, messageSeq, toolCallId, toolName, argsJson, timestamp
-            expect(call.runArgs).toContain("session-xyz");
-            expect(call.runArgs).toContain(42);
-            expect(call.runArgs).toContain("tool-call-abc");
-            expect(call.runArgs).toContain("read_file");
-            const argsJsonArg = call.runArgs.find((a) => typeof a === "string" && a.includes("/etc/hosts"));
-            expect(argsJsonArg).toBeTruthy();
-        });
-        it("is fail-open: a thrown SQL error does NOT propagate to the orchestrator", () => {
-            dbShouldThrow = true;
-            try {
-                expect(() => persistToolCallWriteAhead("session-y", 1, "tc-1", "bash", "{}")).not.toThrow();
-            }
-            finally {
-                dbShouldThrow = false;
-            }
-        });
-        it("accepts -1 as a sentinel message_seq when prediction is unavailable", () => {
-            persistToolCallWriteAhead("session-zzz", -1, "tc-2", "grep", "{}");
-            expect(preparedCalls).toHaveLength(1);
-            expect(preparedCalls[0].runArgs).toContain(-1);
-        });
-    });
-    describe("markToolCallErrored", () => {
-        it("updates the row to status='errored' with a completed_at timestamp", () => {
-            markToolCallErrored("session-a", "tc-99", "tool execution threw");
-            expect(preparedCalls).toHaveLength(1);
-            const call = preparedCalls[0];
-            expect(call.sql).toMatch(/UPDATE tool_calls/);
-            expect(call.sql).toMatch(/SET status = 'errored'/);
-            expect(call.sql).toMatch(/completed_at = \?/);
-            expect(call.runArgs).toContain("session-a");
-            expect(call.runArgs).toContain("tc-99");
-        });
-        it("truncates extreme error messages to 500 chars in the fallback args_json", () => {
-            const huge = "x".repeat(2_000);
-            markToolCallErrored("session-b", "tc-100", huge);
-            expect(preparedCalls).toHaveLength(1);
-            const call = preparedCalls[0];
-            const fallbackArgsJson = call.runArgs.find((a) => typeof a === "string" && a.startsWith('{"error":'));
-            expect(fallbackArgsJson).toBeDefined();
-            // Parsed shape: {"error":"xxx...xxx"} — payload <= 500 chars + JSON overhead.
-            expect(fallbackArgsJson.length).toBeLessThan(600);
-        });
-        it("is fail-open: a thrown SQL error does NOT propagate", () => {
-            dbShouldThrow = true;
-            try {
-                expect(() => markToolCallErrored("session-c", "tc-200", "boom")).not.toThrow();
-            }
-            finally {
-                dbShouldThrow = false;
-            }
-        });
-    });
-    describe("integration: pending → completed handoff via appendMessages", () => {
-        it("documents the contract: write-ahead uses INSERT OR IGNORE so post-stream UPDATE finalizes the same row", () => {
-            // This test pins the SQL contract — appendMessages() in transcript.ts
-            // uses the same (session_id, tool_call_id) UNIQUE constraint to UPDATE
-            // the pending row to status='completed' after the turn settles.
-            //
-            // If a future refactor switches write-ahead to plain INSERT, the
-            // post-stream path would hit a UNIQUE constraint violation and the
-            // whole turn-persistence transaction would roll back.
-            persistToolCallWriteAhead("s", 1, "tc-shared", "bash", "{}");
-            expect(preparedCalls[0].sql).toContain("INSERT OR IGNORE");
-        });
-    });
-});
-//# sourceMappingURL=write-ahead.test.js.map

package/dist/src/orchestrator/abort.test.d.ts

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

package/dist/src/orchestrator/abort.test.js

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createAbortContext } from "./abort.js";
-describe("AbortContext", () => {
-    it("Test 1: initial state — not aborted", () => {
-        const ctx = createAbortContext();
-        expect(ctx.signal.aborted).toBe(false);
-        expect(ctx.isAborted()).toBe(false);
-        expect(ctx.reason()).toBeUndefined();
-    });
-    it("Test 1: after abort — signal is aborted and reason is captured", () => {
-        const ctx = createAbortContext();
-        ctx.abort("test");
-        expect(ctx.signal.aborted).toBe(true);
-        expect(ctx.isAborted()).toBe(true);
-        expect(ctx.reason()).toBe("test");
-    });
-    it("Test 2: abort is idempotent — second call does not throw", () => {
-        const ctx = createAbortContext();
-        expect(() => {
-            ctx.abort("first");
-            ctx.abort("second");
-        }).not.toThrow();
-        // Reason captured from first call only
-        expect(ctx.reason()).toBe("first");
-    });
-    it("Test 2: abort with no reason is idempotent", () => {
-        const ctx = createAbortContext();
-        ctx.abort();
-        ctx.abort("later");
-        expect(ctx.isAborted()).toBe(true);
-        expect(ctx.reason()).toBeUndefined();
-    });
-});
-//# sourceMappingURL=abort.test.js.map

package/dist/src/orchestrator/agent.test.d.ts

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

package/dist/src/orchestrator/agent.test.js

@@ -1,178 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-async function importAgentModule() {
-    vi.resetModules();
-    const { loadCatalog } = await import("../models/registry.js");
-    await loadCatalog();
-    vi.doMock("../storage/index", () => ({
-        appendCompaction: vi.fn(),
-        appendMessages: vi.fn(() => []),
-        appendSystemMessage: vi.fn(() => 0),
-        buildChatEntries: vi.fn(() => []),
-        getNextMessageSequence: vi.fn(() => 0),
-        getSessionTotalTokens: vi.fn(() => 0),
-        loadTranscript: vi.fn(() => []),
-        loadTranscriptState: vi.fn(() => ({ messages: [], seqs: [] })),
-        recordUsageEvent: vi.fn(),
-        SessionStore: class {
-            getWorkspace() {
-                return null;
-            }
-            openSession() {
-                return null;
-            }
-            createSession() {
-                return null;
-            }
-            setModel() { }
-            getRequiredSession() {
-                return null;
-            }
-            setMode() { }
-            touchSession() { }
-        },
-    }));
-    return import("./orchestrator.js");
-}
-afterEach(() => {
-    vi.restoreAllMocks();
-    vi.resetModules();
-    vi.doUnmock("../storage/index.js");
-});
-describe("Agent class", { timeout: 30_000 }, () => {
-    it("constructs with default options", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-        });
-        expect(agent).toBeDefined();
-        expect(agent.getMode()).toBe("agent");
-    });
-    it("can switch mode", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-        });
-        agent.setMode("plan");
-        expect(agent.getMode()).toBe("plan");
-        agent.setMode("ask");
-        expect(agent.getMode()).toBe("ask");
-        agent.setMode("agent");
-        expect(agent.getMode()).toBe("agent");
-    });
-    it("returns a model string", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-        });
-        const model = agent.getModel();
-        expect(typeof model).toBe("string");
-        expect(model.length).toBeGreaterThan(0);
-    });
-    it("can set model", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-        });
-        agent.setModel("claude-sonnet-4-6-20250514");
-        expect(agent.getModel()).toBe("claude-sonnet-4-6-20250514");
-    });
-    it("constructs with sandbox mode — always returns 'off' (sandbox removed)", async () => {
-        const { Agent } = await importAgentModule();
-        // Sandbox has been removed; passing sandboxMode: "shuru" is accepted for
-        // back-compat but getSandboxMode() always returns "off" until a new
-        // sandbox implementation is wired in.
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-            sandboxMode: "shuru",
-        });
-        expect(agent.getSandboxMode()).toBe("off");
-    });
-    it("defaults sandbox mode to off", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-        });
-        expect(agent.getSandboxMode()).toBe("off");
-    });
-    it("constructs with sandbox settings", async () => {
-        const { Agent } = await importAgentModule();
-        const settings = { allowNet: true, cpus: 4 };
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-            sandboxMode: "shuru",
-            sandboxSettings: settings,
-        });
-        expect(agent.getSandboxSettings()).toEqual(settings);
-    });
-    it("buffers council question answers that arrive before the resolver is registered", async () => {
-        // Headless auto-answer race: respondToCouncilQuestion fires after the
-        // chunk yields but BEFORE the council generator's await on
-        // respondToQuestion(qid) registers a resolver. The buffer must catch
-        // the answer so the eventual Promise resolves immediately.
-        //
-        // This behavior lives on CouncilManager (extracted from Agent in Phase 12.1-02).
-        // We test it here via CouncilManager directly since _createQuestionResponder
-        // was never a method on Agent.
-        const { CouncilManager } = await import("./council-manager.js");
-        const stubDeps = {
-            getModelId: () => "stub",
-            getSessionId: () => null,
-            hasSessionStore: () => false,
-            getMessages: () => [],
-            getBash: () => ({}),
-            getMode: () => "agent",
-        };
-        const m = new CouncilManager(stubDeps);
-        m.respondToQuestion("qid-1", "buffered-answer");
-        const promise = m.createQuestionResponder()("qid-1");
-        await expect(promise).resolves.toBe("buffered-answer");
-        // After consumption the buffer slot is gone — a second responder waits.
-        const stalled = m.createQuestionResponder()("qid-1");
-        let settled = false;
-        void stalled.then(() => {
-            settled = true;
-        });
-        await new Promise((r) => setTimeout(r, 10));
-        expect(settled).toBe(false);
-        m.respondToQuestion("qid-1", "second");
-        await expect(stalled).resolves.toBe("second");
-    });
-    it("buffers council preflight approvals before the resolver registers", async () => {
-        const { CouncilManager } = await import("./council-manager.js");
-        const stubDeps = {
-            getModelId: () => "stub",
-            getSessionId: () => null,
-            hasSessionStore: () => false,
-            getMessages: () => [],
-            getBash: () => ({}),
-            getMode: () => "agent",
-        };
-        const m = new CouncilManager(stubDeps);
-        m.respondToPreflight("pf-1", false);
-        await expect(m.createPreflightResponder()("pf-1")).resolves.toBe(false);
-    });
-    it("respects MUONROI_MAX_TOKENS env var", async () => {
-        vi.stubEnv("MUONROI_MAX_TOKENS", "32768");
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-        });
-        expect(agent).toBeDefined();
-    });
-    it("constructs with permission mode", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-            permissionMode: "yolo",
-        });
-        expect(agent).toBeDefined();
-    });
-    it("constructs with explicit model parameter", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, "claude-sonnet-4-6-20250514", undefined, {
-            persistSession: false,
-        });
-        expect(agent.getModel()).toBe("claude-sonnet-4-6-20250514");
-    });
-});
-//# sourceMappingURL=agent.test.js.map

package/dist/src/orchestrator/cleanup.test.d.ts

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