antechamber 0.1.0 → 0.2.0

package/dist/server.js

@@ -1,4 +1,5 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
+import { createHash } from "node:crypto";
 import { createServer } from "node:http";
 import { debugLog } from "./misc-routes.js";
 import { SessionManager } from "./sessions.js";
@@ -14,17 +15,22 @@ export class AdapterServer {
     sessions;
     sse;
     sseClients = new Map();
+    webSocketClients = new Set();
+    webSocketEvents = [];
+    nextWebSocketEventID = 0;
     catalogPromise;
     actualPort;
-    http = new Http();
+    http = new Http(() => this.url);
     constructor(options) {
         this.options = options;
         this.sse = new SSE(options, this.sseClients);
         this.sessions = new SessionManager((directory, event) => this.broadcast(directory, event), undefined, options.defaultDirectory);
         this.server = createServer((req, res) => void this.route(req, res));
+        this.server.on("upgrade", (req, socket, head) => this.handleUpgrade(req, socket, head));
     }
     catalog() {
         this.catalogPromise ??= loadCatalog(this.options.defaultDirectory).catch((err) => {
+            this.catalogPromise = undefined;
             console.error("[catalog] failed to load models from pi:", err);
             return { providers: [], defaults: {} };
         });
@@ -50,6 +56,9 @@ export class AdapterServer {
         // session RPC groups and private task hosts are still being disposed.
         const closed = new Promise((resolve) => this.server.close(() => resolve()));
         this.sse.close();
+        for (const socket of this.webSocketClients)
+            socket.destroy();
+        this.webSocketClients.clear();
         try {
             await this.sessions.disposeAll();
         }
@@ -64,12 +73,91 @@ export class AdapterServer {
     // ---------------------------------------------------------------
     broadcast(directory, event) {
         this.sse.broadcast(directory, event);
+        this.broadcastWebSocket(directory, event);
     }
     writeSSE(res, frame) {
         return this.sse.writeSSE(res, frame);
     }
-    handleSSE(res, flavor) {
-        this.sse.handleSSE(res, flavor, this.writeSSE.bind(this));
+    handleSSE(req, res, flavor, directory, global) {
+        const lastEventID = req.headers["last-event-id"];
+        this.sse.handleSSE(res, { flavor, global, ...(global ? {} : { directory }) }, Array.isArray(lastEventID) ? lastEventID[0] : lastEventID, this.writeSSE.bind(this));
+    }
+    handleUpgrade(req, socket, _head) {
+        const url = new URL(req.url ?? "/", this.url);
+        if (url.pathname !== "/api/global/event/ws") {
+            this.rejectUpgrade(socket, 404, "Not Found");
+            return;
+        }
+        if (!this.http.allowsUpgrade(req)) {
+            this.rejectUpgrade(socket, 403, "Forbidden");
+            return;
+        }
+        const keyHeader = req.headers["sec-websocket-key"];
+        const key = Array.isArray(keyHeader) ? keyHeader[0] : keyHeader;
+        if (req.headers["sec-websocket-version"] !== "13" || typeof key !== "string") {
+            this.rejectUpgrade(socket, 400, "Bad Request");
+            return;
+        }
+        const accept = createHash("sha1").update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
+        socket.write([
+            "HTTP/1.1 101 Switching Protocols",
+            "Upgrade: websocket",
+            "Connection: Upgrade",
+            `Sec-WebSocket-Accept: ${accept}`,
+            "",
+            "",
+        ].join("\r\n"));
+        this.webSocketClients.add(socket);
+        socket.once("close", () => this.webSocketClients.delete(socket));
+        socket.once("error", () => this.webSocketClients.delete(socket));
+        const cursor = Number(url.searchParams.get("lastEventId"));
+        const replayReset = Number.isSafeInteger(cursor) && cursor >= 0 && cursor < this.nextWebSocketEventID - this.webSocketEvents.length;
+        this.writeWebSocket(socket, { type: "ready", ...(replayReset ? { replayReset: true } : {}) });
+        if (!Number.isSafeInteger(cursor) || cursor < 0)
+            return;
+        for (const event of this.webSocketEvents) {
+            if (event.id > cursor)
+                this.writeWebSocketEvent(socket, event);
+        }
+    }
+    rejectUpgrade(socket, status, message) {
+        socket.end(`HTTP/1.1 ${status} ${message}\r\nConnection: close\r\n\r\n`);
+    }
+    broadcastWebSocket(directory, payload) {
+        const event = { id: ++this.nextWebSocketEventID, directory, payload };
+        this.webSocketEvents.push(event);
+        if (this.webSocketEvents.length > 1024)
+            this.webSocketEvents.shift();
+        for (const socket of this.webSocketClients)
+            this.writeWebSocketEvent(socket, event);
+    }
+    writeWebSocketEvent(socket, event) {
+        this.writeWebSocket(socket, {
+            type: "event",
+            eventId: String(event.id),
+            directory: event.directory,
+            scope: "global",
+            payload: event.payload,
+        });
+    }
+    writeWebSocket(socket, frame) {
+        if (socket.destroyed || !socket.writable) {
+            this.webSocketClients.delete(socket);
+            return;
+        }
+        const payload = Buffer.from(JSON.stringify(frame));
+        const header = payload.length < 126
+            ? Buffer.from([0x81, payload.length])
+            : payload.length <= 0xffff
+                ? Buffer.from([0x81, 126, payload.length >> 8, payload.length & 0xff])
+                : (() => {
+                    const value = Buffer.alloc(10);
+                    value[0] = 0x81;
+                    value[1] = 127;
+                    value.writeBigUInt64BE(BigInt(payload.length), 2);
+                    return value;
+                })();
+        socket.write(Buffer.concat([header, payload]));
     }
     // ---------------------------------------------------------------
     // Router
@@ -82,18 +170,30 @@ export class AdapterServer {
         const url = new URL(req.url ?? "/", this.url);
         const path = url.pathname.replace(/\/+$/, "") || "/";
         const method = req.method ?? "GET";
-        const directory = url.searchParams.get("directory") ??
+        const directoryQuery = url.searchParams.get("directory") ??
             url.searchParams.get("location[directory]") ??
-            url.searchParams.get("location") ??
-            req.headers["x-opencode-directory"] ??
-            this.options.defaultDirectory;
+            url.searchParams.get("location");
+        const directoryHeader = req.headers["x-opencode-directory"];
+        const encodedDirectory = Array.isArray(directoryHeader) ? directoryHeader[0] : directoryHeader;
+        const directoryEncodingHeader = req.headers["x-opencode-directory-encoding"];
+        const directoryEncoding = Array.isArray(directoryEncodingHeader)
+            ? directoryEncodingHeader[0]
+            : directoryEncodingHeader;
+        let headerDirectory = encodedDirectory;
+        if (encodedDirectory !== undefined &&
+            (directoryEncoding?.toLowerCase() === "uri" || /^(?:%|[a-z]%3a)/i.test(encodedDirectory))) {
+            headerDirectory = decodeURIComponent(encodedDirectory);
+        }
+        const directory = directoryQuery ?? headerDirectory ?? this.options.defaultDirectory;
         // SSE stream (v2 clients subscribe at /api/event; v1 at /event)
         if (method === "GET" && (path === "/event" || path === "/global/event")) {
-            this.handleSSE(res, "v1");
+            this.handleSSE(req, res, "v1", directory, path === "/global/event");
             return;
         }
         if (method === "GET" && path === "/api/event") {
-            this.handleSSE(res, "v2");
+            // OpenChamber 2.3.2 opens one unscoped /api/event as its global hub (captured);
+            // only an explicit directory selector scopes the stream.
+            this.handleSSE(req, res, "v2", directory, directoryQuery === null && headerDirectory === undefined);
             return;
         }
         const services = {

package/dist/session-commands.d.ts

@@ -1,16 +1,18 @@
+import type { OCPromptPart } from "./types.js";
 import type { ManagedSession, SessionManager } from "./sessions.js";
 import type { OCAssistantMessage, OCEvent, OCMessageWithParts, OCToolPart, OCTextPart, OCUserMessage } from "./types.js";
-export type CommandDescriptor = {
+type CommandDescriptor = {
     name: string;
     description: string;
     template: "";
 };
-export type SlashCommandInput = {
+type SlashCommandInput = {
     command: string;
     arguments: string;
     messageID?: string;
+    parts?: OCPromptPart[];
 };
-export type ShellResult = {
+type ShellResult = {
     output: string;
     exitCode: number | null;
     cancelled: boolean;
@@ -20,40 +22,36 @@ export type ShellMessage = OCMessageWithParts & {
     info: OCAssistantMessage;
     parts: [OCToolPart];
 };
-export type ShellUserMessage = OCMessageWithParts & {
+type ShellUserMessage = OCMessageWithParts & {
     info: OCUserMessage;
     parts: [OCTextPart];
 };
-export type ShareNoticeMessage = OCMessageWithParts & {
-    info: OCAssistantMessage;
-    parts: [OCTextPart];
-};
-export type ShellExecution = {
+type ShellExecution = {
     kind: "completed";
     message: ShellMessage;
 } | {
     kind: "error";
     message: string;
 };
-export interface ShellCommandContext {
+interface ShellCommandContext {
     sessions: SessionManager;
     session: ManagedSession;
     command: string;
     emit: (directory: string, event: OCEvent) => void;
 }
-export interface ShareNoticeContext {
+interface ShareNoticeContext {
     sessions: SessionManager;
     session: ManagedSession;
     emit: (directory: string, event: OCEvent) => void;
 }
-export type CompactResult = {
+type CompactResult = {
     kind: "compacted";
 } | {
     kind: "error";
     message: string;
 };
 export declare const unsupportedShare: {
-    readonly name: "BadRequestError";
+    readonly name: "UnsupportedError";
     readonly data: {
         readonly message: "Sharing is not available with OmO";
     };
@@ -61,10 +59,16 @@ export declare const unsupportedShare: {
 export declare function shellTitle(command: string): string;
 export declare function getCommands(directory: string): Promise<CommandDescriptor[]>;
 export declare function parseSlashCommand(value: unknown): SlashCommandInput | undefined;
-export declare function slashCommandPrompt(input: SlashCommandInput): string;
+/**
+ * OmO never auto-titles a first prompt that starts with "/", so a session opened
+ * with `/skill:plan Build the importer` kept its first-message title. Title from
+ * the command's arguments instead; a bare command has nothing to title from.
+ */
+export declare function slashTitlePrompt(text: string): {
+    sessionTitlePrompt?: string;
+};
 export declare function runSlashCommand(sessions: SessionManager, sessionId: string, input: SlashCommandInput): Promise<OCMessageWithParts | undefined>;
 export declare function parseShellCommand(value: unknown): string | undefined;
-export declare function parseShellResult(value: unknown): ShellResult;
 export declare function createShellMessage(session: ManagedSession, command: string): ShellMessage;
 export declare function shellUserMessage(message: ShellMessage): ShellUserMessage;
 export declare function announceSessionNotice(context: ShareNoticeContext, messageText: string, error?: OCAssistantMessage["error"]): void;
@@ -73,3 +77,4 @@ export declare function completeShellMessage(message: ShellMessage, command: str
 export declare function failShellMessage(message: ShellMessage, command: string, error: string, metadata?: Record<string, unknown>): void;
 export declare function compactSession(sessions: SessionManager, sessionId: string): Promise<CompactResult>;
 export declare function runShellCommand(context: ShellCommandContext): Promise<ShellExecution>;
+export {};

package/dist/session-commands.js

@@ -1,9 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { PiRpcClient } from "./pi-rpc.js";
+import { PiRpcClient, UpstreamProtocolError } from "./pi-rpc.js";
 import { getAgentName } from "./agent-name.js";
+import { nativePromptInput, parsePromptParts } from "./prompt-parts.js";
 // OpenChamber drops rejected Share actions, so emit a visible session notice too.
 export const unsupportedShare = {
-    name: "BadRequestError",
+    name: "UnsupportedError",
     data: { message: "Sharing is not available with OmO" },
 };
 function isRecord(value) {
@@ -12,8 +13,10 @@ function isRecord(value) {
 function id(prefix) {
     return `${prefix}_${randomUUID().replaceAll("-", "")}`;
 }
+const SHELL_TITLE_MAX_CHARS = 60;
+const SHELL_TITLE_TRUNCATED_CHARS = 57;
 export function shellTitle(command) {
-    const short = command.length > 60 ? `${command.slice(0, 57)}…` : command;
+    const short = command.length > SHELL_TITLE_MAX_CHARS ? `${command.slice(0, SHELL_TITLE_TRUNCATED_CHARS)}…` : command;
     return `bash: ${short}`;
 }
 function assistantMessage(session) {
@@ -112,13 +115,30 @@ export function parseSlashCommand(value) {
         return undefined;
     // OpenChamber inserts the command's user message optimistically under this id.
     const messageID = typeof value.messageID === "string" && value.messageID !== "" ? value.messageID : undefined;
-    return { command: value.command, arguments: value.arguments, ...(messageID ? { messageID } : {}) };
+    const parts = parsePromptParts(value.parts);
+    nativePromptInput("", parts);
+    return {
+        command: value.command,
+        arguments: value.arguments,
+        ...(messageID ? { messageID } : {}),
+        ...(parts.length > 0 ? { parts } : {}),
+    };
 }
-export function slashCommandPrompt(input) {
+/**
+ * OmO never auto-titles a first prompt that starts with "/", so a session opened
+ * with `/skill:plan Build the importer` kept its first-message title. Title from
+ * the command's arguments instead; a bare command has nothing to title from.
+ */
+export function slashTitlePrompt(text) {
+    const match = /^\s*\/\S+\s+([\s\S]*\S)/.exec(text);
+    return match?.[1] !== undefined && !match[1].startsWith("/") ? { sessionTitlePrompt: match[1] } : {};
+}
+function slashCommandPrompt(input) {
     return input.arguments === "" ? `/${input.command}` : `/${input.command} ${input.arguments}`;
 }
 export async function runSlashCommand(sessions, sessionId, input) {
-    await sessions.prompt(sessionId, slashCommandPrompt(input), undefined, false, input.messageID);
+    const text = slashCommandPrompt(input);
+    await sessions.prompt(sessionId, text, undefined, false, input.messageID, "steer", input.parts ? [{ type: "text", text }, ...input.parts] : undefined);
     await sessions.reloadMessages(sessionId);
     const messages = sessions.messages(sessionId) ?? [];
     return [...messages].reverse().find((message) => message.info.role === "assistant") ?? messages[messages.length - 1];
@@ -128,7 +148,7 @@ export function parseShellCommand(value) {
         return undefined;
     return value.command;
 }
-export function parseShellResult(value) {
+function parseShellResult(value) {
     if (!isRecord(value) ||
         typeof value.output !== "string" ||
         (typeof value.exitCode !== "number" &&
@@ -136,7 +156,7 @@ export function parseShellResult(value) {
             !(value.cancelled === true && value.exitCode === undefined)) ||
         typeof value.cancelled !== "boolean" ||
         typeof value.truncated !== "boolean") {
-        throw new Error("OmO bash returned an invalid result");
+        throw new UpstreamProtocolError("OmO bash returned an invalid result");
     }
     return {
         output: value.output,
@@ -256,6 +276,15 @@ export async function runShellCommand(context) {
     sessions.messages(session.info.id);
     const message = createShellMessage(session, command);
     const user = shellUserMessage(message);
+    const shell = {
+        id: message.parts[0].callID,
+        command,
+        cwd: session.info.directory,
+        shell: "bash",
+        file: "",
+        metadata: {},
+        time: { started: message.info.time.created },
+    };
     const dispatch = (session.tree.shellDispatch ??= {});
     dispatch[message.info.id] = false;
     const afterEntryId = session.tree.leafId ?? null;
@@ -276,8 +305,12 @@ export async function runShellCommand(context) {
     shellEvent(context, { type: "message.updated", properties: { info: user.info } });
     shellEvent(context, { type: "message.part.updated", properties: { part: user.parts[0] } });
     emitShellMessage(context, message);
+    shellEvent(context, {
+        type: "session.shell.started",
+        properties: { sessionID: session.info.id, shell: { ...shell, status: "running" } },
+    });
     try {
-        sessions.update(session.info.id, {});
+        await sessions.update(session.info.id, {});
         const response = await sessions.sessionRpc(session.info.id, { type: "bash", command }, controller.signal, () => {
             dispatch[message.info.id] = true;
             // Only actual dispatch admissions are durable; queued attempts stay in the live cache.
@@ -285,7 +318,7 @@ export async function runShellCommand(context) {
             // A native result can land beyond the last synchronized leaf.
             if (!session.tree.revert)
                 delete session.tree.leafId;
-            sessions.update(session.info.id, {});
+            void sessions.update(session.info.id, {}).catch((error) => controller.abort(error));
         });
         if (controller.signal.aborted)
             throw controller.signal.reason;
@@ -317,7 +350,24 @@ export async function runShellCommand(context) {
     }
     finally {
         delete session.cancelShell;
+        const state = message.parts[0].state;
+        const metadata = state.status === "pending" ? undefined : state.metadata;
+        const output = state.status === "completed" ? state.output : state.status === "error" ? state.error : "";
+        const size = Buffer.byteLength(output);
+        shellEvent(context, {
+            type: "session.shell.ended",
+            properties: {
+                sessionID: session.info.id,
+                shell: {
+                    ...shell,
+                    status: state.status === "completed" ? "exited" : "killed",
+                    ...(typeof metadata?.exitCode === "number" ? { exit: metadata.exitCode } : {}),
+                    time: { ...shell.time, completed: message.info.time.completed ?? Date.now() },
+                },
+                output: { output, cursor: size, size, truncated: metadata?.truncated === true },
+            },
+        });
         setShellStatus(context, "idle");
-        sessions.update(session.info.id, {});
+        await sessions.update(session.info.id, {});
     }
 }

package/dist/session-diff.d.ts

@@ -11,4 +11,4 @@ export interface SessionFileDiff {
     status: "added" | "modified" | "deleted";
 }
 export declare function touchedFiles(parts: readonly OCPart[]): string[];
-export declare function sessionDiff(directory: string, messages: readonly OCMessageWithParts[]): Promise<SessionFileDiff[]>;
+export declare function sessionDiff(directory: string, messages: readonly OCMessageWithParts[], context?: number): Promise<SessionFileDiff[]>;

package/dist/session-diff.js

@@ -3,6 +3,8 @@ import { readFile, realpath, lstat } from "node:fs/promises";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 const exec = promisify(execFile);
+const GIT_EXEC_TIMEOUT_MS = 5_000;
+const GIT_EXEC_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 export function touchedFiles(parts) {
     return [
         ...new Set(parts.flatMap((part) => part.type === "tool" &&
@@ -14,7 +16,11 @@ export function touchedFiles(parts) {
     ];
 }
 async function git(directory, args) {
-    const result = await exec("git", args, { cwd: directory, timeout: 5000, maxBuffer: 16 * 1024 * 1024 });
+    const result = await exec("git", args, {
+        cwd: directory,
+        timeout: GIT_EXEC_TIMEOUT_MS,
+        maxBuffer: GIT_EXEC_MAX_BUFFER_BYTES,
+    });
     return result.stdout;
 }
 /** A removed file may be absent, but neither traversal nor symlinks may escape. */
@@ -49,7 +55,7 @@ async function confinedFile(directory, path) {
     }
     return absolute;
 }
-export async function sessionDiff(directory, messages) {
+export async function sessionDiff(directory, messages, context = 3) {
     let gitRoot;
     try {
         gitRoot = (await git(directory, ["rev-parse", "--show-toplevel"])).trim();
@@ -104,6 +110,7 @@ export async function sessionDiff(directory, messages) {
                     "HEAD",
                     "--no-ext-diff",
                     "--no-color",
+                    `--unified=${Math.floor(context)}`,
                     "--src-prefix=a/",
                     "--dst-prefix=b/",
                     "--",
@@ -118,6 +125,7 @@ export async function sessionDiff(directory, messages) {
                         "--no-index",
                         "--no-ext-diff",
                         "--no-color",
+                        `--unified=${Math.floor(context)}`,
                         "--src-prefix=a/",
                         "--dst-prefix=b/",
                         "--",

package/dist/session-history.js

@@ -2,10 +2,11 @@
 import { readFileSync } from "node:fs";
 import { applyProviderToolResults, finishProviderToolParts, mapTool, providerToolParts, resultMetadata, resultText, } from "./tool-map.js";
 import { TodoBridge } from "./todo-bridge.js";
+import { contextMessageID } from "./prompt-parts.js";
 import { bindMessageEntries } from "./session-tree.js";
 import { taskParts, updateTaskParts, taskCompletions } from "./subagents.js";
 import { shellTitle, shellUserMessage } from "./session-commands.js";
-import { piModelId, piStopReason, textOf } from "./pi-event-translation.js";
+import { compactionMessages, piModelId, piStopReason, textOf } from "./pi-event-translation.js";
 function entryTime(e) {
     if (typeof e.timestamp === "number")
         return e.timestamp;
@@ -38,9 +39,7 @@ export function parsePiSessionFile(s, agentName) {
     }
     return parsePiSessionText(s, agentName, raw);
 }
-export function parsePiSessionText(s, agentName, raw) {
-    const sessionID = s.info.id;
-    const directory = s.info.directory;
+function parseEntries(raw) {
     const entries = [];
     for (const line of raw.split("\n")) {
         if (line.length === 0)
@@ -54,12 +53,43 @@ export function parsePiSessionText(s, agentName, raw) {
             /* torn trailing write — ignore */
         }
     }
-    const indexOf = new Map();
-    entries.forEach((e, i) => indexOf.set(e, i));
+    return entries;
+}
+function nativeTree(entries, leaf) {
+    return {
+        leafId: leaf?.id ?? null,
+        entries: entries.flatMap((entry) => {
+            if (entry.id === undefined || entry.type === undefined)
+                return [];
+            const message = entry.message;
+            return [
+                {
+                    type: entry.type,
+                    id: entry.id,
+                    parentId: entry.parentId ?? null,
+                    ...(message?.role === undefined
+                        ? {}
+                        : {
+                            message: {
+                                role: message.role,
+                                ...(message.clientMessageId === undefined ? {} : { clientMessageId: message.clientMessageId }),
+                                ...(message.role === "user" ? { content: [{ type: "text", text: textOf(message.content) }] } : {}),
+                                ...(message.command === undefined ? {} : { command: message.command }),
+                                ...(message.output === undefined ? {} : { output: message.output }),
+                                ...(message.exitCode === undefined ? {} : { exitCode: message.exitCode }),
+                                ...(message.cancelled === undefined ? {} : { cancelled: message.cancelled }),
+                            },
+                        }),
+                },
+            ];
+        }),
+    };
+}
+function activeChain(s, entries) {
     const byId = new Map();
-    for (const e of entries)
-        if (typeof e.id === "string")
-            byId.set(e.id, e);
+    for (const entry of entries)
+        if (typeof entry.id === "string")
+            byId.set(entry.id, entry);
     let leaf = [...entries].reverse().find((entry) => entry.type !== "session" && typeof entry.id === "string");
     let selectedLeaf = s.tree.revert ? s.tree.revert.previousLeafId : s.tree.leafId;
     if (!s.tree.revert && s.tree.localShellTurns?.length) {
@@ -77,40 +107,21 @@ export function parsePiSessionText(s, agentName, raw) {
         leaf = selectedLeaf === null ? undefined : byId.get(selectedLeaf);
     const chain = [];
     const seen = new Set();
-    for (let cur = leaf; cur !== undefined && !seen.has(cur);) {
-        seen.add(cur);
-        chain.push(cur);
-        cur = typeof cur.parentId === "string" ? byId.get(cur.parentId) : undefined;
+    for (let entry = leaf; entry !== undefined && !seen.has(entry);) {
+        seen.add(entry);
+        chain.push(entry);
+        entry = typeof entry.parentId === "string" ? byId.get(entry.parentId) : undefined;
     }
     chain.reverse();
-    const nativeTree = {
-        leafId: leaf?.id ?? null,
-        entries: entries.flatMap((entry) => {
-            if (entry.id === undefined || entry.type === undefined)
-                return [];
-            const m = entry.message;
-            return [
-                {
-                    type: entry.type,
-                    id: entry.id,
-                    parentId: entry.parentId ?? null,
-                    ...(m?.role === undefined
-                        ? {}
-                        : {
-                            message: {
-                                role: m.role,
-                                ...(m.clientMessageId === undefined ? {} : { clientMessageId: m.clientMessageId }),
-                                ...(m.role === "user" ? { content: [{ type: "text", text: textOf(m.content) }] } : {}),
-                                ...(m.command === undefined ? {} : { command: m.command }),
-                                ...(m.output === undefined ? {} : { output: m.output }),
-                                ...(m.exitCode === undefined ? {} : { exitCode: m.exitCode }),
-                                ...(m.cancelled === undefined ? {} : { cancelled: m.cancelled }),
-                            },
-                        }),
-                },
-            ];
-        }),
-    };
+    return { chain, nativeTree: nativeTree(entries, leaf) };
+}
+export function parsePiSessionText(s, agentName, raw) {
+    const sessionID = s.info.id;
+    const directory = s.info.directory;
+    const entries = parseEntries(raw);
+    const indexOf = new Map();
+    entries.forEach((e, i) => indexOf.set(e, i));
+    const { chain, nativeTree } = activeChain(s, entries);
     if (s.tree.localShellTurns?.length)
         bindMessageEntries(s, nativeTree);
     const out = [];
@@ -131,6 +142,45 @@ export function parsePiSessionText(s, agentName, raw) {
             currentModel = { providerID: e.provider, modelID: e.modelId };
             continue;
         }
+        if (e.type === "compaction" && typeof e.summary === "string" && typeof e.firstKeptEntryId === "string") {
+            // Not a run boundary: an automatic compaction can sit between steps of one turn.
+            out.push(...compactionMessages(s, e.id ?? `r${indexOf.get(e) ?? 0}`, e.summary, entryTime(e), currentModel));
+            continue;
+        }
+        const contextID = contextMessageID(e);
+        if (contextID !== undefined) {
+            endRun();
+            const content = Array.isArray(e.content)
+                ? e.content
+                : typeof e.content === "string"
+                    ? [{ type: "text", text: e.content }]
+                    : [];
+            const time = entryTime(e);
+            if (e.id)
+                s.tree.messageEntries[contextID] = e.id;
+            out.push({
+                info: {
+                    id: contextID,
+                    sessionID,
+                    role: "user",
+                    time: { created: time },
+                    agent: agentName,
+                    model: currentModel,
+                    synthetic: true,
+                },
+                parts: [
+                    {
+                        id: `prt_${contextID}_context`,
+                        sessionID,
+                        messageID: contextID,
+                        type: "text",
+                        text: textOf(content),
+                        time: { start: time, end: time },
+                    },
+                ],
+            });
+            continue;
+        }
         if (e.type !== "message")
             continue;
         const m = e.message;
@@ -367,7 +417,9 @@ export function parsePiSessionText(s, agentName, raw) {
         finishProviderToolParts([...toolParts.values()].flat(), entryTime(lastAssistant), stopReason === "aborted" ? "Cancelled" : "No result");
     }
     s.todoBridge = new TodoBridge(sessionID);
-    s.todoBridge.restore(entries, new Map([...toolParts].flatMap(([callID, parts]) => (parts[0] ? [[callID, parts[0]]] : []))));
+    // Tree-less snapshots predate branch selection and have no competing ancestor chain.
+    const todoEntries = chain.length === 0 && s.tree.leafId === undefined && !s.tree.revert ? entries : chain;
+    s.todoBridge.restore(todoEntries, new Map([...toolParts].flatMap(([callID, parts]) => (parts[0] ? [[callID, parts[0]]] : []))));
     // Completions can be appended after the newest message, outside its ancestor chain.
     for (const entry of entries) {
         if (entry.customType !== "omo-senpi:wake")
@@ -412,5 +464,24 @@ export function parsePiSessionText(s, agentName, raw) {
         });
         (s.inputs ??= new Map()).set(messageID, { text, delivery, accepted: true, delivered: false });
     }
+    for (const message of out) {
+        const metadata = s.tree.promptMetadata?.[message.info.id];
+        if (message.info.role === "user" && metadata !== undefined)
+            message.info.metadata = metadata;
+        const inputParts = s.tree.promptParts?.[message.info.id];
+        if (message.info.role === "user" && inputParts !== undefined)
+            message.parts = inputParts.map((part, index) => ({
+                ...part,
+                id: part.id ?? `prt_${message.info.id}_${index}`,
+                sessionID,
+                messageID: message.info.id,
+            }));
+        const identities = s.tree.messageParts?.[message.info.id];
+        for (const [index, part] of message.parts.entries()) {
+            const identity = identities?.[index];
+            if (identity !== undefined)
+                part.id = identity;
+        }
+    }
     return out;
 }