muonroi-cli 1.8.1 → 1.8.4

package/dist/src/utils/subagent-display.test.js

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatSubagentName } from "./subagent-display.js";
-describe("formatSubagentName", () => {
-    it("formats built-in sub-agents with leading uppercase labels", () => {
-        expect(formatSubagentName("general")).toBe("General");
-        expect(formatSubagentName("explore")).toBe("Explore");
-        expect(formatSubagentName("vision")).toBe("Vision");
-        expect(formatSubagentName("verify")).toBe("Verify");
-        expect(formatSubagentName("verify-detect")).toBe("Verify Detect");
-        expect(formatSubagentName("verify-manifest")).toBe("Verify Manifest");
-        expect(formatSubagentName("computer")).toBe("Computer");
-    });
-    it("capitalizes custom sub-agent names", () => {
-        expect(formatSubagentName("security-review")).toBe("Security-review");
-        expect(formatSubagentName("Docs")).toBe("Docs");
-    });
-    it("falls back to Sub-agent for empty names", () => {
-        expect(formatSubagentName("")).toBe("Sub-agent");
-    });
-});
-//# sourceMappingURL=subagent-display.test.js.map

package/dist/src/utils/subagents-settings.test.d.ts

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

package/dist/src/utils/subagents-settings.test.js

@@ -1,64 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { getTestModels } from "../__test-helpers__/catalog-fixtures.js";
-import { loadCatalog } from "../models/registry.js";
-import { getCurrentModel, parseSubAgentsRawList } from "./settings.js";
-beforeAll(async () => {
-    await loadCatalog();
-});
-describe("parseSubAgentsRawList", () => {
-    it("returns empty for non-array or missing", () => {
-        expect(parseSubAgentsRawList(undefined)).toEqual([]);
-        expect(parseSubAgentsRawList(null)).toEqual([]);
-        expect(parseSubAgentsRawList({})).toEqual([]);
-    });
-    it("returns empty when model list is not yet populated", () => {
-        expect(parseSubAgentsRawList([
-            { name: "docs", model: "grok-4-1-fast-reasoning", instruction: "Focus on documentation." },
-        ])).toEqual([]);
-    });
-    it("returns empty when model ids are not recognized", () => {
-        expect(parseSubAgentsRawList([
-            { name: "research", model: "x-ai/grok-4.20-multi-agent-beta", instruction: "Focus on research." },
-        ])).toEqual([]);
-    });
-    it("skips unknown models", () => {
-        expect(parseSubAgentsRawList([{ name: "bad", model: "not-a-real-model", instruction: "x" }])).toEqual([]);
-    });
-    it("skips reserved and empty names", () => {
-        expect(parseSubAgentsRawList([
-            { name: "general", model: "grok-4-1-fast-reasoning", instruction: "x" },
-            { name: "Explore", model: "grok-4-1-fast-reasoning", instruction: "x" },
-            { name: "vision", model: "grok-4-1-fast-reasoning", instruction: "x" },
-            { name: "Verify", model: "grok-4-1-fast-reasoning", instruction: "x" },
-            { name: "computer", model: "grok-4-1-fast-reasoning", instruction: "x" },
-            { name: "", model: "grok-4-1-fast-reasoning", instruction: "x" },
-            { name: "  ", model: "grok-4-1-fast-reasoning", instruction: "x" },
-        ])).toEqual([]);
-    });
-    it("returns empty for deduplication when model list not populated", () => {
-        expect(parseSubAgentsRawList([
-            { name: "Docs", model: "grok-4-1-fast", instruction: "first" },
-            { name: "docs", model: "grok-code-fast-1", instruction: "second" },
-        ])).toEqual([]);
-    });
-    it("ignores non-object rows", () => {
-        expect(parseSubAgentsRawList([null, "x", { name: "ok", model: "grok-3-mini", instruction: "" }])).toEqual([]);
-    });
-});
-describe("getCurrentModel with modeModels", () => {
-    beforeEach(() => {
-        delete process.env.MUONROI_MODEL;
-    });
-    it("respects mode-specific models when provided", () => {
-        const result = getCurrentModel("agent");
-        expect(typeof result).toBe("string");
-        expect(result.length).toBeGreaterThan(0);
-    });
-    it("respects MUONROI_MODEL environment variable over modeModels", () => {
-        const catalogModel = getTestModels().premium;
-        process.env.MUONROI_MODEL = catalogModel;
-        const result = getCurrentModel("agent");
-        expect(result).toBe(catalogModel);
-    });
-});
-//# sourceMappingURL=subagents-settings.test.js.map

package/dist/src/utils/telegram-audio-settings.test.d.ts

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

package/dist/src/utils/telegram-audio-settings.test.js

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveTelegramAudioInputSettings } from "./settings.js";
-describe("resolveTelegramAudioInputSettings", () => {
-    it("returns Grok STT defaults when audio input is unset", () => {
-        expect(resolveTelegramAudioInputSettings(undefined)).toEqual({
-            enabled: true,
-            language: "en",
-        });
-    });
-    it("preserves explicit telegram audio overrides", () => {
-        expect(resolveTelegramAudioInputSettings({
-            audioInput: {
-                enabled: false,
-                language: "fr",
-            },
-        })).toEqual({
-            enabled: false,
-            language: "fr",
-        });
-    });
-    it("ignores deprecated whisper-only keys without failing", () => {
-        const legacy = {
-            audioInput: {
-                enabled: true,
-                language: "en",
-                binaryPath: "/opt/whisper-cli",
-                model: "base.en",
-                modelPath: "/tmp/ggml-base.en.bin",
-                autoDownloadModel: false,
-                engine: "whisper.cpp",
-            },
-        };
-        expect(resolveTelegramAudioInputSettings(legacy)).toEqual({
-            enabled: true,
-            language: "en",
-        });
-    });
-});
-//# sourceMappingURL=telegram-audio-settings.test.js.map

package/dist/src/utils/update-checker.test.d.ts

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

package/dist/src/utils/update-checker.test.js

@@ -1,142 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-const RELEASE_URL = "https://api.github.com/repos/muonroi/muonroi-cli/releases/latest";
-beforeEach(() => {
-    vi.stubGlobal("fetch", vi.fn());
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    vi.resetModules();
-});
-async function importModule() {
-    return import("./update-checker.js");
-}
-describe("checkForUpdate", () => {
-    it("returns hasUpdate=true when release version is newer", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ tag_name: "v2.0.0", assets: [] }),
-        });
-        vi.stubGlobal("fetch", mockFetch);
-        const { checkForUpdate } = await importModule();
-        const result = await checkForUpdate("1.0.0");
-        expect(result).not.toBeNull();
-        expect(result.hasUpdate).toBe(true);
-        expect(result.latestVersion).toBe("2.0.0");
-        expect(result.currentVersion).toBe("1.0.0");
-        expect(mockFetch).toHaveBeenCalledWith(RELEASE_URL, expect.objectContaining({
-            headers: expect.objectContaining({
-                Accept: "application/vnd.github+json",
-            }),
-        }));
-    });
-    it("returns hasUpdate=false when current version matches latest", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ tag_name: "v1.0.0", assets: [] }),
-        }));
-        const { checkForUpdate } = await importModule();
-        const result = await checkForUpdate("1.0.0");
-        expect(result).not.toBeNull();
-        expect(result.hasUpdate).toBe(false);
-    });
-    it("detects update from prerelease to stable release", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ tag_name: "v1.0.0", assets: [] }),
-        }));
-        const { checkForUpdate } = await importModule();
-        const result = await checkForUpdate("1.0.0-rc7");
-        expect(result).not.toBeNull();
-        expect(result.hasUpdate).toBe(true);
-        expect(result.latestVersion).toBe("1.0.0");
-        expect(result.currentVersion).toBe("1.0.0-rc7");
-    });
-    it("returns hasUpdate=false when prerelease is newer than registry", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ tag_name: "v0.9.0", assets: [] }),
-        }));
-        const { checkForUpdate } = await importModule();
-        const result = await checkForUpdate("1.0.0-rc7");
-        expect(result).not.toBeNull();
-        expect(result.hasUpdate).toBe(false);
-    });
-    it("returns null when the fetch fails", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("network error")));
-        const { checkForUpdate } = await importModule();
-        const result = await checkForUpdate("1.0.0");
-        expect(result).toBeNull();
-    });
-    it("returns null when the release API returns a non-ok response", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ ok: false, status: 404 }));
-        const { checkForUpdate } = await importModule();
-        const result = await checkForUpdate("1.0.0");
-        expect(result).toBeNull();
-    });
-    it("returns null when the release API returns an invalid version", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ tag_name: "not-a-version", assets: [] }),
-        }));
-        const { checkForUpdate } = await importModule();
-        const result = await checkForUpdate("1.0.0");
-        expect(result).toBeNull();
-    });
-    it("returns null when the current version is invalid", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ tag_name: "v2.0.0", assets: [] }),
-        }));
-        const { checkForUpdate } = await importModule();
-        const result = await checkForUpdate("garbage");
-        expect(result).toBeNull();
-    });
-    it("handles fetch timeout gracefully", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockImplementation(() => new Promise((_, reject) => setTimeout(() => reject(new Error("aborted")), 10))));
-        const { checkForUpdate } = await importModule();
-        const result = await checkForUpdate("1.0.0");
-        expect(result).toBeNull();
-    });
-});
-describe("runUpdate", () => {
-    it("returns success when the managed updater succeeds", async () => {
-        vi.doMock("./install-manager", async () => {
-            const actual = await vi.importActual("./install-manager");
-            return {
-                ...actual,
-                runManagedUpdate: vi.fn().mockResolvedValue({ success: true, output: "Updated to muonroi-cli 2.0.0." }),
-            };
-        });
-        const { runUpdate } = await importModule();
-        const result = await runUpdate("1.0.0");
-        expect(result.success).toBe(true);
-        expect(result.output).toContain("Updated");
-    });
-    it("returns failure when the managed updater fails", async () => {
-        vi.doMock("./install-manager", async () => {
-            const actual = await vi.importActual("./install-manager");
-            return {
-                ...actual,
-                runManagedUpdate: vi.fn().mockResolvedValue({ success: false, output: "permission denied" }),
-            };
-        });
-        const { runUpdate } = await importModule();
-        const result = await runUpdate("1.0.0");
-        expect(result.success).toBe(false);
-        expect(result.output).toContain("permission denied");
-    });
-});
-describe("getUpdateCommandForMethod", () => {
-    it("maps bun/npm global installs to the right update command", async () => {
-        const { getUpdateCommandForMethod } = await import("./install-manager.js");
-        expect(getUpdateCommandForMethod("bun-global")).toBe("bun add -g muonroi-cli@latest");
-        expect(getUpdateCommandForMethod("npm-global")).toBe("npm install -g muonroi-cli@latest");
-    });
-    it("returns null for methods without a package-manager command", async () => {
-        const { getUpdateCommandForMethod } = await import("./install-manager.js");
-        expect(getUpdateCommandForMethod("script")).toBeNull();
-        expect(getUpdateCommandForMethod("compiled")).toBeNull();
-        expect(getUpdateCommandForMethod("unknown")).toBeNull();
-    });
-});
-//# sourceMappingURL=update-checker.test.js.map

package/dist/src/verify/__tests__/coverage-parsers.test.d.ts

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

package/dist/src/verify/__tests__/coverage-parsers.test.js

@@ -1,69 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractCoverageFromOutput, parseBunCoverage, parseJestCoverage, parsePytestCoverage, parseVitestCoverage, } from "../coverage-parsers.js";
-const BUN_OUTPUT = `
-[0.12ms] 11 tests passed
-[0.00ms] 0 tests failed
-
------------------------|---------|---------|---------|---------|-----------------------
-File                   | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
------------------------|---------|---------|---------|---------|-----------------------
-All files              |   85.50 |   70.00 |   90.00 |   85.50 |
- index.ts              |   85.50 |   70.00 |   90.00 |   85.50 | 10-15
------------------------|---------|---------|---------|---------|-----------------------
-`;
-const VITEST_OUTPUT = `
-  Files                    | % Stmts | % Branch | % Funcs | % Lines | Uncovered Lines
- --------------------------|---------|---------|---------|---------|-----------------
-  All files                |   92.31 |   85.71 |     100 |   92.31 | 
-   reality-anchor.ts       |     100 |     100 |     100 |     100 | 
-   verify-result.ts        |   83.33 |      75 |     100 |   83.33 | 12-15
- --------------------------|---------|---------|---------|---------|-----------------
-`;
-const JEST_OUTPUT = `
-----------|---------|----------|---------|---------|-------------------
-File      | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
-----------|---------|----------|---------|---------|-------------------
-All files |   75.42 |    62.15 |   80.52 |   75.42 |                   
-----------|---------|----------|---------|---------|-------------------
-`;
-const PYTEST_OUTPUT = `
-Name                      Stmts   Miss  Cover
----------------------------------------------
-muonroi/__init__.py           0      0   100%
-muonroi/cli.py               42      8    81%
----------------------------------------------
-TOTAL                        42      8    81%
-`;
-describe("Coverage Parsers", () => {
-    it("should parse bun coverage", () => {
-        expect(parseBunCoverage(BUN_OUTPUT)).toBe(0.855);
-    });
-    it("should parse vitest coverage", () => {
-        expect(parseVitestCoverage(VITEST_OUTPUT)).toBe(0.9231);
-    });
-    it("should parse jest coverage", () => {
-        expect(parseJestCoverage(JEST_OUTPUT)).toBe(0.7542);
-    });
-    it("should parse pytest coverage", () => {
-        expect(parsePytestCoverage(PYTEST_OUTPUT)).toBe(0.81);
-    });
-    it("should return null on parse miss", () => {
-        expect(parseBunCoverage("No coverage info here")).toBeNull();
-        expect(parsePytestCoverage("No coverage info here")).toBeNull();
-    });
-    describe("extractCoverageFromOutput", () => {
-        it("should dispatch correctly by ecosystem", () => {
-            expect(extractCoverageFromOutput(BUN_OUTPUT, "bun")).toBe(0.855);
-            expect(extractCoverageFromOutput(VITEST_OUTPUT, "vitest")).toBe(0.9231);
-            expect(extractCoverageFromOutput(JEST_OUTPUT, "jest")).toBe(0.7542);
-            expect(extractCoverageFromOutput(PYTEST_OUTPUT, "python")).toBe(0.81);
-        });
-        it("should handle case insensitivity", () => {
-            expect(extractCoverageFromOutput(BUN_OUTPUT, "BUN")).toBe(0.855);
-        });
-        it("should fall back to Istanbul-style for unknown ecosystems", () => {
-            expect(extractCoverageFromOutput(VITEST_OUTPUT, "unknown")).toBe(0.9231);
-        });
-    });
-});
-//# sourceMappingURL=coverage-parsers.test.js.map

package/dist/src/verify/__tests__/dotnet-recipe.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Tests for the .NET recipe detector.
- *
- * Why this exists: before this detector existed, `inferFallbackRecipe()` had
- * no awareness of .csproj/.sln/Directory.Build.props markers, so a scaffolded
- * .NET project (Muonroi.BaseTemplate, etc.) would fall through to the generic
- * "unknown" recipe with `coverage: null` — tripping CB-3 (`no_recipe`) and
- * halting the sprint with `reason=no_recipe`. The detector fixes that.
- */
-export {};

package/dist/src/verify/__tests__/dotnet-recipe.test.js

@@ -1,70 +0,0 @@
-/**
- * Tests for the .NET recipe detector.
- *
- * Why this exists: before this detector existed, `inferFallbackRecipe()` had
- * no awareness of .csproj/.sln/Directory.Build.props markers, so a scaffolded
- * .NET project (Muonroi.BaseTemplate, etc.) would fall through to the generic
- * "unknown" recipe with `coverage: null` — tripping CB-3 (`no_recipe`) and
- * halting the sprint with `reason=no_recipe`. The detector fixes that.
- */
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { inferVerifyProjectProfile } from "../recipes.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(".NET recipe detection", () => {
-    it("detects a root-level .sln solution and emits dotnet restore/build/test", () => {
-        const cwd = makeTempDir("muonroi-dotnet-sln-");
-        fs.writeFileSync(path.join(cwd, "MyApp.sln"), "Microsoft Visual Studio Solution File, Format Version 12.00\n");
-        const profile = inferVerifyProjectProfile(cwd);
-        expect(profile.recipe.ecosystem).toBe("dotnet");
-        expect(profile.recipe.appKind).toBe("dotnet");
-        expect(profile.recipe.appLabel).toBe(".NET project");
-        expect(profile.recipe.installCommands).toEqual(['dotnet restore "MyApp.sln"']);
-        expect(profile.recipe.buildCommands).toEqual(['dotnet build "MyApp.sln" --no-restore']);
-        expect(profile.recipe.testCommands).toEqual(['dotnet test "MyApp.sln" --no-build --nologo']);
-        expect(profile.recipe.evidence.some((line) => line.includes("MyApp.sln"))).toBe(true);
-    });
-    it("detects a single .csproj when no .sln is present", () => {
-        const cwd = makeTempDir("muonroi-dotnet-csproj-");
-        fs.mkdirSync(path.join(cwd, "src"));
-        fs.writeFileSync(path.join(cwd, "src", "Worker.csproj"), '<Project Sdk="Microsoft.NET.Sdk"/>\n');
-        const profile = inferVerifyProjectProfile(cwd);
-        expect(profile.recipe.ecosystem).toBe("dotnet");
-        expect(profile.recipe.installCommands[0]).toContain("dotnet restore");
-        expect(profile.recipe.installCommands[0]).toContain("Worker.csproj");
-    });
-    it("labels the project as Muonroi BB when Directory.Build.props is present", () => {
-        const cwd = makeTempDir("muonroi-dotnet-bb-");
-        fs.writeFileSync(path.join(cwd, "Muonroi.App.sln"), "Microsoft Visual Studio Solution File\n");
-        fs.writeFileSync(path.join(cwd, "Directory.Build.props"), "<Project/>\n");
-        const profile = inferVerifyProjectProfile(cwd);
-        expect(profile.recipe.appLabel).toBe(".NET (Muonroi BB)");
-        expect(profile.recipe.evidence.some((line) => line.includes("Directory.Build.props"))).toBe(true);
-        expect(profile.recipe.notes.some((line) => line.toLowerCase().includes("modular-boundaries"))).toBe(true);
-    });
-    it("falls through to unknown when no .NET markers exist (regression guard)", () => {
-        const cwd = makeTempDir("muonroi-dotnet-empty-");
-        const profile = inferVerifyProjectProfile(cwd);
-        expect(profile.recipe.ecosystem).toBe("unknown");
-    });
-    it("prefers package.json (Node) over .NET when both exist (priority order preserved)", () => {
-        const cwd = makeTempDir("muonroi-dotnet-mixed-");
-        fs.writeFileSync(path.join(cwd, "package.json"), JSON.stringify({ name: "x", scripts: { test: "jest" } }));
-        fs.writeFileSync(path.join(cwd, "MyApp.sln"), "Solution\n");
-        const profile = inferVerifyProjectProfile(cwd);
-        expect(profile.recipe.ecosystem).toBe("node");
-    });
-});
-//# sourceMappingURL=dotnet-recipe.test.js.map

package/dist/src/verify/checkpoint.test.d.ts

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

package/dist/src/verify/checkpoint.test.js

@@ -1,160 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-vi.mock("child_process", () => {
-    const actual = require("child_process");
-    return {
-        ...actual,
-        execFile: vi.fn(),
-        spawn: vi.fn(() => {
-            const { EventEmitter } = require("events");
-            const { Readable } = require("stream");
-            const child = new EventEmitter();
-            child.stdout = new Readable({
-                read() {
-                    this.push(null);
-                },
-            });
-            child.stderr = new Readable({
-                read() {
-                    this.push(null);
-                },
-            });
-            setTimeout(() => child.emit("close", 0), 0);
-            return child;
-        }),
-    };
-});
-import { execFile, spawn } from "child_process";
-import { ensureVerifyCheckpoint, getVerifyCheckpointName } from "./checkpoint.js";
-import { inferVerifyProjectProfile } from "./entrypoint.js";
-const execFileMock = vi.mocked(execFile);
-const spawnMock = vi.mocked(spawn);
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-afterEach(() => {
-    execFileMock.mockReset();
-    spawnMock.mockReset();
-    spawnMock.mockImplementation(() => {
-        const { EventEmitter } = require("events");
-        const { Readable } = require("stream");
-        const child = new EventEmitter();
-        child.stdout = new Readable({
-            read() {
-                this.push(null);
-            },
-        });
-        child.stderr = new Readable({
-            read() {
-                this.push(null);
-            },
-        });
-        setTimeout(() => child.emit("close", 0), 0);
-        return child;
-    });
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-});
-describe("verify checkpoints", () => {
-    it("skips checkpoint creation when no install commands are needed", async () => {
-        const dir = makeTempDir("muonroi-verify-ckpt-go-");
-        fs.writeFileSync(path.join(dir, "go.mod"), "module example.com/demo\n");
-        const profile = inferVerifyProjectProfile(dir);
-        const result = await ensureVerifyCheckpoint(dir, profile, profile.sandboxSettings);
-        expect(result).toEqual({ created: false });
-        expect(execFileMock).not.toHaveBeenCalled();
-    });
-    it("creates a deterministic checkpoint for install-based recipes", async () => {
-        const dir = makeTempDir("muonroi-verify-ckpt-node-");
-        fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ dependencies: { next: "15.0.0" }, scripts: { dev: "next dev" } }, null, 2));
-        fs.writeFileSync(path.join(dir, "package-lock.json"), "");
-        execFileMock.mockImplementation((_command, args, _options, callback) => {
-            const cb = callback;
-            if (Array.isArray(args) && args[0] === "checkpoint" && args[1] === "list") {
-                cb(null, "", "");
-                return {};
-            }
-            cb(null, "", "");
-            return {};
-        });
-        const profile = inferVerifyProjectProfile(dir);
-        const result = await ensureVerifyCheckpoint(dir, profile, profile.sandboxSettings);
-        expect(result.created).toBe(true);
-        expect(result.checkpointName).toMatch(/^verify-nextjs-/);
-        expect(result.guestWorkdir).toBe("/muonroi/verify/worktree");
-        expect(execFileMock).toHaveBeenCalledTimes(1);
-        expect(spawnMock).toHaveBeenCalledTimes(1);
-        const spawnArgs = spawnMock.mock.calls[0];
-        expect(spawnArgs[0]).toBe("shuru");
-        const createArgs = spawnArgs[1];
-        expect(createArgs.slice(0, 3)).toEqual(["checkpoint", "create", result.checkpointName]);
-        expect(createArgs.join(" ")).toContain("export DEBIAN_FRONTEND=noninteractive");
-    });
-    it("reuses an existing checkpoint when present", async () => {
-        const dir = makeTempDir("muonroi-verify-ckpt-existing-");
-        fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ dependencies: { next: "15.0.0" }, scripts: { dev: "next dev" } }, null, 2));
-        fs.writeFileSync(path.join(dir, "package-lock.json"), "");
-        const profile = inferVerifyProjectProfile(dir);
-        const checkpointName = getVerifyCheckpointName(dir, profile.recipe);
-        execFileMock.mockImplementation((_command, args, _options, callback) => {
-            const cb = callback;
-            if (Array.isArray(args) && args[0] === "checkpoint" && args[1] === "list") {
-                cb(null, `${checkpointName}\n`, "");
-                return {};
-            }
-            cb(null, "", "");
-            return {};
-        });
-        const result = await ensureVerifyCheckpoint(dir, profile, profile.sandboxSettings);
-        expect(result.created).toBe(false);
-        expect(execFileMock).toHaveBeenCalledTimes(1);
-    });
-    it("deletes a failed checkpoint when bootstrap/install fails", async () => {
-        const dir = makeTempDir("muonroi-verify-ckpt-fail-");
-        fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ dependencies: { next: "15.0.0" } }, null, 2));
-        fs.writeFileSync(path.join(dir, "bun.lock"), "");
-        const profile = inferVerifyProjectProfile(dir);
-        const checkpointName = getVerifyCheckpointName(dir, profile.recipe);
-        execFileMock.mockImplementation((_command, args, _options, callback) => {
-            const cb = callback;
-            if (Array.isArray(args) && args[0] === "checkpoint" && args[1] === "list") {
-                cb(null, "", "");
-                return {};
-            }
-            if (Array.isArray(args) && args[0] === "checkpoint" && args[1] === "delete") {
-                cb(null, "", "");
-                return {};
-            }
-            cb(null, "", "");
-            return {};
-        });
-        spawnMock.mockImplementation(() => {
-            const { EventEmitter } = require("events");
-            const { Readable } = require("stream");
-            const child = new EventEmitter();
-            child.stdout = new Readable({
-                read() {
-                    this.push(null);
-                },
-            });
-            child.stderr = new Readable({
-                read() {
-                    this.push("bun: not found\n");
-                    this.push(null);
-                },
-            });
-            setTimeout(() => child.emit("close", 1), 0);
-            return child;
-        });
-        await expect(ensureVerifyCheckpoint(dir, profile, profile.sandboxSettings)).rejects.toThrow(`Verify checkpoint bootstrap failed for "${checkpointName}"`);
-        expect(execFileMock).toHaveBeenCalledTimes(2);
-        expect(execFileMock.mock.calls[1]?.[1]).toEqual(["checkpoint", "delete", checkpointName]);
-    });
-});
-//# sourceMappingURL=checkpoint.test.js.map

package/dist/src/verify/entrypoint.test.d.ts

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