muonroi-cli 1.8.1 → 1.8.4

package/dist/src/tools/bash.test.js

@@ -1,90 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { BashTool } from "./bash.js";
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-afterEach(() => {
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-});
-describe("BashTool non-sandbox behavior", () => {
-    it("translates POSIX-style absolute paths in cd when shell is POSIX", async () => {
-        if (process.platform !== "win32")
-            return;
-        const root = makeTempDir("muonroi-bash-cdposix-");
-        // Pretend the configured shell is bash (forces POSIX path translation in cd handler).
-        const bash = new BashTool(root, { shellSettings: { kind: "bash" } });
-        if (!bash.getResolvedShell().isPosix)
-            return; // skip if no bash on this Windows host
-        const driveLetter = root.match(/^([A-Za-z]):/)?.[1]?.toLowerCase();
-        if (!driveLetter)
-            return;
-        const posixPath = `/${driveLetter}${root.slice(2).replace(/\\/g, "/")}`;
-        const result = await bash.execute(`cd ${posixPath}`);
-        expect(result.success).toBe(true);
-        expect(bash.getCwd()).toBe(root);
-    });
-    it("strips trailing backslash from quoted cd target on Windows (E1 regression)", async () => {
-        if (process.platform !== "win32")
-            return;
-        const root = makeTempDir("muonroi-bash-trailbs-");
-        const bash = new BashTool(os.tmpdir());
-        // Simulate: cd "C:\foo\bar\" && pwd  — the trailing \" is mis-parsed as
-        // escaped quote, leaving the path as "C:\foo\bar\". After the fix the
-        // trailing backslash is stripped and the directory resolves correctly.
-        const result = await bash.execute(`cd "${root}\\"`);
-        expect(result.success).toBe(true);
-        expect(bash.getCwd()).toBe(root);
-    });
-    it("splits `cd <dir> && <cmd>` and runs <cmd> in the new cwd (session 127140a47b56 regression)", async () => {
-        const root = makeTempDir("muonroi-bash-cdchain-");
-        const bash = new BashTool(os.tmpdir());
-        const echoCmd = process.platform === "win32" ? "echo split-ok" : "echo split-ok";
-        const quoted = process.platform === "win32" ? `"${root}"` : root;
-        const result = await bash.execute(`cd ${quoted} && ${echoCmd}`);
-        expect(result.success).toBe(true);
-        expect(result.output ?? "").toContain("split-ok");
-        expect(bash.getCwd()).toBe(root);
-    });
-    it("respects `&&` short-circuit: failed cd does NOT run the chained command", async () => {
-        const bash = new BashTool(os.tmpdir());
-        const result = await bash.execute(`cd /this/path/does/not/exist && echo should-not-run`);
-        expect(result.success).toBe(false);
-        expect(result.error ?? "").toMatch(/Cannot change directory/);
-        expect(result.output ?? "").not.toContain("should-not-run");
-    });
-    it("respects `||` short-circuit: failed cd DOES run the chained command", async () => {
-        const start = os.tmpdir();
-        const bash = new BashTool(start);
-        const result = await bash.execute(`cd /this/path/does/not/exist || echo fallback-ran`);
-        expect(result.success).toBe(true);
-        expect(result.output ?? "").toContain("fallback-ran");
-        expect(bash.getCwd()).toBe(start); // cwd unchanged after failed cd
-    });
-    it("strips cmd.exe DOS flag `/d` from `cd /d <path> && <cmd>` (session 7dcf8fd7d6a4 regression)", async () => {
-        const root = makeTempDir("muonroi-bash-cddosflag-");
-        const bash = new BashTool(os.tmpdir());
-        const quoted = process.platform === "win32" ? `"${root}"` : root;
-        const result = await bash.execute(`cd /d ${quoted} && echo dos-flag-ok`);
-        expect(result.success).toBe(true);
-        expect(result.output ?? "").toContain("dos-flag-ok");
-        expect(bash.getCwd()).toBe(root);
-    });
-    it("respects `;` separator: runs remainder regardless of cd outcome", async () => {
-        const root = makeTempDir("muonroi-bash-cdsemicolon-");
-        const bash = new BashTool(os.tmpdir());
-        const quoted = process.platform === "win32" ? `"${root}"` : root;
-        const result = await bash.execute(`cd ${quoted} ; echo always-runs`);
-        expect(result.success).toBe(true);
-        expect(result.output ?? "").toContain("always-runs");
-        expect(bash.getCwd()).toBe(root);
-    });
-});
-//# sourceMappingURL=bash.test.js.map

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

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

package/dist/src/tools/computer.test.js

@@ -1,142 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { buildAgentDesktopEnv, buildScreenshotPath, computerClick, computerLaunch, computerScreenshot, computerSnapshot, computerType, } from "./computer.js";
-describe("computer tools", () => {
-    const tempDirs = [];
-    afterEach(() => {
-        for (const dir of tempDirs.splice(0)) {
-            fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-        }
-    });
-    it("stores screenshots under .muonroi-cli/computer by default", () => {
-        const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "muonroi-computer-"));
-        tempDirs.push(cwd);
-        const outputPath = buildScreenshotPath(cwd);
-        expect(outputPath).toContain(path.join(".muonroi-cli", "computer"));
-        expect(path.dirname(outputPath)).toBe(path.join(cwd, ".muonroi-cli", "computer"));
-    });
-    it("captures screenshots through agent-desktop", async () => {
-        const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "muonroi-computer-"));
-        tempDirs.push(cwd);
-        const outputPath = path.join(cwd, "artifacts", "screen.png");
-        const runner = vi.fn(async () => ({
-            success: true,
-            stdout: JSON.stringify({ ok: true, command: "screenshot", data: { path: outputPath } }),
-            stderr: "",
-        }));
-        const result = await computerScreenshot({ output_path: "artifacts/screen.png", app: "Google Chrome", window_id: "w-42" }, cwd, undefined, runner);
-        expect(result.success).toBe(true);
-        expect(result.media).toEqual([{ kind: "image", path: outputPath, mediaType: "image/png" }]);
-        expect(result.computer).toEqual({
-            action: "screenshot",
-            path: outputPath,
-            app: "Google Chrome",
-            windowId: "w-42",
-            hint: "Use computer_snapshot to inspect accessibility refs before clicking or typing.",
-        });
-        expect(runner).toHaveBeenCalledWith(["screenshot", outputPath, "--app", "Google Chrome", "--window-id", "w-42"], cwd, undefined);
-    });
-    it("formats snapshots with refs and raw JSON", async () => {
-        const runner = vi.fn(async () => ({
-            success: true,
-            stdout: JSON.stringify({
-                ok: true,
-                command: "snapshot",
-                data: {
-                    refs: ["@e1", "@e2"],
-                },
-            }),
-            stderr: "",
-        }));
-        const result = await computerSnapshot({ app: "Finder" }, "/tmp", undefined, runner);
-        expect(result.success).toBe(true);
-        expect(result.output).toContain("Refs: @e1, @e2");
-        expect(result.output).toContain('"command": "snapshot"');
-        expect(result.computer).toEqual({
-            action: "snapshot",
-            app: "Finder",
-            windowId: undefined,
-        });
-        expect(runner).toHaveBeenCalledWith(["snapshot", "--app", "Finder", "--interactive-only"], "/tmp", undefined);
-    });
-    it("clicks by accessibility ref", async () => {
-        const runner = vi.fn(async () => ({
-            success: true,
-            stdout: JSON.stringify({ ok: true, command: "click", data: { action: "click" } }),
-            stderr: "",
-        }));
-        const result = await computerClick({ ref: "@e7" }, "/tmp", undefined, runner);
-        expect(result.success).toBe(true);
-        expect(result.computer).toEqual({ action: "click", ref: "@e7" });
-        expect(runner).toHaveBeenCalledWith(["click", "@e7"], "/tmp", undefined);
-    });
-    it("reports a specific error for non-left ref clicks", async () => {
-        const runner = vi.fn(async () => ({
-            success: true,
-            stdout: "",
-            stderr: "",
-        }));
-        const result = await computerClick({ ref: "@e7", button: "right" }, "/tmp", undefined, runner);
-        expect(result.success).toBe(false);
-        expect(result.output).toContain("supports only the left button");
-        expect(runner).not.toHaveBeenCalled();
-    });
-    it("types into an element ref", async () => {
-        const runner = vi.fn(async () => ({
-            success: true,
-            stdout: JSON.stringify({ ok: true, command: "type", data: { action: "type" } }),
-            stderr: "",
-        }));
-        const result = await computerType({ ref: "@e5", text: "hello from muonroi" }, "/tmp", undefined, runner);
-        expect(result.success).toBe(true);
-        expect(result.output).toContain("Typed into @e5.");
-        expect(runner).toHaveBeenCalledWith(["type", "@e5", "hello from muonroi"], "/tmp", undefined);
-    });
-    it("launches apps through agent-desktop", async () => {
-        const runner = vi.fn(async () => ({
-            success: true,
-            stdout: JSON.stringify({ ok: true, command: "launch", data: { launched: true } }),
-            stderr: "",
-        }));
-        const result = await computerLaunch({ app: "Google Chrome", timeout_ms: 15000 }, "/tmp", undefined, runner);
-        expect(result.success).toBe(true);
-        expect(runner).toHaveBeenCalledWith(["launch", "Google Chrome", "--timeout", "15000"], "/tmp", undefined);
-    });
-    it("adds a macOS accessibility hint on permission failures", async () => {
-        const runner = vi.fn(async () => ({
-            success: false,
-            stdout: JSON.stringify({
-                ok: false,
-                command: "snapshot",
-                error: {
-                    code: "PERM_DENIED",
-                    message: "Accessibility permission not granted",
-                    suggestion: "Open System Settings > Privacy & Security > Accessibility and add your terminal application",
-                },
-            }),
-            stderr: "",
-        }));
-        const result = await computerSnapshot({ app: "Finder" }, "/tmp", undefined, runner);
-        expect(result.success).toBe(false);
-        expect(result.output).toContain("Accessibility permission");
-    });
-    it("only forwards an allowlisted environment to agent-desktop", () => {
-        const env = buildAgentDesktopEnv({
-            PATH: "/usr/bin:/bin",
-            HOME: "/Users/tester",
-            TERM: "xterm-256color",
-            GROK_API_KEY: "secret",
-            TELEGRAM_BOT_TOKEN: "also-secret",
-            CUSTOM_SECRET: "nope",
-        });
-        expect(env).toEqual({
-            FORCE_COLOR: "0",
-            HOME: "/Users/tester",
-            PATH: "/usr/bin:/bin",
-            TERM: "xterm-256color",
-        });
-    });
-});
-//# sourceMappingURL=computer.test.js.map

package/dist/src/tools/file-tracker.test.d.ts

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

package/dist/src/tools/file-tracker.test.js

@@ -1,77 +0,0 @@
-import { readFile as fsRead, writeFile as fsWrite, mkdtemp, rm } from "fs/promises";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { editFile, readFile, writeFile } from "./file.js";
-import { FileTracker } from "./file-tracker.js";
-vi.mock("../lsp/runtime", () => ({
-    summarizeDiagnostics: () => "",
-    syncFileWithLsp: async () => [],
-}));
-const tempDirs = [];
-afterEach(async () => {
-    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 })));
-});
-async function createTempDir() {
-    const dir = await mkdtemp(path.join(os.tmpdir(), "muonroi-tracker-"));
-    tempDirs.push(dir);
-    return dir;
-}
-describe("FileTracker — read-before-write guard", () => {
-    it("rejects edit on an existing file that was not read first", async () => {
-        const cwd = await createTempDir();
-        await fsWrite(path.join(cwd, "demo.ts"), "const a = 1;\n", "utf8");
-        const tracker = new FileTracker();
-        const result = await editFile("demo.ts", "1", "2", cwd, tracker);
-        expect(result.success).toBe(false);
-        expect(result.output).toMatch(/must be read first/i);
-    });
-    it("rejects overwrite on an existing file that was not read first", async () => {
-        const cwd = await createTempDir();
-        await fsWrite(path.join(cwd, "demo.ts"), "old\n", "utf8");
-        const tracker = new FileTracker();
-        const result = await writeFile("demo.ts", "new\n", cwd, tracker);
-        expect(result.success).toBe(false);
-        expect(result.output).toMatch(/must be read first/i);
-    });
-    it("allows creating a new file without a prior read", async () => {
-        const cwd = await createTempDir();
-        const tracker = new FileTracker();
-        const result = await writeFile("brand-new.ts", "fresh\n", cwd, tracker);
-        expect(result.success).toBe(true);
-        expect(await fsRead(path.join(cwd, "brand-new.ts"), "utf8")).toBe("fresh\n");
-    });
-    it("allows edit after a read of the same file", async () => {
-        const cwd = await createTempDir();
-        await fsWrite(path.join(cwd, "demo.ts"), "const a = 1;\n", "utf8");
-        const tracker = new FileTracker();
-        readFile("demo.ts", cwd, undefined, undefined, tracker);
-        const result = await editFile("demo.ts", "1", "2", cwd, tracker);
-        expect(result.success).toBe(true);
-        expect(await fsRead(path.join(cwd, "demo.ts"), "utf8")).toBe("const a = 2;\n");
-    });
-    it("rejects edit when file changed on disk after the read (hash mismatch)", async () => {
-        const cwd = await createTempDir();
-        const filePath = path.join(cwd, "demo.ts");
-        await fsWrite(filePath, "const a = 1;\n", "utf8");
-        const tracker = new FileTracker();
-        readFile("demo.ts", cwd, undefined, undefined, tracker);
-        // Simulate external modification.
-        await fsWrite(filePath, "const a = 99;\n", "utf8");
-        const result = await editFile("demo.ts", "99", "100", cwd, tracker);
-        expect(result.success).toBe(false);
-        expect(result.output).toMatch(/changed on disk/i);
-    });
-    it("allows back-to-back edits without re-reading (write refreshes tracker)", async () => {
-        const cwd = await createTempDir();
-        await fsWrite(path.join(cwd, "demo.ts"), "1 2 3\n", "utf8");
-        const tracker = new FileTracker();
-        readFile("demo.ts", cwd, undefined, undefined, tracker);
-        const r1 = await editFile("demo.ts", "1", "A", cwd, tracker);
-        const r2 = await editFile("demo.ts", "2", "B", cwd, tracker);
-        expect(r1.success).toBe(true);
-        expect(r2.success).toBe(true);
-        expect(await fsRead(path.join(cwd, "demo.ts"), "utf8")).toBe("A B 3\n");
-    });
-});
-//# sourceMappingURL=file-tracker.test.js.map

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

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

package/dist/src/tools/file.test.js

@@ -1,106 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile as writeFsFile } from "fs/promises";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { editFile, writeFile } from "./file.js";
-const summarizeDiagnosticsMock = vi.fn(() => "1 LSP issue · 1 error");
-const syncFileWithLspMock = vi.fn(async () => [
-    {
-        filePath: "/tmp/demo.ts",
-        serverId: "typescript",
-        diagnostics: [
-            {
-                message: "Type error",
-                severity: 1,
-                range: {
-                    start: { line: 0, character: 0 },
-                    end: { line: 0, character: 5 },
-                },
-            },
-        ],
-    },
-]);
-vi.mock("../lsp/runtime", () => ({
-    summarizeDiagnostics: (diagnostics) => summarizeDiagnosticsMock(diagnostics),
-    syncFileWithLsp: (cwd, filePath, content, save, waitForDiagnostics) => syncFileWithLspMock(cwd, filePath, content, save, waitForDiagnostics),
-}));
-const tempDirs = [];
-afterEach(async () => {
-    summarizeDiagnosticsMock.mockClear();
-    syncFileWithLspMock.mockClear();
-    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 })));
-});
-describe("file tool LSP integration", () => {
-    it("includes diagnostics metadata when writing a file", async () => {
-        const cwd = await createTempDir();
-        const result = await writeFile("demo.ts", "const answer = 42;\n", cwd);
-        expect(result.success).toBe(true);
-        expect(result.output).toContain("1 LSP issue");
-        expect(result.lspDiagnostics).toHaveLength(1);
-        expect(syncFileWithLspMock).toHaveBeenCalledWith(cwd, path.join(cwd, "demo.ts"), "const answer = 42;\n", true, true);
-    });
-    it("syncs edited file contents through the LSP runtime", async () => {
-        const cwd = await createTempDir();
-        const filePath = path.join(cwd, "demo.ts");
-        await writeFsFile(filePath, "const answer = 41;\n", "utf8");
-        const result = await editFile("demo.ts", "41", "42", cwd);
-        const content = await readFile(filePath, "utf8");
-        expect(result.success).toBe(true);
-        expect(content).toContain("42");
-        expect(syncFileWithLspMock).toHaveBeenCalledWith(cwd, filePath, "const answer = 42;\n", true, true);
-    });
-});
-describe("editFile line-ending normalization", () => {
-    it("matches a multi-line old_string (LF) against a CRLF file and preserves CRLF", async () => {
-        // Live finding (storyflow_ui A/B 2026-06-06): both DeepSeek and Grok failed
-        // 8-9/10 edit_file calls on CRLF-terminated Angular templates. The model
-        // emits old_string with \n line breaks; the on-disk file uses \r\n, so an
-        // exact substring match never finds a multi-line old_string. Only a
-        // single-line edit (no newline) succeeded. The tool must normalize EOLs.
-        const cwd = await createTempDir();
-        const filePath = path.join(cwd, "tpl.html");
-        const crlf = '<div class="a">\r\n  <span></span>\r\n</div>\r\n';
-        await writeFsFile(filePath, crlf, "utf8");
-        // old_string + new_string use \n (what an LLM emits).
-        const oldStr = '<div class="a">\n  <span></span>\n</div>';
-        const newStr = '<div class="a">\n  <span>X</span>\n</div>';
-        const result = await editFile("tpl.html", oldStr, newStr, cwd);
-        const content = await readFile(filePath, "utf8");
-        expect(result.success).toBe(true);
-        expect(content).toContain("<span>X</span>");
-        // CRLF must be preserved on the written lines (no silent LF conversion).
-        expect(content).toContain('<div class="a">\r\n  <span>X</span>\r\n</div>\r\n');
-        expect(content).not.toMatch(/[^\r]\n/); // no bare LF remains
-    });
-    it("still edits a plain LF file with an LF old_string (no regression)", async () => {
-        const cwd = await createTempDir();
-        const filePath = path.join(cwd, "tpl.ts");
-        await writeFsFile(filePath, "const a = 1;\nconst b = 2;\n", "utf8");
-        const result = await editFile("tpl.ts", "const a = 1;\nconst b = 2;", "const a = 1;\nconst b = 3;", cwd);
-        const content = await readFile(filePath, "utf8");
-        expect(result.success).toBe(true);
-        expect(content).toBe("const a = 1;\nconst b = 3;\n");
-    });
-    it("still reports old_string not found when it is genuinely absent (CRLF file)", async () => {
-        const cwd = await createTempDir();
-        const filePath = path.join(cwd, "tpl.html");
-        await writeFsFile(filePath, '<div class="a">\r\n  <span></span>\r\n</div>\r\n', "utf8");
-        const result = await editFile("tpl.html", "<p>\n  nope\n</p>", "<p>yes</p>", cwd);
-        expect(result.success).toBe(false);
-        expect(result.output).toContain("old_string not found");
-    });
-    it("reports non-unique when the EOL-normalized old_string matches multiple times (CRLF file)", async () => {
-        const cwd = await createTempDir();
-        const filePath = path.join(cwd, "tpl.html");
-        await writeFsFile(filePath, "<li>x</li>\r\n<li>x</li>\r\n", "utf8");
-        const result = await editFile("tpl.html", "<li>x</li>", "<li>y</li>", cwd);
-        expect(result.success).toBe(false);
-        expect(result.output).toContain("not unique");
-    });
-});
-async function createTempDir() {
-    const dir = await mkdtemp(path.join(os.tmpdir(), "muonroi-file-tools-"));
-    tempDirs.push(dir);
-    return dir;
-}
-//# sourceMappingURL=file.test.js.map

package/dist/src/tools/git-safety.test.d.ts

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

package/dist/src/tools/git-safety.test.js

@@ -1,155 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { __resetGitSafetyState, analyzeGitCommand, checkPushGate, commitBlockedMessage, detectSensitiveStaging, recordCommandOutcome, stagingWarning, } from "./git-safety.js";
-describe("analyzeGitCommand", () => {
-    it("detects git push (with flags and chained)", () => {
-        expect(analyzeGitCommand("git push").isPush).toBe(true);
-        expect(analyzeGitCommand("git push origin main").isPush).toBe(true);
-        expect(analyzeGitCommand("git -c x=y push --force").isPush).toBe(true);
-        expect(analyzeGitCommand("git add -A && git commit -m x && git push origin main").isPush).toBe(true);
-    });
-    it("does not match 'push' inside a quoted commit message", () => {
-        expect(analyzeGitCommand('git commit -m "fix git push regression"').isPush).toBe(false);
-    });
-    it("detects a real push on its own line in a multi-line script", () => {
-        expect(analyzeGitCommand("git config user.name x\ngit push origin main").isPush).toBe(true);
-    });
-    it("does not bleed across a newline into an unrelated command", () => {
-        // 'git status' then a separate line with the word 'push' is NOT a git push.
-        expect(analyzeGitCommand("git status\necho push-notification").isPush).toBe(false);
-        expect(analyzeGitCommand("git log\nrm push.txt").isPush).toBe(false);
-    });
-    it("detects broad staging (-A / . / --all / commit -a)", () => {
-        expect(analyzeGitCommand("git add -A").isBroadStage).toBe(true);
-        expect(analyzeGitCommand("git add .").isBroadStage).toBe(true);
-        expect(analyzeGitCommand("git add --all").isBroadStage).toBe(true);
-        expect(analyzeGitCommand("git commit -am 'x'").isBroadStage).toBe(true);
-        expect(analyzeGitCommand("git commit -a").isBroadStage).toBe(true);
-    });
-    it("detects broad staging even with git global options before the subcommand", () => {
-        expect(analyzeGitCommand("git -c core.editor=true commit -a").isBroadStage).toBe(true);
-        expect(analyzeGitCommand("git -c x=y add -A").isBroadStage).toBe(true);
-    });
-    it("does not flag explicit/narrow staging or non-staging flags", () => {
-        expect(analyzeGitCommand("git add src/foo.ts src/bar.ts").isBroadStage).toBe(false);
-        expect(analyzeGitCommand("git add ./src/foo.ts").isBroadStage).toBe(false);
-        expect(analyzeGitCommand("git commit -m 'message'").isBroadStage).toBe(false);
-        expect(analyzeGitCommand("git commit --amend").isBroadStage).toBe(false);
-        // -a must be a clean flag cluster — a malformed `-a--otherflag` is not `-a`.
-        expect(analyzeGitCommand("git commit -a--otherflag").isBroadStage).toBe(false);
-    });
-    it("detects any `git commit` for the LSP commit gate (with or without -a)", () => {
-        expect(analyzeGitCommand("git commit -m 'x'").isCommit).toBe(true);
-        expect(analyzeGitCommand("git commit").isCommit).toBe(true);
-        expect(analyzeGitCommand("git commit -am 'x'").isCommit).toBe(true);
-        expect(analyzeGitCommand("git commit --amend --no-edit").isCommit).toBe(true);
-        expect(analyzeGitCommand("git -c x=y commit -m 'x'").isCommit).toBe(true);
-        expect(analyzeGitCommand("git add -A && git commit -m 'x'").isCommit).toBe(true);
-    });
-    it("does not treat commit plumbing / quoted messages as a commit", () => {
-        // `commit` must terminate at whitespace/clause-end — plumbing subcommands stay clear.
-        expect(analyzeGitCommand("git commit-tree $TREE").isCommit).toBe(false);
-        expect(analyzeGitCommand("git commit-graph write").isCommit).toBe(false);
-        // option values and quoted messages mentioning commit must not match.
-        expect(analyzeGitCommand("git log --grep=commit").isCommit).toBe(false);
-        expect(analyzeGitCommand('git push -m "amend the commit later"').isCommit).toBe(false);
-        // separate clause / line cannot bleed in.
-        expect(analyzeGitCommand("git status\necho commit").isCommit).toBe(false);
-    });
-    it("separates broad-add from commit-all so the gate scopes the right path set", () => {
-        const addAll = analyzeGitCommand("git add -A");
-        expect(addAll.isBroadAdd).toBe(true);
-        expect(addAll.isCommitAll).toBe(false);
-        const commitAll = analyzeGitCommand("git commit -am 'x'");
-        expect(commitAll.isCommitAll).toBe(true);
-        expect(commitAll.isBroadAdd).toBe(false);
-        expect(commitAll.isCommit).toBe(true);
-        const plainCommit = analyzeGitCommand("git commit -m 'x'");
-        expect(plainCommit.isBroadAdd).toBe(false);
-        expect(plainCommit.isCommitAll).toBe(false);
-        expect(plainCommit.isCommit).toBe(true);
-    });
-});
-describe("commitBlockedMessage", () => {
-    it("surfaces the diagnostic summary and does NOT advertise the env bypass", () => {
-        const msg = commitBlockedMessage("src/foo.ts:3 error TS2322");
-        expect(msg).toMatch(/BLOCKED/);
-        expect(msg).toContain("src/foo.ts:3 error TS2322");
-        expect(msg).toMatch(/git_commit/);
-        // G1 convention: the user-only escape hatch is never shown to the agent.
-        expect(msg).not.toMatch(/MUONROI_COMMIT_GATE/);
-    });
-    it("falls back gracefully when no summary is provided", () => {
-        expect(commitBlockedMessage()).toMatch(/no diagnostic detail/i);
-    });
-});
-describe("push gate", () => {
-    beforeEach(() => {
-        __resetGitSafetyState();
-        delete process.env.MUONROI_ALLOW_PUSH_ON_RED;
-    });
-    afterEach(() => {
-        delete process.env.MUONROI_ALLOW_PUSH_ON_RED;
-    });
-    it("does not block when no verification has failed", () => {
-        expect(checkPushGate("s1").blocked).toBe(false);
-    });
-    it("blocks push after a verification command fails", () => {
-        recordCommandOutcome("s1", "npm test", false);
-        const gate = checkPushGate("s1");
-        expect(gate.blocked).toBe(true);
-        expect(gate.failed).toContain("npm test");
-    });
-    it("clears the block when that same command re-runs green", () => {
-        recordCommandOutcome("s1", "npm test", false);
-        expect(checkPushGate("s1").blocked).toBe(true);
-        recordCommandOutcome("s1", "npm test", true);
-        expect(checkPushGate("s1").blocked).toBe(false);
-    });
-    it("a different verify passing does NOT clear an unrelated failed verify", () => {
-        recordCommandOutcome("s1", "npm test", false);
-        recordCommandOutcome("s1", "npm run build", true); // build green, tests still red
-        expect(checkPushGate("s1").blocked).toBe(true);
-        expect(checkPushGate("s1").failed).toEqual(["npm test"]);
-    });
-    it("is session-scoped (one session's failure does not gate another)", () => {
-        recordCommandOutcome("s1", "vitest run", false);
-        expect(checkPushGate("s1").blocked).toBe(true);
-        expect(checkPushGate("s2").blocked).toBe(false);
-    });
-    it("ignores non-verification command outcomes", () => {
-        recordCommandOutcome("s1", "git status", false);
-        recordCommandOutcome("s1", "ls -la", false);
-        expect(checkPushGate("s1").blocked).toBe(false);
-    });
-    it("respects the MUONROI_ALLOW_PUSH_ON_RED override", () => {
-        recordCommandOutcome("s1", "npm test", false);
-        process.env.MUONROI_ALLOW_PUSH_ON_RED = "1";
-        expect(checkPushGate("s1").blocked).toBe(false);
-    });
-});
-describe("sensitive staging detection", () => {
-    let dir;
-    beforeEach(() => {
-        dir = mkdtempSync(join(tmpdir(), "git-safety-"));
-    });
-    afterEach(() => {
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("flags .env and .muonroi-cli present in the repo root", () => {
-        writeFileSync(join(dir, ".env"), "SECRET=1");
-        writeFileSync(join(dir, ".muonroi-cli"), ""); // a file is enough for existsSync
-        const found = detectSensitiveStaging(dir);
-        expect(found).toContain(".env");
-        expect(found).toContain(".muonroi-cli");
-        expect(stagingWarning(dir)).toMatch(/WARNING/);
-    });
-    it("returns no warning for a clean repo", () => {
-        writeFileSync(join(dir, "README.md"), "# ok");
-        expect(detectSensitiveStaging(dir)).toEqual([]);
-        expect(stagingWarning(dir)).toBe("");
-    });
-});
-//# sourceMappingURL=git-safety.test.js.map

package/dist/src/tools/registry-bash-empty-command.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Corrective guard for malformed bash tool calls (missing / empty `command`).
- *
- * Live obs (2026-06-04, deepseek long session 734e65cffdf6): on an open-ended
- * "find a bug" task the cheap model emitted `bash` calls with EMPTY arguments
- * (`{}`, no `command`) three times in a row until the loop-guard askcard fired.
- * Root cause: the registry passed `input.command` (undefined) straight to
- * `bash.execute()`, where `command.startsWith(...)` threw an opaque TypeError.
- * An opaque error doesn't steer a cheap model to self-correct — it just repeats
- * the malformed call. The guard returns a crisp, actionable instruction instead
- * so the next step supplies a real command.
- */
-export {};

package/dist/src/tools/registry-bash-empty-command.test.js

@@ -1,57 +0,0 @@
-/**
- * Corrective guard for malformed bash tool calls (missing / empty `command`).
- *
- * Live obs (2026-06-04, deepseek long session 734e65cffdf6): on an open-ended
- * "find a bug" task the cheap model emitted `bash` calls with EMPTY arguments
- * (`{}`, no `command`) three times in a row until the loop-guard askcard fired.
- * Root cause: the registry passed `input.command` (undefined) straight to
- * `bash.execute()`, where `command.startsWith(...)` threw an opaque TypeError.
- * An opaque error doesn't steer a cheap model to self-correct — it just repeats
- * the malformed call. The guard returns a crisp, actionable instruction instead
- * so the next step supplies a real command.
- */
-import os from "node:os";
-import { describe, expect, it } from "vitest";
-import { BashTool } from "./bash.js";
-import { createBuiltinTools } from "./registry.js";
-async function runBash(tools, args) {
-    const t = tools.bash;
-    if (!t?.execute)
-        throw new Error("bash tool has no execute");
-    const out = await t.execute(args);
-    return typeof out === "string" ? out : JSON.stringify(out);
-}
-describe("bash tool — empty/missing command corrective guard", () => {
-    it("returns a corrective error (not a thrown TypeError) for missing command {}", async () => {
-        const bash = new BashTool(os.tmpdir());
-        const tools = createBuiltinTools(bash, "agent");
-        const out = await runBash(tools, {});
-        // Guard uses "BLOCKED (empty-bash):" prefix — more semantic than bare "ERROR".
-        expect(out).toMatch(/BLOCKED/);
-        expect(out).toMatch(/non-empty/i);
-        expect(out).toMatch(/command/i);
-    });
-    it("returns the corrective error for an empty-string command", async () => {
-        const bash = new BashTool(os.tmpdir());
-        const tools = createBuiltinTools(bash, "agent");
-        const out = await runBash(tools, { command: "" });
-        expect(out).toMatch(/BLOCKED/);
-        expect(out).toMatch(/non-empty/i);
-    });
-    it("returns the corrective error for a whitespace-only command", async () => {
-        const bash = new BashTool(os.tmpdir());
-        const tools = createBuiltinTools(bash, "agent");
-        const out = await runBash(tools, { command: "   " });
-        expect(out).toMatch(/BLOCKED/);
-        expect(out).toMatch(/non-empty/i);
-    });
-    it("does NOT block a real command", async () => {
-        const bash = new BashTool(os.tmpdir());
-        const tools = createBuiltinTools(bash, "agent");
-        const out = await runBash(tools, { command: "echo guard-ok", timeout: 10_000 });
-        expect(out).toContain("guard-ok");
-        expect(out).toMatch(/\[bash_run_id: bash-\d+\]/);
-        expect(out).not.toMatch(/non-empty/i);
-    }, 15_000);
-});
-//# sourceMappingURL=registry-bash-empty-command.test.js.map