muonroi-cli 1.8.1 → 1.8.3

package/dist/src/self-qa/__tests__/agentic-loop.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createMockBrain, parseDecision } from "../agentic-loop.js";
-describe("agentic-loop brain primitives", () => {
-    it("createMockBrain plays scripted decisions in order", async () => {
-        const script = [
-            { action: "type", text: "/ideal", reason: "kick off" },
-            { action: "press", key: "Enter", reason: "submit" },
-            { action: "done", verdict: "pass", reason: "ok" },
-        ];
-        const brain = createMockBrain(script);
-        const sink = {
-            goal: "test",
-            historyExcerpt: "",
-            turn: 1,
-            maxTurns: 5,
-            context: { prompt: "x", estimatedTokens: 1, truncated: false },
-        };
-        expect((await brain.decide(sink)).action).toBe("type");
-        expect((await brain.decide(sink)).action).toBe("press");
-        expect((await brain.decide(sink)).action).toBe("done");
-    });
-    it("createMockBrain returns inconclusive done once exhausted", async () => {
-        const brain = createMockBrain([]);
-        const d = await brain.decide({
-            goal: "test",
-            historyExcerpt: "",
-            turn: 1,
-            maxTurns: 5,
-            context: { prompt: "x", estimatedTokens: 1, truncated: false },
-        });
-        expect(d.action).toBe("done");
-        expect(d.action === "done" && d.verdict).toBe("inconclusive");
-    });
-});
-describe("parseDecision", () => {
-    it("strips ```json fences and parses cleanly", () => {
-        const r = parseDecision('```json\n{"action":"type","text":"hi","reason":"go"}\n```');
-        expect(r).toMatchObject({ action: "type", text: "hi" });
-    });
-    it("rejects malformed", () => {
-        expect(parseDecision("nope")).toBeNull();
-    });
-    it("parses done with verdict", () => {
-        const r = parseDecision('{"action":"done","verdict":"pass","reason":"all good"}');
-        expect(r).toMatchObject({ action: "done", verdict: "pass" });
-    });
-    it("parses wait_for with selector + timeout", () => {
-        const r = parseDecision('{"action":"wait_for","selector":"id=askcard","timeoutMs":3000,"reason":"x"}');
-        expect(r).toMatchObject({ action: "wait_for", selector: "id=askcard", timeoutMs: 3000 });
-    });
-    it("parses press with key", () => {
-        const r = parseDecision('{"action":"press","key":"Enter","reason":"submit"}');
-        expect(r).toMatchObject({ action: "press", key: "Enter" });
-    });
-    it("rejects invalid verdict on done", () => {
-        expect(parseDecision('{"action":"done","verdict":"weird","reason":"x"}')).toBeNull();
-    });
-    it("rejects unknown action", () => {
-        expect(parseDecision('{"action":"nuke","reason":"x"}')).toBeNull();
-    });
-});
-//# sourceMappingURL=agentic-loop.test.js.map

package/dist/src/self-qa/__tests__/delta-encoder.test.d.ts

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

package/dist/src/self-qa/__tests__/delta-encoder.test.js

@@ -1,97 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { applyDelta, compressionRatio, encodeDelta } from "../delta-encoder.js";
-const baseFrame = (nodes, extra = {}) => ({
-    mode: "live",
-    version: "0.4.0",
-    seq: 1,
-    ts: Date.now(),
-    nodes,
-    ...extra,
-});
-describe("delta-encoder", () => {
-    it("marks every node as added on first frame", () => {
-        const next = baseFrame([
-            { id: "a", role: "region" },
-            { id: "b", role: "button" },
-        ]);
-        const d = encodeDelta(null, next);
-        expect(d.baseSeq).toBeNull();
-        expect(d.added.map((n) => n.id).sort()).toEqual(["a", "b"]);
-        expect(d.removed).toEqual([]);
-        expect(d.changed).toEqual([]);
-    });
-    it("detects added + removed + changed in one pass", () => {
-        const prev = baseFrame([
-            { id: "a", role: "region", name: "old" },
-            { id: "b", role: "button" },
-        ]);
-        const next = baseFrame([
-            { id: "a", role: "region", name: "new" },
-            { id: "c", role: "textbox" },
-        ], { seq: 2 });
-        const d = encodeDelta(prev, next);
-        expect(d.added.map((n) => n.id)).toEqual(["c"]);
-        expect(d.removed).toEqual(["b"]);
-        expect(d.changed).toEqual([{ id: "a", fields: { name: "new" } }]);
-        expect(d.baseSeq).toBe(1);
-    });
-    it("emits focusChanged and modalsChanged when those change", () => {
-        const prev = baseFrame([{ id: "a", role: "region" }], { focus: "a", modals: [] });
-        const next = baseFrame([{ id: "a", role: "region" }], {
-            focus: "b",
-            modals: ["m1"],
-            seq: 2,
-        });
-        const d = encodeDelta(prev, next);
-        expect(d.focusChanged).toEqual({ from: "a", to: "b" });
-        expect(d.modalsChanged).toEqual({ from: [], to: ["m1"] });
-    });
-    it("recurses into children for indexing", () => {
-        const prev = baseFrame([
-            {
-                id: "root",
-                role: "region",
-                children: [{ id: "leaf", role: "button", name: "x" }],
-            },
-        ]);
-        const next = baseFrame([
-            {
-                id: "root",
-                role: "region",
-                children: [{ id: "leaf", role: "button", name: "y" }],
-            },
-        ], { seq: 2 });
-        const d = encodeDelta(prev, next);
-        expect(d.changed).toEqual([{ id: "leaf", fields: { name: "y" } }]);
-    });
-    it("applyDelta reconstructs node set (id-level)", () => {
-        const prev = baseFrame([
-            { id: "a", role: "region", name: "old" },
-            { id: "b", role: "button" },
-        ]);
-        const next = baseFrame([
-            { id: "a", role: "region", name: "new" },
-            { id: "c", role: "textbox" },
-        ], { seq: 2, focus: "c" });
-        const d = encodeDelta(prev, next);
-        const reconstructed = applyDelta(prev, d);
-        const ids = reconstructed.nodes.map((n) => n.id).sort();
-        expect(ids).toEqual(["a", "c"]);
-        expect(reconstructed.nodes.find((n) => n.id === "a")?.name).toBe("new");
-        expect(reconstructed.focus).toBe("c");
-    });
-    it("compressionRatio drops below 0.3 for tiny changes in large trees", () => {
-        const bigChildren = Array.from({ length: 100 }, (_, i) => ({
-            id: `n${i}`,
-            role: "listitem",
-            name: `item ${i}`,
-        }));
-        const prev = baseFrame([{ id: "list", role: "listbox", children: bigChildren }]);
-        const nextChildren = bigChildren.map((n, i) => (i === 50 ? { ...n, name: "changed" } : n));
-        const next = baseFrame([{ id: "list", role: "listbox", children: nextChildren }], { seq: 2 });
-        const d = encodeDelta(prev, next);
-        expect(d.changed).toHaveLength(1);
-        expect(compressionRatio(next, d)).toBeLessThan(0.3);
-    });
-});
-//# sourceMappingURL=delta-encoder.test.js.map

package/dist/src/self-qa/__tests__/judge.test.d.ts

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

package/dist/src/self-qa/__tests__/judge.test.js

@@ -1,131 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { judge, summariseResults } from "../judge.js";
-const baseScenario = (over = {}) => ({
-    id: "test-scn",
-    description: "test",
-    derivedFrom: { files: [], semanticIds: [] },
-    steps: [],
-    expectations: [],
-    budgetMs: 10_000,
-    ...over,
-});
-const makeRun = (scenario, events, finalFrame, extra = {}) => ({
-    scenario,
-    events,
-    finalFrame,
-    startedAt: 1_000,
-    endedAt: 2_000,
-    timedOut: false,
-    crashed: false,
-    ...extra,
-});
-describe("judge", () => {
-    it("returns inconclusive when run crashed", () => {
-        const run = makeRun(baseScenario(), [], null, { crashed: true, errorTrace: "boom" });
-        const r = judge(run);
-        expect(r.verdict).toBe("inconclusive");
-        expect(r.checks[0]?.reason).toContain("boom");
-    });
-    it("returns inconclusive when run timed out", () => {
-        const run = makeRun(baseScenario(), [], null, { timedOut: true });
-        const r = judge(run);
-        expect(r.verdict).toBe("inconclusive");
-    });
-    it("passes when no expectations and no crash", () => {
-        const r = judge(makeRun(baseScenario(), [], null));
-        expect(r.verdict).toBe("pass");
-    });
-    it("noErrorToast passes when no error toasts", () => {
-        const scn = baseScenario({ expectations: [{ kind: "noErrorToast" }] });
-        const events = [{ t: "event", kind: "toast", level: "info", text: "hi" }];
-        expect(judge(makeRun(scn, events, null)).verdict).toBe("pass");
-    });
-    it("noErrorToast fails when error toast present", () => {
-        const scn = baseScenario({ expectations: [{ kind: "noErrorToast" }] });
-        const events = [{ t: "event", kind: "toast", level: "error", text: "BOOM" }];
-        const r = judge(makeRun(scn, events, null));
-        expect(r.verdict).toBe("fail");
-        expect(r.checks[0]?.reason).toContain("BOOM");
-    });
-    it("eventFired passes when event present with matching payload", () => {
-        const scn = baseScenario({
-            expectations: [{ kind: "eventFired", event: "route-decision", payloadMatch: { path: "hot-path" } }],
-        });
-        const events = [
-            {
-                t: "event",
-                kind: "route-decision",
-                path: "hot-path",
-                complexity: "easy",
-                forceCouncil: false,
-                runId: "r1",
-            },
-        ];
-        expect(judge(makeRun(scn, events, null)).verdict).toBe("pass");
-    });
-    it("eventFired fails when payload mismatches", () => {
-        const scn = baseScenario({
-            expectations: [{ kind: "eventFired", event: "route-decision", payloadMatch: { path: "hot-path" } }],
-        });
-        const events = [
-            {
-                t: "event",
-                kind: "route-decision",
-                path: "council",
-                complexity: "complex",
-                forceCouncil: true,
-                runId: "r1",
-            },
-        ];
-        expect(judge(makeRun(scn, events, null)).verdict).toBe("fail");
-    });
-    it("eventAbsent passes when event never fired", () => {
-        const scn = baseScenario({ expectations: [{ kind: "eventAbsent", event: "sprint-halt" }] });
-        expect(judge(makeRun(scn, [], null)).verdict).toBe("pass");
-    });
-    it("selectorPresent finds id selector in frame", () => {
-        const scn = baseScenario({
-            expectations: [{ kind: "selectorPresent", selector: "id=composer" }],
-        });
-        const frame = {
-            mode: "live",
-            version: "0.4.0",
-            seq: 1,
-            ts: 0,
-            nodes: [{ id: "composer", role: "textbox" }],
-        };
-        expect(judge(makeRun(scn, [], frame)).verdict).toBe("pass");
-    });
-    it("selectorPresent fails when frame is null", () => {
-        const scn = baseScenario({
-            expectations: [{ kind: "selectorPresent", selector: "id=composer" }],
-        });
-        expect(judge(makeRun(scn, [], null)).verdict).toBe("fail");
-    });
-    it("idleReached passes when duration within budget", () => {
-        const scn = baseScenario({
-            expectations: [{ kind: "idleReached", withinMs: 5_000 }],
-            budgetMs: 10_000,
-        });
-        const run = makeRun(scn, [], null, { startedAt: 0, endedAt: 3_000 });
-        expect(judge(run).verdict).toBe("pass");
-    });
-    it("idleReached fails when duration exceeds budget", () => {
-        const scn = baseScenario({
-            expectations: [{ kind: "idleReached", withinMs: 1_000 }],
-            budgetMs: 10_000,
-        });
-        const run = makeRun(scn, [], null, { startedAt: 0, endedAt: 5_000 });
-        expect(judge(run).verdict).toBe("fail");
-    });
-    it("summariseResults reports correct counts", () => {
-        const s = summariseResults([
-            { verdict: "pass", scenarioId: "a", checks: [], durationMs: 0 },
-            { verdict: "pass", scenarioId: "b", checks: [], durationMs: 0 },
-            { verdict: "fail", scenarioId: "c", checks: [], durationMs: 0 },
-            { verdict: "inconclusive", scenarioId: "d", checks: [], durationMs: 0 },
-        ]);
-        expect(s).toEqual({ total: 4, passed: 2, failed: 1, inconclusive: 1, passRate: 0.5 });
-    });
-});
-//# sourceMappingURL=judge.test.js.map

package/dist/src/self-qa/__tests__/scenario-planner.test.d.ts

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

package/dist/src/self-qa/__tests__/scenario-planner.test.js

@@ -1,79 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { extractSemanticHits, planScenarios } from "../scenario-planner.js";
-describe("scenario-planner", () => {
-    describe("extractSemanticHits", () => {
-        it("extracts id+role from simple Semantic", () => {
-            const src = `<Semantic id="composer" role="textbox" name="Prompt">`;
-            const hits = extractSemanticHits(src, "x.tsx");
-            expect(hits).toHaveLength(1);
-            expect(hits[0]).toMatchObject({
-                id: "composer",
-                role: "textbox",
-                name: "Prompt",
-                file: "x.tsx",
-            });
-        });
-        it("detects isModal boolean shorthand", () => {
-            const src = `<Semantic id="modal-x" role="dialog" name="X" isModal>`;
-            const hits = extractSemanticHits(src, "y.tsx");
-            expect(hits[0]?.isModal).toBe(true);
-        });
-        it("extracts template-literal ids", () => {
-            const src = '<Semantic id={`ideal-phase-cost`} role="listitem">';
-            const hits = extractSemanticHits(src, "z.tsx");
-            expect(hits[0]?.id).toBe("ideal-phase-cost");
-        });
-        it("records line numbers", () => {
-            const src = `\n\n<Semantic id="a" role="region">\n`;
-            const hits = extractSemanticHits(src, "f.tsx");
-            expect(hits[0]?.line).toBe(3);
-        });
-        it("handles multiple hits in one file", () => {
-            const src = `
-        <Semantic id="one" role="textbox">
-        <Semantic id="two" role="button">
-      `;
-            const hits = extractSemanticHits(src, "f.tsx");
-            expect(hits.map((h) => h.id)).toEqual(["one", "two"]);
-        });
-    });
-    describe("planScenarios", () => {
-        it("returns smoke-boot only when no files changed", () => {
-            const scn = planScenarios({ diffFilesOverride: [] });
-            expect(scn).toHaveLength(1);
-            expect(scn[0]?.id).toBe("smoke-boot");
-        });
-        it("includes smoke-boot first when scenarios derived from hits", () => {
-            // Use this very test file as a probe — it has no Semantic but we can
-            // exercise the path by passing extraFiles pointing at a real UI file.
-            const scn = planScenarios({
-                diffFilesOverride: [],
-                extraFiles: ["src/ui/components/halt-recovery-card.tsx"],
-            });
-            expect(scn[0]?.id).toBe("smoke-boot");
-            // halt-recovery-card has 1 Semantic (id=ideal-halt-card role=dialog)
-            const ids = scn.map((s) => s.id);
-            expect(ids.some((id) => id.startsWith("dialog-ideal-halt-card"))).toBe(true);
-        });
-        it("respects maxScenarios cap", () => {
-            const scn = planScenarios({
-                diffFilesOverride: [],
-                extraFiles: ["src/ui/components/init-new-form-card.tsx"],
-                maxScenarios: 2,
-            });
-            expect(scn.length).toBeLessThanOrEqual(2);
-        });
-        it("textbox scenario types probe text and asserts idle", () => {
-            const scn = planScenarios({
-                diffFilesOverride: [],
-                extraFiles: ["src/ui/agents-modal.tsx"],
-                maxScenarios: 6,
-            });
-            const textboxScn = scn.find((s) => s.id.startsWith("textbox-"));
-            expect(textboxScn).toBeDefined();
-            const typeStep = textboxScn?.steps.find((s) => s.op === "type");
-            expect(typeStep).toMatchObject({ op: "type" });
-        });
-    });
-});
-//# sourceMappingURL=scenario-planner.test.js.map

package/dist/src/self-qa/__tests__/spec-emitter.test.d.ts

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

package/dist/src/self-qa/__tests__/spec-emitter.test.js

@@ -1,62 +0,0 @@
-import { mkdtempSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import { emitSpec } from "../spec-emitter.js";
-const scenario = {
-    id: "demo-scn",
-    description: "demo scenario",
-    derivedFrom: { files: ["src/ui/x.tsx"], semanticIds: ["composer"] },
-    steps: [
-        { op: "wait_for", idle: true, timeoutMs: 5_000 },
-        { op: "focus", selector: "id=composer" },
-        { op: "type", text: "hello" },
-        { op: "press", key: "Enter" },
-    ],
-    expectations: [
-        { kind: "noErrorToast" },
-        { kind: "selectorPresent", selector: "id=composer" },
-        { kind: "idleReached", withinMs: 5_000 },
-    ],
-    budgetMs: 10_000,
-};
-const passResult = {
-    verdict: "pass",
-    scenarioId: scenario.id,
-    durationMs: 1234,
-    checks: [],
-};
-describe("spec-emitter", () => {
-    it("writes a runnable spec for a passing scenario", () => {
-        const dir = mkdtempSync(join(tmpdir(), "self-qa-emit-"));
-        const file = emitSpec(scenario, passResult, {
-            outDir: dir,
-            now: () => new Date("2026-05-21T00:00:00Z"),
-        });
-        expect(file).toContain("demo-scn.spec.ts");
-        const src = readFileSync(file, "utf8");
-        expect(src).toContain("AUTO-GENERATED by /self-verify");
-        expect(src).toContain("describe.skipIf");
-        expect(src).toContain("spawnHarness");
-        expect(src).toContain('driver.type("hello")');
-        expect(src).toContain('driver.press("Enter")');
-        expect(src).toContain('driver.queryAll("id=composer")');
-        expect(src).toContain('expect(driver.last_event("toast")?.level).not.toBe("error");');
-    });
-    it("throws on non-passing verdict", () => {
-        const dir = mkdtempSync(join(tmpdir(), "self-qa-emit-"));
-        expect(() => emitSpec(scenario, { ...passResult, verdict: "fail" }, { outDir: dir })).toThrow(/non-passing/);
-    });
-    it("emits banner referencing derived files", () => {
-        const dir = mkdtempSync(join(tmpdir(), "self-qa-emit-"));
-        const file = emitSpec(scenario, passResult, {
-            outDir: dir,
-            now: () => new Date("2026-05-21T00:00:00Z"),
-        });
-        const src = readFileSync(file, "utf8");
-        expect(src).toContain("src/ui/x.tsx");
-        expect(src).toContain("composer");
-        expect(src).toContain("2026-05-21T00:00:00.000Z");
-    });
-});
-//# sourceMappingURL=spec-emitter.test.js.map

package/dist/src/storage/__tests__/hierarchical-session.test.d.ts

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

package/dist/src/storage/__tests__/hierarchical-session.test.js

@@ -1,161 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-const sessionsDb = new Map();
-const messagesDb = new Map();
-const toolCallsDb = new Map();
-const toolResultsDb = new Map();
-const compactionsDb = new Map();
-vi.mock("../db", () => {
-    return {
-        getDatabase: () => ({
-            prepare: (sql) => {
-                const lower = sql.toLowerCase();
-                return {
-                    get: (param) => {
-                        if (lower.includes("from sessions")) {
-                            if (lower.includes("where parent_session_id =")) {
-                                for (const [id, val] of sessionsDb.entries()) {
-                                    if (val.parent_session_id === param) {
-                                        return { id };
-                                    }
-                                }
-                                return undefined;
-                            }
-                            return sessionsDb.get(param) || { parent_session_id: null };
-                        }
-                        if (lower.includes("from tool_calls") && lower.includes("todo_write")) {
-                            const calls = toolCallsDb.get(param) || [];
-                            const todo = calls.find((c) => c.tool_name === "todo_write");
-                            return todo ? { args_json: todo.args_json } : undefined;
-                        }
-                        if (lower.includes("from compactions")) {
-                            return compactionsDb.get(param);
-                        }
-                        return undefined;
-                    },
-                    all: (...params) => {
-                        if (lower.includes("from messages")) {
-                            return messagesDb.get(params[0]) || [];
-                        }
-                        if (lower.includes("from tool_results")) {
-                            return toolResultsDb.get(params[0]) || [];
-                        }
-                        if (lower.includes("from sessions")) {
-                            if (lower.includes("where parent_session_id =")) {
-                                const results = [];
-                                for (const [id, val] of sessionsDb.entries()) {
-                                    if (val.parent_session_id === params[0]) {
-                                        results.push({ id });
-                                    }
-                                }
-                                return results;
-                            }
-                            if (lower.includes("where id in")) {
-                                return params.map((id) => ({ id }));
-                            }
-                        }
-                        return [];
-                    },
-                    run: () => ({ changes: 0 }),
-                };
-            },
-            exec: () => undefined,
-            pragma: () => undefined,
-            transaction: (fn) => fn,
-        }),
-        withTransaction: (fn) => fn({}),
-    };
-});
-import { buildChatEntries, getLastTodoWriteArgs, getSessionChain } from "../transcript.js";
-describe("Hierarchical Sessions (Silent Rotation Support)", () => {
-    beforeEach(() => {
-        sessionsDb.clear();
-        messagesDb.clear();
-        toolCallsDb.clear();
-        toolResultsDb.clear();
-        compactionsDb.clear();
-    });
-    describe("getSessionChain", () => {
-        it("returns correct chain for a single session", () => {
-            sessionsDb.set("sessionA", { parent_session_id: null });
-            expect(getSessionChain("sessionA")).toEqual(["sessionA"]);
-        });
-        it("traverses up the parent session chain recursively", () => {
-            sessionsDb.set("sessionA", { parent_session_id: null });
-            sessionsDb.set("sessionB", { parent_session_id: "sessionA" });
-            sessionsDb.set("sessionC", { parent_session_id: "sessionB" });
-            expect(getSessionChain("sessionC")).toEqual(["sessionA", "sessionB", "sessionC"]);
-        });
-        it("handles loops gracefully and does not infinite loop", () => {
-            sessionsDb.set("sessionA", { parent_session_id: "sessionB" });
-            sessionsDb.set("sessionB", { parent_session_id: "sessionA" });
-            // Should break loop and return traversed list in some order
-            const chain = getSessionChain("sessionB");
-            expect(chain.length).toBe(2);
-            expect(chain).toContain("sessionA");
-            expect(chain).toContain("sessionB");
-        });
-    });
-    describe("getLastTodoWriteArgs", () => {
-        it("returns null if no todo_write exists in chain", () => {
-            sessionsDb.set("sessionA", { parent_session_id: null });
-            expect(getLastTodoWriteArgs("sessionA")).toBeNull();
-        });
-        it("retrieves todo_write arguments from the current session", () => {
-            sessionsDb.set("sessionA", { parent_session_id: null });
-            toolCallsDb.set("sessionA", [
-                { id: 1, tool_call_id: "call_1", tool_name: "todo_write", args_json: '{"items":[]}' },
-            ]);
-            expect(getLastTodoWriteArgs("sessionA")).toBe('{"items":[]}');
-        });
-        it("retrieves todo_write arguments recursively from parent session", () => {
-            sessionsDb.set("sessionA", { parent_session_id: null });
-            sessionsDb.set("sessionB", { parent_session_id: "sessionA" });
-            toolCallsDb.set("sessionA", [
-                { id: 1, tool_call_id: "call_1", tool_name: "todo_write", args_json: '{"items":["task1"]}' },
-            ]);
-            // sessionB has no todo_write calls
-            expect(getLastTodoWriteArgs("sessionB")).toBe('{"items":["task1"]}');
-        });
-    });
-    describe("buildChatEntries", () => {
-        it("merges messages from parent and child session chronologically", () => {
-            sessionsDb.set("sessionA", { parent_session_id: null });
-            sessionsDb.set("sessionB", { parent_session_id: "sessionA" });
-            messagesDb.set("sessionA", [
-                {
-                    seq: 1,
-                    role: "user",
-                    message_json: JSON.stringify({ role: "user", content: "Hello A" }),
-                    created_at: "2026-06-25T12:00:00Z",
-                },
-                {
-                    seq: 2,
-                    role: "assistant",
-                    message_json: JSON.stringify({ role: "assistant", content: "Reply A" }),
-                    created_at: "2026-06-25T12:01:00Z",
-                },
-            ]);
-            messagesDb.set("sessionB", [
-                {
-                    seq: 1,
-                    role: "system",
-                    // compaction summary (should be skipped since it's the first message of a child)
-                    message_json: JSON.stringify({ role: "system", content: "[Context checkpoint summary]\nEarlier work" }),
-                    created_at: "2026-06-25T12:02:00Z",
-                },
-                {
-                    seq: 2,
-                    role: "user",
-                    message_json: JSON.stringify({ role: "user", content: "Hello B" }),
-                    created_at: "2026-06-25T12:03:00Z",
-                },
-            ]);
-            const entries = buildChatEntries("sessionB");
-            expect(entries.length).toBe(3);
-            expect(entries[0]).toEqual(expect.objectContaining({ type: "user", content: "Hello A" }));
-            expect(entries[1]).toEqual(expect.objectContaining({ type: "assistant", content: "Reply A" }));
-            expect(entries[2]).toEqual(expect.objectContaining({ type: "user", content: "Hello B" }));
-        });
-    });
-});
-//# sourceMappingURL=hierarchical-session.test.js.map

package/dist/src/storage/__tests__/migrations.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * src/storage/__tests__/migrations.test.ts
- *
- * Tests for DB migration v3 (pil_active + enrichment_delta columns).
- *
- * Uses an in-memory SQLiteDatabase implemented via vi.mock for bun:sqlite,
- * then delegates to a pure-JS in-memory store to verify schema mutations.
- *
- * Strategy: mock `bun:sqlite` before import, then use the SQLiteDatabase
- * interface directly to call applyMigrations() and assert column additions.
- */
-export {};