antechamber 0.1.0 → 0.2.0

package/dist/sessions.js

@@ -2,24 +2,29 @@
  * Session registry: one OpenCode session maps to one `pi --mode rpc` process.
  * Composes the live event bridge and restored-session history reconstruction.
  */
-import { id, PiEventTranslator } from "./pi-event-translation.js";
+import { id, PiEventTranslator, syncSessionCost } from "./pi-event-translation.js";
 import { parsePiSessionFile, parsePiSessionText } from "./session-history.js";
+import { CONTEXT_MESSAGE_TYPE, nativePromptInput, v2PromptAttachments } from "./prompt-parts.js";
 import { existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { PiRpcClient, RPC_COMMAND_TIMEOUT_MS } from "./pi-rpc.js";
+import { COMPACT_RPC_TIMEOUT_MS, PiRpcClient, RPC_COMMAND_TIMEOUT_MS, } from "./pi-rpc.js";
 import { stopSessionHosts } from "./session-hosts.js";
 import { setThinkingLevel } from "./thinking-levels.js";
 import { SessionLifecycle } from "./lifecycle.js";
 import { ApprovalBridge, extensionUiRequestFrom } from "./approvals.js";
-import { getAgentName } from "./agent-name.js";
-import { bindMessageEntries, durableShellTree, forkConversation, getEntries, navigate, readSessionTree, revertConversation, revertNotice, SessionTreeError, unrevertConversation, } from "./session-tree.js";
+import { getAgentName, getExposedAgentNames } from "./agent-name.js";
+import { RequestBodyError } from "./http.js";
+import { bindMessageEntries, durableShellTree, forkConversation, getEntries, navigate, readSessionTree, revertConversation, SessionTreeError, unrevertConversation, } from "./session-tree.js";
 import { SubagentBridge } from "./subagents.js";
 import { sessionDiff } from "./session-diff.js";
-import { announceSessionNotice } from "./session-commands.js";
-import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionPersistenceError, SessionStore, readSessionTitle, } from "./session-store.js";
+import { announceSessionNotice, slashTitlePrompt } from "./session-commands.js";
+import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionTitle, } from "./session-store.js";
 import { ADAPTER_VERSION } from "./version.js";
 export { ADAPTER_VERSION } from "./version.js";
 const SESSION_SCAN_CACHE_TTL_MS = 5_000;
+const PI_FILE_RESOLVE_ATTEMPTS = 10;
+const PI_FILE_RESOLVE_RETRY_MS = 200;
+const SESSION_TITLE_MAX_CHARS = 60;
 export class SessionManager {
     emit;
     defaultDirectory;
@@ -57,10 +62,14 @@ export class SessionManager {
             persistMeta: (s) => this.persistMeta(s),
         });
     }
-    async create(directory, title, parentID) {
-        return this.lifecycle.run(() => this.createLive(directory, title, parentID));
+    async create(directory, title, parentID, options = {}) {
+        if (options.agent !== undefined && !getExposedAgentNames().includes(options.agent))
+            throw new RequestBodyError(400, `unknown agent: ${options.agent}`);
+        return this.lifecycle.run(() => this.createLive(directory, title, parentID, options));
     }
-    async createLive(directory, title, parentID) {
+    async createLive(directory, title, parentID, options = {}) {
+        if (options.id !== undefined && (options.id === "" || this.get(options.id) !== undefined))
+            throw new RequestBodyError(400, "session id must be nonempty and unused");
         await this.lifecycle.makeRoom();
         const pi = new PiRpcClient({ cwd: directory, clock: this.lifecycle.clock });
         const state = await pi.command({ type: "get_state" }).catch(async (error) => {
@@ -78,12 +87,18 @@ export class SessionManager {
         if (piSessionId !== undefined)
             this.createdSessions.set(piSessionId, directory);
         const info = {
-            id: piSessionId !== undefined ? ocIdFor(piSessionId) : id("ses"),
+            id: options.id ?? (piSessionId !== undefined ? ocIdFor(piSessionId) : id("ses")),
             projectID: directory,
             directory,
             title: title?.trim() || "New session",
             version: ADAPTER_VERSION,
             time: { created: now, updated: now },
+            agent: options.agent ?? getAgentName(),
+            slug: piSessionId ?? id("session"),
+            path: "",
+            summary: { additions: 0, deletions: 0, files: 0 },
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+            ...(options.metadata !== undefined ? { metadata: options.metadata } : {}),
             ...(parentID !== undefined ? { parentID } : {}),
         };
         const managed = {
@@ -101,44 +116,73 @@ export class SessionManager {
             ...(piSessionId !== undefined ? { piSessionId } : {}),
             ...(state.data.thinkingLevel !== undefined ? { thinkingLevel: state.data.thinkingLevel } : {}),
         };
-        managed.approvals = this.approvalsFor(managed);
-        this.sessions.set(info.id, managed);
-        this.subagents.wire(managed);
-        this.lifecycle.touch(managed);
-        this.wirePi(managed, pi);
-        this.emit(directory, { type: "session.created", properties: { info } });
-        // Announce pi's real model *after* session.created, so the client already
-        // knows the session when the switch marker lands in its transcript.
-        this.applyPiModel(managed, state.data.model?.provider, state.data.model?.id);
-        // Bind pi's session file so the session survives adapter restarts. pi
-        // reports the path directly; fall back to a background scan for older pi
-        // versions, and re-bind after the first prompt (pi persists lazily).
-        if (typeof state.data.sessionFile === "string" && state.data.sessionFile !== "") {
-            managed.piPath = state.data.sessionFile;
-            this.persistMeta(managed);
-        }
-        else if (piSessionId !== undefined) {
-            void this.resolvePiFile(directory, piSessionId)
-                .then((piPath) => {
-                if (piPath !== undefined && managed.piPath === undefined) {
+        let published = false;
+        try {
+            managed.approvals = this.approvalsFor(managed);
+            this.sessions.set(info.id, managed);
+            published = true;
+            this.subagents.wire(managed);
+            this.lifecycle.touch(managed);
+            this.wirePi(managed, pi);
+            if (options.model !== undefined)
+                await this.setModel(info.id, options.model);
+            this.emit(directory, { type: "session.created", properties: { info } });
+            // Announce pi's real model *after* session.created, so the client already
+            // knows the session when the switch marker lands in its transcript.
+            if (options.model === undefined)
+                this.applyPiModel(managed, state.data.model?.provider, state.data.model?.id);
+            // Bind pi's session file so the session survives adapter restarts. pi
+            // reports the path directly; fall back to a background scan for older pi
+            // versions, and re-bind after the first prompt (pi persists lazily).
+            if (typeof state.data.sessionFile === "string" && state.data.sessionFile !== "") {
+                managed.piPath = state.data.sessionFile;
+                this.persistMeta(managed);
+            }
+            else if (piSessionId !== undefined) {
+                void this.resolvePiFile(directory, piSessionId)
+                    .then((piPath) => {
+                    if (this.sessions.get(info.id) !== managed || piPath === undefined || managed.piPath !== undefined)
+                        return;
                     managed.piPath = piPath;
                     this.persistMeta(managed);
-                }
-            })
-                .catch((error) => this.reportPersistenceError(managed, error));
-        }
-        if (managed.titleSource === "user") {
-            const renamed = await pi.command({ type: "set_session_name", name: info.title });
-            if (!renamed.success)
-                throw new Error(renamed.error ?? "session rename rejected");
+                })
+                    .catch((error) => {
+                    if (this.sessions.get(info.id) === managed)
+                        this.reportPersistenceError(managed, error);
+                });
+            }
+            if (managed.titleSource === "user") {
+                const renamed = await pi.command({ type: "set_session_name", name: info.title });
+                if (!renamed.success)
+                    throw new Error(renamed.error ?? "session rename rejected");
+            }
+            else {
+                this.applyNativeTitle(managed, state.data.sessionName);
+            }
+            const reconciled = await pi.command({ type: "get_state" });
+            if (reconciled.success)
+                this.applyNativeTitle(managed, reconciled.data?.sessionName);
+            return info;
         }
-        else {
-            this.applyNativeTitle(managed, state.data.sessionName);
+        catch (error) {
+            if (published)
+                await this.rollbackCreate(managed, piSessionId);
+            else
+                await pi.dispose();
+            throw error;
         }
-        const reconciled = await pi.command({ type: "get_state" });
-        if (reconciled.success)
-            this.applyNativeTitle(managed, reconciled.data?.sessionName);
-        return info;
+    }
+    async rollbackCreate(managed, piSessionId) {
+        this.sessions.delete(managed.info.id);
+        if (piSessionId !== undefined)
+            this.createdSessions.delete(piSessionId);
+        managed.unwirePi?.();
+        const pi = managed.pi;
+        managed.pi = undefined;
+        if (pi !== undefined)
+            await pi.dispose();
+        this.store.remove(managed.info.id);
+        this.emit(managed.info.directory, { type: "session.deleted", properties: { info: managed.info } });
     }
     applyNativeTitle(s, value) {
         if (s.titleSource === "user" || typeof value !== "string")
@@ -186,12 +230,15 @@ export class SessionManager {
         const onExit = (code) => {
             if (s.pi !== pi)
                 return;
-            s.approvals?.finishTurn();
+            this.events.finishInterruptedRun(s, {
+                name: "UnknownError",
+                data: { message: `pi process exited (code=${code})` },
+            });
+            delete s.interruptRequested;
             this.subagents.stopParent(s.info.id);
             void this.lifecycle
                 .dormant(s)
                 .catch((error) => console.error("[lifecycle] exit cleanup failed:", error));
-            this.events.setStatus(s, { type: "idle" });
             this.emit(s.info.directory, {
                 type: "session.error",
                 properties: {
@@ -199,6 +246,7 @@ export class SessionManager {
                     error: { name: "UnknownError", data: { message: `pi process exited (code=${code})` } },
                 },
             });
+            this.events.setStatus(s, { type: "idle" });
         };
         pi.onEvent(onEvent);
         pi.onExtensionUI(onExtensionUI);
@@ -214,7 +262,7 @@ export class SessionManager {
     async resolvePiFile(directory, piSessionId) {
         const dir = piSessionDir(directory);
         const suffix = `_${piSessionId}.jsonl`;
-        for (let attempt = 0; attempt < 10; attempt++) {
+        for (let attempt = 0; attempt < PI_FILE_RESOLVE_ATTEMPTS; attempt++) {
             try {
                 for (const name of readdirSync(dir)) {
                     if (name.endsWith(suffix))
@@ -224,7 +272,7 @@ export class SessionManager {
             catch {
                 /* session dir may not exist until pi writes the first entry */
             }
-            await new Promise((resolve) => setTimeout(resolve, 200));
+            await new Promise((resolve) => setTimeout(resolve, PI_FILE_RESOLVE_RETRY_MS));
         }
         return undefined;
     }
@@ -277,8 +325,9 @@ export class SessionManager {
             try {
                 unlinkSync(piPath);
             }
-            catch {
-                /* file already gone — deleting the registry entry is enough */
+            catch (error) {
+                if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                    throw error;
             }
         }
         this.store.remove(sessionId);
@@ -290,14 +339,26 @@ export class SessionManager {
      * (SDK v2 session.update); `title` is only touched when actually sent,
      * otherwise an archive-only PATCH would blank the title.
      */
-    update(sessionId, patch) {
+    async update(sessionId, patch) {
         const s = this.get(sessionId);
         if (!s)
             return undefined;
+        if (patch.agent !== undefined && !getExposedAgentNames().includes(patch.agent))
+            throw new RequestBodyError(400, `unknown agent: ${patch.agent}`);
         if (typeof patch.title === "string" && patch.title.trim() !== "") {
-            s.info.title = patch.title.trim().replace(/\s+/g, " ");
+            const title = patch.title.trim().replace(/\s+/g, " ");
+            if (s.pi !== undefined) {
+                const renamed = await s.pi.command({ type: "set_session_name", name: title });
+                if (!renamed.success)
+                    throw new Error(renamed.error ?? "session rename rejected");
+            }
+            s.info.title = title;
             s.titleSource = "user";
         }
+        if (patch.metadata !== undefined)
+            s.info.metadata = patch.metadata;
+        if (patch.agent !== undefined)
+            s.info.agent = patch.agent;
         if (patch.archived !== undefined) {
             if (patch.archived > 0)
                 s.info.time.archived = patch.archived;
@@ -306,9 +367,6 @@ export class SessionManager {
         }
         s.info.time.updated = Date.now();
         this.persistMeta(s);
-        if (typeof patch.title === "string" && patch.title !== "" && s.pi !== undefined) {
-            void s.pi.command({ type: "set_session_name", name: s.info.title }).catch(() => undefined);
-        }
         this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
         return s.info;
     }
@@ -324,11 +382,7 @@ export class SessionManager {
                 properties: { sessionID: s.info.id, todos: s.todoBridge.todos },
             });
         }
-        const notice = revertNotice(s);
-        if (!notice)
-            return messages;
-        const boundary = messages.findIndex((message) => message.info.id === s.tree.revert?.messageID);
-        return [...messages.slice(0, boundary), notice, ...messages.slice(boundary)];
+        return messages;
     }
     /** Append to canonical history, before the hidden redo branch while reverted. */
     appendMessage(sessionId, message) {
@@ -353,6 +407,25 @@ export class SessionManager {
                 this.operations.delete(s.info.id);
         }
     }
+    /** Cancellation releases only the caller; the native action keeps its queue lease. */
+    async waitForOperation(pending, signal) {
+        if (!signal)
+            return pending;
+        let onAbort;
+        const aborted = new Promise((_, reject) => {
+            onAbort = () => reject(signal.reason);
+            signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        });
+        try {
+            return await Promise.race([pending, aborted]);
+        }
+        finally {
+            if (onAbort)
+                signal.removeEventListener("abort", onAbort);
+        }
+    }
     async syncTree(s, treeOperation = false) {
         const pi = s.pi;
         if (!pi)
@@ -409,7 +482,8 @@ export class SessionManager {
         });
     }
     async fork(sessionId, messageID) {
-        return this.treeSession(sessionId, async (s, pi) => {
+        // Admission must see either the parent or child owner throughout the transfer.
+        return this.treeSession(sessionId, (s, pi) => this.lifecycle.run(async () => {
             const tree = await this.syncTree(s, true);
             const state = await forkConversation(s, pi, tree, messageID);
             this.createdSessions.set(state.sessionId, s.info.directory);
@@ -427,6 +501,12 @@ export class SessionManager {
             child.piSessionId = state.sessionId;
             delete child.restored;
             child.model = s.model;
+            child.info.parentID = s.info.id;
+            if (messageID !== undefined)
+                child.info.parentMessageID = messageID;
+            child.info.agent = s.info.agent ?? getAgentName();
+            if (s.info.metadata !== undefined)
+                child.info.metadata = structuredClone(s.info.metadata);
             const childTree = await getEntries(pi);
             child.tree.leafId = childTree.leafId;
             this.ensureMessages(child);
@@ -435,50 +515,39 @@ export class SessionManager {
             this.persistMeta(child);
             this.emit(child.info.directory, { type: "session.created", properties: { info: child.info } });
             return child.info;
-        });
+        }));
     }
     async revert(sessionId, messageID) {
         return this.treeSession(sessionId, async (s, pi) => {
             const tree = await this.syncTree(s, true);
-            const previousNotice = revertNotice(s);
+            // OpenChamber renders its own reverted-message dock from session.revert.
             if (!(await revertConversation(s, pi, tree, messageID)))
                 return s.info;
-            this.removeRevertNotice(s, previousNotice);
             this.persistMeta(s);
             this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
-            const notice = revertNotice(s);
-            if (notice) {
-                this.emit(s.info.directory, { type: "message.updated", properties: { info: notice.info } });
-                for (const part of notice.parts)
-                    this.events.emitPart(s, part);
-            }
+            this.emit(s.info.directory, {
+                type: "session.revert.staged",
+                properties: { sessionID: s.info.id, revert: { messageID } },
+            });
             return s.info;
         });
     }
     async unrevert(sessionId) {
         return this.treeSession(sessionId, async (s, pi) => {
             await this.syncTree(s, true);
-            const previousNotice = revertNotice(s);
             if (!(await unrevertConversation(s, pi)))
                 return s.info;
-            this.removeRevertNotice(s, previousNotice);
             this.persistMeta(s);
             this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
+            this.emit(s.info.directory, { type: "session.revert.cleared", properties: { sessionID: s.info.id } });
             return s.info;
         });
     }
-    removeRevertNotice(s, notice) {
-        if (notice)
-            this.emit(s.info.directory, {
-                type: "message.removed",
-                properties: { sessionID: s.info.id, messageID: notice.info.id },
-            });
-    }
     async reloadMessages(sessionId, signal) {
         const s = this.get(sessionId);
         if (!s)
             return undefined;
-        return this.operation(s, () => this.reloadMessagesLive(s, signal));
+        return this.waitForOperation(this.operation(s, () => this.reloadMessagesLive(s, signal)), signal);
     }
     /** Called only within the conversation operation queue, including RPC refreshes. */
     async reloadMessagesLive(s, signal) {
@@ -489,13 +558,13 @@ export class SessionManager {
         const pi = s.pi;
         if (!pi)
             throw new SessionTreeError("Session cannot be resumed");
-        const tree = await getEntries(pi, signal);
+        const tree = await getEntries(pi);
         signal?.throwIfAborted();
         bindMessageEntries(s, tree);
         // Compact/bash and extension slash commands can append without agent_end.
         // Binding follows new descendants, never a stale ancestor of the selection.
         if (s.tree.revert && s.tree.leafId !== undefined && tree.leafId !== s.tree.leafId)
-            await navigate(pi, s.tree.leafId, signal);
+            await navigate(pi, s.tree.leafId);
         signal?.throwIfAborted();
         const previous = s.messages ?? [];
         const messages = this.refreshMessageCache(s);
@@ -513,7 +582,7 @@ export class SessionManager {
             for (const part of message.parts)
                 this.events.emitPart(s, part);
         }
-        this.update(sessionId, {});
+        await this.update(sessionId, {});
         return messages;
     }
     statuses() {
@@ -529,11 +598,45 @@ export class SessionManager {
         this.ensureMessages(s);
         return s.todoBridge?.todos ?? [];
     }
-    async diff(sessionId) {
+    async commitRevert(sessionId) {
+        await this.treeSession(sessionId, async (s, pi) => {
+            await this.commitRevertLive(s, pi);
+            return s.info;
+        });
+    }
+    async commitRevertLive(s, pi) {
+        const revert = s.tree.revert;
+        if (revert === undefined)
+            return;
+        const boundary = s.messages?.findIndex((message) => message.info.id === revert.messageID) ?? -1;
+        if (boundary >= 0) {
+            for (const message of s.messages?.splice(boundary) ?? []) {
+                this.emit(s.info.directory, {
+                    type: "message.removed",
+                    properties: { sessionID: s.info.id, messageID: message.info.id },
+                });
+            }
+        }
+        delete s.tree.revert;
+        delete s.info.revert;
+        bindMessageEntries(s, await getEntries(pi));
+        this.persistMeta(s);
+        this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
+        this.emit(s.info.directory, {
+            type: "session.revert.committed",
+            properties: { sessionID: s.info.id, to: revert.messageID },
+        });
+    }
+    async diff(sessionId, options = {}) {
         const s = this.get(sessionId);
         if (s === undefined)
             throw new Error(`unknown session: ${sessionId}`);
-        return sessionDiff(s.info.directory, this.ensureMessages(s));
+        const messages = this.ensureMessages(s);
+        const start = options.from === undefined ? 0 : messages.findIndex((message) => message.info.id === options.from);
+        const end = options.to === undefined ? messages.length : messages.findIndex((message) => message.info.id === options.to);
+        if (start < 0 || end < 0 || start > end)
+            throw new RequestBodyError(400, "invalid diff message range");
+        return sessionDiff(s.info.directory, messages.slice(start, end), options.context);
     }
     emitDiff(s) {
         if (!this.dirtyDiffs.delete(s.info.id))
@@ -564,9 +667,17 @@ export class SessionManager {
         if (!s)
             return false;
         if (s.pi !== undefined) {
-            const response = await s.pi.command({ type: "abort" });
-            if (!response.success)
-                throw new Error(response.error ?? "pi abort failed");
+            if (s.status.type !== "idle")
+                s.interruptRequested = true;
+            try {
+                const response = await s.pi.command({ type: "abort" });
+                if (!response.success)
+                    throw new Error(response.error ?? "pi abort failed");
+            }
+            catch (error) {
+                delete s.interruptRequested;
+                throw error;
+            }
         }
         s.cancelShell?.();
         s.approvals?.cancelAll();
@@ -620,27 +731,14 @@ export class SessionManager {
             if (pi === undefined)
                 throw new Error(`session cannot be resumed: ${sessionId}`);
             this.lifecycle.touch(s);
-            const response = await pi.command(command, RPC_COMMAND_TIMEOUT_MS, signal, onDispatch);
+            const timeout = command.type === "compact" ? COMPACT_RPC_TIMEOUT_MS : RPC_COMMAND_TIMEOUT_MS;
+            signal?.throwIfAborted();
+            const response = await pi.command(command, timeout, undefined, onDispatch);
             if (!signal?.aborted && response.success && (command.type === "compact" || command.type === "bash"))
                 await this.reloadMessagesLive(s, signal);
             return response;
         });
-        if (!signal)
-            return pending;
-        // Cancel the caller's wait without releasing the conversation queue. The
-        // queued action checks the signal before dispatch when its predecessor ends.
-        let onAbort;
-        const aborted = new Promise((_, reject) => {
-            onAbort = () => reject(signal.reason);
-            signal.addEventListener("abort", onAbort, { once: true });
-        });
-        try {
-            return await Promise.race([pending, aborted]);
-        }
-        finally {
-            if (onAbort)
-                signal.removeEventListener("abort", onAbort);
-        }
+        return this.waitForOperation(pending, signal);
     }
     /**
      * POST /api/session/{id}/model — OpenChamber awaits this before every prompt
@@ -712,6 +810,7 @@ export class SessionManager {
             return false;
         const model = { providerID: provider, modelID: modelId };
         s.model = model;
+        s.info.model = { id: modelId, providerID: provider, variant: s.thinkingLevel ?? "default" };
         this.persistMeta(s);
         this.emit(s.info.directory, {
             type: "model.changed",
@@ -719,13 +818,13 @@ export class SessionManager {
         });
         return true;
     }
-    async prompt(sessionId, text, model, noReply = false, messageID, delivery = "steer") {
+    async prompt(sessionId, text, model, noReply = false, messageID, delivery = "steer", parts, metadata) {
         const s = this.get(sessionId);
         if (!s)
             throw new Error(`unknown session: ${sessionId}`);
-        return this.operation(s, () => this.promptLive(s, text, model, noReply, messageID, delivery));
+        return this.operation(s, () => this.promptLive(s, text, model, noReply, messageID, delivery, parts, metadata));
     }
-    async promptLive(s, text, model, noReply = false, messageID, delivery = "steer") {
+    async preparePrompt(s, model) {
         const sessionId = s.info.id;
         if (s.pi === undefined)
             await this.revive(s);
@@ -734,42 +833,29 @@ export class SessionManager {
             throw new Error(`session cannot be resumed: ${sessionId}`);
         this.lifecycle.touch(s);
         this.ensureMessages(s);
-        if (s.tree.revert) {
-            const boundary = s.messages?.findIndex((message) => message.info.id === s.tree.revert?.messageID) ?? -1;
-            if (boundary >= 0) {
-                for (const message of s.messages?.splice(boundary) ?? []) {
-                    this.emit(s.info.directory, {
-                        type: "message.removed",
-                        properties: { sessionID: s.info.id, messageID: message.info.id },
-                    });
-                }
-            }
-            this.removeRevertNotice(s, revertNotice(s));
-            delete s.tree.revert;
-            delete s.info.revert;
-            bindMessageEntries(s, await getEntries(pi));
-            this.persistMeta(s);
-            this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
-        }
-        // Same funnel as POST /api/session/{id}/model. Failing loudly matters: the
-        // previous code swallowed pi's refusal and then reported the *requested*
-        // model as though the switch had happened.
+        await this.commitRevertLive(s, pi);
         if (model !== undefined) {
             try {
                 // This prompt already owns the operation queue; do not enqueue recursively.
                 await this.setModelLive(s, model);
             }
-            catch (err) {
+            catch (error) {
                 this.emit(s.info.directory, {
                     type: "session.error",
                     properties: {
                         sessionID: s.info.id,
-                        error: { name: "UnknownError", data: { message: err instanceof Error ? err.message : String(err) } },
+                        error: {
+                            name: "UnknownError",
+                            data: { message: error instanceof Error ? error.message : String(error) },
+                        },
                     },
                 });
-                throw err;
+                throw error;
             }
         }
+        return pi;
+    }
+    publishPrompt(s, text, model, messageID, inputParts, metadata, context = false) {
         // OpenChamber sends a client-generated messageID with its optimistic
         // insert; the server MUST reuse it so the echoed message.part.updated /
         // message.updated events reconcile the optimistic entry in place instead
@@ -781,12 +867,23 @@ export class SessionManager {
             time: { created: Date.now() },
             agent: getAgentName(),
             model: s.model ?? model ?? { providerID: "unknown", modelID: "unknown" },
+            ...(context ? { synthetic: true } : {}),
+            ...(metadata !== undefined ? { metadata } : {}),
         };
-        const parts = [{ id: id("prt"), sessionID: s.info.id, messageID: userMsg.id, type: "text", text }];
+        if (metadata !== undefined)
+            (s.tree.promptMetadata ??= {})[userMsg.id] = metadata;
+        const parts = (inputParts ?? [{ type: "text", text }]).map((part) => ({
+            ...part,
+            id: part.id ?? id("prt"),
+            sessionID: s.info.id,
+            messageID: userMsg.id,
+        }));
+        if (inputParts?.some((part) => part.type !== "text"))
+            (s.tree.promptParts ??= {})[userMsg.id] = [...inputParts];
         s.messages?.push({ info: userMsg, parts });
         s.info.time.updated = Date.now();
-        if (s.info.title === "New session" && s.titleSource !== "user" && s.titleSource !== "native") {
-            s.info.title = text.trim().replace(/\s+/g, " ").slice(0, 60) || "New session";
+        if (!context && s.info.title === "New session" && s.titleSource !== "user" && s.titleSource !== "native") {
+            s.info.title = text.trim().replace(/\s+/g, " ").slice(0, SESSION_TITLE_MAX_CHARS) || "New session";
             s.titleSource = "fallback";
         }
         this.persistMeta(s);
@@ -795,19 +892,74 @@ export class SessionManager {
         // Echo the user text part: the reducer replaces the client's sessionID-less
         // optimistic part (same type, new id) in place — without this echo a page
         // fetch merges the optimistic part back in and the text shows twice.
-        for (const p of parts)
-            this.events.emitPart(s, p);
-        if (noReply)
-            return; // register-only semantics: record the message, do not run the agent
+        for (const part of parts)
+            this.events.emitPart(s, part);
+        return userMsg;
+    }
+    async promptLive(s, text, model, noReply = false, messageID, delivery = "steer", parts, metadata) {
+        const pi = await this.preparePrompt(s, model);
+        const native = nativePromptInput(text, parts ?? []);
+        const userMsg = this.publishPrompt(s, text, model, messageID, parts, metadata, noReply);
+        if (noReply) {
+            await this.admitContext(s, pi, userMsg, native.message);
+            return;
+        }
+        if (!(await this.dispatchPrompt(s, pi, userMsg, text, delivery, native, parts ?? [])))
+            return;
+        await this.bindPromptState(s);
+    }
+    /**
+     * No-reply context (v2 synthetic, v1 noReply) joins the native conversation without a turn:
+     * OmO appends it now when idle, or after the running turn, so the next prompt carries it.
+     */
+    async admitContext(s, pi, userMsg, text) {
+        const res = await pi.command({
+            type: "send_custom_message",
+            customType: CONTEXT_MESSAGE_TYPE,
+            content: [{ type: "text", text }],
+            display: true,
+            details: { messageID: userMsg.id },
+            triggerTurn: false,
+        });
+        if (!res.success) {
+            if (s.tree.promptParts)
+                delete s.tree.promptParts[userMsg.id];
+            if (s.tree.promptMetadata)
+                delete s.tree.promptMetadata[userMsg.id];
+            s.messages = s.messages?.filter((message) => message.info.id !== userMsg.id);
+            this.emit(s.info.directory, {
+                type: "message.removed",
+                properties: { sessionID: s.info.id, messageID: userMsg.id },
+            });
+            throw new Error(res.error ?? "context admission rejected");
+        }
+        // Bind the appended entry and persist the new leaf before announcing delivery, or a restart
+        // restores the old branch without the context.
+        await this.bindPromptState(s);
+        this.emit(s.info.directory, {
+            type: "session.inbox.enqueued",
+            properties: {
+                sessionID: s.info.id,
+                inboxID: userMsg.id,
+                item: { type: "synthetic", payload: { text, ...(userMsg.metadata ? { metadata: userMsg.metadata } : {}) } },
+            },
+        });
+        this.events.deliverInput(s, userMsg.id);
+    }
+    async dispatchPrompt(s, pi, userMsg, text, delivery, native, parts) {
         const wasIdle = s.status.type === "idle";
         if (wasIdle) {
             s.toolByCallId = new Map();
             this.events.setStatus(s, { type: "busy" });
         }
-        const input = { text, delivery, accepted: false, delivered: false };
+        const input = { text: native.message, delivery, accepted: false, delivered: false };
         (s.inputs ??= new Map()).set(userMsg.id, input);
         const rejectInput = () => {
             s.inputs?.delete(userMsg.id);
+            if (s.tree.promptParts)
+                delete s.tree.promptParts[userMsg.id];
+            if (s.tree.promptMetadata)
+                delete s.tree.promptMetadata[userMsg.id];
             s.messages = s.messages?.filter((message) => message.info.id !== userMsg.id);
             this.emit(s.info.directory, {
                 type: "message.removed",
@@ -826,9 +978,10 @@ export class SessionManager {
         const res = await pi
             .command({
             type: "prompt",
-            message: text,
+            ...native,
             streamingBehavior: delivery === "queue" ? "followUp" : "steer",
             clientMessageId: userMsg.id,
+            ...slashTitlePrompt(text),
         })
             .catch((error) => {
             rejectInput();
@@ -846,12 +999,24 @@ export class SessionManager {
                     error: { name: "UnknownError", data: { message: res.error ?? "prompt rejected" } },
                 },
             });
-            return;
+            return false;
         }
         input.accepted = true;
         this.emit(s.info.directory, {
             type: "session.inbox.enqueued",
-            properties: { sessionID: s.info.id, inboxID: userMsg.id, item: { type: "user", delivery, payload: { text } } },
+            properties: {
+                sessionID: s.info.id,
+                inboxID: userMsg.id,
+                item: {
+                    type: "user",
+                    delivery,
+                    payload: {
+                        text,
+                        ...v2PromptAttachments(parts),
+                        ...(userMsg.metadata ? { metadata: userMsg.metadata } : {}),
+                    },
+                },
+            },
         });
         if (input.delivered)
             this.events.deliverInput(s, userMsg.id);
@@ -860,9 +1025,14 @@ export class SessionManager {
             typeof res.data === "object" &&
             "disposition" in res.data &&
             res.data.disposition === "handled") {
+            if (!input.delivered)
+                this.events.deliverInput(s, userMsg.id);
             if (wasIdle)
                 this.events.setStatus(s, { type: "idle" });
         }
+        return true;
+    }
+    async bindPromptState(s) {
         // First message makes pi write the session file — bind it now so the
         // session (and its current title) survives an adapter restart.
         if (s.piPath === undefined && s.piSessionId !== undefined) {
@@ -969,6 +1139,8 @@ export class SessionManager {
             this.subagents.discover(s, s.messages);
             if (admissions)
                 this.persistMeta(s);
+            if (syncSessionCost(s))
+                this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
         }
         return s.messages;
     }
@@ -1039,7 +1211,7 @@ export class SessionManager {
         }
     }
     adopt(sc) {
-        const ocId = ocIdFor(sc.piSessionId);
+        const ocId = this.store.idFor(sc.piSessionId) ?? ocIdFor(sc.piSessionId);
         const reg = this.store.get(ocId);
         const titleSource = reg?.titleSource ??
             (reg?.title && reg.title !== "New session" && reg.title !== sc.fallbackTitle ? "user" : "fallback");
@@ -1049,6 +1221,19 @@ export class SessionManager {
             projectID: sc.directory,
             directory: sc.directory,
             title: useRegistry ? (reg?.title ?? sc.title) : sc.title,
+            agent: reg?.agent ?? getAgentName(),
+            slug: sc.piSessionId,
+            path: "",
+            summary: { additions: 0, deletions: 0, files: 0 },
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+            ...(reg?.metadata !== undefined ? { metadata: reg.metadata } : {}),
+            ...(reg?.parentID !== undefined ? { parentID: reg.parentID } : {}),
+            ...(reg?.parentMessageID !== undefined ? { parentMessageID: reg.parentMessageID } : {}),
+            ...(reg?.model !== undefined
+                ? {
+                    model: { id: reg.model.modelID, providerID: reg.model.providerID, variant: reg.model.variant ?? "default" },
+                }
+                : {}),
             ...(reg?.tree?.revert ? { revert: { messageID: reg.tree.revert.messageID } } : {}),
             version: ADAPTER_VERSION,
             time: {
@@ -1106,6 +1291,11 @@ export class SessionManager {
     }
     /** Registry write for adapter-owned metadata (title override, pi path). */
     persistMeta(s) {
+        for (const message of s.messages ?? []) {
+            if (s.localMessageIds?.has(message.info.id))
+                continue;
+            (s.tree.messageParts ??= {})[message.info.id] = message.parts.map((part) => part.id);
+        }
         const piPath = s.piPath ?? s.restored?.piPath;
         const piSessionId = s.piSessionId ?? s.restored?.piSessionId;
         if (piPath === undefined || piSessionId === undefined)
@@ -1120,6 +1310,10 @@ export class SessionManager {
             ...(s.info.title !== "New session" ? { title: s.info.title } : {}),
             ...(s.titleSource !== undefined ? { titleSource: s.titleSource } : {}),
             ...(s.info.time.archived !== undefined ? { archived: s.info.time.archived } : {}),
+            ...(s.info.metadata !== undefined ? { metadata: s.info.metadata } : {}),
+            ...(s.info.agent !== undefined ? { agent: s.info.agent } : {}),
+            ...(s.info.parentID !== undefined ? { parentID: s.info.parentID } : {}),
+            ...(s.info.parentMessageID !== undefined ? { parentMessageID: s.info.parentMessageID } : {}),
             ...(s.model !== undefined ? { model: { providerID: s.model.providerID, modelID: s.model.modelID } } : {}),
             created: s.info.time.created,
             updated: s.info.time.updated,
@@ -1127,11 +1321,11 @@ export class SessionManager {
     }
     /** Async event callbacks cannot reject an HTTP operation; report save failures through SSE. */
     reportPersistenceError(s, error) {
-        if (!(error instanceof SessionPersistenceError))
-            throw error;
+        const name = error instanceof Error ? error.name : "UnknownError";
+        const message = error instanceof Error ? error.message : String(error);
         this.emit(s.info.directory, {
             type: "session.error",
-            properties: { sessionID: s.info.id, error: { name: error.name, data: { message: error.message } } },
+            properties: { sessionID: s.info.id, error: { name, data: { message } } },
         });
     }
     /** Keep the existing event entry point for RPC wiring and test harnesses. */