muonroi-cli 1.8.1 → 1.8.4

package/dist/src/orchestrator/pending-calls.test.js

@@ -1,188 +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 { createPendingCallsLog, stableCallId } from "./pending-calls.js";
-// ── helpers ──────────────────────────────────────────────────────────────────
-async function makeTmpDir() {
-    const base = path.join(os.tmpdir(), `pending-calls-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    await fs.mkdir(base, { recursive: true });
-    return base;
-}
-async function readJSONL(filePath) {
-    try {
-        const raw = await fs.readFile(filePath, "utf8");
-        return raw
-            .split("\n")
-            .filter(Boolean)
-            .map((line) => JSON.parse(line));
-    }
-    catch {
-        return [];
-    }
-}
-// ── Tests ─────────────────────────────────────────────────────────────────────
-let tmpBase;
-let sessionCounter = 0;
-function nextSessionId() {
-    return `test-session-${++sessionCounter}-${Date.now()}`;
-}
-beforeEach(async () => {
-    tmpBase = await makeTmpDir();
-    // Override home dir for getSessionDir so it writes into our temp dir
-    process.env.MUONROI_CLI_HOME = tmpBase;
-});
-afterEach(async () => {
-    delete process.env.MUONROI_CLI_HOME;
-    await fs.rm(tmpBase, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 }).catch(() => {
-        /* best-effort cleanup */
-    });
-});
-describe("stableCallId", () => {
-    it("Test 3: same inputs → same id (determinism)", () => {
-        const id1 = stableCallId("turn-1", "Bash", { command: "ls" });
-        const id2 = stableCallId("turn-1", "Bash", { command: "ls" });
-        expect(id1).toBe(id2);
-    });
-    it("Test 3: different inputs → different ids", () => {
-        const a = stableCallId("turn-1", "Bash", { command: "ls" });
-        const b = stableCallId("turn-1", "Bash", { command: "pwd" });
-        const c = stableCallId("turn-2", "Bash", { command: "ls" });
-        const d = stableCallId("turn-1", "Edit", { command: "ls" });
-        expect(a).not.toBe(b);
-        expect(a).not.toBe(c);
-        expect(a).not.toBe(d);
-    });
-});
-describe("PendingCallsLog", () => {
-    it("Test 4: begin → end produces two JSONL lines with consistent state", async () => {
-        const sid = nextSessionId();
-        const log = createPendingCallsLog(sid);
-        await log.begin({ call_id: "c1", tool_name: "Bash" });
-        await log.end("c1", "settled");
-        const sessionDir = path.join(tmpBase, "sessions", sid);
-        const lines = await readJSONL(path.join(sessionDir, "pending_calls.jsonl"));
-        expect(lines).toHaveLength(2);
-        const begin = lines[0];
-        const end = lines[1];
-        expect(begin.event).toBe("begin");
-        expect(begin.call_id).toBe("c1");
-        expect(begin.tool_name).toBe("Bash");
-        expect(begin.status).toBe("pending");
-        expect(typeof begin.started_ms).toBe("number");
-        expect(end.event).toBe("end");
-        expect(end.call_id).toBe("c1");
-        expect(end.status).toBe("settled");
-        expect(typeof end.ended_ms).toBe("number");
-    });
-    it("Test 5: reconcile marks abandoned entries from prior process", async () => {
-        const sid = nextSessionId();
-        const sessionDir = path.join(tmpBase, "sessions", sid);
-        await fs.mkdir(sessionDir, { recursive: true });
-        // Seed a stale "pending" begin event
-        const staleEntry = JSON.stringify({
-            event: "begin",
-            call_id: "stale-1",
-            tool_name: "Edit",
-            started_ms: Date.now() - 60_000,
-            status: "pending",
-        });
-        await fs.writeFile(path.join(sessionDir, "pending_calls.jsonl"), `${staleEntry}\n`, "utf8");
-        const log = createPendingCallsLog(sid);
-        const result = await log.reconcile();
-        expect(result.abandoned).toBe(1);
-        expect(result.settled).toBe(0);
-        // Final line must have status=abandoned
-        const lines = await readJSONL(path.join(sessionDir, "pending_calls.jsonl"));
-        const last = lines[lines.length - 1];
-        expect(last.status).toBe("abandoned");
-    });
-    it("Test 6: reconcile unlinks .tmp staged_path when final file does NOT exist (rollback)", async () => {
-        const sid = nextSessionId();
-        const sessionDir = path.join(tmpBase, "sessions", sid);
-        await fs.mkdir(sessionDir, { recursive: true });
-        const tmpFile = path.join(sessionDir, "output.txt.tmp");
-        await fs.writeFile(tmpFile, "partial content", "utf8");
-        // final (output.txt) does NOT exist → rollback: unlink .tmp
-        const staleEntry = JSON.stringify({
-            event: "begin",
-            call_id: "stale-2",
-            tool_name: "Edit",
-            started_ms: Date.now() - 60_000,
-            status: "pending",
-            staged_paths: [tmpFile],
-        });
-        await fs.writeFile(path.join(sessionDir, "pending_calls.jsonl"), `${staleEntry}\n`, "utf8");
-        const log = createPendingCallsLog(sid);
-        await log.reconcile();
-        // .tmp must have been unlinked (rolled back)
-        await expect(fs.access(tmpFile)).rejects.toThrow();
-    });
-    it("Test 7: reconcile unlinks orphan .tmp when BOTH .tmp and final exist (post-crash cleanup)", async () => {
-        const sid = nextSessionId();
-        const sessionDir = path.join(tmpBase, "sessions", sid);
-        await fs.mkdir(sessionDir, { recursive: true });
-        const tmpFile = path.join(sessionDir, "output.txt.tmp");
-        const finalFile = path.join(sessionDir, "output.txt");
-        await fs.writeFile(tmpFile, "orphan", "utf8");
-        await fs.writeFile(finalFile, "committed", "utf8");
-        const staleEntry = JSON.stringify({
-            event: "begin",
-            call_id: "stale-3",
-            tool_name: "Edit",
-            started_ms: Date.now() - 60_000,
-            status: "pending",
-            staged_paths: [tmpFile],
-        });
-        await fs.writeFile(path.join(sessionDir, "pending_calls.jsonl"), `${staleEntry}\n`, "utf8");
-        const log = createPendingCallsLog(sid);
-        await log.reconcile();
-        // orphan .tmp must be unlinked; final file must remain intact
-        await expect(fs.access(tmpFile)).rejects.toThrow();
-        await expect(fs.access(finalFile)).resolves.toBeUndefined();
-    });
-    it("Test 8: concurrent begin() calls do not corrupt the JSONL", async () => {
-        const sid = nextSessionId();
-        const log = createPendingCallsLog(sid);
-        // Fire 10 concurrent begin() calls
-        const N = 10;
-        await Promise.all(Array.from({ length: N }, (_, i) => log.begin({ call_id: `c-${i}`, tool_name: "Bash" })));
-        const sessionDir = path.join(tmpBase, "sessions", sid);
-        const lines = await readJSONL(path.join(sessionDir, "pending_calls.jsonl"));
-        // All N entries must be present and each line must be valid JSON
-        expect(lines).toHaveLength(N);
-        const callIds = lines.map((l) => l.call_id);
-        for (let i = 0; i < N; i++) {
-            expect(callIds).toContain(`c-${i}`);
-        }
-    });
-});
-describe("getSessionDir (B-3)", () => {
-    it("Test 9: returns path under .muonroi-cli/sessions/<id> and creates the directory", async () => {
-        const { getSessionDir } = await import("../storage/session-dir.js");
-        const sid = `test-b3-${Date.now()}`;
-        const dir = await getSessionDir(sid, tmpBase);
-        expect(dir).toContain("sessions");
-        expect(dir).toContain(sid);
-        // Directory must exist after the call
-        const stat = await fs.stat(dir);
-        expect(stat.isDirectory()).toBe(true);
-        // Calling twice is idempotent (no throw)
-        const dir2 = await getSessionDir(sid, tmpBase);
-        expect(dir2).toBe(dir);
-    });
-    it("Test 10: createPendingCallsLog uses getSessionDir (writes to sibling dir, not SQLite)", async () => {
-        const sid = nextSessionId();
-        const log = createPendingCallsLog(sid);
-        await log.begin({ call_id: "b3-test", tool_name: "Bash" });
-        const sessionDir = path.join(tmpBase, "sessions", sid);
-        const jsonl = path.join(sessionDir, "pending_calls.jsonl");
-        const stat = await fs.stat(jsonl);
-        expect(stat.isFile()).toBe(true);
-        // Must NOT import or reference bun:sqlite — verified by source inspection in Task 1 verify.
-        // Here we verify the side-effect: the JSONL is written and SQLite db is NOT touched.
-        const lines = await readJSONL(jsonl);
-        expect(lines.length).toBeGreaterThan(0);
-    });
-});
-//# sourceMappingURL=pending-calls.test.js.map

package/dist/src/orchestrator/provider-options-shape.spec.d.ts

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

package/dist/src/orchestrator/provider-options-shape.spec.js

@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractProviderOptionsShape } from "./provider-options-shape.js";
-describe("extractProviderOptionsShape", () => {
-    it("returns null for undefined/null/empty input", () => {
-        expect(extractProviderOptionsShape(undefined)).toBeNull();
-        expect(extractProviderOptionsShape(null)).toBeNull();
-        expect(extractProviderOptionsShape({})).toBeNull();
-        expect(extractProviderOptionsShape([])).toBeNull();
-        // Non-object primitives also return null (defensive).
-        expect(extractProviderOptionsShape("abc")).toBeNull();
-        expect(extractProviderOptionsShape(42)).toBeNull();
-    });
-    it("replaces flat-object leaves with typeof strings (no values leaked)", () => {
-        const shape = extractProviderOptionsShape({
-            openai: { store: true, promptCacheKey: "abc-secret-xyz" },
-        });
-        expect(shape).not.toBeNull();
-        const parsed = JSON.parse(shape);
-        expect(parsed).toEqual({
-            openai: { store: "boolean", promptCacheKey: "string" },
-        });
-        // Hard guarantee: the actual key value is never in the output.
-        expect(shape).not.toContain("abc-secret-xyz");
-    });
-    it("recurses into nested objects (depth 2)", () => {
-        const shape = extractProviderOptionsShape({
-            anthropic: {
-                thinking: {
-                    type: "enabled",
-                    budgetTokens: 8192,
-                },
-            },
-        });
-        expect(JSON.parse(shape)).toEqual({
-            anthropic: {
-                thinking: {
-                    type: "string",
-                    budgetTokens: "number",
-                },
-            },
-        });
-    });
-    it("caps recursion at depth 4 to avoid runaway/circular structures", () => {
-        // Build a 6-deep nested object: a.b.c.d.e.f = "leaf"
-        const deep = { a: { b: { c: { d: { e: { f: "leaf" } } } } } };
-        const shape = extractProviderOptionsShape(deep);
-        const parsed = JSON.parse(shape);
-        // Depths 0..3 are walked (a, b, c, d) — at depth 4 we truncate.
-        // The element at the 4-deep position should be the truncated marker.
-        expect(parsed.a.b.c.d).toBe("<max-depth>");
-        // And no actual leaf value survives.
-        expect(shape).not.toContain("leaf");
-    });
-    it("preserves arrays and recurses into their elements", () => {
-        const shape = extractProviderOptionsShape({
-            xai: { stopSequences: ["foo", "bar"], topLogprobs: 3 },
-        });
-        expect(JSON.parse(shape)).toEqual({
-            xai: { stopSequences: ["string", "string"], topLogprobs: "number" },
-        });
-    });
-});
-//# sourceMappingURL=provider-options-shape.spec.js.map

package/dist/src/orchestrator/reasoning.test.d.ts

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

package/dist/src/orchestrator/reasoning.test.js

@@ -1,101 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { containsEncryptedReasoning, sanitizeModelMessages } from "./reasoning.js";
-describe("reasoning helpers", () => {
-    it("detects encrypted reasoning markers", () => {
-        expect(containsEncryptedReasoning("-----BEGIN PGP MESSAGE-----\nabc")).toBe(true);
-        expect(containsEncryptedReasoning("normal reasoning text")).toBe(false);
-    });
-    it("removes encrypted reasoning from assistant messages", () => {
-        const messages = [
-            {
-                role: "assistant",
-                content: [
-                    { type: "reasoning", text: "-----BEGIN PGP MESSAGE-----\nabc" },
-                    { type: "text", text: "Final answer" },
-                ],
-            },
-        ];
-        expect(sanitizeModelMessages(messages)).toEqual([
-            {
-                role: "assistant",
-                content: [{ type: "text", text: "Final answer" }],
-            },
-        ]);
-    });
-    // Session 7dcf8fd7d6a4 regression: 57/100 assistant messages contained
-    // inter-tool narration like "Let me check..." → "Now let me look at...". The
-    // PIL L6 text-based ban is ignored by budget models, so strip structurally.
-    describe("inter-tool narration stripping", () => {
-        it("drops 'Let me X' text when followed by a tool-call in the same message", () => {
-            const messages = [
-                {
-                    role: "assistant",
-                    content: [
-                        { type: "text", text: "Let me check the current GitHub Actions status." },
-                        { type: "tool-call", toolCallId: "c1", toolName: "bash", input: { command: "gh run list" } },
-                    ],
-                },
-            ];
-            const result = sanitizeModelMessages(messages);
-            expect(result[0]?.content).toEqual([
-                { type: "tool-call", toolCallId: "c1", toolName: "bash", input: { command: "gh run list" } },
-            ]);
-        });
-        it("drops Vietnamese narration 'Tiếp theo tôi sẽ...' before tool-call", () => {
-            const messages = [
-                {
-                    role: "assistant",
-                    content: [
-                        { type: "text", text: "Tiếp theo tôi sẽ kiểm tra log." },
-                        { type: "tool-call", toolCallId: "c2", toolName: "read_file", input: { path: "x" } },
-                    ],
-                },
-            ];
-            const result = sanitizeModelMessages(messages);
-            expect((result[0]?.content).length).toBe(1);
-        });
-        it("KEEPS final-answer text when there is no tool-call in the same message", () => {
-            const messages = [
-                {
-                    role: "assistant",
-                    content: [{ type: "text", text: "Let me explain — actually this IS my final answer." }],
-                },
-            ];
-            const result = sanitizeModelMessages(messages);
-            expect(result).toEqual(messages); // unchanged
-        });
-        it("KEEPS non-narration text even when followed by a tool-call", () => {
-            // E.g. agent quoted a finding before drilling deeper. We don't want to
-            // strip substantive commentary — only the narration boilerplate.
-            const messages = [
-                {
-                    role: "assistant",
-                    content: [
-                        { type: "text", text: "Failure is in cost-leak-b3-tui.spec.ts line 47." },
-                        { type: "tool-call", toolCallId: "c3", toolName: "read_file", input: { path: "spec" } },
-                    ],
-                },
-            ];
-            const result = sanitizeModelMessages(messages);
-            expect(result).toEqual(messages); // text was substantive, kept
-        });
-        it("strips multiple narration text parts but keeps tool-calls intact", () => {
-            const messages = [
-                {
-                    role: "assistant",
-                    content: [
-                        { type: "text", text: "Let me check the status." },
-                        { type: "tool-call", toolCallId: "c4", toolName: "bash", input: { command: "ls" } },
-                        { type: "text", text: "Now let me read the file." },
-                        { type: "tool-call", toolCallId: "c5", toolName: "read_file", input: { path: "x" } },
-                    ],
-                },
-            ];
-            const result = sanitizeModelMessages(messages);
-            const content = result[0]?.content;
-            expect(content.every((p) => p.type === "tool-call")).toBe(true);
-            expect(content.length).toBe(2);
-        });
-    });
-});
-//# sourceMappingURL=reasoning.test.js.map

package/dist/src/orchestrator/repetition-detector.test.d.ts

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

package/dist/src/orchestrator/repetition-detector.test.js

@@ -1,103 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { _internals, _resetForTests, buildRepetitionReminder, extractLeadingPhrase, recordAssistantBurst, shouldInjectRepetitionReminder, } from "./repetition-detector.js";
-describe("extractLeadingPhrase", () => {
-    it("returns lowercased first N words stripped of punctuation", () => {
-        expect(extractLeadingPhrase("YES still on scope. Commit pushed.")).toBe("yes still on scope");
-    });
-    it("returns null when fewer than N words", () => {
-        expect(extractLeadingPhrase("hi there")).toBeNull();
-        expect(extractLeadingPhrase("")).toBeNull();
-        expect(extractLeadingPhrase(null)).toBeNull();
-        expect(extractLeadingPhrase(undefined)).toBeNull();
-    });
-    it("strips code fences before counting words", () => {
-        const text = "```ts\nconst x = 1;\nconst y = 2;\nconst z = 3;\n```\nYES still on scope here we go";
-        expect(extractLeadingPhrase(text)).toBe("yes still on scope");
-    });
-    it("handles Vietnamese accents", () => {
-        expect(extractLeadingPhrase("Tiếp tục theo dõi CI rồi")).toBe("tiếp tục theo dõi");
-    });
-});
-describe("recordAssistantBurst + shouldInjectRepetitionReminder", () => {
-    beforeEach(() => _resetForTests());
-    afterEach(() => _resetForTests());
-    it("counts consecutive bursts that share the same opening phrase", () => {
-        expect(recordAssistantBurst("s1", "YES still on scope. Doing X.")).toBe(1);
-        expect(recordAssistantBurst("s1", "YES still on scope. Doing Y.")).toBe(2);
-        expect(recordAssistantBurst("s1", "YES still on scope. Doing Z.")).toBe(3);
-    });
-    it("resets the run when the opening phrase changes", () => {
-        recordAssistantBurst("s1", "YES still on scope. A");
-        recordAssistantBurst("s1", "YES still on scope. B");
-        expect(recordAssistantBurst("s1", "Switching approach now to a totally different plan")).toBe(1);
-    });
-    it("preserves the run when an interleaved burst has no phrase (tool-only step)", () => {
-        recordAssistantBurst("s1", "YES still on scope. First call");
-        recordAssistantBurst("s1", "YES still on scope. Second call");
-        // Non-text burst — counter should not reset.
-        expect(recordAssistantBurst("s1", "")).toBe(2);
-        expect(recordAssistantBurst("s1", "YES still on scope. Third call")).toBe(3);
-    });
-    it("isolates state per session", () => {
-        recordAssistantBurst("a", "YES still on scope. one");
-        recordAssistantBurst("a", "YES still on scope. two");
-        recordAssistantBurst("b", "Totally different opening phrase here");
-        expect(recordAssistantBurst("a", "YES still on scope. three")).toBe(3);
-        expect(recordAssistantBurst("b", "Totally different opening phrase here")).toBe(2);
-    });
-    it("returns 1 for null/empty sessionId", () => {
-        expect(recordAssistantBurst(null, "YES still on scope. x")).toBe(1);
-        expect(recordAssistantBurst("", "YES still on scope. x")).toBe(1);
-        expect(recordAssistantBurst(undefined, "YES still on scope. x")).toBe(1);
-    });
-    it("trigger fires once at runLength >= TRIGGER_RUN_LENGTH", () => {
-        recordAssistantBurst("s1", "YES still on scope. one");
-        recordAssistantBurst("s1", "YES still on scope. two");
-        expect(shouldInjectRepetitionReminder("s1")).toBe(false);
-        recordAssistantBurst("s1", "YES still on scope. three");
-        expect(shouldInjectRepetitionReminder("s1")).toBe(true);
-    });
-    it("trigger does not re-fire while the run continues", () => {
-        recordAssistantBurst("s1", "YES still on scope. one");
-        recordAssistantBurst("s1", "YES still on scope. two");
-        recordAssistantBurst("s1", "YES still on scope. three");
-        expect(shouldInjectRepetitionReminder("s1")).toBe(true);
-        recordAssistantBurst("s1", "YES still on scope. four");
-        expect(shouldInjectRepetitionReminder("s1")).toBe(false);
-        recordAssistantBurst("s1", "YES still on scope. five");
-        expect(shouldInjectRepetitionReminder("s1")).toBe(false);
-    });
-    it("trigger re-arms when a new run begins", () => {
-        recordAssistantBurst("s1", "YES still on scope. one");
-        recordAssistantBurst("s1", "YES still on scope. two");
-        recordAssistantBurst("s1", "YES still on scope. three");
-        shouldInjectRepetitionReminder("s1"); // mark fired
-        // New phrase — counter resets, fire flag clears.
-        recordAssistantBurst("s1", "Switching approach now to a totally different plan");
-        recordAssistantBurst("s1", "Switching approach now to step two");
-        recordAssistantBurst("s1", "Switching approach now to step three");
-        expect(shouldInjectRepetitionReminder("s1")).toBe(true);
-    });
-    it("trigger no-op for unknown / null session", () => {
-        expect(shouldInjectRepetitionReminder(null)).toBe(false);
-        expect(shouldInjectRepetitionReminder("never-recorded")).toBe(false);
-    });
-});
-describe("buildRepetitionReminder", () => {
-    beforeEach(() => _resetForTests());
-    afterEach(() => _resetForTests());
-    it("includes the perseveration phrase and runLength", () => {
-        recordAssistantBurst("s1", "YES still on scope. one");
-        recordAssistantBurst("s1", "YES still on scope. two");
-        recordAssistantBurst("s1", "YES still on scope. three");
-        const msg = buildRepetitionReminder("s1");
-        expect(msg).toContain("self-repetition detected");
-        expect(msg).toContain("yes still on scope");
-        expect(msg).toContain("3");
-    });
-    it("constants are stable for callers", () => {
-        expect(_internals.PHRASE_WORD_COUNT).toBe(4);
-        expect(_internals.TRIGGER_RUN_LENGTH).toBe(3);
-    });
-});
-//# sourceMappingURL=repetition-detector.test.js.map

package/dist/src/orchestrator/sandbox.test.d.ts

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

package/dist/src/orchestrator/sandbox.test.js

@@ -1,99 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-async function importAgentModule() {
-    vi.resetModules();
-    const { loadCatalog } = await import("../models/registry.js");
-    await loadCatalog();
-    vi.doMock("../storage/index", () => ({
-        appendCompaction: vi.fn(),
-        appendMessages: vi.fn(() => []),
-        appendSystemMessage: vi.fn(() => 0),
-        buildChatEntries: vi.fn(() => []),
-        getNextMessageSequence: vi.fn(() => 0),
-        getSessionTotalTokens: vi.fn(() => 0),
-        loadTranscript: vi.fn(() => []),
-        loadTranscriptState: vi.fn(() => ({ messages: [], seqs: [] })),
-        recordUsageEvent: vi.fn(),
-        SessionStore: class {
-            getWorkspace() {
-                return null;
-            }
-            openSession() {
-                return null;
-            }
-            createSession() {
-                return null;
-            }
-            setModel() { }
-            getRequiredSession() {
-                return null;
-            }
-            setMode() { }
-            touchSession() { }
-        },
-    }));
-    return import("./orchestrator.js");
-}
-afterEach(() => {
-    vi.restoreAllMocks();
-    vi.resetModules();
-    vi.doUnmock("../storage/index.js");
-});
-describe("Agent sandbox mode", { timeout: 30_000 }, () => {
-    it("can switch sandbox mode at runtime — always 'off' (sandbox removed)", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-            sandboxMode: "off",
-        });
-        expect(agent.getSandboxMode()).toBe("off");
-        // Sandbox has been removed: setSandboxMode is a no-op stub.
-        // The mode remains "off" regardless of what is passed.
-        agent.setSandboxMode("shuru");
-        expect(agent.getSandboxMode()).toBe("off");
-    });
-    it("passes sandbox mode into background delegations — always 'off' (sandbox removed)", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-            sandboxMode: "shuru", // accepted for back-compat but ignored
-        });
-        const startMock = vi.fn(async () => ({ success: true, output: "ok" }));
-        agent.delegations.start = startMock;
-        await agent.runDelegation({
-            agent: "explore",
-            description: "Inspect",
-            prompt: "Look around",
-        });
-        // Sandbox removed: delegations always receive sandboxMode: "off".
-        expect(startMock).toHaveBeenCalledWith(expect.objectContaining({ agent: "explore" }), expect.objectContaining({ sandboxMode: "off" }));
-    });
-    it("can get and set sandbox settings", async () => {
-        const { Agent } = await importAgentModule();
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-            sandboxMode: "shuru",
-            sandboxSettings: { allowNet: true, cpus: 4 },
-        });
-        expect(agent.getSandboxSettings()).toEqual({ allowNet: true, cpus: 4 });
-        agent.setSandboxSettings({ allowNet: false, memory: 2048 });
-        expect(agent.getSandboxSettings()).toEqual({ allowNet: false, memory: 2048 });
-    });
-    it("passes sandbox settings into background delegations", async () => {
-        const { Agent } = await importAgentModule();
-        const settings = { allowNet: true, allowedHosts: ["api.openai.com"] };
-        const agent = new Agent(undefined, undefined, undefined, undefined, {
-            persistSession: false,
-            sandboxMode: "shuru",
-            sandboxSettings: settings,
-        });
-        const startMock = vi.fn(async () => ({ success: true, output: "ok" }));
-        agent.delegations.start = startMock;
-        await agent.runDelegation({
-            agent: "explore",
-            description: "Inspect",
-            prompt: "Look around",
-        });
-        expect(startMock).toHaveBeenCalledWith(expect.objectContaining({ agent: "explore" }), expect.objectContaining({ sandboxSettings: settings }));
-    });
-});
-//# sourceMappingURL=sandbox.test.js.map

package/dist/src/orchestrator/scope-ceiling.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Tests for scope-ceiling module (Plan 04-4B).
- *
- * Covers:
- *  - Matrix lookup for every task_type × size cell (all 7 task_type rows
- *    referenced verbatim per locked CONTEXT)
- *  - Unknown taskType fallback to "general" row
- *  - parseBudgetOverride flag extraction + prompt cleaning
- *  - Session counter persistence + per-session isolation
- *  - Soft-warn step computation
- *  - forcedFinalize delegates to passed-in model factory (no hardcoded IDs)
- */
-export {};