@earendil-works/pi-agent-core 0.85.1 → 0.86.0

package/dist/harness/session/testing/conformance/session-repo.js

@@ -1,7 +1,7 @@
 import { deepStrictEqual, rejects, strictEqual } from "node:assert/strict";
 import { BACKGROUND_CONTEXT } from "../../../context.js";
 import { insertEntry, insertUsage } from "../../commit.js";
-import { appendList, branchTip, entryLabel, laneConfig, laneState, list, operationMeta, operationPreparation, operationResult, operationState, operationToolArgs, pendingEntry, sessionName, setValue, value, } from "../../values.js";
+import { appendList, branchTip, deleteList, entryLabel, laneConfig, laneState, list, operationMeta, operationPreparation, operationResult, operationState, operationToolArgs, pendingEntry, sessionName, setValue, value, } from "../../values.js";
 const ROOT_ID = "00000000-0000-7000-8000-000000000001";
 const CHILD_ID = "00000000-0000-7000-8000-000000000002";
 const SIBLING_ID = "00000000-0000-7000-8000-000000000003";
@@ -491,6 +491,225 @@ export function createSessionRepoForkBehaviorConformance(backendFactory, onClose
         }),
     ];
 }
+/** WP08 cases enabled for Memory and JSONL while SQLite's streaming fork implementation is pending. */
+export function createSessionRepoStreamingForkConformance(backendFactory, onClose) {
+    // Merge into createSessionRepoForkConformance once SQLite supports these cases.
+    return [
+        ...createSessionRepoForkApplicationListConformance(backendFactory, onClose),
+        ...createSessionRepoBranchForkApplicationStateConformance(backendFactory, onClose),
+        ...createSessionRepoForkLaneValidationConformance(backendFactory, onClose),
+    ];
+}
+function createSessionRepoForkLaneValidationConformance(backendFactory, onClose) {
+    const factory = prepareRepoCaseFactory(backendFactory, onClose);
+    return [
+        createCase(factory, "fork lane validation", "ignores malformed unrelated lanes", async ({ repo }) => {
+            const source = await repo.create({ id: "source" }, BACKGROUND_CONTEXT);
+            let tree;
+            let branch;
+            try {
+                await source.createBranch("main", null, BACKGROUND_CONTEXT);
+                await source.mutate((mutator) => mutator.commit([
+                    setValue(laneConfig("main"), configuration),
+                    setValue(laneState("main"), idleLaneState),
+                    setValue(laneConfig("unrelated"), configuration),
+                ], BACKGROUND_CONTEXT), BACKGROUND_CONTEXT);
+                tree = await repo.fork(source.metadata, { id: "tree", scope: "tree" }, BACKGROUND_CONTEXT);
+                branch = await repo.fork(source.metadata, { id: "branch", scope: "branch", branch: "main" }, BACKGROUND_CONTEXT);
+                strictEqual(await getBranchTip(branch), null);
+            }
+            finally {
+                await Promise.all([
+                    source.close(BACKGROUND_CONTEXT),
+                    tree?.close(BACKGROUND_CONTEXT),
+                    branch?.close(BACKGROUND_CONTEXT),
+                ]);
+            }
+        }),
+    ];
+}
+/** Creates application-list fork cases. */
+function createSessionRepoForkApplicationListConformance(backendFactory, onClose) {
+    const factory = prepareRepoCaseFactory(backendFactory, onClose);
+    return ["open", "closed"].flatMap((sourceState) => [
+        createCase(factory, `fork application lists (${sourceState} source)`, "tree fork copies lists at distinct addresses", async ({ repo }) => {
+            // Each list keeps its own contents: keys "" and "other" in one namespace must not merge.
+            // A different namespace also stays separate; pi2.events is application-owned, not reserved.
+            const source = await repo.create({ id: "source" }, BACKGROUND_CONTEXT);
+            let fork;
+            try {
+                const events = list("test.application.events");
+                const sibling = list(events.namespace, "other");
+                const otherNamespace = list("pi2.events");
+                const absent = list(events.namespace, "absent");
+                await source.appendList(events, "event", BACKGROUND_CONTEXT);
+                await source.appendList(sibling, "sibling", BACKGROUND_CONTEXT);
+                await source.appendList(otherNamespace, "other namespace", BACKGROUND_CONTEXT);
+                if (sourceState === "closed")
+                    await source.close(BACKGROUND_CONTEXT);
+                fork = await repo.fork(source.metadata, { id: "fork", scope: "tree" }, BACKGROUND_CONTEXT);
+                deepStrictEqual((await fork.readList(events, undefined, BACKGROUND_CONTEXT)).map(({ value }) => value), ["event"]);
+                deepStrictEqual((await fork.readList(sibling, undefined, BACKGROUND_CONTEXT)).map(({ value }) => value), ["sibling"]);
+                deepStrictEqual((await fork.readList(otherNamespace, undefined, BACKGROUND_CONTEXT)).map(({ value }) => value), ["other namespace"]);
+                deepStrictEqual(await fork.readList(absent, undefined, BACKGROUND_CONTEXT), []);
+            }
+            finally {
+                await Promise.all([source.close(BACKGROUND_CONTEXT), fork?.close(BACKGROUND_CONTEXT)]);
+            }
+        }),
+        createCase(factory, `fork application lists (${sourceState} source)`, "tree fork copies only survivors after list deletion and reappend", async ({ repo }) => {
+            // Append old -> delete -> append new must copy only new, even when changes share a transaction.
+            // A list deleted without a later append must remain empty in the fork.
+            const source = await repo.create({ id: "source" }, BACKGROUND_CONTEXT);
+            let fork;
+            try {
+                const events = list("test.application.events");
+                const deleted = list(events.namespace, "deleted");
+                await source.appendList(events, "old", BACKGROUND_CONTEXT);
+                await source.appendList(deleted, "removed", BACKGROUND_CONTEXT);
+                await source.mutate((mutator) => mutator.commit([
+                    deleteList(events),
+                    appendList(events, "temporary"),
+                    deleteList(events),
+                    appendList(events, "first survivor"),
+                    deleteList(deleted),
+                ], BACKGROUND_CONTEXT), BACKGROUND_CONTEXT);
+                await source.appendList(events, "second survivor", BACKGROUND_CONTEXT);
+                if (sourceState === "closed")
+                    await source.close(BACKGROUND_CONTEXT);
+                fork = await repo.fork(source.metadata, { id: "fork", scope: "tree" }, BACKGROUND_CONTEXT);
+                deepStrictEqual((await fork.readList(events, undefined, BACKGROUND_CONTEXT)).map(({ value }) => value), ["first survivor", "second survivor"]);
+                deepStrictEqual(await fork.readList(deleted, undefined, BACKGROUND_CONTEXT), []);
+            }
+            finally {
+                await Promise.all([source.close(BACKGROUND_CONTEXT), fork?.close(BACKGROUND_CONTEXT)]);
+            }
+        }),
+        createCase(factory, `fork application lists (${sourceState} source)`, "tree fork preserves list element sequences including gaps", async ({ repo }) => {
+            // Other writes consume sequences too. List elements at seq 2 and 4 must stay at 2 and 4
+            // in the fork, not be renumbered to 1 and 2.
+            const source = await repo.create({ id: "source" }, BACKGROUND_CONTEXT);
+            let fork;
+            try {
+                const events = list("test.application.events");
+                const committed = await source.mutate((mutator) => mutator.commit([
+                    setValue(sessionName, "before"),
+                    appendList(events, "first"),
+                    setValue(sessionName, "between"),
+                    appendList(events, "second"),
+                ], BACKGROUND_CONTEXT), BACKGROUND_CONTEXT);
+                if (sourceState === "closed")
+                    await source.close(BACKGROUND_CONTEXT);
+                fork = await repo.fork(source.metadata, { id: "fork", scope: "tree" }, BACKGROUND_CONTEXT);
+                deepStrictEqual(await fork.readList(events, undefined, BACKGROUND_CONTEXT), [
+                    { seq: committed.seqs[1], value: "first" },
+                    { seq: committed.seqs[3], value: "second" },
+                ]);
+            }
+            finally {
+                await Promise.all([source.close(BACKGROUND_CONTEXT), fork?.close(BACKGROUND_CONTEXT)]);
+            }
+        }),
+        ...["asc", "desc"].map((order) => createCase(factory, `fork application lists (${sourceState} source)`, `tree fork continues ${order} pagination using source cursors`, async ({ repo }) => {
+            // A cursor from the source must resume at the same place in the fork. After reading
+            // [first, second] ascending, continue with [third]; descending does the reverse.
+            // Continuing after the final element must return an empty page, not repeat that element.
+            const source = await repo.create({ id: "source" }, BACKGROUND_CONTEXT);
+            let fork;
+            try {
+                const events = list("test.application.events");
+                for (const item of ["first", "second", "third"]) {
+                    await source.appendList(events, item, BACKGROUND_CONTEXT);
+                }
+                const firstPage = await source.readList(events, { order, limit: 2 }, BACKGROUND_CONTEXT);
+                strictEqual(firstPage.length, 2);
+                const cursor = { seq: firstPage[1].seq };
+                const lastPage = await source.readList(events, { order, cursor, limit: 2 }, BACKGROUND_CONTEXT);
+                deepStrictEqual(lastPage.map(({ value }) => value), [order === "asc" ? "third" : "first"]);
+                const endCursor = { seq: lastPage[0].seq };
+                if (sourceState === "closed")
+                    await source.close(BACKGROUND_CONTEXT);
+                fork = await repo.fork(source.metadata, { id: "fork", scope: "tree" }, BACKGROUND_CONTEXT);
+                deepStrictEqual(await fork.readList(events, { order, limit: 2 }, BACKGROUND_CONTEXT), firstPage);
+                deepStrictEqual(await fork.readList(events, { order, cursor, limit: 2 }, BACKGROUND_CONTEXT), lastPage);
+                deepStrictEqual(await fork.readList(events, { order, cursor: endCursor, limit: 2 }, BACKGROUND_CONTEXT), []);
+            }
+            finally {
+                await Promise.all([source.close(BACKGROUND_CONTEXT), fork?.close(BACKGROUND_CONTEXT)]);
+            }
+        })),
+    ]);
+}
+/** Creates branch application-state cases. */
+function createSessionRepoBranchForkApplicationStateConformance(backendFactory, onClose) {
+    const factory = prepareRepoCaseFactory(backendFactory, onClose);
+    return ["open", "closed"].flatMap((sourceState) => [
+        createCase(factory, `branch fork application state (${sourceState} source)`, "excludes overwritten and unchanged application values", async ({ repo }) => {
+            // WP08 §1.1: set v1 -> fork point -> overwrite with v2. A branch fork copies neither
+            // version: it cannot reconstruct v1 and must not copy v2. Even unchanged older values
+            // are excluded, so filtering current values by the fork point's sequence is not enough.
+            const source = await repo.create({ id: "source" }, BACKGROUND_CONTEXT);
+            let fork;
+            try {
+                const state = value("test.application.state");
+                const unchanged = value("test.application.settings");
+                const branch = await source.createBranch("review", null, BACKGROUND_CONTEXT);
+                await source.mutate((mutator) => mutator.commit([
+                    setValue(laneConfig("review"), configuration),
+                    setValue(laneState("review"), idleLaneState),
+                    setValue(state, "v1"),
+                    setValue(unchanged, "predates fork point"),
+                ], BACKGROUND_CONTEXT), BACKGROUND_CONTEXT);
+                const entryId = await branch.appendCustomEntry("fork-point", undefined, BACKGROUND_CONTEXT);
+                await source.setValue(state, "v2", BACKGROUND_CONTEXT);
+                strictEqual((await source.getValue(state, BACKGROUND_CONTEXT))?.value, "v2");
+                if (sourceState === "closed")
+                    await source.close(BACKGROUND_CONTEXT);
+                fork = await repo.fork(source.metadata, { scope: "branch", branch: "review", entryId }, BACKGROUND_CONTEXT);
+                strictEqual(await getBranchTip(fork, "review"), entryId);
+                strictEqual(await fork.getValue(state, BACKGROUND_CONTEXT), undefined);
+                // A survivor older than the fork point must also be excluded, not copied by a seq cutoff.
+                strictEqual(await fork.getValue(unchanged, BACKGROUND_CONTEXT), undefined);
+            }
+            finally {
+                await Promise.all([source.close(BACKGROUND_CONTEXT), fork?.close(BACKGROUND_CONTEXT)]);
+            }
+        }),
+        createCase(factory, `branch fork application state (${sourceState} source)`, "excludes deleted/reappended and untouched application lists", async ({ repo }) => {
+            // WP08 §1.1: append old -> fork point -> delete -> append new. A branch fork copies
+            // neither the deleted elements nor the new ones. A separate untouched list is also
+            // excluded, even though its elements still survive from before the fork point.
+            const source = await repo.create({ id: "source" }, BACKGROUND_CONTEXT);
+            let fork;
+            try {
+                const events = list("test.application.events");
+                const untouched = list(events.namespace, "untouched");
+                const branch = await source.createBranch("review", null, BACKGROUND_CONTEXT);
+                await source.mutate((mutator) => mutator.commit([
+                    setValue(laneConfig("review"), configuration),
+                    setValue(laneState("review"), idleLaneState),
+                    appendList(events, "old first"),
+                    appendList(events, "old second"),
+                    appendList(untouched, "predates fork point"),
+                ], BACKGROUND_CONTEXT), BACKGROUND_CONTEXT);
+                const entryId = await branch.appendCustomEntry("fork-point", undefined, BACKGROUND_CONTEXT);
+                await source.deleteList(events, BACKGROUND_CONTEXT);
+                await source.appendList(events, "new", BACKGROUND_CONTEXT);
+                deepStrictEqual((await source.readList(events, undefined, BACKGROUND_CONTEXT)).map(({ value }) => value), ["new"]);
+                if (sourceState === "closed")
+                    await source.close(BACKGROUND_CONTEXT);
+                fork = await repo.fork(source.metadata, { scope: "branch", branch: "review", entryId }, BACKGROUND_CONTEXT);
+                strictEqual(await getBranchTip(fork, "review"), entryId);
+                deepStrictEqual(await fork.readList(events, undefined, BACKGROUND_CONTEXT), []);
+                // Even elements still surviving from before the fork point are excluded.
+                deepStrictEqual(await fork.readList(untouched, undefined, BACKGROUND_CONTEXT), []);
+            }
+            finally {
+                await Promise.all([source.close(BACKGROUND_CONTEXT), fork?.close(BACKGROUND_CONTEXT)]);
+            }
+        }),
+    ]);
+}
 /** Creates fork cases that require destination reservation across create and fork. */
 export function createSessionRepoForkDestinationReservationConformance(backendFactory, onClose) {
     const factory = prepareRepoCaseFactory(backendFactory, onClose);