@andorra-labs/code 0.0.0-stage → 0.1.4

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

@@ -0,0 +1,300 @@
+import { andorraUuidv7 } from "../../../../ai/utils/uuid.js";
+import { AndorraStorageBackedSession } from "../session.js";
+import { andorraParseJsonlSessionHeader } from "./codec.js";
+import { andorraRunJsonlFork } from "./fork.js";
+import { andorraFileValue } from "./io.js";
+import { AndorraLegacyV3Source, andorraMetadataFromLegacyV3Header } from "./legacy-v3.js";
+import { AndorraJsonlStorage } from "./storage.js";
+import { JSONL_FORMAT_VERSION, JSONL_STORAGE_VERSION, } from "./types.js";
+function andorraMetadataFromHeader(header, path, modifiedAt) {
+    return {
+        id: header.id,
+        createdAt: header.createdAt,
+        storageVersion: header.storageVersion,
+        cwd: header.cwd,
+        path,
+        modifiedAt,
+        ...(header.parentSessionId === undefined ? {} : { parentSessionId: header.parentSessionId }),
+        ...(header.legacyParentSessionPath === undefined
+            ? {}
+            : { legacyParentSessionPath: header.legacyParentSessionPath }),
+    };
+}
+function andorraSessionDirectoryName(cwd) {
+    return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+function andorraSessionFileName(createdAt, id) {
+    const timestamp = new Date(createdAt).toISOString().replace(/[:.]/g, "-");
+    return `${timestamp}_${encodeURIComponent(id)}.jsonl`;
+}
+/** File-backed format-4 session repository lifecycle. */
+export class AndorraJsonlSessionRepo {
+    fileSystem;
+    sessionsRootInput;
+    now;
+    openSessions = new Map();
+    pendingCreates = new Set();
+    closed = false;
+    closePromise;
+    constructor(options) {
+        this.fileSystem = options.fileSystem;
+        this.sessionsRootInput = options.sessionsRoot;
+        this.now = options.now ?? Date.now;
+    }
+    async create(options, context) {
+        this.assertOpen();
+        const createdAt = this.now();
+        const { cwd, id } = await this.resolveCreateDestination(options.cwd, options.id, createdAt, context);
+        const key = this.sessionKey(cwd, id);
+        if (this.openSessions.has(key) || this.pendingCreates.has(key))
+            throw new Error(`Session already exists: ${id}`);
+        this.pendingCreates.add(key);
+        let path;
+        let storage;
+        try {
+            path = await this.resolveNewSessionPath(cwd, createdAt, id, context);
+            const header = {
+                v: JSONL_FORMAT_VERSION,
+                kind: "header",
+                id,
+                storageVersion: JSONL_STORAGE_VERSION,
+                createdAt,
+                cwd,
+                ...(options.parentSessionId === undefined ? {} : { parentSessionId: options.parentSessionId }),
+            };
+            storage = await AndorraJsonlStorage.create({ fileSystem: this.fileSystem, path, now: this.now }, header, [], context);
+            const info = andorraFileValue(await this.fileSystem.fileInfo(path, context), `Failed to read session ${path}`);
+            return this.publishOpenSession(andorraMetadataFromHeader(header, path, info.mtimeMs), storage, key);
+        }
+        catch (error) {
+            await storage?.close(context).catch(() => undefined);
+            if (path !== undefined)
+                await this.fileSystem.remove(path, { force: true }, context);
+            throw error;
+        }
+        finally {
+            this.pendingCreates.delete(key);
+        }
+    }
+    async open(metadata, context) {
+        this.assertOpen();
+        const key = this.sessionKey(metadata.cwd, metadata.id);
+        if (this.openSessions.has(key))
+            throw new Error(`Session is already open: ${metadata.id}`);
+        let storage;
+        try {
+            storage = await this.loadStorage(metadata, context);
+            return this.publishOpenSession(metadata, storage, key);
+        }
+        catch (error) {
+            await storage?.close(context);
+            throw error;
+        }
+    }
+    async list(options, context) {
+        options ??= {};
+        this.assertOpen();
+        const cwd = options.cwd === undefined
+            ? undefined
+            : andorraFileValue(await this.fileSystem.absolutePath(options.cwd, context), `Failed to resolve session cwd ${options.cwd}`);
+        const root = await this.root(context);
+        if (!andorraFileValue(await this.fileSystem.exists(root, context), `Failed to check sessions root ${root}`))
+            return [];
+        const directories = cwd === undefined ? await this.sessionDirectories(root, context) : [await this.sessionDirectory(cwd, context)];
+        const metadata = [];
+        for (const directory of directories)
+            metadata.push(...(await this.listDirectory(directory, cwd, context)));
+        return metadata.sort((left, right) => right.createdAt - left.createdAt || left.id.localeCompare(right.id) || left.cwd.localeCompare(right.cwd));
+    }
+    async delete(metadata, context) {
+        this.assertOpen();
+        const key = this.sessionKey(metadata.cwd, metadata.id);
+        if (this.openSessions.has(key))
+            throw new Error(`Session is open: ${metadata.id}`);
+        if (!andorraFileValue(await this.fileSystem.exists(metadata.path, context), `Failed to check session ${metadata.path}`)) {
+            throw new Error(`Session file does not exist: ${metadata.path}`);
+        }
+        andorraFileValue(await this.fileSystem.remove(metadata.path, undefined, context), `Failed to delete session ${metadata.path}`);
+    }
+    async fork(source, options, context) {
+        this.assertOpen();
+        const createdAt = this.now();
+        const cwd = source.cwd;
+        const id = options.id ?? andorraUuidv7(createdAt);
+        const destinationKey = this.sessionKey(cwd, id);
+        if (this.openSessions.has(destinationKey) || this.pendingCreates.has(destinationKey)) {
+            throw new Error(`Session already exists: ${id}`);
+        }
+        this.pendingCreates.add(destinationKey);
+        const sourceStorage = this.openSessions.get(this.sessionKey(source.cwd, source.id));
+        let path;
+        let storage;
+        try {
+            const input = await this.resolveForkInput(source, sourceStorage, context);
+            path = await this.resolveNewSessionPath(cwd, createdAt, id, context);
+            const header = {
+                v: JSONL_FORMAT_VERSION,
+                kind: "header",
+                id,
+                storageVersion: JSONL_STORAGE_VERSION,
+                createdAt,
+                cwd,
+                parentSessionId: source.id,
+            };
+            await andorraRunJsonlFork({
+                input,
+                fileSystem: this.fileSystem,
+                destinationPath: path,
+                destinationHeader: header,
+                fork: options,
+            }, context);
+            storage = await AndorraJsonlStorage.open({ fileSystem: this.fileSystem, path, now: this.now }, context);
+            const info = andorraFileValue(await this.fileSystem.fileInfo(path, context), `Failed to read session ${path}`);
+            return this.publishOpenSession(andorraMetadataFromHeader(header, path, info.mtimeMs), storage, destinationKey);
+        }
+        catch (error) {
+            await storage?.close(context).catch(() => undefined);
+            if (path !== undefined)
+                await this.fileSystem.remove(path, { force: true }, context);
+            throw error;
+        }
+        finally {
+            this.pendingCreates.delete(destinationKey);
+        }
+    }
+    close(_context) {
+        if (this.closePromise !== undefined)
+            return this.closePromise;
+        this.closed = true;
+        // TODO: Define ownership semantics before deciding whether repository close should close session handles.
+        this.closePromise = Promise.resolve();
+        return this.closePromise;
+    }
+    async resolveCreateDestination(cwdInput, id, createdAt, context) {
+        const destinationId = id ?? andorraUuidv7(createdAt);
+        const cwd = andorraFileValue(await this.fileSystem.absolutePath(cwdInput, context), `Failed to resolve session cwd ${cwdInput}`);
+        return { cwd, id: destinationId };
+    }
+    async listDirectory(directory, cwd, context) {
+        if (!andorraFileValue(await this.fileSystem.exists(directory, context), `Failed to check sessions directory ${directory}`)) {
+            return [];
+        }
+        const files = andorraFileValue(await this.fileSystem.listDir(directory, context), `Failed to list sessions directory ${directory}`).filter((file) => file.kind !== "directory" && file.name.endsWith(".jsonl"));
+        const metadata = [];
+        for (const file of files) {
+            const discovered = await this.readSessionMetadata(file, context);
+            if (discovered === undefined)
+                continue;
+            // Directory encoding is lossy: /a/b and /a-b both map to --a-b--.
+            if (cwd === undefined || discovered.cwd === cwd)
+                metadata.push(discovered);
+        }
+        return metadata;
+    }
+    async readSessionMetadata(file, context) {
+        const lines = andorraFileValue(await this.fileSystem.readTextLines(file.path, { maxLines: 1 }, context), `Failed to read session header ${file.path}`);
+        if (lines[0] === undefined)
+            return undefined;
+        const parsedHeader = andorraParseJsonlSessionHeader(lines[0]);
+        if (!parsedHeader.ok)
+            return undefined;
+        if (parsedHeader.value.format === "v3-legacy") {
+            const metadata = await andorraMetadataFromLegacyV3Header(this.fileSystem, parsedHeader.value.header, context);
+            return { ...metadata, path: file.path, modifiedAt: file.mtimeMs };
+        }
+        return andorraMetadataFromHeader(parsedHeader.value.header, file.path, file.mtimeMs);
+    }
+    async sessionDirectories(root, context) {
+        return andorraFileValue(await this.fileSystem.listDir(root, context), `Failed to list sessions root ${root}`)
+            .filter((entry) => entry.kind === "directory")
+            .map((entry) => entry.path);
+    }
+    async sessionDirectory(cwd, context) {
+        return andorraFileValue(await this.fileSystem.joinPath([await this.root(context), andorraSessionDirectoryName(cwd)], context), `Failed to resolve sessions directory for ${cwd}`);
+    }
+    async resolveNewSessionPath(cwd, createdAt, id, context) {
+        const directory = await this.sessionDirectory(cwd, context);
+        await this.assertSessionIdAvailable(directory, id, context);
+        andorraFileValue(await this.fileSystem.createDir(directory, undefined, context), `Failed to create sessions directory ${directory}`);
+        return andorraFileValue(await this.fileSystem.joinPath([directory, andorraSessionFileName(createdAt, id)], context), `Failed to resolve path for session ${id}`);
+    }
+    async assertSessionIdAvailable(directory, id, context) {
+        if (!andorraFileValue(await this.fileSystem.exists(directory, context), `Failed to check sessions directory ${directory}`))
+            return;
+        const suffix = `_${encodeURIComponent(id)}.jsonl`;
+        const idExists = andorraFileValue(await this.fileSystem.listDir(directory, context), `Failed to list sessions directory ${directory}`).some((entry) => entry.kind !== "directory" && entry.name.endsWith(suffix));
+        if (idExists)
+            throw new Error(`Session already exists: ${id}`);
+    }
+    async resolveForkInput(source, storage, context) {
+        if (storage !== undefined) {
+            if (storage.isLegacyV3()) {
+                throw new Error("Cannot fork an open legacy v3 JSONL session; commit a non-empty transaction to upgrade it to format 4 first");
+            }
+            const nextSeq = await storage.captureForkNextSeq(context);
+            return { kind: "open", metadata: source, nextSeq };
+        }
+        if (await this.isLegacyV3ForkSource(source, context)) {
+            const normalized = await AndorraLegacyV3Source.read(this.fileSystem, source.path, context);
+            if (normalized.header.id !== source.id || normalized.header.cwd !== source.cwd) {
+                throw new Error(`Session identity does not match header: ${source.id}`);
+            }
+            return { kind: "legacy-v3", normalized };
+        }
+        return { kind: "closed", metadata: source };
+    }
+    async isLegacyV3ForkSource(source, context) {
+        const lines = andorraFileValue(await this.fileSystem.readTextLines(source.path, { maxLines: 1 }, context), `Failed to read session header ${source.path}`);
+        if (lines[0] === undefined)
+            return false;
+        const parsed = andorraParseJsonlSessionHeader(lines[0]);
+        return parsed.ok && parsed.value.format === "v3-legacy";
+    }
+    publishOpenSession(metadata, storage, key) {
+        if (this.openSessions.has(key))
+            throw new Error(`Session is already open: ${metadata.id}`);
+        const session = new AndorraStorageBackedSession(metadata, storage, {
+            onClose: () => {
+                if (this.openSessions.get(key) === storage)
+                    this.openSessions.delete(key);
+            },
+        });
+        this.openSessions.set(key, storage);
+        return session;
+    }
+    sessionKey(cwd, id) {
+        return `${cwd}\0${id}`;
+    }
+    async loadStorage(metadata, context) {
+        if (!andorraFileValue(await this.fileSystem.exists(metadata.path, context), `Failed to check session ${metadata.path}`)) {
+            throw new Error(`Session file does not exist: ${metadata.path}`);
+        }
+        const storage = await AndorraJsonlStorage.open({
+            fileSystem: this.fileSystem,
+            path: metadata.path,
+            now: this.now,
+        }, context);
+        try {
+            if (storage.header.id !== metadata.id || storage.header.cwd !== metadata.cwd) {
+                throw new Error(`Session identity does not match header: ${metadata.id}`);
+            }
+            if (storage.header.storageVersion !== JSONL_STORAGE_VERSION) {
+                throw new Error(`Session ${metadata.id} uses unsupported storage version ${storage.header.storageVersion}`);
+            }
+            return storage;
+        }
+        catch (error) {
+            await storage.close(context);
+            throw error;
+        }
+    }
+    root(context) {
+        return this.fileSystem
+            .absolutePath(this.sessionsRootInput, context)
+            .then((result) => andorraFileValue(result, `Failed to resolve sessions root ${this.sessionsRootInput}`));
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error("JsonlSessionRepo is closed");
+    }
+}

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

@@ -0,0 +1,40 @@
+import type { Context } from "../../context.js";
+import type { CommitResult, Entry, EntryScan, EntryStructure, SessionStats, Storage, StorageBranchScan, UsageRow, UsageScan, Write } from "../types.js";
+import type { ListElement, ListReadOptions, StoredValue, Value, ValueList } from "../values.js";
+import { type JsonlStorageHeader, type JsonlStorageOptions } from "./types.js";
+/** JSONL storage backed by an injected filesystem capability. */
+export declare class AndorraJsonlStorage implements Storage {
+    private readonly fileSystem;
+    private readonly path;
+    private readonly now;
+    readonly header: JsonlStorageHeader;
+    private backing;
+    private readonly storageState;
+    private commitQueue;
+    private state;
+    private closePromise;
+    private constructor();
+    static create(options: JsonlStorageOptions, header: JsonlStorageHeader, initialWrites: Write[], context: Context): Promise<AndorraJsonlStorage>;
+    static open(options: JsonlStorageOptions, context: Context): Promise<AndorraJsonlStorage>;
+    private static openV4;
+    private static openLegacyV3;
+    private replayCommitted;
+    commit(writes: Write[], context: Context): Promise<CommitResult>;
+    private applyCommit;
+    /** Atomically upgrade legacy v3 backing and preserve the first caller write as a v4 transaction. */
+    private upgradeLegacyV3ToV4;
+    getEntries(ids: string[], _context: Context): Promise<Map<string, Entry>>;
+    getValue<T>(address: Value<T>, _context: Context): Promise<StoredValue<T> | undefined>;
+    scanValues<T>(prefix: Value<T>, _context: Context): Promise<StoredValue<T>[]>;
+    readList<T>(address: ValueList<T>, options: ListReadOptions | undefined, _context: Context): Promise<ListElement<T>[]>;
+    scanBranch(query: StorageBranchScan, _context: Context): Promise<Entry[]>;
+    scanBranchStructure(query: StorageBranchScan, _context: Context): Promise<EntryStructure[]>;
+    scanEntries(query: EntryScan, _context: Context): Promise<Entry[]>;
+    scanUsage(query: UsageScan, _context: Context): Promise<UsageRow[]>;
+    getStats(_context: Context): Promise<SessionStats>;
+    private withImportedUsage;
+    isLegacyV3(): boolean;
+    /** Capture the first sequence a later source commit would use. */
+    captureForkNextSeq(_context: Context): Promise<number>;
+    close(_context: Context): Promise<void>;
+}

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

@@ -0,0 +1,199 @@
+import { andorraUuidv7 } from "../../../../ai/utils/uuid.js";
+import { andorraInsertUsage } from "../commit.js";
+import { AndorraInMemoryStorageState } from "../in-memory-storage-state.js";
+import { andorraFileValue, andorraParseJsonlTransaction, andorraPublishFileAtomically, andorraPublishJsonl, andorraReadJsonlHeader, andorraSerializeJsonlTransaction, } from "./io.js";
+import { AndorraLegacyV3Source } from "./legacy-v3.js";
+import { JSONL_STORAGE_VERSION } from "./types.js";
+function andorraSplitCompleteLines(content) {
+    if (content.endsWith("\n"))
+        return { lines: content.slice(0, -1).split("\n"), torn: false };
+    const lastNewline = content.lastIndexOf("\n");
+    if (lastNewline === -1)
+        return { lines: [], torn: true };
+    return { lines: content.slice(0, lastNewline).split("\n"), torn: true };
+}
+/** JSONL storage backed by an injected filesystem capability. */
+export class AndorraJsonlStorage {
+    fileSystem;
+    path;
+    now;
+    header;
+    backing;
+    storageState = new AndorraInMemoryStorageState();
+    commitQueue = Promise.resolve();
+    state = "open";
+    closePromise;
+    constructor(options, header, backing) {
+        this.fileSystem = options.fileSystem;
+        this.path = options.path;
+        this.now = options.now ?? Date.now;
+        this.header = header;
+        this.backing = backing;
+    }
+    static async create(options, header, initialWrites, context) {
+        const storage = new AndorraJsonlStorage(options, header, { kind: "v4" });
+        const prepared = storage.storageState.prepareCommit(initialWrites, storage.now());
+        await andorraPublishJsonl(options.fileSystem, options.path, header, context, async (append) => {
+            if (prepared.writes.length !== 0)
+                await append(prepared.writes);
+        });
+        storage.storageState.applyValidated(prepared.writes);
+        return storage;
+    }
+    static async open(options, context) {
+        const reader = andorraFileValue(await options.fileSystem.openTextLineReader(options.path, context), `Failed to read JSONL storage ${options.path}`);
+        const parsed = await andorraReadJsonlHeader(reader, options.path, context).finally(() => reader.close(context));
+        return parsed.format === "v3-legacy"
+            ? AndorraJsonlStorage.openLegacyV3(options, context)
+            : AndorraJsonlStorage.openV4(options, parsed.header, context);
+    }
+    static async openV4(options, header, context) {
+        const content = andorraFileValue(await options.fileSystem.readTextFile(options.path, context), `Failed to read JSONL storage ${options.path}`);
+        const { lines, torn } = andorraSplitCompleteLines(content);
+        if (header.storageVersion !== JSONL_STORAGE_VERSION) {
+            throw new Error(`Session ${header.id} uses unsupported storage version ${header.storageVersion}`);
+        }
+        const storage = new AndorraJsonlStorage(options, header, { kind: "v4" });
+        for (let index = 1; index < lines.length; index++) {
+            const line = lines[index];
+            try {
+                storage.replayCommitted(andorraParseJsonlTransaction(line));
+            }
+            catch (error) {
+                throw new Error(`Invalid JSONL storage ${options.path}: line ${index + 1}`, { cause: error });
+            }
+        }
+        if (header.nextSeq !== undefined)
+            storage.storageState.advanceNextSeq(header.nextSeq);
+        if (torn) {
+            await andorraPublishFileAtomically(options.fileSystem, options.path, context, (append) => append(`${lines.join("\n")}\n`));
+        }
+        return storage;
+    }
+    static async openLegacyV3(options, context) {
+        const source = await AndorraLegacyV3Source.read(options.fileSystem, options.path, context);
+        const storage = new AndorraJsonlStorage(options, { ...source.header, nextSeq: source.nextSeq }, { kind: "v3", source });
+        for await (const write of source.writes(context))
+            storage.replayCommitted([write]);
+        return storage;
+    }
+    replayCommitted(writes) {
+        this.storageState.validateCommitted(writes);
+        this.storageState.applyValidated(writes);
+    }
+    async commit(writes, context) {
+        if (this.state !== "open")
+            throw new Error("JsonlStorage is closed");
+        const result = this.commitQueue.then(() => this.applyCommit(writes, context));
+        this.commitQueue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async applyCommit(writes, context) {
+        if (this.backing.kind === "v3" && writes.length !== 0) {
+            return this.upgradeLegacyV3ToV4(this.backing.source, writes, context);
+        }
+        const prepared = this.storageState.prepareCommit(writes, this.now());
+        if (prepared.writes.length !== 0) {
+            andorraFileValue(await this.fileSystem.appendFile(this.path, `${andorraSerializeJsonlTransaction(prepared.writes)}\n`, context), `Failed to append JSONL storage ${this.path}`);
+        }
+        const stats = this.storageState.applyValidated(prepared.writes);
+        return { ...prepared.result, stats: this.withImportedUsage(stats) };
+    }
+    /** Atomically upgrade legacy v3 backing and preserve the first caller write as a v4 transaction. */
+    async upgradeLegacyV3ToV4(source, callerWrites, context) {
+        const timestamp = this.now();
+        const prepared = this.storageState.prepareCommit([
+            andorraInsertUsage({
+                id: andorraUuidv7(timestamp),
+                usage: source.importedUsage,
+                adjustment: true,
+                details: { source: "v3-import" },
+            }),
+            ...callerWrites,
+        ], timestamp);
+        const nextSeq = prepared.result.firstSeq + prepared.writes.length;
+        const upgradedHeader = { ...this.header, nextSeq };
+        await andorraPublishJsonl(this.fileSystem, this.path, upgradedHeader, context, async (append) => {
+            for await (const write of source.writes(context))
+                await append([write]);
+            await append(prepared.writes);
+        });
+        const stats = this.storageState.applyValidated(prepared.writes);
+        this.backing = { kind: "v4" };
+        // The first sequence belongs to the internal usage adjustment; return only caller-write sequences.
+        return {
+            ...prepared.result,
+            firstSeq: prepared.result.firstSeq + 1,
+            seqs: prepared.result.seqs.slice(1),
+            stats,
+        };
+    }
+    getEntries(ids, _context) {
+        if (this.state !== "open")
+            return Promise.reject(new Error("JsonlStorage is closed"));
+        return Promise.resolve(this.storageState.getEntries(ids));
+    }
+    getValue(address, _context) {
+        if (this.state !== "open")
+            return Promise.reject(new Error("JsonlStorage is closed"));
+        return Promise.resolve(this.storageState.getValue(address));
+    }
+    scanValues(prefix, _context) {
+        if (this.state !== "open")
+            return Promise.reject(new Error("JsonlStorage is closed"));
+        return Promise.resolve(this.storageState.scanValues(prefix));
+    }
+    async readList(address, options, _context) {
+        if (this.state !== "open")
+            throw new Error("JsonlStorage is closed");
+        return this.storageState.readList(address, options);
+    }
+    async scanBranch(query, _context) {
+        if (this.state !== "open")
+            throw new Error("JsonlStorage is closed");
+        return this.storageState.scanBranch(query);
+    }
+    async scanBranchStructure(query, _context) {
+        if (this.state !== "open")
+            throw new Error("JsonlStorage is closed");
+        return this.storageState.scanBranchStructure(query);
+    }
+    scanEntries(query, _context) {
+        if (this.state !== "open")
+            return Promise.reject(new Error("JsonlStorage is closed"));
+        return Promise.resolve(this.storageState.scanEntries(query));
+    }
+    scanUsage(query, _context) {
+        if (this.state !== "open")
+            return Promise.reject(new Error("JsonlStorage is closed"));
+        return Promise.resolve(this.storageState.scanUsage(query));
+    }
+    getStats(_context) {
+        if (this.state !== "open")
+            return Promise.reject(new Error("JsonlStorage is closed"));
+        return Promise.resolve(this.withImportedUsage(this.storageState.getStats()));
+    }
+    withImportedUsage(stats) {
+        return this.backing.kind === "v4" ? stats : { ...stats, usage: this.backing.source.importedUsage };
+    }
+    isLegacyV3() {
+        return this.backing.kind === "v3";
+    }
+    /** Capture the first sequence a later source commit would use. */
+    captureForkNextSeq(_context) {
+        if (this.state !== "open")
+            return Promise.reject(new Error("JsonlStorage is closed"));
+        const result = this.commitQueue.then(() => this.storageState.getNextSeq());
+        this.commitQueue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    close(_context) {
+        if (this.closePromise !== undefined)
+            return this.closePromise;
+        this.state = "closing";
+        this.closePromise = this.commitQueue.then(() => {
+            this.state = "closed";
+        });
+        return this.closePromise;
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { FileSystem } from "../../types.js";
+import type { SessionCreateOptions, SessionMetadata } from "../types.js";
+export declare const JSONL_FORMAT_VERSION = 4;
+export declare const JSONL_STORAGE_VERSION = 1;
+export interface JsonlStorageHeader {
+    v: typeof JSONL_FORMAT_VERSION;
+    kind: "header";
+    id: string;
+    storageVersion: number;
+    createdAt: number;
+    cwd: string;
+    parentSessionId?: string;
+    legacyParentSessionPath?: string;
+    /** Sequence high-water mark written by snapshot rewrites. */
+    nextSeq?: number;
+}
+export interface JsonlStorageOptions {
+    fileSystem: FileSystem;
+    path: string;
+    now?: () => number;
+}
+export interface JsonlSessionMetadata extends SessionMetadata {
+    cwd: string;
+    path: string;
+    /** Filesystem modification time as milliseconds since Unix epoch. */
+    modifiedAt: number;
+}
+export interface JsonlSessionCreateOptions extends SessionCreateOptions {
+    cwd: string;
+}
+export interface JsonlSessionListOptions {
+    cwd?: string;
+}
+export interface JsonlSessionRepoOptions {
+    fileSystem: FileSystem;
+    sessionsRoot: string;
+    now?: () => number;
+}

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

@@ -0,0 +1,2 @@
+export const JSONL_FORMAT_VERSION = 4;
+export const JSONL_STORAGE_VERSION = 1;

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

@@ -0,0 +1,47 @@
+import type { Context } from "../context.js";
+import type { CommitResult, Entry, EntryScan, EntryStructure, ForkOptions, Session, SessionCreateOptions, SessionMetadata, SessionRepo, SessionStats, Storage, StorageBranchScan, UsageRow, UsageScan, Write } from "./types.js";
+import type { ListElement, ListReadOptions, StoredValue, Value, ValueList } from "./values.js";
+export interface MemoryStorageOptions {
+    now?: () => number;
+}
+export interface MemorySessionRepoOptions {
+    now?: () => number;
+}
+export declare class AndorraMemoryStorage implements Storage {
+    private readonly now;
+    private storageState;
+    private commitQueue;
+    private state;
+    private closePromise;
+    constructor(options?: MemoryStorageOptions);
+    commit(writes: Write[], _context: Context): Promise<CommitResult>;
+    getEntries(ids: string[], _context: Context): Promise<Map<string, Entry>>;
+    getValue<T>(address: Value<T>, _context: Context): Promise<StoredValue<T> | undefined>;
+    scanValues<T>(prefix: Value<T>, _context: Context): Promise<StoredValue<T>[]>;
+    readList<T>(address: ValueList<T>, options: ListReadOptions | undefined, _context: Context): Promise<ListElement<T>[]>;
+    scanBranch(query: StorageBranchScan, _context: Context): Promise<Entry[]>;
+    scanBranchStructure(query: StorageBranchScan, _context: Context): Promise<EntryStructure[]>;
+    scanEntries(query: EntryScan, _context: Context): Promise<Entry[]>;
+    scanUsage(query: UsageScan, _context: Context): Promise<UsageRow[]>;
+    getStats(_context: Context): Promise<SessionStats>;
+    /** Construct a destination storage at one serialized boundary between source commits. */
+    fork(options: ForkOptions): Promise<AndorraMemoryStorage>;
+    close(_context: Context): Promise<void>;
+}
+export declare class AndorraMemorySessionRepo implements SessionRepo {
+    private readonly now;
+    private readonly sessions;
+    private readonly pendingIds;
+    private closed;
+    private closePromise;
+    constructor(options?: MemorySessionRepoOptions);
+    create(options: SessionCreateOptions, context: Context): Promise<Session>;
+    open(metadata: SessionMetadata, _context: Context): Promise<Session>;
+    list(_options: undefined, _context: Context): Promise<SessionMetadata[]>;
+    delete(metadata: SessionMetadata, context: Context): Promise<void>;
+    fork(source: SessionMetadata, options: ForkOptions, _context: Context): Promise<Session>;
+    close(context: Context): Promise<void>;
+    private openRecord;
+    private reserveId;
+    private assertOpen;
+}