@code-yeongyu/senpi 2026.9.12-2 → 2026.9.12-3

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/testing/conformance.js

@@ -1,762 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { deepStrictEqual, ok, rejects, strictEqual } from "node:assert/strict";
-function createUserMessage(text) {
-    return {
-        role: "user",
-        content: [{ type: "text", text }],
-        timestamp: 1,
-    };
-}
-function createAssistantMessage(text) {
-    return {
-        role: "assistant",
-        content: [{ type: "text", text }],
-        api: "anthropic-messages",
-        provider: "anthropic",
-        model: "claude-sonnet-4-5",
-        usage: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
-        stopReason: "stop",
-        timestamp: 1,
-    };
-}
-function operationStarted(id, { lane, kind }) {
-    let intent;
-    switch (kind) {
-        case "run":
-            intent = { kind, originalPrompt: [], initialMessages: [] };
-            break;
-        case "compaction":
-            intent = { kind, resultEntryId: `${id}-result` };
-            break;
-        case "navigation":
-            intent = { kind, targetId: null, summarize: false };
-            break;
-    }
-    return { type: "operation_started", id, lane, sourceLeafId: null, intent };
-}
-async function entryIds(entries) {
-    return (await entries).map((entry) => entry.id);
-}
-async function rejectsWithCode(operation, code) {
-    await rejects(operation, (error) => typeof error === "object" && error !== null && "code" in error && error.code === code, `Expected SessionError with code ${code}`);
-}
-function createCase(factory, group, name, test) {
-    return {
-        group,
-        name,
-        async run() {
-            const env_1 = { stack: [], error: void 0, hasError: false };
-            try {
-                const fixture = __addDisposableResource(env_1, await factory(), true);
-                await test(fixture.repository);
-            }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
-            }
-            finally {
-                const result_1 = __disposeResources(env_1);
-                if (result_1)
-                    await result_1;
-            }
-        },
-    };
-}
-/** Creates the session backend conformance cases. Each case creates and disposes its own fixture. */
-export function createSessionBackendConformance(factory) {
-    return [
-        createCase(factory, "entries and lanes", "assigns parents and one sequence across every mutation", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            const root = await session.appendEntry({ type: "message", id: "root", message: createUserMessage("root") }, "main");
-            await session.createLane("thread", root.id);
-            const child = await session.appendEntry({ type: "custom", id: "child", customType: "note", data: { value: 1 } }, "thread");
-            const record = await session.appendRecord(operationStarted("run", { lane: "thread", kind: "run" }));
-            await session.setName("Example");
-            await session.setLabel(root.id, "checkpoint");
-            await session.moveLane("main", child.id);
-            deepStrictEqual({ parentId: root.parentId, seq: root.seq }, { parentId: null, seq: 1 });
-            deepStrictEqual({ parentId: child.parentId, seq: child.seq }, { parentId: "root", seq: 3 });
-            strictEqual(record.seq, 4);
-            for (const timestamp of [root.timestamp, child.timestamp, record.timestamp]) {
-                ok(Number.isSafeInteger(timestamp) && timestamp >= 0, "storage-assigned timestamps must be Unix milliseconds");
-            }
-            deepStrictEqual((await session.getLog()).map((item) => [item.kind, item.seq]), [
-                ["entry", 1],
-                ["lane", 2],
-                ["entry", 3],
-                ["record", 4],
-                ["fact", 5],
-                ["fact", 6],
-                ["lane", 7],
-            ]);
-            deepStrictEqual(await session.getLanes(), [
-                { lane: "main", leafId: "child" },
-                { lane: "thread", leafId: "child" },
-            ]);
-        }),
-        createCase(factory, "records and log", "commits records and lane moves as separate mutations", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            const root = await session.appendEntry({ type: "message", id: "root", message: createUserMessage("root") }, "main");
-            const finished = await session.appendRecord({
-                type: "operation_finished",
-                id: "finish",
-                lane: "main",
-                runId: "run",
-                outcome: "completed",
-            });
-            strictEqual(finished.seq, 2);
-            deepStrictEqual(await session.getLanes(), [{ lane: "main", leafId: "root" }]);
-            await session.moveLane("main", null);
-            deepStrictEqual(await session.getLanes(), [{ lane: "main", leafId: null }]);
-            deepStrictEqual(await session.getLog(), [
-                { kind: "entry", seq: 1, entry: root },
-                { kind: "record", seq: 2, record: finished },
-                { kind: "lane", seq: 3, lane: "main", leafId: null },
-            ]);
-            await rejectsWithCode(session.moveLane("main", "missing"), "not_found");
-            strictEqual((await session.findRecords()).length, 1);
-            deepStrictEqual((await session.getLog()).map((item) => item.seq), [1, 2, 3]);
-        }),
-        createCase(factory, "entries and lanes", "rejects duplicate ids without changing state", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.appendEntry({ type: "message", id: "shared", message: createUserMessage("root") }, "main");
-            await rejectsWithCode(session.appendRecord(operationStarted("shared", { lane: "main", kind: "run" })), "already_exists");
-            await session.appendRecord(operationStarted("run", { lane: "main", kind: "run" }));
-            await rejectsWithCode(session.appendEntry({ type: "custom", id: "run", customType: "note" }, "main"), "already_exists");
-            deepStrictEqual((await session.getLog()).map((item) => item.seq), [1, 2]);
-        }),
-        createCase(factory, "entries and lanes", "isolates lanes while sharing the tree", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.appendEntry({ type: "message", id: "root", message: createUserMessage("root") }, "main");
-            await session.createLane("thread", "root");
-            await session.appendEntry({ type: "message", id: "main-child", message: createUserMessage("main") }, "main");
-            await session.appendEntry({ type: "message", id: "thread-child", message: createUserMessage("thread") }, "thread");
-            deepStrictEqual(await session.getLanes(), [
-                { lane: "main", leafId: "main-child" },
-                { lane: "thread", leafId: "thread-child" },
-            ]);
-            deepStrictEqual(await entryIds(session.findEntriesOnBranch({ start: "main-child", order: "oldestFirst" })), [
-                "root",
-                "main-child",
-            ]);
-            deepStrictEqual(await entryIds(session.findEntriesOnBranch({ start: "thread-child", order: "oldestFirst" })), [
-                "root",
-                "thread-child",
-            ]);
-        }),
-        createCase(factory, "queries and facts", "rejects invalid queries before empty reads", async (repository) => {
-            const session = await repository.create({ id: "invalid-queries" });
-            await session.createLane("thread", null);
-            const thread = session.view("thread");
-            await rejectsWithCode(session.findEntries({ limit: 0 }), "invalid_query");
-            await rejectsWithCode(session.findEntry({ limit: 0 }), "invalid_query");
-            await rejectsWithCode(session.findEntriesOnBranch({ limit: 0 }), "invalid_query");
-            await rejectsWithCode(thread.findEntriesOnBranch({ cursor: { afterSeq: -1 } }), "invalid_query");
-            await rejectsWithCode(thread.findEntryOnBranch({ limit: 0 }), "invalid_query");
-            await rejectsWithCode(session.findRecords({ limit: 0 }), "invalid_query");
-            await rejectsWithCode(session.findRecords({ operationKind: "run" }), "invalid_query");
-            await rejectsWithCode(session.findRecords({ type: "step_attempt", operationKind: "run" }), "invalid_query");
-            await rejectsWithCode(session.findOpenOperations("main", { limit: 0 }), "invalid_query");
-            await rejectsWithCode(session.findOpenOperations("main", { limit: -1 }), "invalid_query");
-            await rejectsWithCode(session.getLog({ afterSeq: -1 }), "invalid_query");
-        }),
-        createCase(factory, "queries and facts", "supports bounded filtered and cursor-based queries", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.appendEntry({ type: "message", id: "root", message: createUserMessage("root") }, "main");
-            await session.appendEntry({ type: "custom", id: "old-note", customType: "note", data: 1 }, "main");
-            await session.appendEntry({ type: "compaction", id: "compact", summary: "summary", retainedTail: [], tokensBefore: 10 }, "main");
-            await session.appendEntry({ type: "custom", id: "new-note", customType: "note", data: 2 }, "main");
-            await session.appendEntry({ type: "message", id: "tail", message: createAssistantMessage("tail") }, "main");
-            deepStrictEqual(await entryIds(session.findEntries()), ["tail", "new-note", "compact", "old-note", "root"]);
-            deepStrictEqual(await entryIds(session.findEntries({ order: "oldestFirst", cursor: { afterSeq: 2 }, limit: 2 })), ["compact", "new-note"]);
-            deepStrictEqual(await entryIds(session.findEntries({ customType: "note" })), ["new-note", "old-note"]);
-            deepStrictEqual(await entryIds(session.findEntriesOnBranch({ start: "tail", customType: "note", limit: 1 })), ["new-note"]);
-            deepStrictEqual(await entryIds(session.findEntriesOnBranch({ start: "tail", stopAtType: "compaction", type: "message" })), ["tail"]);
-            deepStrictEqual(await entryIds(session.findEntriesOnBranch({ start: "tail", stopAtId: "tail", type: "custom" })), []);
-            deepStrictEqual(await entryIds(session.findEntriesOnBranch({ start: "tail", stopAtType: "custom", order: "oldestFirst" })), ["root", "old-note"]);
-            await rejectsWithCode(session.findEntries({ limit: 0 }), "invalid_query");
-            await rejectsWithCode(session.findEntriesOnBranch({ start: "missing" }), "not_found");
-        }),
-        createCase(factory, "records and log", "keeps lane names permanent with their recovery records", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.createLane("thread", null);
-            await session.appendRecord(operationStarted("old-run", { lane: "thread", kind: "run" }));
-            await session.appendRecord({
-                type: "queue_enqueued",
-                id: "old-next-run",
-                lane: "thread",
-                queue: "nextRun",
-                target: { type: "message", id: "queued-message", message: createUserMessage("queued") },
-            });
-            deepStrictEqual((await session.findRecords({ lane: "thread" })).map((record) => record.id), ["old-next-run", "old-run"]);
-            deepStrictEqual((await session.getLog()).flatMap((item) => (item.kind === "record" ? [item.record.id] : [])), ["old-run", "old-next-run"]);
-            await rejectsWithCode(session.createLane("thread", null), "already_exists");
-        }),
-        createCase(factory, "records and log", "persists queue cancellation without consuming its target", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            const enqueued = await session.appendRecord({
-                type: "queue_enqueued",
-                id: "enqueue",
-                lane: "main",
-                queue: "nextRun",
-                target: { type: "message", id: "queued-message", message: createUserMessage("queued") },
-            });
-            const cancelled = await session.appendRecord({
-                type: "queue_cancelled",
-                id: "cancel",
-                lane: "main",
-                entryId: "queued-message",
-            });
-            deepStrictEqual({ seq: cancelled.seq, entryId: cancelled.entryId }, { seq: 2, entryId: "queued-message" });
-            strictEqual("runId" in cancelled, false);
-            strictEqual(await session.getEntry("queued-message"), undefined);
-            const cancellations = await session.findRecords({ type: "queue_cancelled" });
-            strictEqual(cancellations[0]?.entryId, "queued-message");
-            deepStrictEqual(cancellations, [cancelled]);
-            deepStrictEqual(await session.getLog(), [
-                { kind: "record", seq: enqueued.seq, record: enqueued },
-                { kind: "record", seq: cancelled.seq, record: cancelled },
-            ]);
-        }),
-        createCase(factory, "records and log", "filters records by lane type run sequence and order", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.appendRecord(operationStarted("run-1", { lane: "main", kind: "run" }));
-            await session.appendRecord({
-                type: "step_attempt",
-                id: "attempt-1",
-                lane: "main",
-                runId: "run-1",
-                step: "assistant",
-                attempt: 1,
-                resultEntryId: "assistant-1",
-            });
-            await session.createLane("thread", null);
-            await session.appendRecord(operationStarted("run-2", { lane: "thread", kind: "run" }));
-            await session.appendRecord({
-                type: "step_attempt",
-                id: "attempt-2",
-                lane: "thread",
-                runId: "run-2",
-                step: "assistant",
-                attempt: 1,
-                resultEntryId: "assistant-2",
-            });
-            deepStrictEqual((await session.findRecords({ lane: "thread" })).map((record) => record.id), ["attempt-2", "run-2"]);
-            deepStrictEqual((await session.findRecords({ type: "step_attempt", order: "oldestFirst" })).map((record) => record.id), ["attempt-1", "attempt-2"]);
-            deepStrictEqual((await session.findRecords({ runId: "run-1", afterSeq: 1 })).map((record) => record.id), ["attempt-1"]);
-            deepStrictEqual((await session.findRecords({ limit: 1 })).map((record) => record.id), ["attempt-2"]);
-        }),
-        createCase(factory, "records and log", "filters operation starts by operation kind", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.appendRecord(operationStarted("run-old", { lane: "main", kind: "run" }));
-            await session.appendRecord({
-                type: "operation_finished",
-                id: "run-old-finished",
-                lane: "main",
-                runId: "run-old",
-                outcome: "completed",
-            });
-            await session.appendRecord(operationStarted("compaction", { lane: "main", kind: "compaction" }));
-            await session.appendRecord({
-                type: "operation_finished",
-                id: "compaction-finished",
-                lane: "main",
-                runId: "compaction",
-                outcome: "completed",
-            });
-            await session.appendRecord(operationStarted("navigation", { lane: "main", kind: "navigation" }));
-            await session.appendRecord({
-                type: "operation_finished",
-                id: "navigation-finished",
-                lane: "main",
-                runId: "navigation",
-                outcome: "completed",
-            });
-            await session.appendRecord(operationStarted("run-new", { lane: "main", kind: "run" }));
-            deepStrictEqual((await session.findRecords({
-                type: "operation_started",
-                operationKind: "run",
-                order: "oldestFirst",
-            })).map((record) => record.id), ["run-old", "run-new"]);
-            deepStrictEqual((await session.findRecords({
-                type: "operation_started",
-                operationKind: "compaction",
-            })).map((record) => record.id), ["compaction"]);
-            deepStrictEqual((await session.findRecords({
-                type: "operation_started",
-                operationKind: "navigation",
-            })).map((record) => record.id), ["navigation"]);
-            deepStrictEqual((await session.findRecords({
-                type: "operation_started",
-                operationKind: "run",
-                limit: 1,
-            })).map((record) => record.id), ["run-new"]);
-        }),
-        createCase(factory, "records and log", "tracks and enforces one open operation per lane", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            deepStrictEqual(await session.findOpenOperations("main", { limit: 2 }), []);
-            const first = await session.appendRecord(operationStarted("first", { lane: "main", kind: "run" }));
-            deepStrictEqual(await session.findOpenOperations("main", { limit: 2 }), [first]);
-            await rejectsWithCode(session.appendRecord(operationStarted("second", { lane: "main", kind: "run" })), "storage");
-            deepStrictEqual(await session.findOpenOperations("main", { limit: 2 }), [first]);
-            await session.appendRecord({
-                type: "operation_finished",
-                id: "finish-first",
-                lane: "main",
-                runId: first.id,
-                outcome: "completed",
-            });
-            deepStrictEqual(await session.findOpenOperations("main", { limit: 2 }), []);
-        }),
-        createCase(factory, "records and log", "does not let an earlier finish close a later start", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.appendRecord({
-                type: "operation_finished",
-                id: "finish-before-start",
-                lane: "main",
-                runId: "run",
-                outcome: "completed",
-            });
-            const started = await session.appendRecord(operationStarted("run", { lane: "main", kind: "run" }));
-            deepStrictEqual(await session.findOpenOperations("main", { limit: 2 }), [started]);
-        }),
-        createCase(factory, "records and log", "scopes open operations by lane and limit", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.createLane("thread", null);
-            const mainRun = await session.appendRecord(operationStarted("main-run", { lane: "main", kind: "run" }));
-            const threadNavigation = await session.appendRecord(operationStarted("thread-navigation", { lane: "thread", kind: "navigation" }));
-            deepStrictEqual(await session.findOpenOperations("main"), [mainRun]);
-            deepStrictEqual(await session.findOpenOperations("main", { limit: 1 }), [mainRun]);
-            deepStrictEqual(await session.findOpenOperations("thread", { limit: 2 }), [threadNavigation]);
-        }),
-        createCase(factory, "validation and immutability", "returns immutable open-operation records", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            const committed = await session.appendRecord(operationStarted("run", { lane: "main", kind: "run" }));
-            const [read] = await session.findOpenOperations("main");
-            if (read?.intent.kind !== "run")
-                throw new Error("Expected an open run operation");
-            read.intent.originalPrompt.push(createUserMessage("mutated"));
-            deepStrictEqual(await session.findOpenOperations("main"), [committed]);
-        }),
-        createCase(factory, "queries and facts", "keeps latest-value facts and computes ledger statistics across lanes", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            const assistant = createAssistantMessage("answer");
-            if (assistant.role !== "assistant")
-                throw new Error("Expected assistant message");
-            assistant.usage = {
-                input: 10,
-                output: 5,
-                cacheRead: 3,
-                cacheWrite: 2,
-                totalTokens: 20,
-                cost: { input: 1, output: 2, cacheRead: 3, cacheWrite: 4, total: 10 },
-            };
-            await session.appendEntry({ type: "message", id: "user", message: createUserMessage("question") }, "main");
-            await session.appendEntry({ type: "message", id: "assistant", message: assistant }, "main");
-            await session.appendRecord({
-                type: "usage",
-                id: "assistant-usage",
-                lane: "main",
-                cause: "assistant",
-                runId: "run",
-                entryId: "assistant",
-                attempt: 1,
-                stopReason: "stop",
-                usage: assistant.usage,
-            });
-            await session.appendRecord({
-                type: "usage",
-                id: "deferred-usage",
-                lane: "main",
-                cause: "deferred_fetch",
-                runId: "run",
-                entryId: "deferred-result",
-                attempt: 1,
-                stopReason: "deferred",
-                usage: {
-                    input: 0,
-                    output: 0,
-                    cacheRead: 0,
-                    cacheWrite: 0,
-                    totalTokens: 0,
-                    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-                },
-            });
-            await session.createLane("thread", "assistant");
-            await session.appendRecord({
-                type: "usage",
-                id: "correction",
-                lane: "thread",
-                cause: "adjustment",
-                details: { reason: "provider correction" },
-                usage: {
-                    input: -2,
-                    output: 0,
-                    cacheRead: 0,
-                    cacheWrite: 0,
-                    totalTokens: -2,
-                    cost: { input: -0.5, output: 0, cacheRead: 0, cacheWrite: 0, total: -0.5 },
-                },
-            });
-            await session.setName("First");
-            await session.setName("Second");
-            await session.setLabel("user", "keep");
-            await session.setLabel("user", undefined);
-            await rejectsWithCode(session.setLabel("missing", "checkpoint"), "not_found");
-            strictEqual(await session.getName(), "Second");
-            strictEqual(await session.getLabel("user"), undefined);
-            const usageRecords = await session.findRecords({ type: "usage", order: "oldestFirst" });
-            deepStrictEqual(usageRecords.map((record) => record.cause), ["assistant", "deferred_fetch", "adjustment"]);
-            const deferredUsage = usageRecords.find((record) => record.cause === "deferred_fetch");
-            if (deferredUsage?.cause !== "deferred_fetch")
-                throw new Error("Expected deferred usage record");
-            strictEqual(deferredUsage.stopReason, "deferred");
-            deepStrictEqual(await session.getStats(), {
-                messageCount: 2,
-                cachedTokens: 3,
-                uncachedTokens: 10,
-                totalTokens: 18,
-                costTotal: 9.5,
-            });
-        }),
-        createCase(factory, "queries and facts", "clears session names durably", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.setName("Temporary");
-            await session.setName(undefined);
-            strictEqual(await session.getName(), undefined);
-            deepStrictEqual(await session.getLog(), [
-                { kind: "fact", seq: 1, fact: "name", name: "Temporary" },
-                { kind: "fact", seq: 2, fact: "name", name: undefined },
-            ]);
-            const metadata = await session.getMetadata();
-            const reopened = await repository.open(metadata);
-            strictEqual(await reopened.getName(), undefined);
-            deepStrictEqual(await reopened.getLog(), [
-                { kind: "fact", seq: 1, fact: "name", name: "Temporary" },
-                { kind: "fact", seq: 2, fact: "name", name: undefined },
-            ]);
-            const fork = await repository.fork(metadata, { id: "fork" });
-            strictEqual(await fork.getName(), undefined);
-        }),
-        createCase(factory, "validation and immutability", "returns immutable copies from reads", async (repository) => {
-            const session = await repository.create({ id: "immutable" });
-            const metadata = await session.getMetadata();
-            const data = { nested: { value: 1 } };
-            await session.appendEntry({ type: "custom", id: "custom", customType: "note", data }, "main");
-            data.nested.value = 50;
-            const read = await session.getEntry("custom");
-            if (read?.type !== "custom")
-                throw new Error("Expected custom entry");
-            read.data.nested.value = 99;
-            const readMetadata = await session.getMetadata();
-            readMetadata.id = "changed";
-            const log = await session.getLog();
-            if (log[0]?.kind !== "entry" || log[0].entry.type !== "custom")
-                throw new Error("Expected entry log");
-            log[0].entry.data.nested.value = 100;
-            deepStrictEqual(await session.getMetadata(), metadata);
-            deepStrictEqual(await session.getEntry("custom"), {
-                type: "custom",
-                id: "custom",
-                customType: "note",
-                data: { nested: { value: 1 } },
-                parentId: null,
-                seq: 1,
-                timestamp: read.timestamp,
-            });
-        }),
-        createCase(factory, "entries and lanes", "validates lane lifecycle and targets", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await rejectsWithCode(session.createLane("main", null), "already_exists");
-            await rejectsWithCode(session.createLane("thread", "missing"), "not_found");
-            await rejectsWithCode(session.moveLane("missing", null), "invalid_lane");
-        }),
-        createCase(factory, "entries and lanes", "binds lane views without caching leaves", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            const root = await session.appendMessage(createUserMessage("root"));
-            await session.createLane("thread", root);
-            const thread = session.view("thread");
-            const [mainChild, threadChild] = await Promise.all([
-                session.appendMessage(createUserMessage("main")),
-                thread.appendMessage(createUserMessage("thread")),
-            ]);
-            strictEqual(await session.getLeafId(), mainChild);
-            strictEqual(await thread.getLeafId(), threadChild);
-            deepStrictEqual(await entryIds(session.findEntriesOnBranch({ order: "oldestFirst" })), [root, mainChild]);
-            deepStrictEqual(await entryIds(thread.findEntriesOnBranch({ order: "oldestFirst" })), [root, threadChild]);
-            const empty = await repository.create({ id: "empty" });
-            deepStrictEqual(await empty.findEntriesOnBranch(), []);
-        }),
-        createCase(factory, "entries and lanes", "appends provisioned entries with their existing ids", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            const entry = await session.appendEntry({ type: "custom", id: "provisioned", customType: "note", data: { value: 1 } }, "main");
-            strictEqual(entry.customType, "note");
-            deepStrictEqual({ id: entry.id, parentId: entry.parentId, seq: entry.seq }, { id: "provisioned", parentId: null, seq: 1 });
-            strictEqual(await session.getLeafId(), "provisioned");
-        }),
-        createCase(factory, "entries and lanes", "persists tool-result termination decisions", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            const entry = await session.appendEntry({
-                type: "message",
-                id: "tool-result",
-                message: {
-                    role: "toolResult",
-                    toolCallId: "call-1",
-                    toolName: "example",
-                    content: [{ type: "text", text: "done" }],
-                    isError: false,
-                    timestamp: 1,
-                },
-                terminate: true,
-            }, "main");
-            strictEqual(entry.terminate, true);
-            const stored = await session.getEntry(entry.id);
-            if (stored?.type !== "message")
-                throw new Error("Expected message entry");
-            strictEqual(stored.terminate, true);
-            deepStrictEqual(await session.findEntries(), [entry]);
-            deepStrictEqual(await session.getLog(), [{ kind: "entry", seq: entry.seq, entry }]);
-        }),
-        createCase(factory, "validation and immutability", "rejects non-JSON entries before storage mutation", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            const cyclic = {};
-            cyclic.self = cyclic;
-            for (const data of [
-                { value: undefined },
-                [undefined],
-                { value: 1n },
-                { value: Number.NaN },
-                { value: new Map() },
-                cyclic,
-            ]) {
-                await rejectsWithCode(session.appendCustomEntry("invalid", data), "invalid_payload");
-            }
-            strictEqual(await session.getLeafId(), null);
-            deepStrictEqual(await session.findEntries(), []);
-            deepStrictEqual(await session.getLog(), []);
-            const validId = await session.appendCustomEntry("valid", { value: 1 });
-            strictEqual((await session.getEntry(validId))?.seq, 1);
-        }),
-        createCase(factory, "validation and immutability", "rejects non-JSON records before storage mutation", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            for (const [id, value] of [
-                ["undefined-record", undefined],
-                ["bigint-record", 1n],
-            ]) {
-                await rejectsWithCode(session.appendRecord({
-                    type: "tool_started",
-                    id,
-                    lane: "main",
-                    runId: "run",
-                    assistantEntryId: "assistant",
-                    toolIndex: 0,
-                    toolCallId: "call",
-                    toolName: "example",
-                    effectiveArgs: { value },
-                    resultEntryId: "result",
-                    replay: "never",
-                }), "invalid_payload");
-            }
-            deepStrictEqual(await session.findRecords(), []);
-            deepStrictEqual(await session.getLog(), []);
-            strictEqual((await session.appendRecord(operationStarted("valid-record", { lane: "main", kind: "run" }))).seq, 1);
-        }),
-        createCase(factory, "entries and lanes", "linearizes concurrent writes across two lanes", async (repository) => {
-            const session = await repository.create({ id: "session" });
-            await session.appendEntry({ type: "message", id: "root", message: createUserMessage("root") }, "main");
-            await session.createLane("thread", "root");
-            const completionOrder = [];
-            const writes = [
-                session.appendEntry({ type: "custom", id: "main-1", customType: "note" }, "main"),
-                session.appendEntry({ type: "custom", id: "thread-1", customType: "note" }, "thread"),
-                session.appendEntry({ type: "custom", id: "main-2", customType: "note" }, "main"),
-                session.appendEntry({ type: "custom", id: "thread-2", customType: "note" }, "thread"),
-            ].map((write) => write.then((entry) => {
-                completionOrder.push(entry.id);
-                return entry;
-            }));
-            const entries = await Promise.all(writes);
-            const commitOrder = [...entries].sort((left, right) => left.seq - right.seq).map((entry) => entry.id);
-            strictEqual(new Set(entries.map((entry) => entry.seq)).size, entries.length);
-            deepStrictEqual(completionOrder, commitOrder);
-            const concurrentIds = new Set(entries.map((entry) => entry.id));
-            deepStrictEqual((await session.getLog()).flatMap((item) => item.kind === "entry" && concurrentIds.has(item.entry.id) ? [item.entry.id] : []), commitOrder);
-            const sequences = (await session.getLog()).map((item) => item.seq);
-            deepStrictEqual(sequences, [...sequences].sort((left, right) => left - right));
-        }),
-        createCase(factory, "repository and forks", "creates lists and opens sessions", async (repository) => {
-            const session = await repository.create({ id: "one" });
-            const entryId = await session.appendMessage(createUserMessage("persisted"));
-            const metadata = await session.getMetadata();
-            const listed = await repository.list();
-            strictEqual(listed.length, 1);
-            strictEqual(listed[0]?.id, metadata.id);
-            strictEqual(listed[0]?.createdAt, metadata.createdAt);
-            strictEqual(listed[0]?.parentSessionId, metadata.parentSessionId);
-            deepStrictEqual(await entryIds((await repository.open(metadata)).findEntries()), [entryId]);
-            await rejectsWithCode(repository.create({ id: "one" }), "already_exists");
-        }),
-        createCase(factory, "repository and forks", "deletes sessions idempotently", async (repository) => {
-            const session = await repository.create({ id: "one" });
-            const metadata = await session.getMetadata();
-            await repository.delete(metadata);
-            await rejectsWithCode(repository.open(metadata), "not_found");
-            await repository.delete(metadata);
-        }),
-        createCase(factory, "repository and forks", "forks one branch with selected facts and no records", async (repository) => {
-            const source = await repository.create({ id: "source" });
-            const root = await source.appendMessage(createUserMessage("root"));
-            const shared = await source.appendMessage(createAssistantMessage("shared"));
-            await source.createLane("thread", shared);
-            const threadChild = await source.view("thread").appendMessage(createUserMessage("thread"));
-            const mainChild = await source.appendMessage(createUserMessage("main"));
-            await source.setName("Source");
-            await source.setLabel(shared, "copied");
-            await source.setLabel(threadChild, "excluded");
-            await source.appendRecord(operationStarted("run", { lane: "main", kind: "run" }));
-            await source.appendRecord({
-                type: "usage",
-                id: "source-usage",
-                lane: "main",
-                cause: "adjustment",
-                usage: {
-                    input: 10,
-                    output: 5,
-                    cacheRead: 3,
-                    cacheWrite: 2,
-                    totalTokens: 20,
-                    cost: { input: 1, output: 2, cacheRead: 3, cacheWrite: 4, total: 10 },
-                },
-            });
-            const fork = await repository.fork(await source.getMetadata(), {
-                scope: "branch",
-                entryId: mainChild,
-                position: "at",
-                id: "branch-fork",
-            });
-            deepStrictEqual(await entryIds(fork.findEntries({ order: "oldestFirst" })), [root, shared, mainChild]);
-            deepStrictEqual(await fork.getLanes(), [{ lane: "main", leafId: mainChild }]);
-            strictEqual(await fork.getName(), "Source");
-            strictEqual(await fork.getLabel(shared), "copied");
-            strictEqual(await fork.getLabel(threadChild), undefined);
-            deepStrictEqual(await fork.findRecords(), []);
-            deepStrictEqual(await fork.getStats(), {
-                messageCount: 3,
-                cachedTokens: 0,
-                uncachedTokens: 0,
-                totalTokens: 0,
-                costTotal: 0,
-            });
-            await fork.appendMessage(createUserMessage("after fork"));
-            strictEqual((await fork.getStats()).messageCount, 4);
-            const metadata = await fork.getMetadata();
-            deepStrictEqual({ id: metadata.id, parentSessionId: metadata.parentSessionId }, { id: "branch-fork", parentSessionId: "source" });
-        }),
-        createCase(factory, "repository and forks", "forks a complete tree with lanes and facts", async (repository) => {
-            const source = await repository.create({ id: "source" });
-            const root = await source.appendMessage(createUserMessage("root"));
-            await source.createLane("thread", root);
-            const mainChild = await source.appendMessage(createUserMessage("main"));
-            const threadChild = await source.view("thread").appendMessage(createUserMessage("thread"));
-            await source.setLabel(threadChild, "thread-tip");
-            const fork = await repository.fork(await source.getMetadata(), { scope: "tree", id: "tree-fork" });
-            deepStrictEqual(await entryIds(fork.findEntries({ order: "oldestFirst" })), [root, mainChild, threadChild]);
-            deepStrictEqual(await fork.getLanes(), [
-                { lane: "main", leafId: mainChild },
-                { lane: "thread", leafId: threadChild },
-            ]);
-            strictEqual(await fork.getLabel(threadChild), "thread-tip");
-            strictEqual((await fork.getStats()).messageCount, 3);
-            deepStrictEqual((await fork.getLog()).filter((item) => item.kind === "lane"), [
-                { kind: "lane", seq: 4, lane: "main", leafId: mainChild },
-                { kind: "lane", seq: 5, lane: "thread", leafId: threadChild },
-            ]);
-        }),
-        createCase(factory, "repository and forks", "forks before an entry without modifying the source", async (repository) => {
-            const source = await repository.create({ id: "source" });
-            const root = await source.appendMessage(createUserMessage("root"));
-            const tail = await source.appendMessage(createUserMessage("tail"));
-            const fork = await repository.fork(await source.getMetadata(), { entryId: tail, id: "fork" });
-            deepStrictEqual(await entryIds(fork.findEntries({ order: "oldestFirst" })), [root]);
-            strictEqual(await fork.getLeafId(), root);
-            strictEqual(await source.getLeafId(), tail);
-            const beforeDefaultTarget = await repository.fork(await source.getMetadata(), {
-                position: "before",
-                id: "before-default-target",
-            });
-            deepStrictEqual(await entryIds(beforeDefaultTarget.findEntries({ order: "oldestFirst" })), [root]);
-            strictEqual(await beforeDefaultTarget.getLeafId(), root);
-            const atDefaultTarget = await repository.fork(await source.getMetadata(), {
-                position: "at",
-                id: "at-default-target",
-            });
-            deepStrictEqual(await entryIds(atDefaultTarget.findEntries({ order: "oldestFirst" })), [root, tail]);
-            strictEqual(await atDefaultTarget.getLeafId(), tail);
-            await rejectsWithCode(repository.fork(await source.getMetadata(), { entryId: "missing" }), "invalid_fork_target");
-        }),
-        createCase(factory, "repository and forks", "validates the default fork target", async (repository) => {
-            const source = await repository.create({ id: "source-with-custom-leaf" });
-            await source.appendCustomEntry("not-a-message");
-            await rejectsWithCode(repository.fork(await source.getMetadata(), { id: "fork" }), "invalid_fork_target");
-        }),
-    ];
-}
-//# sourceMappingURL=conformance.js.map