muonroi-cli 1.8.1 → 1.8.3

package/dist/src/orchestrator/__tests__/read-path-budget.test.js

@@ -1,156 +0,0 @@
-/**
- * Phase C4 input-keyed read budget tests.
- *
- * Backed by evidence in chat-export-bcf1f0951567 (Agent B report): 3
- * legitimate-looking files (client/vite.config.ts, client/index.html,
- * client/src/main.tsx) were each read 2x across edit turns, missed by C3
- * output-hash dedup because file bytes changed between reads.
- */
-import { describe, expect, it } from "vitest";
-import { _internals, ReadPathBudget, wrapToolSetWithReadBudget } from "../read-path-budget.js";
-describe("ReadPathBudget", () => {
-    it("returns null until cap reached, then stub", () => {
-        const b = new ReadPathBudget(2);
-        expect(b.checkAndIncrement("read_file", "/a/b.ts")).toBeNull();
-        expect(b.checkAndIncrement("read_file", "/a/b.ts")).toBeNull();
-        const stub = b.checkAndIncrement("read_file", "/a/b.ts");
-        expect(stub).toContain("read budget exceeded");
-        expect(stub).toContain("/a/b.ts");
-    });
-    it("normalizes path case + slashes when keying", () => {
-        const b = new ReadPathBudget(1);
-        expect(b.checkAndIncrement("read_file", "C:\\Foo\\Bar.ts")).toBeNull();
-        expect(b.checkAndIncrement("read_file", "c:/foo/bar.ts")).not.toBeNull();
-    });
-    it("keys per (toolName, path) — different tools share budget independently", () => {
-        const b = new ReadPathBudget(1);
-        expect(b.checkAndIncrement("read_file", "/a")).toBeNull();
-        expect(b.checkAndIncrement("mcp_filesystem__read_text_file", "/a")).toBeNull();
-        expect(b.checkAndIncrement("read_file", "/a")).not.toBeNull();
-    });
-    it("disabled (cap=0) is a no-op", () => {
-        const b = new ReadPathBudget(0);
-        for (let i = 0; i < 100; i++) {
-            expect(b.checkAndIncrement("read_file", "/a")).toBeNull();
-        }
-    });
-    it("notifyWrite resets counters for the same path across all tool names", () => {
-        const b = new ReadPathBudget(1);
-        expect(b.checkAndIncrement("read_file", "/a.ts")).toBeNull();
-        expect(b.checkAndIncrement("mcp__filesystem__read_text_file", "/a.ts")).toBeNull();
-        // Both tools are now at cap for /a.ts
-        expect(b.checkAndIncrement("read_file", "/a.ts")).not.toBeNull();
-        // Simulate a write to /a.ts — both counters must reset.
-        b.notifyWrite("/a.ts");
-        expect(b.checkAndIncrement("read_file", "/a.ts")).toBeNull();
-        expect(b.checkAndIncrement("mcp__filesystem__read_text_file", "/a.ts")).toBeNull();
-        expect(b.getStats().writeInvalidations).toBe(2);
-    });
-    it("notifyWrite normalizes path case + slashes", () => {
-        const b = new ReadPathBudget(1);
-        expect(b.checkAndIncrement("read_file", "C:\\Foo\\Bar.ts")).toBeNull();
-        expect(b.checkAndIncrement("read_file", "C:\\Foo\\Bar.ts")).not.toBeNull();
-        b.notifyWrite("c:/foo/bar.ts");
-        expect(b.checkAndIncrement("read_file", "C:\\Foo\\Bar.ts")).toBeNull();
-    });
-    it("notifyWrite does not touch counters for other paths", () => {
-        const b = new ReadPathBudget(1);
-        b.checkAndIncrement("read_file", "/a.ts");
-        b.checkAndIncrement("read_file", "/b.ts");
-        b.notifyWrite("/a.ts");
-        expect(b.checkAndIncrement("read_file", "/a.ts")).toBeNull(); // reset
-        expect(b.checkAndIncrement("read_file", "/b.ts")).not.toBeNull(); // still capped
-    });
-    it("notifyWrite is a no-op when cap=0 (budget disabled)", () => {
-        const b = new ReadPathBudget(0);
-        b.notifyWrite("/a.ts"); // should not throw
-        expect(b.getStats().writeInvalidations).toBe(0);
-    });
-});
-describe("isReadTool detection", () => {
-    it.each([
-        ["read_file", true],
-        // "Read" (built-in tool in Claude Code) is a read tool — should be budgeted.
-        ["Read", true],
-        ["mcp_filesystem__read_file", true],
-        ["mcp_filesystem__read_text_file", true],
-        ["mcp__filesystem__read_file", true],
-        ["write_file", false],
-        ["list_directory", false],
-        ["bash", false],
-    ])("'%s' → %s", (name, expected) => {
-        expect(_internals.isReadTool(name)).toBe(expected);
-    });
-});
-describe("extractPath", () => {
-    it("reads from common arg shapes", () => {
-        expect(_internals.extractPath({ path: "/a" })).toBe("/a");
-        expect(_internals.extractPath({ file_path: "/b" })).toBe("/b");
-        expect(_internals.extractPath({ filePath: "/c" })).toBe("/c");
-        expect(_internals.extractPath({})).toBeNull();
-        expect(_internals.extractPath(null)).toBeNull();
-        expect(_internals.extractPath({ path: "" })).toBeNull();
-    });
-});
-describe("wrapToolSetWithReadBudget", () => {
-    function makeReadTool(executeImpl) {
-        return {
-            description: "read",
-            inputSchema: { type: "object" },
-            execute: executeImpl,
-        };
-    }
-    it("short-circuits read tool with stub once cap exceeded", async () => {
-        const calls = [];
-        const tool = makeReadTool(async (input) => {
-            const p = input.path;
-            calls.push(p);
-            return `content of ${p}`;
-        });
-        const budget = new ReadPathBudget(1);
-        const wrapped = wrapToolSetWithReadBudget({ read_file: tool }, budget);
-        const exec = wrapped.read_file.execute;
-        const r1 = await exec({ path: "/x" });
-        const r2 = await exec({ path: "/x" });
-        expect(r1).toBe("content of /x");
-        // Stub is a string (per ReadPathBudget.checkAndIncrement JSDoc + impl) containing the guidance message.
-        // The wrapper returns it directly so the agent sees the explanation without extra object wrapping.
-        expect(typeof r2).toBe("string");
-        expect(String(r2)).toContain("read budget exceeded");
-        expect(calls).toEqual(["/x"]); // inner execute only fired once
-    });
-    it("passes neither-read-nor-write tools through unchanged", () => {
-        const tool = makeReadTool(() => "nope");
-        const wrapped = wrapToolSetWithReadBudget({ list_directory: tool }, new ReadPathBudget(1));
-        expect(wrapped.list_directory).toBe(tool);
-    });
-    it("wraps write_file/edit_file so post-write read counters reset", async () => {
-        const readCalls = [];
-        const writeCalls = [];
-        const readTool = makeReadTool(async (input) => {
-            const p = input.path;
-            readCalls.push(p);
-            return `content of ${p}`;
-        });
-        const writeTool = makeReadTool(async (input) => {
-            const p = input.path;
-            writeCalls.push(p);
-            return `wrote ${p}`;
-        });
-        const budget = new ReadPathBudget(1);
-        const wrapped = wrapToolSetWithReadBudget({ read_file: readTool, edit_file: writeTool }, budget);
-        const readExec = wrapped.read_file.execute;
-        const editExec = wrapped.edit_file.execute;
-        expect(await readExec({ path: "/foo.ts" })).toBe("content of /foo.ts");
-        expect(String(await readExec({ path: "/foo.ts" }))).toContain("read budget exceeded");
-        expect(await editExec({ path: "/foo.ts" })).toBe("wrote /foo.ts");
-        expect(await readExec({ path: "/foo.ts" })).toBe("content of /foo.ts");
-        expect(readCalls).toEqual(["/foo.ts", "/foo.ts"]);
-        expect(writeCalls).toEqual(["/foo.ts"]);
-    });
-    it("null budget returns original tool set by reference", () => {
-        const tools = { read_file: {} };
-        expect(wrapToolSetWithReadBudget(tools, null)).toBe(tools);
-    });
-});
-//# sourceMappingURL=read-path-budget.test.js.map

package/dist/src/orchestrator/__tests__/retry-classifier.test.d.ts

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

package/dist/src/orchestrator/__tests__/retry-classifier.test.js

@@ -1,112 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { classifyStreamError } from "../retry-classifier.js";
-import { STALL_ABORT_REASON } from "../stall-watchdog.js";
-describe("classifyStreamError", () => {
-    it("classifies ECONNREFUSED as transient", () => {
-        const err = new Error("connect ECONNREFUSED 127.0.0.1:443");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies ETIMEDOUT as transient", () => {
-        const err = new Error("request failed: ETIMEDOUT");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies 'fetch failed' TypeError as transient", () => {
-        const err = new TypeError("fetch failed");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 502 as transient", () => {
-        const err = Object.assign(new Error("Bad Gateway"), { statusCode: 502 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 503 as transient", () => {
-        const err = Object.assign(new Error("Service Unavailable"), { statusCode: 503 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 504 as transient", () => {
-        const err = Object.assign(new Error("Gateway Timeout"), { statusCode: 504 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 429 as transient", () => {
-        const err = Object.assign(new Error("Too Many Requests"), { statusCode: 429 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 401 as NOT transient", () => {
-        const err = Object.assign(new Error("Unauthorized"), { statusCode: 401 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies HTTP 400 as NOT transient", () => {
-        const err = Object.assign(new Error("Bad Request"), { statusCode: 400 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies HTTP 403 as NOT transient", () => {
-        const err = Object.assign(new Error("Forbidden"), { statusCode: 403 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies HTTP 422 as NOT transient", () => {
-        const err = Object.assign(new Error("Unprocessable Entity"), { statusCode: 422 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies AbortError (user cancel) as NOT transient", () => {
-        const err = new DOMException("Aborted", "AbortError");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-    it("classifies a provider-stall watchdog abort as NOT transient (no retry-storm)", () => {
-        // The stall watchdog aborts with DOMException(STALL_ABORT_REASON, "TimeoutError").
-        // It must NOT be retried — a stalled provider just stalls again, burning
-        // another full timeout of silence. Distinct from a generic AbortSignal.timeout().
-        const err = new DOMException(STALL_ABORT_REASON, "TimeoutError");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-        expect(result.reason).toBe("provider-stall");
-    });
-    it("classifies TimeoutError (AbortSignal.timeout) as transient", () => {
-        const err = new DOMException("signal timed out", "TimeoutError");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("finds transient code in nested cause chain", () => {
-        const inner = new Error("connect ECONNRESET");
-        const outer = Object.assign(new Error("Request failed"), { cause: inner });
-        const result = classifyStreamError(outer);
-        expect(result.transient).toBe(true);
-        expect(result.reason).toMatch(/^cause:/);
-    });
-    it("classifies 'socket hang up' as transient", () => {
-        const err = new Error("socket hang up");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies 'Unable to connect' as transient", () => {
-        const err = new Error("Cannot connect to API: Unable to connect. Is the computer able to access the url?");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 500 as transient", () => {
-        const err = Object.assign(new Error("Internal Server Error"), { statusCode: 500 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies HTTP 408 as transient", () => {
-        const err = Object.assign(new Error("Request Timeout"), { statusCode: 408 });
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(true);
-    });
-    it("classifies unknown error as NOT transient", () => {
-        const err = new Error("some weird unexpected error");
-        const result = classifyStreamError(err);
-        expect(result.transient).toBe(false);
-    });
-});
-//# sourceMappingURL=retry-classifier.test.js.map

package/dist/src/orchestrator/__tests__/retry-stream.test.d.ts

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

package/dist/src/orchestrator/__tests__/retry-stream.test.js

@@ -1,151 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { withStreamRetry } from "../retry-stream.js";
-// Fast no-op delay for all tests
-const fastDelay = () => Promise.resolve();
-function makeTransientError(msg = "fetch failed", statusCode) {
-    return Object.assign(new TypeError(msg), statusCode != null ? { statusCode } : {});
-}
-function makeNonTransientError(statusCode = 401) {
-    return Object.assign(new Error("Unauthorized"), { statusCode });
-}
-describe("withStreamRetry", () => {
-    it("1. succeeds on first attempt — factory called once", async () => {
-        const factory = vi.fn().mockResolvedValueOnce("ok");
-        const result = await withStreamRetry(factory, { delay: fastDelay });
-        expect(result).toBe("ok");
-        expect(factory).toHaveBeenCalledTimes(1);
-    });
-    it("2. transient on attempt 1, success on 2 — factory called twice, onRetry fired once", async () => {
-        const retries = [];
-        const factory = vi.fn().mockRejectedValueOnce(makeTransientError()).mockResolvedValueOnce("second");
-        const result = await withStreamRetry(factory, {
-            delay: fastDelay,
-            onRetry: (info) => retries.push(info),
-        });
-        expect(result).toBe("second");
-        expect(factory).toHaveBeenCalledTimes(2);
-        expect(retries).toHaveLength(1);
-        expect(retries[0].attempt).toBe(1);
-        expect(retries[0].maxAttempts).toBe(3);
-    });
-    it("3. transient on 1+2, success on 3 — onRetry fired twice", async () => {
-        const retries = [];
-        const factory = vi
-            .fn()
-            .mockRejectedValueOnce(makeTransientError())
-            .mockRejectedValueOnce(makeTransientError())
-            .mockResolvedValueOnce("third");
-        const result = await withStreamRetry(factory, {
-            delay: fastDelay,
-            onRetry: (info) => retries.push(info),
-        });
-        expect(result).toBe("third");
-        expect(factory).toHaveBeenCalledTimes(3);
-        expect(retries).toHaveLength(2);
-        expect(retries[0].attempt).toBe(1);
-        expect(retries[1].attempt).toBe(2);
-    });
-    it("4. transient on all 3 — final error thrown after maxAttempts", async () => {
-        const err = makeTransientError("ECONNREFUSED");
-        const factory = vi.fn().mockRejectedValue(err);
-        await expect(withStreamRetry(factory, { delay: fastDelay, onRetry: () => { } })).rejects.toBe(err);
-        expect(factory).toHaveBeenCalledTimes(3);
-    });
-    it("5. non-transient error — no retry, immediate throw", async () => {
-        const err = makeNonTransientError(401);
-        const factory = vi.fn().mockRejectedValue(err);
-        await expect(withStreamRetry(factory, { delay: fastDelay })).rejects.toBe(err);
-        expect(factory).toHaveBeenCalledTimes(1);
-    });
-    it("6. signal.aborted before first attempt — no factory call, AbortError thrown", async () => {
-        const controller = new AbortController();
-        controller.abort();
-        const factory = vi.fn().mockResolvedValue("x");
-        await expect(withStreamRetry(factory, { delay: fastDelay, signal: controller.signal })).rejects.toMatchObject({
-            name: "AbortError",
-        });
-        expect(factory).toHaveBeenCalledTimes(0);
-    });
-    it("7. signal.aborted between attempts — retry loop bails", async () => {
-        const controller = new AbortController();
-        let callCount = 0;
-        const factory = vi.fn().mockImplementation(async () => {
-            callCount++;
-            if (callCount === 1) {
-                // Abort during the retry
-                controller.abort();
-                throw makeTransientError();
-            }
-            return "should not reach";
-        });
-        await expect(withStreamRetry(factory, {
-            delay: () => Promise.resolve(), // fast delay
-            signal: controller.signal,
-            onRetry: () => { },
-        })).rejects.toMatchObject({ name: "AbortError" });
-        expect(factory).toHaveBeenCalledTimes(1);
-    });
-    it("8. Retry-After header (seconds string) — uses that delay for THIS attempt", async () => {
-        const delays = [];
-        const retryAfterErr = Object.assign(new Error("Rate limited"), {
-            statusCode: 429,
-            retryAfter: "5", // 5 seconds = 5000 ms
-        });
-        const factory = vi.fn().mockRejectedValueOnce(retryAfterErr).mockResolvedValueOnce("ok");
-        const retries = [];
-        await withStreamRetry(factory, {
-            delay: (ms) => {
-                delays.push(ms);
-                return Promise.resolve();
-            },
-            onRetry: (info) => retries.push(info),
-        });
-        expect(retries[0].nextDelayMs).toBe(5000);
-        expect(delays[0]).toBe(5000);
-    });
-    it("9. jitter stays within ±jitter*delay range", async () => {
-        // Run 30 times and check every delay is within ±25% of 500ms base
-        const baseDelayMs = 500;
-        const jitter = 0.25;
-        const spread = baseDelayMs * jitter;
-        const min = baseDelayMs - spread;
-        const max = baseDelayMs + spread;
-        for (let i = 0; i < 30; i++) {
-            const delays = [];
-            const factory = vi.fn().mockRejectedValueOnce(makeTransientError()).mockResolvedValueOnce("ok");
-            await withStreamRetry(factory, {
-                maxAttempts: 2,
-                baseDelayMs,
-                jitter,
-                delay: (ms) => {
-                    delays.push(ms);
-                    return Promise.resolve();
-                },
-            });
-            expect(delays[0]).toBeGreaterThanOrEqual(min);
-            expect(delays[0]).toBeLessThanOrEqual(max);
-        }
-    });
-    it("10. maxDelayMs cap respected", async () => {
-        const delays = [];
-        const factory = vi
-            .fn()
-            .mockRejectedValueOnce(makeTransientError())
-            .mockRejectedValueOnce(makeTransientError())
-            .mockResolvedValueOnce("ok");
-        await withStreamRetry(factory, {
-            maxAttempts: 3,
-            baseDelayMs: 500,
-            maxDelayMs: 1000, // lower cap than default 8000
-            jitter: 0, // no jitter so we get exact values
-            delay: (ms) => {
-                delays.push(ms);
-                return Promise.resolve();
-            },
-        });
-        // attempt 1: 500, attempt 2: 2000 → capped to 1000
-        expect(delays[0]).toBe(500);
-        expect(delays[1]).toBe(1000);
-    });
-});
-//# sourceMappingURL=retry-stream.test.js.map

package/dist/src/orchestrator/__tests__/route-feedback.test.d.ts

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

package/dist/src/orchestrator/__tests__/route-feedback.test.js

@@ -1,47 +0,0 @@
-// Test stubs for ROUTE-11 routeFeedback wiring in orchestrator
-import { beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("../../ee/bridge.js", () => ({
-    routeFeedback: vi.fn().mockResolvedValue(true),
-    routeModel: vi.fn().mockResolvedValue(null),
-    classifyViaBrain: vi.fn().mockResolvedValue(null),
-    searchCollection: vi.fn().mockResolvedValue([]),
-    getEmbeddingRaw: vi.fn().mockResolvedValue(null),
-    resetBridge: vi.fn(),
-}));
-vi.mock("../../pil/task-tier-map.js", () => ({
-    taskTypeToTier: vi.fn().mockReturnValue("balanced"),
-}));
-describe("routeFeedback wiring", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it("should import routeFeedback from bridge", async () => {
-        const bridge = await import("../../ee/bridge.js");
-        expect(bridge.routeFeedback).toBeDefined();
-    });
-    it("should import taskTypeToTier from task-tier-map", async () => {
-        const tierMap = await import("../../pil/task-tier-map.js");
-        expect(tierMap.taskTypeToTier).toBeDefined();
-    });
-    it("routeFeedback signature accepts required params", async () => {
-        const { routeFeedback } = await import("../../ee/bridge.js");
-        // Verify the function can be called with correct signature
-        await routeFeedback("hash123", "balanced", "claude-3", "success", 0, 1500);
-        expect(routeFeedback).toHaveBeenCalledWith("hash123", "balanced", "claude-3", "success", 0, 1500);
-    });
-    it("taskTypeToTier maps correctly for routeFeedback tier param", async () => {
-        const { taskTypeToTier } = await import("../../pil/task-tier-map.js");
-        expect(taskTypeToTier("debug")).toBe("balanced");
-    });
-    it("routeFeedback returns true when bridge is available", async () => {
-        const { routeFeedback } = await import("../../ee/bridge.js");
-        const result = await routeFeedback("hash456", "premium", "claude-opus", "fail", 0, 3000);
-        expect(result).toBe(true);
-    });
-    it("routeFeedback is called with 'cancelled' outcome for cancelled turns", async () => {
-        const { routeFeedback } = await import("../../ee/bridge.js");
-        await routeFeedback("hash789", "fast", "claude-haiku", "cancelled", 0, 500);
-        expect(routeFeedback).toHaveBeenCalledWith("hash789", "fast", "claude-haiku", "cancelled", 0, 500);
-    });
-});
-//# sourceMappingURL=route-feedback.test.js.map

package/dist/src/orchestrator/__tests__/stream-runner.test.d.ts

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