@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/vendor/engine/runtime/agent/harness/session/in-memory-storage-state.js

@@ -0,0 +1,275 @@
+import { andorraAddUsage, andorraEmptyUsage } from "../utils/usage.js";
+import { andorraPrepareStorageCommit, andorraValidateCommittedWrites, } from "./commit.js";
+import { andorraProjectForkCurrentStateWrite, andorraSelectBranchFork } from "./fork-policy.js";
+import { andorraBranchTip, andorraLaneConfig, andorraLaneState, andorraList, andorraResolveListReadOptions, andorraValue, } from "./values.js";
+function andorraPhysicalKey(namespace, key) {
+    return `${namespace}\u0000${key}`;
+}
+function andorraCompareKeys(left, right) {
+    const leftCodePoints = Array.from(left, (character) => character.codePointAt(0));
+    const rightCodePoints = Array.from(right, (character) => character.codePointAt(0));
+    const length = Math.min(leftCodePoints.length, rightCodePoints.length);
+    for (let index = 0; index < length; index++) {
+        const difference = leftCodePoints[index] - rightCodePoints[index];
+        if (difference !== 0)
+            return difference;
+    }
+    return leftCodePoints.length - rightCodePoints.length;
+}
+/**
+ * Complete materialized session state for MemoryStorage and JsonlStorage.
+ *
+ * This is intentionally unsuitable for database backends and long-running sessions that may not fit in memory.
+ * Those backends should query indexed durable state and update durable aggregates within each commit transaction.
+ */
+export class AndorraInMemoryStorageState {
+    entries;
+    entriesBySeq;
+    scalarValues;
+    listValues;
+    usage;
+    stats;
+    nextSeq;
+    constructor() {
+        this.entries = new Map();
+        this.entriesBySeq = [];
+        this.scalarValues = new Map();
+        this.listValues = new Map();
+        this.usage = new Map();
+        this.stats = { messageCount: 0, usage: andorraEmptyUsage() };
+        this.nextSeq = 1;
+    }
+    prepareCommit(writes, timestamp) {
+        const prepared = andorraPrepareStorageCommit(writes, this.nextSeq, timestamp);
+        this.validateCommitted(prepared.writes);
+        return prepared;
+    }
+    validateCommitted(writes) {
+        andorraValidateCommittedWrites(writes, this.nextSeq, {
+            hasEntryOrUsageId: (id) => this.entries.has(id) || this.usage.has(id),
+            hasEntryId: (id) => this.entries.has(id),
+        });
+    }
+    /** Apply writes already accepted by validateCommitted() and return the post-apply totals. */
+    applyValidated(writes) {
+        for (const write of writes) {
+            switch (write.kind) {
+                case "entry": {
+                    const { kind: _kind, ...entry } = write;
+                    this.entries.set(entry.id, entry);
+                    this.entriesBySeq.push(entry);
+                    if (entry.type === "message")
+                        this.stats = { ...this.stats, messageCount: this.stats.messageCount + 1 };
+                    break;
+                }
+                case "usage": {
+                    const { kind: _kind, ...row } = write;
+                    this.usage.set(row.id, row);
+                    this.stats = { ...this.stats, usage: andorraAddUsage(this.stats.usage, row.usage) };
+                    break;
+                }
+                case "value":
+                    if (write.op === "delete")
+                        this.scalarValues.delete(andorraPhysicalKey(write.namespace, write.key));
+                    else
+                        this.applyValueSetOrListAppend(write);
+                    break;
+                case "list":
+                    if (write.op === "delete")
+                        this.listValues.delete(andorraPhysicalKey(write.namespace, write.key));
+                    else
+                        this.applyValueSetOrListAppend(write);
+                    break;
+            }
+            this.nextSeq = write.seq + 1;
+        }
+        return this.stats;
+    }
+    createFork(options) {
+        const plan = this.selectForkPlan(options);
+        const andorraIsEntryCopied = (entryId) => {
+            if (plan.scope === "tree")
+                return true;
+            return plan.entryIds.has(entryId);
+        };
+        const destination = new AndorraInMemoryStorageState();
+        let messageCount = 0;
+        for (const entry of this.entriesBySeq) {
+            if (!andorraIsEntryCopied(entry.id))
+                continue;
+            destination.entries.set(entry.id, entry);
+            destination.entriesBySeq.push(entry);
+            if (entry.type === "message")
+                messageCount++;
+        }
+        destination.stats = { ...destination.stats, messageCount };
+        for (const stored of this.scalarValues.values()) {
+            const projected = andorraProjectForkCurrentStateWrite({
+                kind: "value",
+                op: "set",
+                seq: stored.seq,
+                namespace: stored.address.namespace,
+                key: stored.address.key,
+                value: stored.value,
+            }, plan, andorraIsEntryCopied);
+            if (projected !== undefined)
+                destination.applyValueSetOrListAppend(projected);
+        }
+        for (const stored of this.listValues.values()) {
+            for (const element of stored.elements) {
+                const projected = andorraProjectForkCurrentStateWrite({
+                    kind: "list",
+                    op: "append",
+                    seq: element.seq,
+                    namespace: stored.address.namespace,
+                    key: stored.address.key,
+                    value: element.value,
+                }, plan, andorraIsEntryCopied);
+                if (projected !== undefined)
+                    destination.applyValueSetOrListAppend(projected);
+            }
+        }
+        destination.nextSeq = this.nextSeq;
+        return destination;
+    }
+    selectForkPlan(options) {
+        if (options.scope === "tree")
+            return { scope: "tree" };
+        const entryIds = new Set();
+        const plan = andorraSelectBranchFork(options, {
+            tip: this.getValue(andorraBranchTip(options.branch))?.value,
+            getParent: (entryId) => this.entries.get(entryId)?.parentId,
+            selectEntry: (entryId) => entryIds.add(entryId),
+        });
+        if (this.getValue(andorraLaneConfig(options.branch)) === undefined ||
+            this.getValue(andorraLaneState(options.branch)) === undefined) {
+            throw new Error(`Source branch ${JSON.stringify(options.branch)} is not a configured AgentLane`);
+        }
+        return { ...plan, entryIds };
+    }
+    applyValueSetOrListAppend(write) {
+        const key = andorraPhysicalKey(write.namespace, write.key);
+        if (write.kind === "value") {
+            this.scalarValues.set(key, {
+                address: andorraValue(write.namespace, write.key),
+                value: write.value,
+                seq: write.seq,
+            });
+            return;
+        }
+        const element = { seq: write.seq, value: write.value };
+        const stored = this.listValues.get(key);
+        if (stored === undefined) {
+            this.listValues.set(key, {
+                address: andorraList(write.namespace, write.key),
+                elements: [element],
+            });
+        }
+        else {
+            stored.elements.push(element);
+        }
+    }
+    advanceNextSeq(nextSeq) {
+        if (!Number.isSafeInteger(nextSeq) || nextSeq < 1) {
+            throw new Error(`Invalid storage sequence high-water mark: ${nextSeq}`);
+        }
+        this.nextSeq = Math.max(this.nextSeq, nextSeq);
+    }
+    getEntries(ids) {
+        const found = new Map();
+        for (const id of ids) {
+            const entry = this.entries.get(id);
+            if (entry !== undefined)
+                found.set(id, entry);
+        }
+        return found;
+    }
+    getValue(address) {
+        return this.scalarValues.get(andorraPhysicalKey(address.namespace, address.key));
+    }
+    scanValues(prefix) {
+        return [...this.scalarValues.values()]
+            .filter((stored) => stored.address.namespace === prefix.namespace && stored.address.key.startsWith(prefix.key))
+            .sort((left, right) => andorraCompareKeys(left.address.key, right.address.key));
+    }
+    readList(address, options) {
+        const resolved = andorraResolveListReadOptions(options);
+        const elements = this.listValues.get(andorraPhysicalKey(address.namespace, address.key))?.elements ?? [];
+        const filtered = elements.filter((element) => {
+            if (resolved.cursor === undefined)
+                return true;
+            return resolved.order === "asc" ? element.seq > resolved.cursor.seq : element.seq < resolved.cursor.seq;
+        });
+        const ordered = resolved.order === "asc" ? filtered : [...filtered].reverse();
+        return ordered.slice(0, resolved.limit);
+    }
+    scanBranch(query) {
+        const start = this.entries.get(query.start);
+        if (start === undefined)
+            throw new Error(`Unknown branch start: ${query.start}`);
+        const path = [];
+        let entry = start;
+        while (entry !== undefined) {
+            path.push(entry);
+            if (entry.parentId === null)
+                break;
+            entry = this.entries.get(entry.parentId);
+            if (entry === undefined)
+                throw new Error("Corrupt branch: missing parent");
+        }
+        if (query.order === "oldestFirst")
+            path.reverse();
+        const stopped = [];
+        for (const candidate of path) {
+            stopped.push(candidate);
+            if (candidate.id === query.stopAtId || candidate.type === query.stopAtType)
+                break;
+        }
+        const filtered = stopped
+            .filter((candidate) => query.type === undefined || candidate.type === query.type)
+            .filter((candidate) => query.customType === undefined || candidate.customType === query.customType)
+            .filter((candidate) => query.cursor === undefined ||
+            (query.order === "oldestFirst" ? candidate.seq > query.cursor.seq : candidate.seq < query.cursor.seq));
+        return query.limit === undefined ? filtered : filtered.slice(0, Math.max(0, query.limit));
+    }
+    scanBranchStructure(query) {
+        return this.scanBranch(query).map((entry) => ({
+            id: entry.id,
+            parentId: entry.parentId,
+            seq: entry.seq,
+            timestamp: entry.timestamp,
+            type: entry.type,
+            ...(entry.customType === undefined ? {} : { customType: entry.customType }),
+        }));
+    }
+    scanEntries(query) {
+        const limit = query.limit === undefined ? Number.POSITIVE_INFINITY : Math.max(0, Math.trunc(query.limit));
+        const entries = [];
+        const descending = query.order === "desc";
+        let index = descending ? this.entriesBySeq.length - 1 : 0;
+        while (index >= 0 && index < this.entriesBySeq.length && entries.length < limit) {
+            const entry = this.entriesBySeq[index];
+            if ((query.type === undefined || entry.type === query.type) &&
+                (query.customType === undefined || entry.customType === query.customType) &&
+                (query.fromSeq === undefined || entry.seq >= query.fromSeq) &&
+                (query.toSeq === undefined || entry.seq <= query.toSeq)) {
+                entries.push(entry);
+            }
+            index += descending ? -1 : 1;
+        }
+        return entries;
+    }
+    scanUsage(query) {
+        const rows = [...this.usage.values()]
+            .filter((row) => query.fromSeq === undefined || row.seq >= query.fromSeq)
+            .filter((row) => query.toSeq === undefined || row.seq <= query.toSeq)
+            .sort((left, right) => (query.order === "desc" ? right.seq - left.seq : left.seq - right.seq));
+        return query.limit === undefined ? rows : rows.slice(0, Math.max(0, query.limit));
+    }
+    getStats() {
+        return this.stats;
+    }
+    getNextSeq() {
+        return this.nextSeq;
+    }
+}

package/dist/vendor/engine/runtime/agent/harness/session/index.d.ts

@@ -0,0 +1,10 @@
+export type { CommittedEntryWrite, CommittedListAppendWrite, CommittedListDeleteWrite, CommittedUsageWrite, CommittedValueDeleteWrite, CommittedValueSetWrite, CommittedWrite, CommitValidationState, PreparedCommit, } from "./commit.js";
+export { andorraCommitWrite, andorraInsertEntry, andorraInsertUsage, andorraPrepareStorageCommit, andorraValidateCommittedWrites } from "./commit.js";
+export { andorraCreateForkSnapshot, type ForkSourceSnapshot } from "./fork.js";
+export { type ForkCurrentStatePlan, andorraProjectForkCurrentStateWrite } from "./fork-policy.js";
+export { JSONL_STORAGE_VERSION, type JsonlSessionCreateOptions, type JsonlSessionListOptions, type JsonlSessionMetadata, AndorraJsonlSessionRepo, type JsonlSessionRepoOptions, } from "./jsonl/index.js";
+export type { MemorySessionRepoOptions } from "./memory.js";
+export { AndorraMemorySessionRepo } from "./memory.js";
+export { AndorraSessionBranchExistsError, AndorraSessionInvalidBranchError, AndorraSessionInvariantError, AndorraSessionPendingAssistantMessageError, AndorraSessionUnknownTargetError, AndorraStorageBackedSession, type StorageBackedSessionOptions, } from "./session.js";
+export * from "./types.js";
+export * from "./values.js";

package/dist/vendor/engine/runtime/agent/harness/session/index.js

@@ -0,0 +1,8 @@
+export { andorraCommitWrite, andorraInsertEntry, andorraInsertUsage, andorraPrepareStorageCommit, andorraValidateCommittedWrites } from "./commit.js";
+export { andorraCreateForkSnapshot } from "./fork.js";
+export { andorraProjectForkCurrentStateWrite } from "./fork-policy.js";
+export { JSONL_STORAGE_VERSION, AndorraJsonlSessionRepo, } from "./jsonl/index.js";
+export { AndorraMemorySessionRepo } from "./memory.js";
+export { AndorraSessionBranchExistsError, AndorraSessionInvalidBranchError, AndorraSessionInvariantError, AndorraSessionPendingAssistantMessageError, AndorraSessionUnknownTargetError, AndorraStorageBackedSession, } from "./session.js";
+export * from "./types.js";
+export * from "./values.js";

package/dist/vendor/engine/runtime/agent/harness/session/jsonl/codec.d.ts

@@ -0,0 +1,20 @@
+import { type Result } from "../../types.js";
+import { type JsonlStorageHeader } from "./types.js";
+export interface LegacyV3SessionHeader {
+    type: "session";
+    version: 3;
+    id: string;
+    timestamp: string;
+    cwd: string;
+    parentSession?: string;
+}
+export declare function andorraIsLegacyV3SessionHeader(value: unknown): value is LegacyV3SessionHeader;
+export declare function andorraIsJsonlStorageHeader(value: unknown): value is JsonlStorageHeader;
+export type JsonlParsedSessionHeader = {
+    format: "v4";
+    header: JsonlStorageHeader;
+} | {
+    format: "v3-legacy";
+    header: LegacyV3SessionHeader;
+};
+export declare function andorraParseJsonlSessionHeader(line: string): Result<JsonlParsedSessionHeader, Error>;

package/dist/vendor/engine/runtime/agent/harness/session/jsonl/codec.js

@@ -0,0 +1,44 @@
+import { andorraErr, andorraOk } from "../../types.js";
+import { JSONL_FORMAT_VERSION } from "./types.js";
+function andorraIsRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function andorraIsSafeIntegerAtLeast(value, minimum) {
+    return Number.isSafeInteger(value) && value >= minimum;
+}
+export function andorraIsLegacyV3SessionHeader(value) {
+    return (andorraIsRecord(value) &&
+        value.type === "session" &&
+        value.version === 3 &&
+        typeof value.id === "string" &&
+        typeof value.cwd === "string" &&
+        typeof value.timestamp === "string" &&
+        Number.isFinite(Date.parse(value.timestamp)) &&
+        (value.parentSession === undefined || typeof value.parentSession === "string"));
+}
+export function andorraIsJsonlStorageHeader(value) {
+    return (andorraIsRecord(value) &&
+        value.kind === "header" &&
+        value.v === JSONL_FORMAT_VERSION &&
+        typeof value.id === "string" &&
+        typeof value.cwd === "string" &&
+        andorraIsSafeIntegerAtLeast(value.storageVersion, 1) &&
+        andorraIsSafeIntegerAtLeast(value.createdAt, 0) &&
+        (value.nextSeq === undefined || andorraIsSafeIntegerAtLeast(value.nextSeq, 1)) &&
+        (value.parentSessionId === undefined || typeof value.parentSessionId === "string") &&
+        (value.legacyParentSessionPath === undefined || typeof value.legacyParentSessionPath === "string"));
+}
+export function andorraParseJsonlSessionHeader(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch (error) {
+        return andorraErr(new Error("Invalid JSONL session header: not valid JSON", { cause: error }));
+    }
+    if (andorraIsJsonlStorageHeader(value))
+        return andorraOk({ format: "v4", header: value });
+    if (andorraIsLegacyV3SessionHeader(value))
+        return andorraOk({ format: "v3-legacy", header: value });
+    return andorraErr(new Error("Unsupported JSONL session header"));
+}

package/dist/vendor/engine/runtime/agent/harness/session/jsonl/fork.d.ts

@@ -0,0 +1,37 @@
+import type { Context } from "../../context.js";
+import type { FileSystem } from "../../types.js";
+import type { ForkOptions } from "../types.js";
+import type { AndorraLegacyV3Source } from "./legacy-v3.js";
+import { type JsonlStorageHeader } from "./types.js";
+interface JsonlForkSourceMetadata {
+    id: string;
+    cwd: string;
+    path: string;
+}
+/** Prepared fork input: format-4 file metadata or an already-normalized legacy source. */
+export type JsonlForkInput = {
+    kind: "open";
+    metadata: JsonlForkSourceMetadata;
+    nextSeq: number;
+} | {
+    kind: "closed";
+    metadata: JsonlForkSourceMetadata;
+} | {
+    kind: "legacy-v3";
+    normalized: AndorraLegacyV3Source;
+};
+/**
+ * Index the source, validate the requested fork, and stream selected entries and current state
+ * into an atomically published format-4 destination without modifying the source.
+ * Preserve copied sequences and the source's nextSeq while excluding usage and open-operation state.
+ * Source files must not be replaced or edited between passes; later append-only writes are excluded
+ * by the captured sequence boundary or legacy record count. Does not open the destination Session.
+ */
+export declare function andorraRunJsonlFork(options: {
+    input: JsonlForkInput;
+    fileSystem: FileSystem;
+    destinationPath: string;
+    destinationHeader: Omit<JsonlStorageHeader, "nextSeq">;
+    fork: ForkOptions;
+}, context: Context): Promise<void>;
+export {};

package/dist/vendor/engine/runtime/agent/harness/session/jsonl/fork.js

@@ -0,0 +1,263 @@
+import { andorraProjectForkCurrentStateWrite, andorraSelectBranchFork } from "../fork-policy.js";
+import { andorraFileValue, andorraParseJsonlTransaction, andorraPublishJsonl, andorraReadJsonlHeader } from "./io.js";
+import { JSONL_STORAGE_VERSION } from "./types.js";
+function andorraPhysicalKey(namespace, key) {
+    return `${namespace}\u0000${key}`;
+}
+async function andorraReadJsonlForkHeader(reader, source, context) {
+    const parsed = await andorraReadJsonlHeader(reader, source.path, context);
+    if (parsed.format !== "v4") {
+        throw new Error(`Invalid JSONL storage ${source.path}: expected format 4 header`);
+    }
+    const header = parsed.header;
+    if (header.id !== source.id || header.cwd !== source.cwd) {
+        throw new Error(`Session identity does not match header: ${source.id}`);
+    }
+    if (header.storageVersion !== JSONL_STORAGE_VERSION) {
+        throw new Error(`Session ${source.id} uses unsupported storage version ${header.storageVersion}`);
+    }
+    return header;
+}
+function andorraReachesForkBoundary(writes, stopBeforeSeq) {
+    if (stopBeforeSeq === undefined || writes.length === 0)
+        return false;
+    const first = writes[0];
+    const last = writes.at(-1);
+    if (first.seq >= stopBeforeSeq)
+        return true;
+    if (last.seq >= stopBeforeSeq) {
+        throw new Error(`JSONL transaction crosses fork sequence boundary ${stopBeforeSeq}`);
+    }
+    return false;
+}
+/** Read complete transactions after the header, never splitting a transaction at the sequence boundary. */
+async function* andorraReadJsonlForkTransactions(reader, path, stopBeforeSeq, context) {
+    while (true) {
+        const line = andorraFileValue(await reader.readLine(context), `Failed to read JSONL fork source ${path}`);
+        if (line === undefined || !line.terminated)
+            break;
+        const writes = andorraParseJsonlTransaction(line.text);
+        if (andorraReachesForkBoundary(writes, stopBeforeSeq))
+            break;
+        yield writes;
+    }
+}
+class AndorraJsonlForkIndex {
+    currentScalarSeqs = new Map();
+    branchTips = new Map();
+    firstSurvivingListSeqs = new Map();
+    entryParents = new Map();
+    copiedEntryIds = new Set();
+    laneConfigs = new Set();
+    laneStates = new Set();
+    applyEntry(id, parentId) {
+        this.entryParents.set(id, parentId);
+    }
+    applyWrites(writes) {
+        for (const write of writes) {
+            switch (write.kind) {
+                case "entry":
+                    this.applyEntry(write.id, write.parentId);
+                    break;
+                case "value": {
+                    const key = andorraPhysicalKey(write.namespace, write.key);
+                    if (write.op === "delete") {
+                        this.currentScalarSeqs.delete(key);
+                    }
+                    else {
+                        this.currentScalarSeqs.set(key, write.seq);
+                    }
+                    this.applyLaneValue(write);
+                    break;
+                }
+                case "list": {
+                    const key = andorraPhysicalKey(write.namespace, write.key);
+                    if (write.op === "delete")
+                        this.firstSurvivingListSeqs.delete(key);
+                    else if (!this.firstSurvivingListSeqs.has(key))
+                        this.firstSurvivingListSeqs.set(key, write.seq);
+                    break;
+                }
+                case "usage":
+                    break;
+            }
+        }
+    }
+    applyLaneValue(write) {
+        const present = write.op === "set";
+        switch (write.namespace) {
+            case "pi.branch.tip":
+                if (present)
+                    this.branchTips.set(write.key, write.value);
+                else
+                    this.branchTips.delete(write.key);
+                break;
+            case "pi.lane.config":
+                if (present)
+                    this.laneConfigs.add(write.key);
+                else
+                    this.laneConfigs.delete(write.key);
+                break;
+            case "pi.lane.state":
+                if (present)
+                    this.laneStates.add(write.key);
+                else
+                    this.laneStates.delete(write.key);
+                break;
+        }
+    }
+    getBranchTip(branch) {
+        return this.branchTips.get(branch);
+    }
+    hasCompleteLane(branch) {
+        return this.laneConfigs.has(branch) && this.laneStates.has(branch);
+    }
+    getCurrentScalarSeq(namespace, key) {
+        return this.currentScalarSeqs.get(andorraPhysicalKey(namespace, key));
+    }
+    isSurvivingListElement(namespace, key, seq) {
+        const firstSeq = this.firstSurvivingListSeqs.get(andorraPhysicalKey(namespace, key));
+        return firstSeq !== undefined && seq >= firstSeq;
+    }
+    getParent(entryId) {
+        return this.entryParents.get(entryId);
+    }
+    selectEntry(entryId) {
+        this.copiedEntryIds.add(entryId);
+    }
+    isEntrySelected(entryId) {
+        return this.copiedEntryIds.has(entryId);
+    }
+}
+/**
+ * Validate the source lanes and return the fork plan.
+ *
+ * Branch scope updates JsonlForkIndex's selected entries via index.selectEntry(): it selects the
+ * destination tip and its ancestors after validating entryId and applying "at"/"before". The plan
+ * records the branch name and destination tip; the copy pass uses the index to filter entries and labels.
+ *
+ * Tree scope leaves the index's selected entries unchanged because the copy pass keeps every entry.
+ * Both formats use the same indexed metadata; this function performs no file I/O.
+ */
+function andorraSelectJsonlFork(index, options) {
+    if (options.scope === "tree")
+        return { scope: "tree" };
+    const plan = andorraSelectBranchFork(options, {
+        tip: index.getBranchTip(options.branch),
+        getParent: (entryId) => index.getParent(entryId),
+        selectEntry: (entryId) => index.selectEntry(entryId),
+    });
+    if (!index.hasCompleteLane(options.branch)) {
+        throw new Error(`Source branch ${JSON.stringify(options.branch)} is not a configured AgentLane`);
+    }
+    return plan;
+}
+function andorraProjectJsonlForkWrite(write, index, plan, isEntryCopied) {
+    switch (write.kind) {
+        case "entry":
+            return isEntryCopied(write.id) ? write : undefined;
+        case "value":
+            if (write.op !== "set")
+                return undefined;
+            if (index.getCurrentScalarSeq(write.namespace, write.key) !== write.seq)
+                return undefined;
+            return andorraProjectForkCurrentStateWrite(write, plan, isEntryCopied);
+        case "list":
+            if (write.op !== "append")
+                return undefined;
+            if (!index.isSurvivingListElement(write.namespace, write.key, write.seq))
+                return undefined;
+            return andorraProjectForkCurrentStateWrite(write, plan, isEntryCopied);
+        case "usage":
+            return undefined;
+    }
+}
+/**
+ * Build the index used to select branch ancestry and identify current scalar/list writes.
+ * Retains entry parent links, current-row sequences, and lane inventory, not entry payloads.
+ * Returns the index and the source's nextSeq high-water mark; no destination writes occur here.
+ *
+ * V3: LegacyV3Source already scanned the file and assigned normalized IDs/sequences. Copy its
+ * in-memory entry structures and derived values without reopening the file or calling writes(),
+ * which would unnecessarily parse payloads and reconstruct compaction tails before fork selection.
+ *
+ * V4: Open the source file and fold complete transactions into the index. For an open source,
+ * stop at the captured commit-queue sequence boundary. For a closed source, scan to EOF or a torn
+ * final line and derive nextSeq from the header and highest complete write sequence.
+ * The later copy pass reopens the source file in both formats and emits only selected writes.
+ */
+async function andorraIndexForkInput(input, fileSystem, context) {
+    const index = new AndorraJsonlForkIndex();
+    if (input.kind === "legacy-v3") {
+        for (const entry of input.normalized.entryStructures())
+            index.applyEntry(entry.id, entry.parentId);
+        index.applyWrites(input.normalized.values);
+        return { index, nextSeq: input.normalized.nextSeq };
+    }
+    const reader = andorraFileValue(await fileSystem.openTextLineReader(input.metadata.path, context), `Failed to open JSONL fork source ${input.metadata.path}`);
+    try {
+        const header = await andorraReadJsonlForkHeader(reader, input.metadata, context);
+        const stopBeforeSeq = input.kind === "open" ? input.nextSeq : undefined;
+        let highestCompleteSeq = 0;
+        for await (const writes of andorraReadJsonlForkTransactions(reader, input.metadata.path, stopBeforeSeq, context)) {
+            index.applyWrites(writes);
+            if (writes.length !== 0)
+                highestCompleteSeq = writes.at(-1).seq;
+        }
+        return {
+            index,
+            nextSeq: input.kind === "open" ? input.nextSeq : Math.max(header.nextSeq ?? 1, highestCompleteSeq + 1),
+        };
+    }
+    finally {
+        await reader.close(context);
+    }
+}
+/** Yield source writes; the caller owns final projection and filtering. */
+async function* andorraStreamForkWrites(input, fileSystem, stopBeforeSeq, isEntryCopied, context) {
+    if (input.kind === "legacy-v3") {
+        // V3 filters early to avoid rereading messages and reconstructing unselected compaction tails.
+        // V4 already stores complete payloads, so it streams all captured writes below.
+        // Both formats still pass through projectJsonlForkWrite() for final filtering and transformation.
+        yield* input.normalized.writes(context, isEntryCopied);
+        return;
+    }
+    const reader = andorraFileValue(await fileSystem.openTextLineReader(input.metadata.path, context), `Failed to open JSONL fork source ${input.metadata.path}`);
+    try {
+        await andorraReadJsonlForkHeader(reader, input.metadata, context);
+        for await (const writes of andorraReadJsonlForkTransactions(reader, input.metadata.path, stopBeforeSeq, context)) {
+            yield* writes;
+        }
+    }
+    finally {
+        await reader.close(context);
+    }
+}
+/**
+ * Index the source, validate the requested fork, and stream selected entries and current state
+ * into an atomically published format-4 destination without modifying the source.
+ * Preserve copied sequences and the source's nextSeq while excluding usage and open-operation state.
+ * Source files must not be replaced or edited between passes; later append-only writes are excluded
+ * by the captured sequence boundary or legacy record count. Does not open the destination Session.
+ */
+export async function andorraRunJsonlFork(options, context) {
+    const { index, nextSeq } = await andorraIndexForkInput(options.input, options.fileSystem, context);
+    let fork = options.fork;
+    if (options.input.kind === "legacy-v3" && fork.scope === "branch" && fork.entryId !== undefined) {
+        fork = { ...fork, entryId: options.input.normalized.translateForkEntryId(fork.entryId) };
+    }
+    const plan = andorraSelectJsonlFork(index, fork);
+    const andorraIsEntryCopied = (entryId) => {
+        if (plan.scope === "tree")
+            return true;
+        return index.isEntrySelected(entryId);
+    };
+    await andorraPublishJsonl(options.fileSystem, options.destinationPath, { ...options.destinationHeader, nextSeq }, context, async (append) => {
+        const sourceWrites = andorraStreamForkWrites(options.input, options.fileSystem, nextSeq, andorraIsEntryCopied, context);
+        for await (const write of sourceWrites) {
+            const projected = andorraProjectJsonlForkWrite(write, index, plan, andorraIsEntryCopied);
+            if (projected !== undefined)
+                await append([projected]);
+        }
+    });
+}

package/dist/vendor/engine/runtime/agent/harness/session/jsonl/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./repo.js";
+export * from "./storage.js";
+export * from "./types.js";

package/dist/vendor/engine/runtime/agent/harness/session/jsonl/index.js

@@ -0,0 +1,3 @@
+export * from "./repo.js";
+export * from "./storage.js";
+export * from "./types.js";