muonroi-cli 1.8.0 → 1.8.3

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

@@ -1,67 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { startStubEEServer } from "../__test-stubs__/ee-server.js";
-import { createEEClient } from "../ee/client.js";
-import { extractSession } from "../ee/extract-session.js";
-import { setDefaultEEClient } from "../ee/intercept.js";
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-function buildTestMessages(userCount) {
-    const msgs = [];
-    for (let i = 0; i < userCount; i++) {
-        msgs.push({ role: "user", content: `Message ${i + 1}` });
-        msgs.push({ role: "assistant", content: `Response ${i + 1}` });
-    }
-    return msgs;
-}
-// ─── Tests ────────────────────────────────────────────────────────────────────
-describe("cleanup -> extractSession -> /api/extract integration", () => {
-    // Stub server started fresh per test via beforeEach / per-test setup
-    // afterAll cleanup is handled within each test using try/finally
-    it("Test 1 (EXTRACT-01): extractSession hits /api/extract on stub server with correct source", async () => {
-        const stub = await startStubEEServer();
-        const client = createEEClient({ baseUrl: `http://127.0.0.1:${stub.port}` });
-        setDefaultEEClient(client);
-        try {
-            // 6 user messages — exceeds 5-message threshold
-            await extractSession(buildTestMessages(6), "/tmp/test-project", "cli-exit", "session-abc");
-            expect(stub.calls.extract.length).toBe(1);
-            expect(stub.calls.extract[0].meta?.source).toBe("cli-exit");
-            expect(stub.calls.extract[0].projectPath).toBe("/tmp/test-project");
-        }
-        finally {
-            setDefaultEEClient(null);
-            await stub.stop();
-        }
-    });
-    it("Test 2 (EXTRACT-03): extractSession completes within 2.5s against 3s-latency stub", async () => {
-        const stub = await startStubEEServer({ latencyMs: 3000 });
-        const client = createEEClient({ baseUrl: `http://127.0.0.1:${stub.port}` });
-        setDefaultEEClient(client);
-        try {
-            const start = Date.now();
-            // Should complete quickly because AbortSignal.timeout(2000) fires
-            await extractSession(buildTestMessages(6), "/tmp/test-project", "cli-exit");
-            const elapsed = Date.now() - start;
-            // AbortSignal(2000ms) fires and error is swallowed — must complete in < 2500ms
-            expect(elapsed).toBeLessThan(2500);
-            // Request was aborted before server responded — no extract calls logged
-            expect(stub.calls.extract.length).toBe(0);
-        }
-        finally {
-            setDefaultEEClient(null);
-            await stub.stop();
-        }
-    });
-    it("Test 3 (D-05): extractSession resolves without throwing when EE server is unreachable", async () => {
-        // Point at port 1 — nothing listening there
-        const client = createEEClient({ baseUrl: "http://127.0.0.1:1" });
-        setDefaultEEClient(client);
-        try {
-            // Must resolve (not throw) even when server is unreachable
-            await expect(extractSession(buildTestMessages(6), "/tmp/test-project", "cli-exit")).resolves.toBeUndefined();
-        }
-        finally {
-            setDefaultEEClient(null);
-        }
-    });
-});
-//# sourceMappingURL=cleanup.test.js.map

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

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

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

@@ -1,187 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { buildEffectiveTranscript } from "../storage/transcript-view.js";
-import { COMPACTION_META_MAX_OUTPUT_TOKENS, COMPACTION_SUMMARY_HEADER, createCompactionSummaryMessage, findCutPoint, metaCompactionMaxTokens, prepareCompaction, serializeConversation, shouldCompactContext, } from "./compaction.js";
-import { buildCheckpointReminder } from "./scope-reminder.js";
-import { __forceFallbackForTests } from "./token-counter.js";
-// Pin token counts to the chars/4 fallback so cut-point assertions remain stable.
-// The real BPE tokenizer is exercised by token-counter's own tests.
-beforeAll(() => __forceFallbackForTests(true));
-afterAll(() => __forceFallbackForTests(false));
-function user(text) {
-    return { role: "user", content: text };
-}
-function assistantText(text) {
-    return {
-        role: "assistant",
-        content: [{ type: "text", text }],
-    };
-}
-function assistantToolCall(toolCallId, toolName, input = {}) {
-    return {
-        role: "assistant",
-        content: [{ type: "tool-call", toolCallId, toolName, input }],
-    };
-}
-function toolResult(toolCallId, toolName, output) {
-    return {
-        role: "tool",
-        content: [{ type: "tool-result", toolCallId, toolName, output }],
-    };
-}
-describe("compaction helpers", () => {
-    it("triggers when context exceeds reserved headroom", () => {
-        const settings = { reserveTokens: 100, keepRecentTokens: 40 };
-        expect(shouldCompactContext(901, 1000, settings)).toBe(true);
-        expect(shouldCompactContext(900, 1000, settings)).toBe(false);
-    });
-    it("never selects a tool-result message as the cut point", () => {
-        const messages = [
-            user("inspect this file"),
-            assistantToolCall("call-1", "read_file", { path: "src/index.ts" }),
-            toolResult("call-1", "read_file", "x".repeat(400)),
-            assistantText("I found the relevant section."),
-            user("continue"),
-        ];
-        const cutPoint = findCutPoint(messages, 0, 130);
-        expect(cutPoint.firstKeptIndex).not.toBe(2);
-        expect(messages[cutPoint.firstKeptIndex]?.role).not.toBe("tool");
-    });
-    it("detects split turns and captures the turn prefix for summarization", () => {
-        const messages = [
-            user("Refactor the session loader."),
-            assistantText("a".repeat(320)),
-            assistantText("recent status update"),
-        ];
-        const preparation = prepareCompaction(messages, "system prompt", {
-            reserveTokens: 100,
-            keepRecentTokens: 5,
-        });
-        expect(preparation).not.toBeNull();
-        expect(preparation?.isSplitTurn).toBe(true);
-        expect(preparation?.messagesToSummarize).toHaveLength(0);
-        expect(preparation?.turnPrefixMessages).toHaveLength(2);
-        expect(preparation?.keptMessages).toHaveLength(1);
-    });
-    it("excludes the previous summary message from new compaction input", () => {
-        const messages = [
-            createCompactionSummaryMessage("Earlier work"),
-            user("Handle migration edge cases"),
-            assistantText("I added the table and loader changes."),
-            user("Now wire the retry path"),
-        ];
-        const preparation = prepareCompaction(messages, "system prompt", {
-            reserveTokens: 100,
-            keepRecentTokens: 4,
-        });
-        expect(preparation).not.toBeNull();
-        expect(preparation?.previousSummary).toBe("Earlier work");
-        expect(preparation?.messagesToSummarize[0]).toEqual(user("Handle migration edge cases"));
-        expect(preparation?.messagesToSummarize.some((message) => message.role === "system")).toBe(false);
-    });
-    it("serializes tool results with truncation markers", () => {
-        const transcript = serializeConversation([user("Read the output"), toolResult("call-1", "bash", "x".repeat(8105))]);
-        expect(transcript).toContain("[Tool result from bash]:");
-        expect(transcript).toContain("more characters truncated");
-    });
-    it("preserves both head and tail of long tool results", () => {
-        // Distinctive head and tail tokens — head-only truncation would lose the tail.
-        const head = "HEAD_MARKER_START";
-        const tail = "TAIL_MARKER_END";
-        const filler = "x".repeat(10_000);
-        const payload = `${head}${filler}${tail}`;
-        const transcript = serializeConversation([user("read"), toolResult("call-1", "bash", payload)]);
-        expect(transcript).toContain(head);
-        expect(transcript).toContain(tail);
-        expect(transcript).toContain("more characters truncated");
-    });
-    it("dedupes identical large tool-result payloads across history + turn-prefix slices", () => {
-        const bigOutput = "y".repeat(2000); // > DEDUP_MIN_CHARS (500)
-        const messages = [
-            user("read it"),
-            assistantToolCall("c1", "read_file", { path: "src/a.ts" }),
-            toolResult("c1", "read_file", bigOutput),
-            assistantText("ok"),
-            user("read it again"),
-            assistantToolCall("c2", "read_file", { path: "src/a.ts" }),
-            toolResult("c2", "read_file", bigOutput),
-            assistantText("done"),
-            user("latest"),
-            assistantText("recent reply"),
-        ];
-        const preparation = prepareCompaction(messages, "system", {
-            reserveTokens: 100,
-            keepRecentTokens: 50,
-        });
-        expect(preparation).not.toBeNull();
-        const fullSlice = [...(preparation?.messagesToSummarize ?? []), ...(preparation?.turnPrefixMessages ?? [])];
-        const serialized = serializeConversation(fullSlice);
-        // First occurrence kept verbatim, second replaced with the elision marker.
-        expect(serialized).toContain("Identical to earlier read_file result");
-        expect(serialized.match(/y{2000}/g) ?? []).toHaveLength(1);
-    });
-    it("builds the effective transcript from the latest persisted checkpoint", () => {
-        const rawMessages = [
-            user("old request"),
-            assistantText("old answer"),
-            user("new request"),
-            assistantText("new answer"),
-            user("latest request"),
-        ];
-        const seqs = [1, 2, 3, 4, 5];
-        const timestamps = seqs.map((seq) => new Date(`2026-03-20T00:00:0${seq}.000Z`));
-        const checkpoint = {
-            firstKeptSeq: 4,
-            summary: "Summarized old work",
-            tokensBefore: 1234,
-            createdAt: new Date("2026-03-20T00:00:10.000Z"),
-        };
-        const transcript = buildEffectiveTranscript(rawMessages, seqs, timestamps, checkpoint);
-        expect(transcript.messages).toHaveLength(3);
-        expect(transcript.seqs).toEqual([null, 4, 5]);
-        expect(transcript.messages[0]).toEqual(createCompactionSummaryMessage("Summarized old work"));
-        expect(transcript.messages[0]?.role === "system" && typeof transcript.messages[0].content === "string"
-            ? transcript.messages[0].content
-            : "").toContain(COMPACTION_SUMMARY_HEADER);
-    });
-    it("creates compaction summary with EE-extractable checkpoint meta (Progress ✔ DONE shape for pilContext/layer3)", () => {
-        // This is the exact text shape persisted to EE behavioral collection on cli-compact-checkpoint
-        // (orchestrator compactForContext + extract). Layer 3 searches for it; agent uses via "task finished?".
-        const summaryMsg = createCompactionSummaryMessage("Goal: implement anti-mu\nPlan: Phase 1-3\nProgress: ✔ DONE dedup marker\n↻ In Progress: layer1 enrich");
-        const content = typeof summaryMsg.content === "string" ? summaryMsg.content : "";
-        expect(content).toContain("Context checkpoint summary");
-        expect(content).toContain("✔ DONE");
-        expect(content).toContain("Progress");
-        expect(summaryMsg.role).toBe("system");
-    });
-    it("buildCheckpointReminder now includes PRESERVE + KEEP_TOOL_IDS + tool-artifact query for anti-mù (ideas 3+4)", () => {
-        const r = buildCheckpointReminder(3, true);
-        expect(r).toContain("PRESERVE");
-        expect(r).toContain("KEEP_TOOL_IDS");
-        expect(r).toContain("tool-artifact");
-    });
-});
-describe("metaCompactionMaxTokens — meta summary cap (tunable, session 2b7a10219499)", () => {
-    it("defaults to 1536 — looser than the old hard 1024, still well below the 14k-char problem", () => {
-        delete process.env.MUONROI_META_COMPACT_MAX_TOKENS;
-        expect(metaCompactionMaxTokens()).toBe(COMPACTION_META_MAX_OUTPUT_TOKENS);
-        expect(COMPACTION_META_MAX_OUTPUT_TOKENS).toBe(1536);
-        expect(COMPACTION_META_MAX_OUTPUT_TOKENS).toBeGreaterThan(1024);
-    });
-    it("honors a valid MUONROI_META_COMPACT_MAX_TOKENS override", () => {
-        process.env.MUONROI_META_COMPACT_MAX_TOKENS = "2048";
-        try {
-            expect(metaCompactionMaxTokens()).toBe(2048);
-        }
-        finally {
-            delete process.env.MUONROI_META_COMPACT_MAX_TOKENS;
-        }
-    });
-    it("clamps out-of-range / garbage overrides to the default", () => {
-        for (const bad of ["999999", "100", "-5", "abc", ""]) {
-            process.env.MUONROI_META_COMPACT_MAX_TOKENS = bad;
-            expect(metaCompactionMaxTokens(), bad).toBe(COMPACTION_META_MAX_OUTPUT_TOKENS);
-        }
-        delete process.env.MUONROI_META_COMPACT_MAX_TOKENS;
-    });
-});
-//# sourceMappingURL=compaction.test.js.map

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

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

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

@@ -1,107 +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";
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-function readStoredDelegationRecord(home) {
-    const delegationsRoot = path.join(home, ".muonroi-cli", "delegations");
-    const projectDirs = fs.readdirSync(delegationsRoot);
-    expect(projectDirs).toHaveLength(1);
-    const projectDir = path.join(delegationsRoot, projectDirs[0]);
-    const files = fs.readdirSync(projectDir).filter((file) => file.endsWith(".json"));
-    expect(files).toHaveLength(1);
-    return JSON.parse(fs.readFileSync(path.join(projectDir, files[0]), "utf8"));
-}
-async function importDelegationsModule(options = {}) {
-    vi.resetModules();
-    vi.doUnmock("os");
-    vi.doUnmock("child_process");
-    if (options.home) {
-        const osActual = await vi.importActual("os");
-        vi.doMock("os", () => ({
-            ...osActual,
-            default: { ...osActual, homedir: () => options.home },
-            homedir: () => options.home,
-        }));
-    }
-    if (options.spawnMock) {
-        const cpActual = await vi.importActual("child_process");
-        vi.doMock("child_process", () => ({
-            ...cpActual,
-            spawn: options.spawnMock,
-        }));
-    }
-    return import("./delegations.js");
-}
-afterEach(() => {
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    }
-    vi.restoreAllMocks();
-    vi.resetModules();
-    vi.doUnmock("os");
-    vi.doUnmock("child_process");
-});
-describe("DelegationManager sandbox propagation", () => {
-    it("persists sandbox mode in background delegation records", async () => {
-        const home = makeTempDir("muonroi-delegation-home-");
-        const cwd = makeTempDir("muonroi-delegation-cwd-");
-        const spawnMock = vi.fn(() => ({
-            pid: 2468,
-            unref: vi.fn(),
-        }));
-        const mod = await importDelegationsModule({ home, spawnMock });
-        const manager = new mod.DelegationManager(() => cwd);
-        const result = await manager.start({
-            agent: "explore",
-            description: "Inspect the repo",
-            prompt: "Find the execution path.",
-        }, {
-            model: "muonroi-test-model",
-            sandboxMode: "shuru",
-            maxToolRounds: 25,
-            maxTokens: 2048,
-        });
-        expect(result.success).toBe(true);
-        expect(spawnMock).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(["--directory", cwd]), expect.objectContaining({ cwd }));
-        const record = readStoredDelegationRecord(home);
-        expect(record.sandboxMode).toBe("shuru");
-        expect(record.pid).toBe(2468);
-    });
-    it("persists sandbox settings in background delegation records", async () => {
-        const home = makeTempDir("muonroi-delegation-home-");
-        const cwd = makeTempDir("muonroi-delegation-cwd-");
-        const spawnMock = vi.fn(() => ({
-            pid: 3579,
-            unref: vi.fn(),
-        }));
-        const mod = await importDelegationsModule({ home, spawnMock });
-        const manager = new mod.DelegationManager(() => cwd);
-        const sandboxSettings = {
-            allowNet: true,
-            allowedHosts: ["api.openai.com"],
-            cpus: 4,
-            memory: 4096,
-        };
-        await manager.start({
-            agent: "explore",
-            description: "Inspect",
-            prompt: "Look around",
-        }, {
-            model: "muonroi-test-model",
-            sandboxMode: "shuru",
-            sandboxSettings,
-            maxToolRounds: 25,
-            maxTokens: 2048,
-        });
-        const record = readStoredDelegationRecord(home);
-        expect(record.sandboxMode).toBe("shuru");
-        expect(record.sandboxSettings).toEqual(sandboxSettings);
-    });
-});
-//# sourceMappingURL=delegations.test.js.map

package/dist/src/orchestrator/grounding-check.test.d.ts

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

package/dist/src/orchestrator/grounding-check.test.js

@@ -1,94 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildGroundingFootnote, findUnverifiedClaims } from "./grounding-check.js";
-describe("findUnverifiedClaims — count claims", () => {
-    it("flags an exact count not present in the tool-output corpus", () => {
-        // The decisive live case: deepseek claimed 67 tests while no command output
-        // contained 67 (actual 401). corpus has no '67'.
-        const claims = findUnverifiedClaims("There are 67 tests in the repository.", "ran find; output: 401\n");
-        expect(claims.some((c) => c.kind === "count" && c.value === "67")).toBe(true);
-    });
-    it("does NOT flag a count that appears verbatim in the corpus", () => {
-        const claims = findUnverifiedClaims("There are 401 tests.", "$ find src -name '*.test.ts' | wc -l\n401\n");
-        expect(claims).toHaveLength(0);
-    });
-    it("matches counts with thousands separators against an unseparated corpus", () => {
-        // Model prints '1,273 commits'; git output is '1273'. Should be VERIFIED.
-        const claims = findUnverifiedClaims("The repo has 1,273 commits.", "$ git rev-list --count HEAD\n1273\n");
-        expect(claims).toHaveLength(0);
-    });
-    it("ignores small numbers (< 10) — too common, low risk", () => {
-        expect(findUnverifiedClaims("Fixed 3 files.", "")).toHaveLength(0);
-    });
-    it("ignores percentages, multipliers, versions, money", () => {
-        const text = "97% cache hit, 16x faster, v0.4.0 shipped, $50 saved across 99 files.";
-        // Only "99 files" is a real count claim; the rest must be skipped. corpus
-        // lacks 99 -> 99 flagged, others NOT.
-        const claims = findUnverifiedClaims(text, "");
-        expect(claims.map((c) => c.value)).toEqual(["99"]);
-    });
-    it("ignores hedged/approximate numbers (presented as estimates, not facts)", () => {
-        const text = "~130,220 lines, about 500 files, roughly 40 modules.";
-        expect(findUnverifiedClaims(text, "")).toHaveLength(0);
-    });
-    it("only counts a number when followed by a recognised count noun", () => {
-        // A bare number with no count noun is not a verifiable 'count claim'.
-        expect(findUnverifiedClaims("The answer is 42 ultimately.", "")).toHaveLength(0);
-    });
-    // Gap found in the live deepseek-vs-gemini comparison (2026-06-04): deepseek
-    // emitted "total lines of code across all .ts files in src/: 10026" — a
-    // fabricated count where the NOUN precedes the NUMBER (separated by a colon),
-    // which the number-then-noun pattern missed. Cover the noun→:/=→number shape.
-    it("flags a noun-before-number count claim (noun : number)", () => {
-        const claims = findUnverifiedClaims("Total lines of code across all .ts files in src/: 10026.", "");
-        expect(claims.some((c) => c.kind === "count" && c.value === "10026")).toBe(true);
-    });
-    it("flags a noun = number claim", () => {
-        const claims = findUnverifiedClaims("Estimated modules = 240 in the repo.", "");
-        expect(claims.some((c) => c.kind === "count" && c.value === "240")).toBe(true);
-    });
-    it("does NOT flag a noun:number when the number is in the corpus", () => {
-        expect(findUnverifiedClaims("Total commits: 1,273.", "$ git rev-list --count HEAD\n1273\n")).toHaveLength(0);
-    });
-    it("does NOT flag a hedged noun:number", () => {
-        expect(findUnverifiedClaims("Total lines: ~10026.", "")).toHaveLength(0);
-    });
-    it("does NOT treat 'line 42' (no separator) as a count claim", () => {
-        // file:line context — handled separately; must not become a count claim.
-        expect(findUnverifiedClaims("See line 42 for details.", "").filter((c) => c.kind === "count")).toHaveLength(0);
-    });
-});
-describe("findUnverifiedClaims — file:line claims", () => {
-    it("flags a file:line whose file never appears in the corpus", () => {
-        const claims = findUnverifiedClaims("The bug is at app.tsx:836.", "read src/index.ts lines 1-40\n");
-        expect(claims.some((c) => c.kind === "fileline" && c.value === "app.tsx:836")).toBe(true);
-    });
-    it("does NOT flag a file:line whose file was read/grepped this turn", () => {
-        const claims = findUnverifiedClaims("See app.tsx:836.", "$ read_file app.tsx\n...contents of app.tsx...\n");
-        expect(claims).toHaveLength(0);
-    });
-});
-describe("findUnverifiedClaims — bounds & dedup", () => {
-    it("caps the number of returned claims", () => {
-        const text = "100 files, 200 files, 300 files, 400 files, 500 files, 600 files, 700 files.";
-        expect(findUnverifiedClaims(text, "").length).toBeLessThanOrEqual(5);
-    });
-    it("returns empty for empty text", () => {
-        expect(findUnverifiedClaims("", "anything")).toHaveLength(0);
-    });
-});
-describe("buildGroundingFootnote", () => {
-    it("returns empty string when there are no claims", () => {
-        expect(buildGroundingFootnote([])).toBe("");
-    });
-    it("lists the unverified claims with an advisory (non-accusatory) tone", () => {
-        const note = buildGroundingFootnote([
-            { kind: "count", value: "67", text: "67 tests" },
-            { kind: "fileline", value: "app.tsx:836", text: "app.tsx:836" },
-        ]);
-        expect(note).toMatch(/unverified/i);
-        expect(note).toMatch(/67 tests/);
-        expect(note).toMatch(/app\.tsx:836/);
-        expect(note).toMatch(/may be derived|confirm/i);
-    });
-});
-//# sourceMappingURL=grounding-check.test.js.map

package/dist/src/orchestrator/interrupted-turn.test.d.ts

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

package/dist/src/orchestrator/interrupted-turn.test.js

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildInterruptedTurnNote } from "./interrupted-turn.js";
-describe("buildInterruptedTurnNote", () => {
-    it("is never empty — so the stalled turn always leaves a trace in history", () => {
-        expect(buildInterruptedTurnNote("", []).length).toBeGreaterThan(0);
-    });
-    it("records the interruption and the tools that were issued", () => {
-        const note = buildInterruptedTurnNote("", ["bash", "read_file", "grep"]);
-        expect(note).toMatch(/interrupted|stall/i);
-        expect(note).toMatch(/bash/);
-        expect(note).toMatch(/read_file/);
-        expect(note).toMatch(/3 tool/); // count
-    });
-    it("warns against blindly redoing partially-applied work", () => {
-        expect(buildInterruptedTurnNote("", ["bash"])).toMatch(/partial|re-check|recheck/i);
-    });
-    it("prepends any partial assistant text before the note", () => {
-        const note = buildInterruptedTurnNote("Here is what I found so far:", ["bash"]);
-        expect(note.startsWith("Here is what I found so far:")).toBe(true);
-        expect(note).toMatch(/interrupted|stall/i);
-    });
-    it("dedupes tool names but keeps the raw count", () => {
-        const note = buildInterruptedTurnNote("", ["bash", "bash", "bash", "read_file"]);
-        expect(note).toMatch(/4 tool/); // raw count
-        // bash listed once
-        expect(note.match(/bash/g)?.length).toBe(1);
-    });
-    it("handles the no-tools case with a generic note", () => {
-        const note = buildInterruptedTurnNote("", []);
-        expect(note).toMatch(/interrupted|stall/i);
-        expect(note).not.toMatch(/tool call/);
-    });
-});
-//# sourceMappingURL=interrupted-turn.test.js.map

package/dist/src/orchestrator/message-seq.test.d.ts

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

package/dist/src/orchestrator/message-seq.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { lastPersistedSeq } from "./message-seq.js";
-describe("lastPersistedSeq", () => {
-    it("returns null for empty array", () => {
-        expect(lastPersistedSeq([])).toBeNull();
-    });
-    it("returns null when all entries are null", () => {
-        expect(lastPersistedSeq([null, null, null])).toBeNull();
-    });
-    it("returns the last numeric entry when trailing nulls exist", () => {
-        expect(lastPersistedSeq([1, 2, 3, null, null])).toBe(3);
-    });
-    it("returns the highest seq when the last entry is numeric", () => {
-        expect(lastPersistedSeq([1, 2, 3])).toBe(3);
-    });
-    it("skips over interrupted/stub gaps", () => {
-        expect(lastPersistedSeq([5, null, 7, null, 9, null])).toBe(9);
-    });
-    it("returns 0 (not null) when 0 is a valid seq", () => {
-        expect(lastPersistedSeq([0])).toBe(0);
-        expect(lastPersistedSeq([0, null])).toBe(0);
-    });
-});
-//# sourceMappingURL=message-seq.test.js.map

package/dist/src/orchestrator/pending-calls.test.d.ts

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