muonroi-cli 1.8.1 → 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,189 +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,
-        hardMaxToolRounds: 60,
-        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__/prompts.test.d.ts

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

package/dist/src/orchestrator/__tests__/prompts.test.js

@@ -1,88 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-describe("prompts.ts limit helpers", () => {
-    const tmpHome = path.join(os.tmpdir(), `muonroi-cli-prompts-${process.pid}-${Date.now()}`);
-    const origHome = process.env.HOME;
-    const origUserProfile = process.env.USERPROFILE;
-    const origEnvMaxRounds = process.env.MUONROI_MAX_TOOL_ROUNDS;
-    const origEnvHardMax = process.env.MUONROI_HARD_MAX_TOOL_ROUNDS;
-    const origEnvLlmCalls = process.env.MUONROI_MAX_LLM_CALLS_PER_TURN;
-    const origAgentFirst = process.env.MUONROI_AGENT_FIRST;
-    beforeEach(() => {
-        fs.mkdirSync(tmpHome, { recursive: true });
-        process.env.HOME = tmpHome;
-        process.env.USERPROFILE = tmpHome;
-        delete process.env.MUONROI_MAX_TOOL_ROUNDS;
-        delete process.env.MUONROI_HARD_MAX_TOOL_ROUNDS;
-        delete process.env.MUONROI_MAX_LLM_CALLS_PER_TURN;
-        delete process.env.MUONROI_AGENT_FIRST;
-    });
-    afterEach(() => {
-        fs.rmSync(tmpHome, { recursive: true, force: true });
-        if (origHome === undefined)
-            delete process.env.HOME;
-        else
-            process.env.HOME = origHome;
-        if (origUserProfile === undefined)
-            delete process.env.USERPROFILE;
-        else
-            process.env.USERPROFILE = origUserProfile;
-        if (origEnvMaxRounds === undefined)
-            delete process.env.MUONROI_MAX_TOOL_ROUNDS;
-        else
-            process.env.MUONROI_MAX_TOOL_ROUNDS = origEnvMaxRounds;
-        if (origEnvHardMax === undefined)
-            delete process.env.MUONROI_HARD_MAX_TOOL_ROUNDS;
-        else
-            process.env.MUONROI_HARD_MAX_TOOL_ROUNDS = origEnvHardMax;
-        if (origEnvLlmCalls === undefined)
-            delete process.env.MUONROI_MAX_LLM_CALLS_PER_TURN;
-        else
-            process.env.MUONROI_MAX_LLM_CALLS_PER_TURN = origEnvLlmCalls;
-        if (origAgentFirst === undefined)
-            delete process.env.MUONROI_AGENT_FIRST;
-        else
-            process.env.MUONROI_AGENT_FIRST = origAgentFirst;
-        vi.resetModules();
-    });
-    it("loads default limits when agentFirst is false", async () => {
-        const dir = path.join(tmpHome, ".muonroi-cli");
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(path.join(dir, "user-settings.json"), JSON.stringify({ agentFirst: false }));
-        vi.resetModules();
-        const { MAX_TOOL_ROUNDS, HARD_MAX_TOOL_ROUNDS, MAX_LLM_CALLS_PER_TURN } = await import("../prompts.js");
-        expect(MAX_TOOL_ROUNDS).toBe(40);
-        expect(HARD_MAX_TOOL_ROUNDS).toBe(60);
-        expect(MAX_LLM_CALLS_PER_TURN).toBe(12);
-    });
-    it("defaults to agentFirst limits (true) when no config is present", async () => {
-        vi.resetModules();
-        const { MAX_TOOL_ROUNDS, HARD_MAX_TOOL_ROUNDS, MAX_LLM_CALLS_PER_TURN } = await import("../prompts.js");
-        expect(MAX_TOOL_ROUNDS).toBe(200);
-        expect(HARD_MAX_TOOL_ROUNDS).toBe(300);
-        expect(MAX_LLM_CALLS_PER_TURN).toBe(100);
-    });
-    it("loads raised limits when agentFirst is true in settings", async () => {
-        const dir = path.join(tmpHome, ".muonroi-cli");
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(path.join(dir, "user-settings.json"), JSON.stringify({ agentFirst: true }));
-        vi.resetModules();
-        const { MAX_TOOL_ROUNDS, HARD_MAX_TOOL_ROUNDS, MAX_LLM_CALLS_PER_TURN } = await import("../prompts.js");
-        expect(MAX_TOOL_ROUNDS).toBe(200);
-        expect(HARD_MAX_TOOL_ROUNDS).toBe(300);
-        expect(MAX_LLM_CALLS_PER_TURN).toBe(100);
-    });
-    it("respects env overrides and clamps them (when agentFirst is true by default)", async () => {
-        process.env.MUONROI_MAX_TOOL_ROUNDS = "3000"; // Clamped to 2000 in agent-first
-        process.env.MUONROI_HARD_MAX_TOOL_ROUNDS = "50";
-        process.env.MUONROI_MAX_LLM_CALLS_PER_TURN = "15";
-        vi.resetModules();
-        const { MAX_TOOL_ROUNDS, HARD_MAX_TOOL_ROUNDS, MAX_LLM_CALLS_PER_TURN } = await import("../prompts.js");
-        expect(MAX_TOOL_ROUNDS).toBe(2000);
-        expect(HARD_MAX_TOOL_ROUNDS).toBe(50);
-        expect(MAX_LLM_CALLS_PER_TURN).toBe(15);
-    });
-});
-//# sourceMappingURL=prompts.test.js.map

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

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