muonroi-cli 1.8.0 → 1.8.3

package/dist/src/orchestrator/__tests__/mcp-capability-block.test.d.ts

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

package/dist/src/orchestrator/__tests__/mcp-capability-block.test.js

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildMcpCapabilityBlock } from "../prompts.js";
-describe("buildMcpCapabilityBlock", () => {
-    it("returns '' when no MCP tools are connected (non-agent / chitchat / no-client-tools turns add nothing)", () => {
-        expect(buildMcpCapabilityBlock([])).toBe("");
-        expect(buildMcpCapabilityBlock(["read_file", "grep", "bash", "edit_file"])).toBe("");
-    });
-    it("names the exact callable mcp_<server>__<tool> tools connected this turn (regression: session f6f7881a5fae)", () => {
-        const block = buildMcpCapabilityBlock([
-            "read_file",
-            "bash",
-            "mcp_muonroi-docs__setup_guide",
-            "mcp_muonroi-docs__docs_search",
-        ]);
-        // The failure was the agent not knowing it could call setup_guide directly.
-        expect(block).toContain("mcp_muonroi-docs__setup_guide");
-        expect(block).toContain("mcp_muonroi-docs__docs_search");
-        expect(block).toMatch(/CONNECTED MCP TOOLS/);
-        // Steers away from the bash-JSON-RPC fallback the agent actually did.
-        expect(block).toMatch(/do NOT shell out to bash/i);
-    });
-    it("groups tools by server (id with a hyphen split on the first '__')", () => {
-        const block = buildMcpCapabilityBlock([
-            "mcp_muonroi-docs__setup_guide",
-            "mcp_context7__query_docs",
-            "mcp_muonroi-docs__docs_search",
-        ]);
-        // muonroi-docs appears once as a group header with both its tools.
-        expect(block.match(/muonroi-docs:/g)?.length).toBe(1);
-        expect(block).toMatch(/context7:/);
-    });
-    it("ignores non-mcp tool names and is deterministic (tools sorted within a server)", () => {
-        const block = buildMcpCapabilityBlock(["mcp_srv__b_tool", "write_file", "mcp_srv__a_tool"]);
-        expect(block).not.toContain("write_file");
-        // a_tool sorts before b_tool → stable output regardless of input order.
-        expect(block.indexOf("mcp_srv__a_tool")).toBeLessThan(block.indexOf("mcp_srv__b_tool"));
-    });
-});
-//# sourceMappingURL=mcp-capability-block.test.js.map

package/dist/src/orchestrator/__tests__/message-processor.test.d.ts

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

package/dist/src/orchestrator/__tests__/message-processor.test.js

@@ -1,188 +0,0 @@
-// Phase 12.4-03 — MessageProcessor unit tests.
-//
-// Focused smoke: confirms the DI surface (MessageProcessorDeps) is wired
-// correctly and that the auto-council short-circuit + batch-api delegation
-// invariants hold without running a real LLM turn. The full streaming
-// behaviour is covered by tests/harness/cost-leak-{f1,g1,b4,c3}.spec.ts.
-import { beforeAll, describe, expect, it } from "vitest";
-import { loadCatalog } from "../../models/registry.js";
-import { MessageProcessor } from "../message-processor.js";
-function makeBashStub() {
-    return {
-        getCwd: () => process.cwd(),
-        getSandboxMode: () => "off",
-        getSandboxSettings: () => ({}),
-    };
-}
-function makeCouncilStub(extra = {}) {
-    return {
-        isContinuation: false,
-        lastSynthesis: null,
-        setContinuation: () => { },
-        setLastSynthesis: () => { },
-        resolveNonDisabledFallback: async () => ({ modelId: "deepseek-ai/DeepSeek-V4-Flash" }),
-        createQuestionResponder: () => async () => "",
-        ...extra,
-    };
-}
-function makeDeps(overrides = {}) {
-    const messages = [];
-    const messageSeqs = [];
-    let abortCtrl = null;
-    return {
-        messages,
-        messageSeqs,
-        session: null,
-        sessionStore: null,
-        bash: makeBashStub(),
-        mode: "agent",
-        modelId: "deepseek-ai/DeepSeek-V4-Flash",
-        providerId: "siliconflow",
-        maxToolRounds: 50,
-        batchApi: false,
-        permissionMode: "safe",
-        schedules: {},
-        sendTelegramFile: null,
-        externalAbortContext: null,
-        pendingCalls: null,
-        councilManager: makeCouncilStub(),
-        crossTurnDedup: null,
-        readBudget: null,
-        priorWarningIdsInSession: new Set(),
-        sessionEEGuidance: new Map(),
-        flowReady: null,
-        getAbortController: () => abortCtrl,
-        setAbortController: (c) => {
-            abortCtrl = c;
-        },
-        getSessionStartHookFired: () => true, // skip the session-start hook fire path
-        setSessionStartHookFired: () => { },
-        getPlanContext: () => null,
-        setPlanContext: () => { },
-        getResumeDigest: () => null,
-        setResumeDigest: () => { },
-        getActiveRunId: () => null,
-        getPendingCwdNote: () => null,
-        setPendingCwdNote: () => { },
-        setPilActive: () => { },
-        setPilEnrichmentDelta: () => { },
-        setCurrentCallId: () => { },
-        setLastProviderOptionsShape: () => { },
-        setLastPromptBreakdown: () => { },
-        setCompactedThisTurn: () => { },
-        getCompactedThisTurn: () => false,
-        setTurnUserGoalExcerpt: () => { },
-        setTurnAssistantReasoning: () => { },
-        appendTurnAssistantReasoning: () => { },
-        getTurnAssistantReasoning: () => "",
-        setPriorWarningIdsInSession: () => { },
-        setMessages: () => { },
-        requireProvider: () => (() => null),
-        emitSubagentStatus: () => { },
-        fireHook: async () => ({
-            blocked: false,
-            blockingErrors: [],
-            preventContinuation: false,
-            additionalContexts: [],
-            results: [],
-            eeMatches: [],
-        }),
-        consumeBackgroundNotifications: async () => [],
-        initOAuthProvider: async () => { },
-        buildRecentTurnsSummary: () => null,
-        estimateProjectSize: () => "small",
-        countFilesTouched: () => 0,
-        getCompactionSettings: () => ({}),
-        compactForContext: async () => false,
-        postTurnCompact: async () => { },
-        runTask: async () => ({ success: true, output: "" }),
-        runDelegation: async () => ({ success: true, output: "" }),
-        readDelegation: async () => ({ success: true, output: "" }),
-        listDelegations: async () => ({ success: true, output: "" }),
-        killDelegation: async () => ({ success: true, output: "" }),
-        appendCompletedTurn: () => { },
-        discardAbortedTurn: () => { },
-        recordUsage: () => { },
-        respondToToolApproval: () => { },
-        runCouncilV2: async function* () {
-            /* no-op */
-        },
-        processMessage: async function* () {
-            /* no-op */
-        },
-        processMessageBatchTurn: async function* () {
-            /* no-op */
-        },
-        ...overrides,
-    };
-}
-describe("MessageProcessor — DI surface invariants", () => {
-    beforeAll(async () => {
-        await loadCatalog();
-    });
-    it("constructs without throwing when given a valid deps bag", () => {
-        const processor = new MessageProcessor(makeDeps());
-        expect(processor).toBeInstanceOf(MessageProcessor);
-    });
-    it("uses deps.messages as the mutable array reference (not a copy)", () => {
-        const messages = [];
-        const deps = makeDeps({ messages });
-        // The same reference must be observable externally so Agent.messages
-        // mutations from inside run() surface to the host class.
-        expect(deps.messages).toBe(messages);
-    });
-    it("delegates to deps.processMessageBatchTurn when batchApi is true", async () => {
-        let batchCalled = false;
-        const deps = makeDeps({
-            batchApi: true,
-            processMessageBatchTurn: async function* () {
-                batchCalled = true;
-                yield { type: "done" };
-            },
-        });
-        const processor = new MessageProcessor(deps);
-        const chunks = [];
-        for await (const c of processor.run("hi", undefined)) {
-            chunks.push(c);
-        }
-        expect(batchCalled).toBe(true);
-    });
-    it("delegates to deps.runCouncilV2 when auto-council gate is taken", async () => {
-        let councilCalled = false;
-        const deps = makeDeps({
-            councilManager: makeCouncilStub({
-                isContinuation: false,
-                lastSynthesis: null,
-            }),
-            runCouncilV2: async function* () {
-                councilCalled = true;
-                yield { type: "done" };
-            },
-        });
-        // Construct + force the gate via direct gate inspection: we cannot
-        // exercise the gate end-to-end without PIL machinery, so just confirm
-        // the callback is wired and reachable.
-        const processor = new MessageProcessor(deps);
-        expect(processor).toBeInstanceOf(MessageProcessor);
-        // Direct manual invocation as a smoke check for the callable contract.
-        const iter = deps.runCouncilV2("topic", {
-            skipClarification: true,
-            userModelMessage: { role: "user", content: "topic" },
-        });
-        for await (const _ of iter) {
-            /* drain */
-        }
-        expect(councilCalled).toBe(true);
-    });
-    it("respects observer callbacks via notifyObserver (smoke)", () => {
-        const observer = {};
-        const deps = makeDeps();
-        const processor = new MessageProcessor(deps);
-        expect(processor).toBeInstanceOf(MessageProcessor);
-        // Observer wiring is exercised by harness specs; this case confirms
-        // that the optional observer param does not throw at construction
-        // / iteration setup.
-        void observer;
-    });
-});
-//# sourceMappingURL=message-processor.test.js.map

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

@@ -1,22 +0,0 @@
-/**
- * src/orchestrator/__tests__/message-write-ahead.test.ts
- *
- * Phase A5 — write-ahead persistence for `messages`.
- *
- * The orchestrator's `onStepFinish` callback fires `recordUsage` while
- * streamText is in-flight; without a pre-existing row, the user message
- * isn't yet in the DB (it's only inserted by `appendCompletedTurn(...)`
- * after the stream settles). This made `usage_events.message_seq`
- * resolve to NULL — exactly the anomaly that forensics surfaces.
- *
- * A5 persists a `pending` row in `messages` the moment a new user turn
- * starts. The post-stream path upserts the row to `completed` via
- * `ON CONFLICT(session_id, seq) DO UPDATE`; the error path flips it to
- * `errored` so forensics can tell crashed turns apart from in-flight ones.
- *
- * 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 each helper shapes its SQL correctly.
- */
-export {};

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

@@ -1,149 +0,0 @@
-/**
- * src/orchestrator/__tests__/message-write-ahead.test.ts
- *
- * Phase A5 — write-ahead persistence for `messages`.
- *
- * The orchestrator's `onStepFinish` callback fires `recordUsage` while
- * streamText is in-flight; without a pre-existing row, the user message
- * isn't yet in the DB (it's only inserted by `appendCompletedTurn(...)`
- * after the stream settles). This made `usage_events.message_seq`
- * resolve to NULL — exactly the anomaly that forensics surfaces.
- *
- * A5 persists a `pending` row in `messages` the moment a new user turn
- * starts. The post-stream path upserts the row to `completed` via
- * `ON CONFLICT(session_id, seq) DO UPDATE`; the error path flips it to
- * `errored` so forensics can tell crashed turns apart from in-flight ones.
- *
- * 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 each helper shapes its 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 helpers pick up the mocked db module.
-import { markMessageCompleted, markMessageErrored, persistMessageWriteAhead } from "../../storage/transcript.js";
-describe("A5: write-ahead messages persistence", () => {
-    beforeEach(() => {
-        preparedCalls.length = 0;
-    });
-    afterEach(() => {
-        preparedCalls.length = 0;
-    });
-    describe("persistMessageWriteAhead", () => {
-        it("inserts a messages row with status='pending' BEFORE streamText fires", () => {
-            persistMessageWriteAhead("session-xyz", 7, "user", JSON.stringify({ role: "user", content: "hello" }));
-            expect(preparedCalls).toHaveLength(1);
-            const call = preparedCalls[0];
-            expect(call.sql).toMatch(/INSERT OR IGNORE INTO messages/);
-            expect(call.sql).toMatch(/'pending'/);
-            // Run args: sessionId, seq, role, messageJson, createdAt.
-            expect(call.runArgs).toContain("session-xyz");
-            expect(call.runArgs).toContain(7);
-            expect(call.runArgs).toContain("user");
-            const messageJsonArg = call.runArgs.find((a) => typeof a === "string" && a.includes("hello"));
-            expect(messageJsonArg).toBeTruthy();
-        });
-        it("uses INSERT OR IGNORE so a duplicate write-ahead does not clobber a finalized row", () => {
-            persistMessageWriteAhead("s", 1, "user", "{}");
-            expect(preparedCalls[0].sql).toContain("INSERT OR IGNORE");
-        });
-        it("is fail-open: a thrown SQL error does NOT propagate to the orchestrator", () => {
-            dbShouldThrow = true;
-            try {
-                expect(() => persistMessageWriteAhead("session-y", 1, "user", "{}")).not.toThrow();
-            }
-            finally {
-                dbShouldThrow = false;
-            }
-        });
-    });
-    describe("markMessageCompleted", () => {
-        it("updates the row to status='completed' guarded on status='pending'", () => {
-            markMessageCompleted("session-a", 12);
-            expect(preparedCalls).toHaveLength(1);
-            const call = preparedCalls[0];
-            expect(call.sql).toMatch(/UPDATE messages/);
-            expect(call.sql).toMatch(/SET status = 'completed'/);
-            // Guard prevents flipping a row finalized via a different code path
-            // (defensive against double-finalize bugs).
-            expect(call.sql).toMatch(/status = 'pending'/);
-            expect(call.runArgs).toContain("session-a");
-            expect(call.runArgs).toContain(12);
-        });
-        it("is fail-open: a thrown SQL error does NOT propagate", () => {
-            dbShouldThrow = true;
-            try {
-                expect(() => markMessageCompleted("session-c", 5)).not.toThrow();
-            }
-            finally {
-                dbShouldThrow = false;
-            }
-        });
-    });
-    describe("markMessageErrored", () => {
-        it("updates the row to status='errored' guarded on status='pending'", () => {
-            markMessageErrored("session-b", 42);
-            expect(preparedCalls).toHaveLength(1);
-            const call = preparedCalls[0];
-            expect(call.sql).toMatch(/UPDATE messages/);
-            expect(call.sql).toMatch(/SET status = 'errored'/);
-            expect(call.sql).toMatch(/status = 'pending'/);
-            expect(call.runArgs).toContain("session-b");
-            expect(call.runArgs).toContain(42);
-        });
-        it("is fail-open: a thrown SQL error does NOT propagate", () => {
-            dbShouldThrow = true;
-            try {
-                expect(() => markMessageErrored("session-d", 9)).not.toThrow();
-            }
-            finally {
-                dbShouldThrow = false;
-            }
-        });
-    });
-    describe("integration: pending → completed/errored handoff via appendMessages", () => {
-        it("documents the contract: the post-stream upsert uses ON CONFLICT(session_id, seq) DO UPDATE", () => {
-            // This test pins the SQL contract — `appendMessages()` in
-            // transcript.ts uses ON CONFLICT so a write-ahead 'pending' row is
-            // upserted to 'completed' atomically with the assistant message
-            // insert. If a future refactor reverts to plain INSERT, the
-            // write-ahead row would cause a PK violation and the entire
-            // turn-persistence transaction would roll back.
-            persistMessageWriteAhead("s", 1, "user", "{}");
-            expect(preparedCalls[0].sql).toContain("INSERT OR IGNORE");
-        });
-        it("the error path uses a guarded UPDATE so a successful turn's row is never flipped to 'errored'", () => {
-            // Defensive: if the catch block fires after the success path
-            // (race?), the WHERE status='pending' guard prevents corruption.
-            markMessageErrored("s", 1);
-            expect(preparedCalls[0].sql).toMatch(/WHERE session_id = \? AND seq = \? AND status = 'pending'/);
-        });
-    });
-});
-//# sourceMappingURL=message-write-ahead.test.js.map

package/dist/src/orchestrator/__tests__/project-stack.test.d.ts

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

package/dist/src/orchestrator/__tests__/project-stack.test.js

@@ -1,65 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { detectProjectStack } from "../prompts.js";
-// detectProjectStack feeds the ENVIRONMENT block so every model — in any mode,
-// on any provider — knows the concrete stack of the repo it is running inside,
-// instead of assuming Python / asking the user to describe the project
-// (2026-06-14 dogfood: "model native doesn't know what it can do in the CLI").
-describe("detectProjectStack", () => {
-    const mkTemp = (slug) => mkdtempSync(join(tmpdir(), `mr-stack-${slug}-`));
-    it("detects the current repo as a JS/TS project under git", () => {
-        const out = detectProjectStack(process.cwd());
-        expect(out).toMatch(/TypeScript|JavaScript/);
-        expect(out).toMatch(/vcs: git/);
-    });
-    it("returns empty string for a bare directory (greenfield)", () => {
-        const dir = mkTemp("empty");
-        try {
-            expect(detectProjectStack(dir)).toBe("");
-        }
-        finally {
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("detects a Rust project from Cargo.toml", () => {
-        const dir = mkTemp("rust");
-        try {
-            writeFileSync(join(dir, "Cargo.toml"), "[package]\nname = 'x'\n");
-            expect(detectProjectStack(dir)).toMatch(/^Rust/);
-        }
-        finally {
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("detects a .NET project from a .csproj file", () => {
-        const dir = mkTemp("net");
-        try {
-            writeFileSync(join(dir, "App.csproj"), "<Project/>");
-            expect(detectProjectStack(dir)).toMatch(/\.NET\/C#/);
-        }
-        finally {
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("reports package manager + test runner for a bun/vitest TS project", () => {
-        const dir = mkTemp("ts");
-        try {
-            writeFileSync(join(dir, "tsconfig.json"), "{}");
-            writeFileSync(join(dir, "bun.lock"), "");
-            writeFileSync(join(dir, "vitest.config.ts"), "export default {}");
-            const out = detectProjectStack(dir);
-            expect(out).toMatch(/TypeScript/);
-            expect(out).toMatch(/pkg: bun/);
-            expect(out).toMatch(/tests: vitest/);
-        }
-        finally {
-            rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("returns empty (no throw) for a missing directory", () => {
-        expect(detectProjectStack(join(tmpdir(), "definitely-missing-dir-9f8a7b6c"))).toBe("");
-    });
-});
-//# sourceMappingURL=project-stack.test.js.map

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

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

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 {};