hyperbrane 0.1.2 → 0.2.1

package/dist/agent/session/fileTranscript.js

@@ -7,40 +7,25 @@ export function sandboxFiles(sandbox) {
         listDirectory: (path) => sandbox.listDirectory(path),
     };
 }
-/** The file of conversation `nativeId` laid out as `layout` under `home`; null when there's none yet. */
 export function locateTranscript(files, home, layout, nativeId) {
     const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const [before = "", after = ""] = layout.name.split("{id}").map((part) => part.split("*").map(escape).join(".*"));
     const name = new RegExp(`^${before}${escape(nativeId)}${after}$`);
     return findFile(files, `${home}/${layout.dir}`, layout.depth, (entry) => name.test(entry));
 }
-/** How much of the file is read at a time. */
 export const CHUNK_BYTES = 64 * 1024;
-/**
- * How far out of time order lines get, nearly always (parallel branches completing; in long claude
- * sessions half are within 2s, 99% within a minute): searches allow for this much.
- */
 export const TIME_SLACK_MS = 60_000;
-/** How many timed lines a probe of the bisection looks at: the earliest wins, so one odd line can't mislead it. */
 export const PROBE_LINES = 3;
-/** How much a probe reads, at most, before it gives up on finding a timed line (huge tool outputs). */
 export const PROBE_BYTES = 4 * CHUNK_BYTES;
 const NEWLINE = 0x0a;
-/** A line's time (epoch ms) from its `field`, null without a valid one. */
 function lineTime(entry, field) {
     const value = entry?.[field];
     const time = typeof value === "string" ? Date.parse(value) : NaN;
     return Number.isNaN(time) ? null : time;
 }
-/** How much is read at a time when searching the whole file for where stretches were written again. */
 const SCAN_BYTES = 1024 * 1024;
-/**
- * The stretches written again in the files searched last, by path and size: a search reads the whole
- * file, and a file the backend only appends to that hasn't grown has the same ones.
- */
 const searchedCopies = new Map();
 const SEARCHED_FILES = 16;
-/** `locate` finds the file; null when there's none yet (nothing stored). */
 export function createFileTranscript(files, locate, lineMessages, layout) {
     function parse(bytes, start) {
         try {
@@ -48,11 +33,9 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
             return { start, time: lineTime(entry, layout.time), messages: lineMessages(entry) };
         }
         catch {
-            // A line still being written (the last one), or one this reader doesn't know: nothing in it.
             return { start, time: null, messages: [] };
         }
     }
-    /** The stretches between `from` and `to` that aren't skipped, in order. */
     function kept(from, to, skip) {
         const parts = [];
         let start = from;
@@ -67,14 +50,12 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
             parts.push({ start, end: to });
         return parts;
     }
-    /** The file's lines before byte `end`, last first, read a chunk at a time, passing over `skip`. */
     async function* backward(path, end, skip = []) {
         for (const part of kept(0, end, skip).reverse())
             yield* backwardIn(path, part.start, part.end);
     }
     async function* backwardIn(path, floor, end) {
         let position = end;
-        // Bytes of a line that runs on into what was read before (later in the file).
         let carry = new Uint8Array(0);
         while (position > floor) {
             const from = Math.max(floor, position - CHUNK_BYTES);
@@ -94,7 +75,6 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         if (carry.length > 0)
             yield parse(carry, floor);
     }
-    /** The file's lines from byte `start` to byte `end`, in order, read a chunk at a time, passing over `skip`. */
     async function* forward(path, start, end, skip = []) {
         for (const part of kept(start, end, skip))
             yield* forwardIn(path, part.start, part.end);
@@ -121,15 +101,9 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         if (carry.length > 0)
             yield parse(carry, carryStart);
     }
-    /**
-     * Where the lines from time `target` on start, about, between `low` and `high`: the start of a line
-     * (or `high`) with only lines from before it, allowing for the slack, ahead of it. Bisects, each
-     * probe reading the times of the first few lines after its middle, passing over `skip`.
-     */
     async function seek(path, low, high, target, skip) {
         return (await narrow(path, low, high, target, skip)).high;
     }
-    /** seek's bisection: where it got, from both sides. */
     async function narrow(path, low, high, target, skip) {
         while (high - low > CHUNK_BYTES) {
             let middle = Math.floor((low + high) / 2);
@@ -143,7 +117,7 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
             }
             const probe = await probeTime(path, middle, high, skip);
             if (!probe)
-                break; // one line spans it all: start from where the search got
+                break;
             if (probe.time >= target)
                 high = probe.start;
             else
@@ -151,14 +125,13 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         }
         return { low, high };
     }
-    /** The first line starting after `from` (before `limit`), with the earliest time of the next few timed lines. */
     async function probeTime(path, from, limit, skip) {
         let start = -1;
         let time = Infinity;
         let timed = 0;
         for await (const line of forward(path, from, Math.min(limit, from + PROBE_BYTES), skip)) {
             if (line.start === from && from > 0)
-                continue; // the middle of a line: only its end was read
+                continue;
             if (line.start >= limit)
                 break;
             if (start < 0)
@@ -171,25 +144,17 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         }
         return start < 0 || timed === 0 ? null : { start, time };
     }
-    /** The time of the first timed line from `from` on (a line start), if there's one in reach. */
     async function timeAt(path, from, size, skip) {
         for await (const line of forward(path, from, Math.min(size, from + PROBE_BYTES), skip))
             if (line.time !== null)
                 return line.time;
         return null;
     }
-    /** Where the line holding byte `at` starts. */
     async function lineStart(path, at) {
         for await (const line of backward(path, at + 1))
             return line.start;
         return 0;
     }
-    /**
-     * The stretches the backend wrote again (TranscriptLayout.copies): each starts at a line with the
-     * marker whose time goes back from the timed line before it, and runs until a line is newer than
-     * that one. Found by searching the whole file for the marker; the rest only
-     * reads around what's found.
-     */
     function copiesOf(path, size) {
         if (!layout.copies)
             return Promise.resolve([]);
@@ -199,7 +164,6 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
             copies = findCopies(path, size, layout.copies);
             copies.catch(() => searchedCopies.delete(key));
             searchedCopies.set(key, copies);
-            // A few files' worth: a worker serves an agent's sessions.
             if (searchedCopies.size > SEARCHED_FILES)
                 searchedCopies.delete(searchedCopies.keys().next().value);
         }
@@ -209,7 +173,6 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         const needle = Buffer.from(marker);
         const found = [];
         for (let position = 0; position < size; position += SCAN_BYTES) {
-            // Overlapping by the marker's length, so one across two reads is found.
             const from = Math.max(0, position - needle.length + 1);
             const bytes = Buffer.from(await files.readFileRange(path, from, Math.min(size, position + SCAN_BYTES)));
             for (let index = bytes.indexOf(needle); index >= 0; index = bytes.indexOf(needle, index + 1)) {
@@ -219,7 +182,6 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         }
         const copies = [];
         for (const [index, at] of found.entries()) {
-            // The marker's line, and the timed line before it.
             const start = await lineStart(path, at);
             let earlier = null;
             for await (const before of backward(path, start)) {
@@ -235,13 +197,8 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
                 time = line.time;
                 break;
             }
-            // A compaction as it happened comes after what's before it (compacting takes a while: 25s and
-            // more); a copy starts back at its time.
             if (time === null || time >= earlier)
                 continue;
-            // It runs up to what was written before it, and ends with the first line newer than that. It
-            // holds what was said since a compaction, so it ends by the next marker: the rest of the file
-            // (other copies) can't mislead the search.
             const next = found[index + 1];
             const near = await narrow(path, start + 1, next === undefined ? size : await lineStart(path, next), earlier + 1, []);
             let end = near.high;
@@ -255,17 +212,9 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         }
         return copies;
     }
-    /**
-     * The file's lines before `end`, last first, each with the time it's paged by: its own, unless it's
-     * odd, more than the slack away from both the timed lines around it in the same direction (a
-     * background task's result written minutes after it began, a note dated ahead), when it's the one
-     * before it's; a line without a time goes with the timed line after it. These times follow the file
-     * order to within the slack, so the late result is paged where it is in the conversation.
-     * `after`: the time of the first timed line from `end` on.
-     */
     async function* pagedBackward(path, end, after, skip) {
-        let next = after; // the time of the timed line after the one waiting
-        let waiting = []; // a timed line and the untimed ones before it, until the one before it is read
+        let next = after;
+        let waiting = [];
         const settle = function* (before) {
             const [timed, ...untimed] = waiting;
             if (!timed)
@@ -282,7 +231,6 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         };
         for await (const line of backward(path, end, skip)) {
             if (line.time === null) {
-                // Before any timed line: it goes with the line after the end, or is the newest.
                 if (waiting.length === 0)
                     yield { ...line, time: next ?? Infinity };
                 else
@@ -302,11 +250,9 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         const copies = found?.copies ?? (await copiesOf(path, size));
         const from = Math.min(found?.end ?? (before === null ? size : await seek(path, 0, size, before + TIME_SLACK_MS, copies)), size);
         const after = found ? found.after : from < size ? await timeAt(path, from, size, copies) : null;
-        // Read back until the page is full and a line is older than its oldest by more than the slack:
-        // nothing before it can belong on the page.
         const taken = [];
         let count = 0;
-        let oldest = Infinity; // the time of the page's limit-th newest message, once it's full
+        let oldest = Infinity;
         let older = false;
         for await (const line of pagedBackward(path, from, after, copies)) {
             if (count >= limit && line.time < oldest - TIME_SLACK_MS) {
@@ -320,8 +266,6 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
             if (count >= limit)
                 oldest = oldestOnPage(taken, limit);
         }
-        // The page: its newest messages by time, ties with the oldest of them included. A line's messages
-        // stay together, so a page can hold a message or so more than the limit.
         const kept = count >= limit ? taken.filter((line) => line.time >= oldest) : taken;
         if (kept.length < taken.length)
             older = true;
@@ -330,7 +274,6 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
             nextBefore: older && Number.isFinite(oldest) ? new Date(oldest).toISOString() : null,
         };
     }
-    // Passing over the copies too: a resumed session's stretch written again isn't replayed twice.
     async function replay(afterId, emit) {
         const path = await locate();
         if (!path)
@@ -361,9 +304,20 @@ export function createFileTranscript(files, locate, lineMessages, layout) {
         }
         return true;
     }
-    return { page, replay };
+    async function find(match) {
+        const path = await locate();
+        if (!path)
+            return null;
+        const end = await files.size(path);
+        for await (const line of backward(path, end, await copiesOf(path, end))) {
+            const found = line.messages.find(match);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    return { page, replay, find };
 }
-/** The time of the `limit`-th newest message of `lines`. */
 function oldestOnPage(lines, limit) {
     const newestFirst = [...lines].sort((a, b) => b.time - a.time);
     let count = 0;
@@ -386,7 +340,6 @@ function joined(first, second) {
 }
 const DEFAULT_PAGE_SIZE = 50;
 const MAX_PAGE_SIZE = 500;
-/** A page of the API's transcript (AgentTranscript.getTranscript); none stored for a session that never ran. */
 export async function transcriptPage(transcript, { limit, before, cursor } = {}, found) {
     const time = transcriptTime(before ?? cursor);
     if (!transcript)
@@ -395,7 +348,6 @@ export async function transcriptPage(transcript, { limit, before, cursor } = {},
     const page = await transcript.page(time, size, found);
     return { ...page, nextCursor: page.nextBefore };
 }
-/** AgentTranscriptRequest.before as epoch ms; null for none. */
 export function transcriptTime(before) {
     if (before === undefined)
         return null;
@@ -404,35 +356,27 @@ export function transcriptTime(before) {
         throw new AgentInvalidError(`invalid time ${before}: give an ISO 8601 time`);
     return time;
 }
-/**
- * The first file `depth` levels under `dir` whose name `matches` (the backends' own layouts, like
- * projects/<project>/<id>.jsonl), each level listed at once; null when there's none, or no `dir`.
- */
-async function findFile(files, dir, depth, matches) {
-    let names;
+export async function directoryNames(files, dir) {
     try {
-        names = await files.listDirectory(dir);
+        return await files.listDirectory(dir);
     }
     catch (error) {
         if (error instanceof SandboxNotFoundError)
             return null;
         throw error;
     }
+}
+async function findFile(files, dir, depth, matches) {
+    const names = await directoryNames(files, dir);
+    if (!names)
+        return null;
     if (depth <= 1) {
         const name = names.find(matches);
         return name === undefined ? null : `${dir}/${name}`;
     }
-    // Newest first, where names sort by date (codex's YYYY/MM/DD): a recent conversation is the likely one.
-    const found = await Promise.all(names.sort().reverse().map((name) => 
-    // One that isn't a directory has nothing below it.
-    findFile(files, `${dir}/${name}`, depth - 1, matches).catch(() => null)));
+    const found = await Promise.all(names.sort().reverse().map((name) => findFile(files, `${dir}/${name}`, depth - 1, matches).catch(() => null)));
     return found.find((path) => path !== null) ?? null;
 }
-/**
- * `files` with what was already fetched of the file at `path` in the same round trip: its size, and
- * pieces of it (what a page reads, mostly). Reading back beyond them (a page across huge tool
- * outputs) fetches twice as much as the time before, so it takes a few more reads, not one per chunk.
- */
 export function prefetchedFiles(files, path, size, pieces) {
     let more = Math.max(CHUNK_BYTES, ...pieces.map(({ bytes }) => bytes.length));
     return {

package/dist/agent/session/install.d.ts

@@ -0,0 +1,5 @@
+import manifest from "../vendor-types/manifest.json";
+import type { AgentBackendInfo } from "../api.ts";
+export declare function pinnedVersion(vendor: keyof typeof manifest, pkg: string, sourcePackage?: string): string;
+export declare function installedPackage(installDir: string, pkg: string, version: string, executable: () => string): Promise<Omit<AgentBackendInfo, "backend">>;
+export declare function installPackage(installDir: string, pkg: string, version: string, executable: () => string): Promise<void>;

package/dist/agent/session/install.js

@@ -0,0 +1,35 @@
+import { existsSync } from "node:fs";
+import manifest from "../vendor-types/manifest.json" with { type: "json" };
+export function pinnedVersion(vendor, pkg, sourcePackage = pkg) {
+    const prefix = `npm:${sourcePackage}@`;
+    const source = manifest[vendor].sources.find((entry) => entry.source.startsWith(prefix));
+    if (!source)
+        throw new Error(`agent/vendor-types/manifest.json has no ${sourcePackage} for ${vendor} (needed for ${pkg})`);
+    return source.source.slice(prefix.length);
+}
+export async function installedPackage(installDir, pkg, version, executable) {
+    const manifest = Bun.file(`${installDir}/node_modules/${pkg}/package.json`);
+    const found = (await manifest.exists()) ? ((await manifest.json()).version ?? null) : null;
+    return { version: found, ready: found !== null && existsSync(executable()), pinned: version };
+}
+export async function installPackage(installDir, pkg, version, executable) {
+    const installed = await installedPackage(installDir, pkg, version, executable);
+    if (installed.ready && installed.version === version)
+        return;
+    const force = installed.version === version ? ["--force"] : [];
+    const proc = Bun.spawn(["flock", `${installDir}/.install.lock`, process.execPath, "add", "--exact", ...force, `${pkg}@${version}`], {
+        cwd: installDir,
+        stdin: "ignore",
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited,
+    ]);
+    if (exitCode !== 0)
+        throw new Error(`bun add ${pkg}@${version} failed (exit ${exitCode}): ${(stderr || stdout).trim()}`);
+    if (!existsSync(executable()))
+        throw new Error(`bun add ${pkg}@${version} left no ${executable()}: its platform package didn't install`);
+}

package/dist/agent/session/sessionStorage.d.ts

@@ -1,69 +1,38 @@
 import type { Sandbox } from "../../sandbox/api.ts";
-import type { AgentAuthStatus, AgentBackend, AgentPermissionRequest, AgentQuestionRequest, AgentSession } from "../api.ts";
-/** What the worker keeps of a session: never its messages, which are the backend's to store. */
+import type { AgentAuthStatus, AgentBackend, AgentPermissionMode, AgentPermissionRequest, AgentQuestionRequest, AgentSession, AgentSessionState } from "../api.ts";
 export type SessionRecord = {
     spec: AgentSession;
-    /** The backend's id for the conversation, once known: what a new worker resumes. */
     nativeId: string | null;
-    /** Chosen through AgentModels; null for the backend's default. */
     model: string | null;
+    permissionMode?: AgentPermissionMode;
 };
-/** Where a session's CLI stands with its sign-in, as far as it outlives a request. */
 export type SessionAuthRecord = {
-    /** Where the CLI's login in progress asked the user to sign in; null when none is. */
     login: Extract<AgentAuthStatus, {
         state: "pending";
     }> | null;
-    /** Why the last login failed, if it did. */
     error: string | null;
 };
-/** Every name must pass checkName; operations throw InvalidNameError otherwise. */
 export interface SessionStorage {
     getSessions(): Promise<SessionRecord[]>;
-    /** Stores the record unless one with that name exists; returns whichever record is stored afterwards. */
     insertSession(record: SessionRecord): Promise<SessionRecord>;
-    /** Replaces the record. */
     saveSession(record: SessionRecord): Promise<void>;
-    /** Removes the record and everything kept for the session. No-op if missing. */
     removeSession(sessionName: string): Promise<void>;
-    /** The permission requests the session's CLI is waiting on, oldest first. */
     getPermissionRequests(sessionName: string): Promise<AgentPermissionRequest[]>;
     savePermissionRequest(sessionName: string, request: AgentPermissionRequest): Promise<void>;
-    /** No-op if missing. */
     removePermissionRequest(sessionName: string, requestId: string): Promise<void>;
-    /** The questions the session's CLI is waiting on, oldest first. */
     getQuestionRequests(sessionName: string): Promise<AgentQuestionRequest[]>;
     saveQuestionRequest(sessionName: string, request: AgentQuestionRequest): Promise<void>;
-    /** No-op if missing. */
     removeQuestionRequest(sessionName: string, requestId: string): Promise<void>;
-    /** Null until the session's CLI has been asked to sign in. */
     readAuth(sessionName: string): Promise<SessionAuthRecord | null>;
     saveAuth(sessionName: string, record: SessionAuthRecord): Promise<void>;
-    /** Sandbox path of the unix socket the agent's worker listens on (see workerSocketPath). */
+    saveStatus(sessionName: string, status: AgentSessionState): Promise<void>;
     socketPath(): Promise<string>;
-    /**
-     * Sandbox path of the backend CLI's home (claude's config directory, codex's CODEX_HOME): its
-     * sign-in, config and conversations, kept with the rest of the dimension's state. Shared by the
-     * dimension's agents, like a home would be. Creates it.
-     */
     backendHome(backend: AgentBackend): Promise<string>;
 }
-/**
- * The agent's worker socket in a dimension's run directory: RUN_PATH inside the dimension, or the
- * host side of that mount, so the host reaches the worker through it.
- */
 export declare function workerSocketPath(runDirectory: string, agentName: string): string;
-/** Where the session's record is in a dimension's state directory (see createSessionStorage). */
+export declare function workerReadyPath(runDirectory: string, agentName: string): string;
 export declare function sessionRecordPath(stateDirectory: string, agentName: string, sessionName: string): string;
-/** Where the backend CLI's home is (SessionStorage.backendHome) in a dimension's state directory. */
 export declare function backendHomePath(stateDirectory: string, backend: AgentBackend): string;
-/**
- * `stateDirectory` is a sandbox path: the dimension's state directory (STATE_PATH, mounted from the
- * host's hyperbrane storage, so everything here lives there with the rest). Layout:
- * agents/<agent>/sessions/<session>.json, and agents/<agent>/sessions/<session>/ holding
- * permission-requests/<id>.json, question-requests/<id>.json and auth.json; backends/<backend>/
- * (the CLIs' homes). The socket goes in `runDirectory`, the dimension's run directory.
- */
 export declare function createSessionStorage(sandbox: Sandbox, agentName: string, { stateDirectory, runDirectory }?: {
     stateDirectory?: string;
     runDirectory?: string;

package/dist/agent/session/sessionStorage.js

@@ -1,37 +1,28 @@
-import { RUN_PATH, STATE_PATH } from "../../dimension/paths.js";
+import { dimensionLayout } from "../../dimension/api.js";
 import { checkName, createJsonDirectory } from "../../lib/jsonDirectory.js";
-/**
- * The agent's worker socket in a dimension's run directory: RUN_PATH inside the dimension, or the
- * host side of that mount, so the host reaches the worker through it.
- */
 export function workerSocketPath(runDirectory, agentName) {
     return `${runDirectory}/${agentName}.sock`;
 }
+export function workerReadyPath(runDirectory, agentName) {
+    return `${runDirectory}/${agentName}.ready`;
+}
 function sessionsDirectory(stateDirectory, agentName) {
     return `${stateDirectory}/agents/${agentName}/sessions`;
 }
-/** Where the session's record is in a dimension's state directory (see createSessionStorage). */
 export function sessionRecordPath(stateDirectory, agentName, sessionName) {
     return `${sessionsDirectory(stateDirectory, agentName)}/${checkName(sessionName)}.json`;
 }
-/** Where the backend CLI's home is (SessionStorage.backendHome) in a dimension's state directory. */
 export function backendHomePath(stateDirectory, backend) {
     return `${stateDirectory}/backends/${backend}`;
 }
-/**
- * `stateDirectory` is a sandbox path: the dimension's state directory (STATE_PATH, mounted from the
- * host's hyperbrane storage, so everything here lives there with the rest). Layout:
- * agents/<agent>/sessions/<session>.json, and agents/<agent>/sessions/<session>/ holding
- * permission-requests/<id>.json, question-requests/<id>.json and auth.json; backends/<backend>/
- * (the CLIs' homes). The socket goes in `runDirectory`, the dimension's run directory.
- */
-export function createSessionStorage(sandbox, agentName, { stateDirectory = STATE_PATH, runDirectory = RUN_PATH } = {}) {
+export function createSessionStorage(sandbox, agentName, { stateDirectory = dimensionLayout.statePath(), runDirectory = dimensionLayout.runPath() } = {}) {
     const sessionsDir = sessionsDirectory(stateDirectory, agentName);
     const sessions = createJsonDirectory(sandbox, async () => sessionsDir);
     const sessionDir = (sessionName) => `${sessionsDir}/${checkName(sessionName)}`;
     const permissionRequests = (sessionName) => createJsonDirectory(sandbox, async () => `${sessionDir(sessionName)}/permission-requests`);
     const questionRequests = (sessionName) => createJsonDirectory(sandbox, async () => `${sessionDir(sessionName)}/question-requests`);
     const sessionFiles = (sessionName) => createJsonDirectory(sandbox, async () => sessionDir(sessionName));
+    const statusFiles = (sessionName) => createJsonDirectory(sandbox, async () => sessionDir(sessionName));
     async function oldestFirst(stored) {
         return (await stored).sort((a, b) => a.at - b.at).map((entry) => entry.request);
     }
@@ -44,7 +35,6 @@ export function createSessionStorage(sandbox, agentName, { stateDirectory = STAT
     async function saveSession(record) {
         await sessions.save(record.spec.name, record);
     }
-    // Everything kept for it first: while the record is there, the removal can be retried.
     async function removeSession(sessionName) {
         await sandbox.removeDirectory(sessionDir(sessionName));
         await sessions.remove(sessionName);
@@ -73,6 +63,9 @@ export function createSessionStorage(sandbox, agentName, { stateDirectory = STAT
     async function saveAuth(sessionName, record) {
         await sessionFiles(sessionName).save("auth", record);
     }
+    async function saveStatus(sessionName, status) {
+        await statusFiles(sessionName).save("status", { status });
+    }
     async function socketPath() {
         return workerSocketPath(runDirectory, agentName);
     }
@@ -94,6 +87,7 @@ export function createSessionStorage(sandbox, agentName, { stateDirectory = STAT
         removeQuestionRequest,
         readAuth,
         saveAuth,
+        saveStatus,
         socketPath,
         backendHome,
     };

package/dist/agent/session/sharedConnection.d.ts

@@ -1,14 +1,6 @@
 import type { ConnectWorker } from "./workerConnection.ts";
 /** @sealed */
 export type SharedConnector = ConnectWorker & {
-    /** Closes the connection they share (a later connect opens another). */
     close(): void;
 };
-/**
- * One connection to the worker, shared by everyone `connect`s through it: each gets a view of it
- * (its requests go over it, the worker's notifications reach every view, closing a view only
- * detaches it), so calls cost a round trip each rather than a connection each. Over an endpoint
- * that's what matters (workerSseConnector opens an event stream per connection). The connection is
- * opened on first use, and again after it closes.
- */
 export declare function sharedConnector(connect: ConnectWorker): SharedConnector;

package/dist/agent/session/sharedConnection.js

@@ -1,10 +1,3 @@
-/**
- * One connection to the worker, shared by everyone `connect`s through it: each gets a view of it
- * (its requests go over it, the worker's notifications reach every view, closing a view only
- * detaches it), so calls cost a round trip each rather than a connection each. Over an endpoint
- * that's what matters (workerSseConnector opens an event stream per connection). The connection is
- * opened on first use, and again after it closes.
- */
 export function sharedConnector(connect) {
     let current = null;
     function open() {

package/dist/agent/session/storedTranscripts.d.ts

@@ -1,13 +1,8 @@
 import type { AgentBackend } from "../api.ts";
 import type { SessionBackend } from "./backend.ts";
 import type { LineMessages, TranscriptLayout } from "./fileTranscript.ts";
-/**
- * Each backend's conversations as it stores them: where (under the home homeEnvironment points it
- * at) and how a line reads, for reading a transcript with nothing running, from the host. None of
- * the backends' other code, which runs only in the dimension.
- */
 export type StoredTranscripts = Pick<SessionBackend, "homeEnvironment"> & {
     layout: TranscriptLayout;
     lineMessages(nativeId: string): LineMessages;
 };
-export declare const STORED_TRANSCRIPTS: Record<AgentBackend, StoredTranscripts>;
+export declare const STORED_TRANSCRIPTS: Partial<Record<AgentBackend, StoredTranscripts>>;

package/dist/agent/session/storedTranscripts.js

@@ -1,8 +1,5 @@
 import { claudeHomeEnvironment } from "./claude/home.js";
 import { CLAUDE_TRANSCRIPT_LAYOUT, claudeLineMessages } from "./claude/transcript.js";
-import { codexHomeEnvironment } from "./codex/home.js";
-import { CODEX_TRANSCRIPT_LAYOUT, codexLineMessages } from "./codex/transcript.js";
 export const STORED_TRANSCRIPTS = {
     claude: { homeEnvironment: claudeHomeEnvironment, layout: CLAUDE_TRANSCRIPT_LAYOUT, lineMessages: () => claudeLineMessages },
-    codex: { homeEnvironment: codexHomeEnvironment, layout: CODEX_TRANSCRIPT_LAYOUT, lineMessages: codexLineMessages },
 };

package/dist/agent/session/worker/jsonRpc.d.ts

@@ -1,7 +1,3 @@
-/**
- * JSON-RPC 2.0 over a byte stream, one JSON object per line (the framing codex's app-server uses).
- * Either end can send requests and notifications; the worker protocol (protocol.ts) is built on it.
- */
 export type JsonRpcId = string | number;
 export type JsonRpcErrorObject = {
     code: number;
@@ -9,29 +5,22 @@ export type JsonRpcErrorObject = {
     data?: unknown;
 };
 export type JsonRpcPeerOptions = {
-    /** Answers a request; what it throws goes back as an error response, through `encodeError`. */
-    onRequest(method: string, params: unknown): Promise<unknown>;
+    onRequest(method: string, params: unknown, protocol: number | undefined): Promise<unknown>;
+    protocol?: number;
     onNotification?(method: string, params: unknown): void;
     encodeError(error: unknown): JsonRpcErrorObject;
     decodeError(error: JsonRpcErrorObject): Error;
 };
 export interface JsonRpcPeer {
-    /** Feeds text read from the connection; complete lines are handled as they arrive. */
     receive(text: string): void;
     request(method: string, params: unknown): Promise<unknown>;
     notify(method: string, params: unknown): void;
-    /** Fails every request still waiting for its response. */
     close(error: Error): void;
 }
 export declare function createJsonRpcPeer(write: (line: string) => void, options: JsonRpcPeerOptions): JsonRpcPeer;
-/** The part of a Bun socket a writer needs. */
 type WritableSocket = {
     write(data: Uint8Array): number;
 };
-/**
- * Writes to a Bun socket without losing what it can't take yet: the rest is kept and written on
- * `drain`, which the socket's drain handler must call.
- */
 export declare function createSocketWriter(socket: WritableSocket): {
     write(text: string): void;
     drain(): void;

package/dist/agent/session/worker/jsonRpc.js

@@ -1,8 +1,3 @@
-/**
- * JSON-RPC 2.0 over a byte stream, one JSON object per line (the framing codex's app-server uses).
- * Either end can send requests and notifications; the worker protocol (protocol.ts) is built on it.
- */
-/** Answer for a line that isn't JSON-RPC at all. */
 const PARSE_ERROR = -32700;
 export function createJsonRpcPeer(write, options) {
     const pending = new Map();
@@ -31,7 +26,7 @@ export function createJsonRpcPeer(write, options) {
             return;
         }
         const id = message.id;
-        options.onRequest(message.method, message.params).then((result) => send({ id, result: result ?? null }), (error) => send({ id, error: options.encodeError(error) }));
+        options.onRequest(message.method, message.params, message.protocol).then((result) => send({ id, result: result ?? null }), (error) => send({ id, error: options.encodeError(error) }));
     }
     function receive(text) {
         buffered += text;
@@ -58,7 +53,7 @@ export function createJsonRpcPeer(write, options) {
         const id = nextId++;
         return new Promise((resolve, reject) => {
             pending.set(id, { resolve, reject });
-            send({ id, method, params });
+            send({ id, method, params, ...(options.protocol === undefined ? {} : { protocol: options.protocol }) });
         });
     }
     function notify(method, params) {
@@ -72,10 +67,6 @@ export function createJsonRpcPeer(write, options) {
     }
     return { receive, request, notify, close };
 }
-/**
- * Writes to a Bun socket without losing what it can't take yet: the rest is kept and written on
- * `drain`, which the socket's drain handler must call.
- */
 export function createSocketWriter(socket) {
     const encoder = new TextEncoder();
     let backlog = null;