muonroi-cli 1.8.1 → 1.8.3

package/dist/src/storage/config.test.js

@@ -1,29 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { atomicWriteJSON } from "./atomic-io.js";
-import { loadConfig } from "./config.js";
-let tmpDir;
-beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "config-test-"));
-});
-afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-describe("loadConfig", () => {
-    it("Test 5: bootstraps default config when ~/.muonroi-cli/config.json absent", async () => {
-        const config = await loadConfig(tmpDir);
-        expect(config.cap.monthly_usd).toBe(15);
-        // File must be written now
-        const raw = await fs.readFile(path.join(tmpDir, "config.json"), "utf8");
-        const parsed = JSON.parse(raw);
-        expect(parsed.cap.monthly_usd).toBe(15);
-    });
-    it("Test 6: respects user-provided cap.monthly_usd value", async () => {
-        await atomicWriteJSON(path.join(tmpDir, "config.json"), { cap: { monthly_usd: 30 } });
-        const config = await loadConfig(tmpDir);
-        expect(config.cap.monthly_usd).toBe(30);
-    });
-});
-//# sourceMappingURL=config.test.js.map

package/dist/src/storage/session-experience-store.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * session-experience-store — persist + cross-session aggregate of the anti-mù
- * counters that decide whether compaction friction is real at a painful rate.
- */
-export {};

package/dist/src/storage/session-experience-store.test.js

@@ -1,86 +0,0 @@
-/**
- * session-experience-store — persist + cross-session aggregate of the anti-mù
- * counters that decide whether compaction friction is real at a painful rate.
- */
-import { afterEach, describe, expect, it, vi } from "vitest";
-vi.mock("./db.js", () => ({ getDatabase: vi.fn(() => ({ prepare: () => ({ all: () => [] }) })) }));
-const logInteraction = vi.fn();
-vi.mock("./interaction-log.js", () => ({ logInteraction: (...a) => logInteraction(...a) }));
-import { computeExperienceAggregate, persistSessionExperience, } from "./session-experience-store.js";
-function counts(p = {}) {
-    return {
-        compactions: 0,
-        elided: 0,
-        totalElidedChars: 0,
-        rehydratedCache: 0,
-        rehydratedDisk: 0,
-        rehydratedEe: 0,
-        unavailable: 0,
-        eeTimeouts: 0,
-        eeErrors: 0,
-        ...p,
-    };
-}
-function row(sessionId, createdAt, c) {
-    return { session_id: sessionId, created_at: createdAt, metadata_json: JSON.stringify(counts(c)) };
-}
-describe("persistSessionExperience", () => {
-    afterEach(() => logInteraction.mockClear());
-    it("no-ops on a missing sessionId", () => {
-        persistSessionExperience(undefined, counts({ elided: 3 }));
-        persistSessionExperience("", counts({ elided: 3 }));
-        expect(logInteraction).not.toHaveBeenCalled();
-    });
-    it("no-ops on an all-zero snapshot (no signal to store)", () => {
-        persistSessionExperience("sess-1", counts());
-        expect(logInteraction).not.toHaveBeenCalled();
-    });
-    it("writes a session_experience snapshot when something happened", () => {
-        persistSessionExperience("sess-1", counts({ compactions: 2, elided: 5, rehydratedCache: 1 }));
-        expect(logInteraction).toHaveBeenCalledTimes(1);
-        const [sid, type, meta] = logInteraction.mock.calls[0];
-        expect(sid).toBe("sess-1");
-        expect(type).toBe("session_experience");
-        expect(meta.data.elided).toBe(5);
-    });
-});
-describe("computeExperienceAggregate", () => {
-    it("dedups to the latest row per session (rows newest-first) and sums totals", () => {
-        const rows = [
-            // sess-a newest first (cumulative) then an older row that must be ignored
-            row("sess-a", "2026-06-17T10:00:00Z", { compactions: 3, elided: 6, rehydratedCache: 4, unavailable: 1 }),
-            row("sess-a", "2026-06-17T09:00:00Z", { compactions: 1, elided: 2 }),
-            row("sess-b", "2026-06-17T08:00:00Z", { compactions: 1, elided: 2, rehydratedEe: 1, unavailable: 1 }),
-        ];
-        const agg = computeExperienceAggregate(rows);
-        expect(agg.sessionCount).toBe(2);
-        expect(agg.totals.elided).toBe(8); // 6 (latest a) + 2 (b), NOT the stale 2
-        expect(agg.totals.compactions).toBe(4); // 3 + 1
-        expect(agg.sessionsWithElision).toBe(2);
-        expect(agg.sessionsWithUnavailable).toBe(2);
-        // recovery = rehydrated(4+0+1) / (rehydrated 5 + unavailable 2) = 5/7
-        expect(agg.rehydrateRecoveryRate).toBeCloseTo(5 / 7, 5);
-    });
-    it("recovery rate is 1 when no rehydrate was ever attempted", () => {
-        const agg = computeExperienceAggregate([row("s", "2026-06-17T10:00:00Z", { compactions: 1, elided: 2 })]);
-        expect(agg.rehydrateRecoveryRate).toBe(1);
-        expect(agg.sessionsWithUnavailable).toBe(0);
-    });
-    it("caps at `limit` sessions and skips unparseable rows", () => {
-        const rows = [
-            row("s1", "2026-06-17T10:00:03Z", { elided: 1 }),
-            { session_id: "s2", created_at: "2026-06-17T10:00:02Z", metadata_json: "{bad json" },
-            row("s3", "2026-06-17T10:00:01Z", { elided: 1 }),
-        ];
-        const agg = computeExperienceAggregate(rows, 1);
-        expect(agg.sessionCount).toBe(1);
-        expect(agg.perSession[0].sessionId).toBe("s1");
-    });
-    it("empty input yields an empty aggregate with recovery rate 1", () => {
-        const agg = computeExperienceAggregate([]);
-        expect(agg.sessionCount).toBe(0);
-        expect(agg.totals.elided).toBe(0);
-        expect(agg.rehydrateRecoveryRate).toBe(1);
-    });
-});
-//# sourceMappingURL=session-experience-store.test.js.map

package/dist/src/storage/tool-results.test.d.ts

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

package/dist/src/storage/tool-results.test.js

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractToolResultFromOutput, isOutputSuccess } from "./tool-results.js";
-describe("extractToolResultFromOutput", () => {
-    it("passes through a native ToolResult shape", () => {
-        const r = extractToolResultFromOutput({ success: true, output: "hi" });
-        expect(r).toMatchObject({ success: true, output: "hi" });
-    });
-    it("treats error-text as a failure", () => {
-        const r = extractToolResultFromOutput({ type: "error-text", value: "boom" });
-        expect(r).toMatchObject({ success: false, error: "boom" });
-    });
-    it("flattens an MCP content envelope into a successful ToolResult (session 63f2d542b772)", () => {
-        // MCP tools return { type: "content", value: [{ type: "text", text }] }.
-        // Before the fix this returned null, so the persisted output_json had no
-        // `success` field and the renderer showed "Error" for a successful call.
-        const out = {
-            type: "content",
-            value: [
-                { type: "text", text: "package list" },
-                { type: "text", text: "more" },
-            ],
-        };
-        const r = extractToolResultFromOutput(out);
-        expect(r).toMatchObject({ success: true, output: "package list\nmore" });
-    });
-    it("round-trips through JSON so the renderer reads success=true (the actual bug)", () => {
-        // transcript.loadStoredToolResults does JSON.parse(output_json) and the
-        // renderer reads `.success`. Simulate persist→load and assert it is NOT
-        // misread as an error.
-        const mcpOutput = { type: "content", value: [{ type: "text", text: "## Muonroi.Core\nNuGet: Muonroi.Core" }] };
-        const persisted = JSON.stringify(extractToolResultFromOutput(mcpOutput));
-        const loaded = JSON.parse(persisted);
-        const rendered = loaded.success ? loaded.output || "Success" : loaded.error || "Error";
-        expect(rendered).toContain("Muonroi.Core");
-        expect(rendered).not.toBe("Error");
-    });
-    it("describes a non-text-only MCP content result instead of dropping to Error", () => {
-        const out = { type: "content", value: [{ type: "image", data: "..." }] };
-        const r = extractToolResultFromOutput(out);
-        expect(r?.success).toBe(true);
-        expect(r?.output).toMatch(/non-text MCP part/);
-    });
-    it("isOutputSuccess still treats content envelopes as success", () => {
-        expect(isOutputSuccess({ type: "content", value: [] })).toBe(true);
-        expect(isOutputSuccess({ type: "error-text", value: "x" })).toBe(false);
-    });
-});
-//# sourceMappingURL=tool-results.test.js.map

package/dist/src/storage/transcript-response-entry.test.d.ts

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

package/dist/src/storage/transcript-response-entry.test.js

@@ -1,111 +0,0 @@
-/**
- * src/storage/transcript-response-entry.test.ts
- *
- * Regression: buildChatEntries must rebuild a `respond_*` tool-result as a
- * `structured_response` ChatEntry — NOT a bare `tool_result`.
- *
- * Why this matters (live repro, session 9d3d371ca1bd): the live stream yields
- * the terminal answer as a `structured_response` chunk (message-processor.ts),
- * which the UI renders as the answer block. But finalizeActiveTurn (app.tsx)
- * replaces the live message list with `getChatEntries()` → `buildChatEntries()`
- * on EVERY normal turn. If buildChatEntries rebuilt the persisted respond_*
- * tool-call/result pair as a generic tool_result, the rendered answer was
- * silently dropped the instant streaming ended — the user saw only the
- * "→ respond_general" indicator with no answer. This test pins the rebuild to
- * a structured_response entry so the persisted view matches the live view.
- */
-import { afterEach, describe, expect, it, vi } from "vitest";
-let MESSAGE_ROWS = [];
-vi.mock("./db", () => ({
-    getDatabase: () => ({
-        prepare: (sql) => {
-            const lower = sql.toLowerCase();
-            return {
-                all: (...params) => {
-                    if (lower.includes("from messages")) {
-                        return MESSAGE_ROWS;
-                    }
-                    if (lower.includes("from sessions")) {
-                        if (lower.includes("where id in")) {
-                            return params.map((id) => ({ id }));
-                        }
-                    }
-                    return [];
-                },
-                get: () => undefined,
-                run: () => undefined,
-            };
-        },
-    }),
-    withTransaction: (fn) => fn({}),
-}));
-// Pass-through transcript view: no compaction in these fixtures, so the
-// effective transcript is the raw message list unchanged.
-vi.mock("./transcript-view", () => ({
-    buildEffectiveTranscript: (messages, seqs, timestamps) => ({
-        messages,
-        seqs,
-        timestamps,
-    }),
-}));
-const { buildChatEntries } = await import("./transcript.js");
-afterEach(() => {
-    MESSAGE_ROWS = [];
-});
-function row(seq, role, content) {
-    return {
-        session_id: "s1",
-        seq,
-        role,
-        message_json: JSON.stringify({ role, content }),
-        created_at: "2026-06-09T07:27:38.420Z",
-    };
-}
-describe("buildChatEntries — respond_* terminal answer", () => {
-    it("rebuilds a respond_general tool-result as a structured_response entry", () => {
-        const callId = "call-respond-1";
-        MESSAGE_ROWS = [
-            row(1, "user", "how does this CLI affect you?"),
-            row(2, "assistant", [
-                { type: "reasoning", text: "investigated, now answer" },
-                { type: "tool-call", toolCallId: callId, toolName: "respond_general", input: { response: "The answer." } },
-            ]),
-            row(3, "tool", [
-                {
-                    type: "tool-result",
-                    toolCallId: callId,
-                    toolName: "respond_general",
-                    output: { type: "json", value: { response: "The answer." } },
-                },
-            ]),
-        ];
-        const entries = buildChatEntries("s1");
-        const sr = entries.find((e) => e.type === "structured_response");
-        expect(sr).toBeDefined();
-        expect(sr?.structuredResponse?.taskType).toBe("general");
-        expect((sr?.structuredResponse?.data).response).toBe("The answer.");
-        // The respond_* result must NOT also appear as a bare tool_result.
-        expect(entries.some((e) => e.type === "tool_result")).toBe(false);
-    });
-    it("still rebuilds a non-response tool-result as a tool_result entry", () => {
-        const callId = "call-read-1";
-        MESSAGE_ROWS = [
-            row(1, "user", "read the file"),
-            row(2, "assistant", [
-                { type: "tool-call", toolCallId: callId, toolName: "read_file", input: { file_path: "a.ts" } },
-            ]),
-            row(3, "tool", [
-                {
-                    type: "tool-result",
-                    toolCallId: callId,
-                    toolName: "read_file",
-                    output: { type: "json", value: { success: true, output: "file body" } },
-                },
-            ]),
-        ];
-        const entries = buildChatEntries("s1");
-        expect(entries.some((e) => e.type === "structured_response")).toBe(false);
-        expect(entries.some((e) => e.type === "tool_result")).toBe(true);
-    });
-});
-//# sourceMappingURL=transcript-response-entry.test.js.map

package/dist/src/storage/transcript.test.d.ts

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

package/dist/src/storage/transcript.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractToolResultFromOutput } from "./tool-results.js";
-describe("transcript media tool results", () => {
-    it("preserves media metadata when stored tool output is normalized", () => {
-        const mediaResult = {
-            success: true,
-            output: "Generated 1 image.\n- /tmp/example.png",
-            media: [
-                {
-                    kind: "image",
-                    path: "/tmp/example.png",
-                    url: "https://example.com/generated.png",
-                    sourcePath: "/tmp/source.png",
-                    prompt: "Create a new hero image",
-                    modelId: "muonroi-test-image",
-                },
-            ],
-        };
-        expect(extractToolResultFromOutput(mediaResult)).toEqual(mediaResult);
-    });
-});
-//# sourceMappingURL=transcript.test.js.map

package/dist/src/storage/usage-cap.test.d.ts

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

package/dist/src/storage/usage-cap.test.js

@@ -1,51 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { atomicWriteJSON } from "./atomic-io.js";
-import { loadUsage, saveUsage } from "./usage-cap.js";
-let tmpDir;
-beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "usage-test-"));
-});
-afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-function currentMonthUTC() {
-    const d = new Date();
-    const yyyy = d.getUTCFullYear();
-    const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
-    return `${yyyy}-${mm}`;
-}
-describe("loadUsage", () => {
-    it("Test 7: bootstraps usage.json when absent", async () => {
-        const state = await loadUsage(tmpDir);
-        expect(state.current_month_utc).toBe(currentMonthUTC());
-        expect(state.current_usd).toBe(0);
-        expect(state.reservations).toEqual([]);
-        // File must be written
-        const raw = await fs.readFile(path.join(tmpDir, "usage.json"), "utf8");
-        const parsed = JSON.parse(raw);
-        expect(parsed.current_usd).toBe(0);
-    });
-    it("Test 9: auto-resets on stale month", async () => {
-        // Write a state with a past month
-        await atomicWriteJSON(path.join(tmpDir, "usage.json"), {
-            current_month_utc: "2026-03",
-            current_usd: 5.5,
-            reservations: [],
-        });
-        const state = await loadUsage(tmpDir);
-        expect(state.current_month_utc).toBe(currentMonthUTC());
-        expect(state.current_usd).toBe(0);
-    });
-});
-describe("saveUsage", () => {
-    it("Test 8: round-trips via loadUsage", async () => {
-        const initial = await loadUsage(tmpDir);
-        await saveUsage({ ...initial, current_usd: 1.23 }, tmpDir);
-        const loaded = await loadUsage(tmpDir);
-        expect(loaded.current_usd).toBe(1.23);
-    });
-});
-//# sourceMappingURL=usage-cap.test.js.map

package/dist/src/tools/__tests__/native-tools.test.d.ts

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

package/dist/src/tools/__tests__/native-tools.test.js

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { NATIVE_MUONROI_TOOL_NAMES, registerNativeMuonroiTools } from "../native-tools.js";
-async function exec(tools, name, args) {
-    const tool = tools[name];
-    return (await tool.execute(args, {}));
-}
-describe("registerNativeMuonroiTools", () => {
-    it("registers every muonroi-tools capability as a native builtin", () => {
-        const tools = {};
-        registerNativeMuonroiTools(tools);
-        for (const name of NATIVE_MUONROI_TOOL_NAMES) {
-            expect(tools[name], `missing native tool ${name}`).toBeDefined();
-            expect(typeof tools[name].execute).toBe("function");
-        }
-        // ee_query stays the registry's own native tool — not duplicated here.
-        expect(tools.ee_query).toBeUndefined();
-    });
-    it("setup_guide returns the shared guide text (no MCP round-trip)", async () => {
-        const tools = {};
-        registerNativeMuonroiTools(tools);
-        const out = await exec(tools, "setup_guide", {});
-        expect(out).toContain("muonroi-cli Setup Guide");
-        expect(out).toContain("muonroi-cli doctor");
-    });
-    it("ee_feedback rejects a noise verdict with no reason (no network call)", async () => {
-        const tools = {};
-        registerNativeMuonroiTools(tools);
-        const out = await exec(tools, "ee_feedback", { id: "abc", collection: "experience-behavioral", verdict: "noise" });
-        expect(out).toMatch(/reason_required/);
-    });
-    it("ee_feedback validates required args", async () => {
-        const tools = {};
-        registerNativeMuonroiTools(tools);
-        expect(await exec(tools, "ee_feedback", { verdict: "followed" })).toMatch(/invalid_args/);
-    });
-    it("ee_write rejects a too-short lesson (no network call)", async () => {
-        const tools = {};
-        registerNativeMuonroiTools(tools);
-        expect(await exec(tools, "ee_write", { lesson: "oops" })).toMatch(/invalid_args/);
-        expect(await exec(tools, "ee_write", {})).toMatch(/invalid_args/);
-    });
-    it("selfverify_status returns not_found for an unknown runId (shared JobManager)", async () => {
-        const tools = {};
-        registerNativeMuonroiTools(tools);
-        const out = await exec(tools, "selfverify_status", { runId: "does-not-exist" });
-        expect(out).toMatch(/not_found/);
-    });
-    it("selfverify_start rejects agentic mode without goal+llm", async () => {
-        const tools = {};
-        registerNativeMuonroiTools(tools);
-        expect(await exec(tools, "selfverify_start", { mode: "agentic" })).toMatch(/invalid_args/);
-    });
-    it("usage_forensics rejects an empty prefix without touching the DB", async () => {
-        const tools = {};
-        registerNativeMuonroiTools(tools);
-        expect(await exec(tools, "usage_forensics", { prefix: "  " })).toMatch(/invalid_args/);
-    });
-});
-//# sourceMappingURL=native-tools.test.js.map

package/dist/src/tools/__tests__/vision-gate.test.d.ts

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

package/dist/src/tools/__tests__/vision-gate.test.js

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { messagesHaveImagePart, VISION_TOOL_NAMES, visionToolsNeeded } from "../vision-gate.js";
-describe("visionToolsNeeded", () => {
-    it("drops vision tools for a pure-text turn with no image anywhere", () => {
-        expect(visionToolsNeeded({ userMessage: "what is this project about?", messages: [], cachedImageCount: 0 })).toBe(false);
-        expect(visionToolsNeeded({ userMessage: "fix the auth bug in src/auth/login.ts" })).toBe(false);
-    });
-    it("keeps vision tools when the message text references an image", () => {
-        for (const msg of [
-            "analyze screenshot.png",
-            "what does this diagram show?",
-            "review the figma mockup",
-            "here is a data:image/png;base64,AAAA",
-            "phân tích cái ảnh này giúp tôi",
-        ]) {
-            expect(visionToolsNeeded({ userMessage: msg })).toBe(true);
-        }
-    });
-    it("keeps vision tools when the turn carries an image content part (attachment)", () => {
-        const messages = [
-            {
-                role: "user",
-                content: [
-                    { type: "text", text: "what is this?" },
-                    { type: "image", mediaType: "image/png", data: "BASE64" },
-                ],
-            },
-        ];
-        expect(visionToolsNeeded({ userMessage: "what is this?", messages })).toBe(true);
-    });
-    it("keeps vision tools when earlier turns cached images (follow-up queries)", () => {
-        expect(visionToolsNeeded({ userMessage: "what color is the button?", cachedImageCount: 2 })).toBe(true);
-    });
-    it("keeps vision tools on a continuation that already used tools (BUG-A guard)", () => {
-        expect(visionToolsNeeded({ userMessage: "continue", priorTurnHadTools: true })).toBe(true);
-    });
-    it("exports exactly the three vision tool ids (todo_write / core tools excluded)", () => {
-        expect([...VISION_TOOL_NAMES]).toEqual(["analyze_image", "ask_vision_proxy", "list_vision_cache"]);
-        expect(VISION_TOOL_NAMES).not.toContain("todo_write");
-        expect(VISION_TOOL_NAMES).not.toContain("read_file");
-    });
-});
-describe("messagesHaveImagePart", () => {
-    it("detects an image part by type", () => {
-        expect(messagesHaveImagePart([{ role: "user", content: [{ type: "image", data: "x" }] }])).toBe(true);
-    });
-    it("detects an image part by mediaType prefix", () => {
-        expect(messagesHaveImagePart([{ role: "user", content: [{ type: "file", mediaType: "image/jpeg" }] }])).toBe(true);
-    });
-    it("returns false for text-only content and malformed input", () => {
-        expect(messagesHaveImagePart([{ role: "user", content: [{ type: "text", text: "hi" }] }])).toBe(false);
-        expect(messagesHaveImagePart([{ role: "user", content: "plain string" }])).toBe(false);
-        expect(messagesHaveImagePart(undefined)).toBe(false);
-    });
-});
-//# sourceMappingURL=vision-gate.test.js.map

package/dist/src/tools/bash-output-cache.test.d.ts

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

package/dist/src/tools/bash-output-cache.test.js

@@ -1,89 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { clearBashOutputCache, getBashRun, listBashRunIds, nextBashRunId, recordBashRun, sliceBashOutput, stripAnsi, } from "./bash-output-cache.js";
-beforeEach(() => clearBashOutputCache());
-describe("stripAnsi", () => {
-    it("removes CSI color sequences", () => {
-        expect(stripAnsi("red text")).toBe("red text");
-    });
-    it("removes vitest's clear-line + cursor-move sequences", () => {
-        expect(stripAnsi(" PASS test.ts")).toBe(" PASS test.ts");
-    });
-    it("returns input unchanged when no ANSI codes present", () => {
-        expect(stripAnsi("plain text")).toBe("plain text");
-    });
-});
-describe("recordBashRun / getBashRun", () => {
-    it("round-trips a record", () => {
-        const id = nextBashRunId();
-        recordBashRun({ id, command: "ls", stdout: "a\nb", stderr: "", exitCode: 0, durationMs: 12 });
-        const r = getBashRun(id);
-        expect(r?.command).toBe("ls");
-        expect(r?.stdout).toBe("a\nb");
-    });
-    it("returns null for unknown id", () => {
-        expect(getBashRun("bash-9999")).toBeNull();
-    });
-    it("LRU evicts oldest entry past 50", () => {
-        for (let i = 0; i < 60; i++) {
-            recordBashRun({ id: `bash-${i}`, command: "c", stdout: "x", stderr: "", exitCode: 0, durationMs: 1 });
-        }
-        expect(listBashRunIds().length).toBe(50);
-        expect(getBashRun("bash-0")).toBeNull();
-        expect(getBashRun("bash-59")).not.toBeNull();
-    });
-    it("getBashRun touches LRU (most recently used)", () => {
-        for (let i = 0; i < 50; i++) {
-            recordBashRun({ id: `bash-${i}`, command: "c", stdout: "x", stderr: "", exitCode: 0, durationMs: 1 });
-        }
-        // Touch bash-0 to make it freshest.
-        getBashRun("bash-0");
-        recordBashRun({ id: "bash-50", command: "c", stdout: "x", stderr: "", exitCode: 0, durationMs: 1 });
-        // bash-1 (the next-oldest after bash-0 was touched) should be evicted.
-        expect(getBashRun("bash-0")).not.toBeNull();
-        expect(getBashRun("bash-1")).toBeNull();
-    });
-});
-describe("sliceBashOutput", () => {
-    const record = {
-        id: "bash-x",
-        command: "vitest",
-        stdout: ["FAIL test/a.spec.ts", "PASS test/b.spec.ts", "ERROR something", "PASS test/c.spec.ts", "Done"].join("\n"),
-        stderr: "",
-        exitCode: 1,
-        durationMs: 100,
-        completedAt: new Date().toISOString(),
-    };
-    it("head returns first N lines", () => {
-        expect(sliceBashOutput(record, { mode: "head", lines: 2 }).text).toBe("FAIL test/a.spec.ts\nPASS test/b.spec.ts");
-    });
-    it("tail returns last N lines", () => {
-        expect(sliceBashOutput(record, { mode: "tail", lines: 2 }).text).toBe("PASS test/c.spec.ts\nDone");
-    });
-    it("grep filters by regex", () => {
-        const r = sliceBashOutput(record, { mode: "grep", pattern: "FAIL|ERROR" });
-        expect(r.text).toBe("FAIL test/a.spec.ts\nERROR something");
-        expect(r.matchedLines).toBe(2);
-    });
-    it("grep respects caseInsensitive", () => {
-        const r = sliceBashOutput(record, { mode: "grep", pattern: "fail", caseInsensitive: true });
-        expect(r.matchedLines).toBe(1);
-    });
-    it("lines extracts a range", () => {
-        expect(sliceBashOutput(record, { mode: "lines", range: "2-4" }).text).toBe("PASS test/b.spec.ts\nERROR something\nPASS test/c.spec.ts");
-    });
-    it("rejects malformed range", () => {
-        const r = sliceBashOutput(record, { mode: "lines", range: "garbage" });
-        expect(r.ok).toBe(false);
-    });
-    it("rejects invalid regex without throwing", () => {
-        const r = sliceBashOutput(record, { mode: "grep", pattern: "[" });
-        expect(r.ok).toBe(false);
-        expect(r.text).toMatch(/Invalid regex/);
-    });
-    it("merges stderr into output for slicing", () => {
-        const withErr = { ...record, stderr: "stderr line" };
-        const r = sliceBashOutput(withErr, { mode: "full" });
-        expect(r.text).toContain("[stderr]\nstderr line");
-    });
-});
-//# sourceMappingURL=bash-output-cache.test.js.map

package/dist/src/tools/bash-output-integration.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Integration test for Fix #2 — BashTool.execute() must populate
- * bashRunId/bashTotalChars and the bash-output-cache so bash_output_get can
- * read the captured output back.
- *
- * Kept deliberately minimal: ANSI stripping, slicing, and exit-code handling
- * are covered by unit tests in bash-output-cache.test.ts. Here we only verify
- * the wireup between BashTool.execute() and the cache module.
- */
-export {};

package/dist/src/tools/bash-output-integration.test.js

@@ -1,30 +0,0 @@
-/**
- * Integration test for Fix #2 — BashTool.execute() must populate
- * bashRunId/bashTotalChars and the bash-output-cache so bash_output_get can
- * read the captured output back.
- *
- * Kept deliberately minimal: ANSI stripping, slicing, and exit-code handling
- * are covered by unit tests in bash-output-cache.test.ts. Here we only verify
- * the wireup between BashTool.execute() and the cache module.
- */
-import os from "node:os";
-import { beforeEach, describe, expect, it } from "vitest";
-import { BashTool } from "./bash.js";
-import { clearBashOutputCache, getBashRun } from "./bash-output-cache.js";
-describe("BashTool + bash-output-cache integration", () => {
-    beforeEach(() => clearBashOutputCache());
-    it("populates bashRunId / bashTotalChars and caches stdout for a successful echo", async () => {
-        const bash = new BashTool(os.tmpdir());
-        const marker = "muonroi-fix2-marker";
-        // `echo MARKER` is portable across cmd.exe, bash, pwsh, and wsl bash.
-        const result = await bash.execute(`echo ${marker}`, 15_000);
-        expect(result.success).toBe(true);
-        expect(result.bashRunId).toMatch(/^bash-\d+$/);
-        expect(result.bashTotalChars ?? 0).toBeGreaterThan(0);
-        const cached = getBashRun(result.bashRunId);
-        expect(cached?.command).toBe(`echo ${marker}`);
-        expect(cached?.stdout).toContain(marker);
-        expect(cached?.exitCode).toBe(0);
-    }, 20_000);
-});
-//# sourceMappingURL=bash-output-integration.test.js.map

package/dist/src/tools/bash.test.d.ts

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