antechamber 0.1.0 → 0.2.0

package/dist/session-hosts.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { once } from "node:events";
-import { closeSync, constants, openSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
+import { closeSync, constants, openSync, readFileSync, readdirSync, readlinkSync, realpathSync } from "node:fs";
 import { basename } from "node:path";
 import { findPidfdPython } from "./pidfd.js";
 /** Capability and warning state are captured once, before any shutdown work. */
@@ -144,7 +144,7 @@ async function stopSupportedSessionHosts(created, python) {
             try {
                 // The original leader must still exist after the process-table scan:
                 // a recycled group number cannot confer its ownership on new members.
-                return readlinkSync(`/proc/self/fd/${info.fd}/cwd`) === directory;
+                return readlinkSync(`/proc/self/fd/${info.fd}/cwd`) === realpathSync(directory);
             }
             catch (error) {
                 if (error instanceof Error && "code" in error && ["ENOENT", "ESRCH"].includes(String(error.code)))

package/dist/session-store.d.ts

@@ -37,6 +37,9 @@ export interface SessionRegistryEntry {
     connectorOwned?: true;
     tree?: SessionTreeState;
     parentID?: string | undefined;
+    parentMessageID?: string;
+    agent?: string;
+    metadata?: Record<string, unknown>;
     task?: ChildTask;
     piSessionId: string;
     piPath: string;
@@ -53,6 +56,7 @@ export interface SessionRegistryEntry {
     model?: {
         providerID: string;
         modelID: string;
+        variant?: string;
     };
     created: number;
     updated: number;
@@ -81,18 +85,18 @@ export declare function piSessionsRootMtime(): number | undefined;
 export declare function scanAllPiSessions(): ScannedSession[];
 /** All restorable pi sessions recorded for `directory`. Corrupt files are skipped. */
 export declare function scanPiSessions(directory: string): ScannedSession[];
-/**
- * Persistent oc-session-id → metadata registry (title overrides, known pi
- * paths). Atomic writes, lazy load, corrupt file degrades to an empty map.
- */
 export declare class SessionStore {
     readonly stateDir: string;
     private readonly file;
     private entries;
     constructor(stateDir?: string);
     private load;
+    private readEntries;
+    private withRegistryLock;
     private persist;
+    private mutate;
     get(ocSessionId: string): SessionRegistryEntry | undefined;
+    idFor(piSessionId: string): string | undefined;
     childIds(): string[];
     set(ocSessionId: string, entry: SessionRegistryEntry): void;
     /** Merge a partial update (e.g. title override, updated timestamp). */

package/dist/session-store.js

@@ -14,9 +14,10 @@
  * the same OpenChamber id, even if the registry file is lost.
  */
 import { createHash } from "node:crypto";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, writeFileSync, } from "node:fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { piAgentDir } from "./agent-dir.js";
+import { isPromptPart } from "./prompt-parts.js";
 import { defaultStateDir, envSetting } from "./config.js";
 /** pi's session directory for a given cwd (see pi docs/session-format.md). */
 export function piSessionDir(cwd) {
@@ -38,6 +39,12 @@ export class SessionPersistenceError extends Error {
 /** Read at most this many leading bytes when sniffing headers/titles. */
 const SNIFF_BYTES = 256 * 1024;
 const TITLE_MAX_LINES = 200;
+const TITLE_MAX_CHARS = 60;
+const REGISTRY_DIRECTORY_MODE = 0o700;
+const REGISTRY_FILE_MODE = 0o600;
+const REGISTRY_LOCK_RETRY_MS = 10;
+const REGISTRY_LOCK_STALE_MS = 5_000;
+const registryLockWaiter = new Int32Array(new SharedArrayBuffer(4));
 function readHead(path, bytes = SNIFF_BYTES) {
     const fd = openSync(path, "r");
     try {
@@ -70,7 +77,7 @@ function titleFromHead(head, piSessionId) {
             .join("\n")
             .trim();
         if (text !== "")
-            return text.slice(0, 60);
+            return text.slice(0, TITLE_MAX_CHARS);
     }
     return `pi session ${piSessionId.slice(0, 8)}`;
 }
@@ -261,6 +268,105 @@ export function scanPiSessions(directory) {
  * Persistent oc-session-id → metadata registry (title overrides, known pi
  * paths). Atomic writes, lazy load, corrupt file degrades to an empty map.
  */
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringRecord(value) {
+    return record(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function booleanRecord(value) {
+    return record(value) && Object.values(value).every((entry) => typeof entry === "boolean");
+}
+function persistedMessage(value) {
+    return (record(value) &&
+        record(value.info) &&
+        typeof value.info.id === "string" &&
+        typeof value.info.role === "string" &&
+        Array.isArray(value.parts));
+}
+function sessionTreeState(value) {
+    if (!record(value) || !stringRecord(value.messageEntries))
+        return false;
+    if (value.promptParts !== undefined &&
+        (!record(value.promptParts) ||
+            !Object.values(value.promptParts).every((parts) => Array.isArray(parts) && parts.every(isPromptPart))))
+        return false;
+    if (value.promptMetadata !== undefined &&
+        (!record(value.promptMetadata) || !Object.values(value.promptMetadata).every((metadata) => record(metadata))))
+        return false;
+    if (value.messageParts !== undefined &&
+        (!record(value.messageParts) ||
+            !Object.values(value.messageParts).every((parts) => Array.isArray(parts) && parts.every((part) => typeof part === "string"))))
+        return false;
+    if (value.shellDispatch !== undefined && !booleanRecord(value.shellDispatch))
+        return false;
+    if (value.leafId !== undefined && value.leafId !== null && typeof value.leafId !== "string")
+        return false;
+    if (value.revert !== undefined) {
+        if (!record(value.revert) ||
+            typeof value.revert.messageID !== "string" ||
+            (value.revert.previousLeafId !== null && typeof value.revert.previousLeafId !== "string") ||
+            (value.revert.targetId !== null && typeof value.revert.targetId !== "string"))
+            return false;
+    }
+    return (value.localShellTurns === undefined ||
+        (Array.isArray(value.localShellTurns) &&
+            value.localShellTurns.every((turn) => record(turn) &&
+                (turn.afterEntryId === null || typeof turn.afterEntryId === "string") &&
+                Array.isArray(turn.messages) &&
+                turn.messages.length === 2 &&
+                persistedMessage(turn.messages[0]) &&
+                persistedMessage(turn.messages[1]))));
+}
+function childTask(value) {
+    return (record(value) &&
+        typeof value.id === "string" &&
+        typeof value.parentPiId === "string" &&
+        record(value.input) &&
+        record(value.details) &&
+        (value.terminalAt === undefined || (typeof value.terminalAt === "number" && Number.isFinite(value.terminalAt))));
+}
+function titleSource(value) {
+    return value === "user" || value === "native" || value === "fallback" || value === "generated";
+}
+function registryEntry(value) {
+    if (!record(value) ||
+        typeof value.piPath !== "string" ||
+        typeof value.piSessionId !== "string" ||
+        typeof value.directory !== "string" ||
+        typeof value.created !== "number" ||
+        !Number.isFinite(value.created) ||
+        typeof value.updated !== "number" ||
+        !Number.isFinite(value.updated))
+        return false;
+    if (value.connectorOwned !== undefined && value.connectorOwned !== true)
+        return false;
+    if (value.tree !== undefined && !sessionTreeState(value.tree))
+        return false;
+    if (value.parentID !== undefined && typeof value.parentID !== "string")
+        return false;
+    if (value.parentMessageID !== undefined && typeof value.parentMessageID !== "string")
+        return false;
+    if (value.agent !== undefined && typeof value.agent !== "string")
+        return false;
+    if (value.metadata !== undefined && !record(value.metadata))
+        return false;
+    if (value.task !== undefined && !childTask(value.task))
+        return false;
+    if (value.title !== undefined && typeof value.title !== "string")
+        return false;
+    if (value.titleSource !== undefined && !titleSource(value.titleSource))
+        return false;
+    if (value.archived !== undefined && (typeof value.archived !== "number" || !Number.isFinite(value.archived)))
+        return false;
+    if (value.model !== undefined &&
+        (!record(value.model) || typeof value.model.providerID !== "string" || typeof value.model.modelID !== "string"))
+        return false;
+    return true;
+}
+function errorCode(error) {
+    return error instanceof Error && "code" in error ? String(error.code) : undefined;
+}
 export class SessionStore {
     stateDir;
     file;
@@ -273,64 +379,108 @@ export class SessionStore {
     load() {
         if (this.entries !== undefined)
             return this.entries;
-        this.entries = new Map();
+        this.entries = this.readEntries();
+        return this.entries;
+    }
+    readEntries() {
+        const entries = new Map();
         try {
             const raw = JSON.parse(readFileSync(this.file, "utf8"));
-            for (const [k, v] of Object.entries(raw)) {
-                if (v && typeof v.piPath === "string" && typeof v.piSessionId === "string") {
-                    // A hand-edited or partially written registry must not be able to
-                    // poison the model a dormant session advertises.
-                    if (v.model !== undefined &&
-                        (typeof v.model.providerID !== "string" || typeof v.model.modelID !== "string")) {
-                        delete v.model;
-                    }
-                    this.entries.set(k, v);
-                }
-            }
+            if (!record(raw))
+                return entries;
+            for (const [id, value] of Object.entries(raw))
+                if (registryEntry(value))
+                    entries.set(id, value);
         }
         catch {
             /* missing or corrupt — start empty */
         }
-        return this.entries;
+        return entries;
     }
-    persist(entries) {
-        const obj = Object.fromEntries(entries);
+    withRegistryLock(action) {
+        const lock = `${this.file}.lock`;
+        let fd;
         try {
-            mkdirSync(join(this.file, ".."), { recursive: true });
-            const tmp = `${this.file}.${process.pid}.tmp`;
-            writeFileSync(tmp, JSON.stringify(obj, null, 2));
-            renameSync(tmp, this.file);
+            mkdirSync(this.stateDir, { recursive: true, mode: REGISTRY_DIRECTORY_MODE });
+            chmodSync(this.stateDir, REGISTRY_DIRECTORY_MODE);
+            for (;;) {
+                try {
+                    fd = openSync(lock, "wx", REGISTRY_FILE_MODE);
+                    break;
+                }
+                catch (error) {
+                    if (errorCode(error) !== "EEXIST")
+                        throw error;
+                    try {
+                        if (Date.now() - statSync(lock).mtimeMs >= REGISTRY_LOCK_STALE_MS) {
+                            unlinkSync(lock);
+                            continue;
+                        }
+                    }
+                    catch (staleLockError) {
+                        if (errorCode(staleLockError) !== "ENOENT")
+                            throw staleLockError;
+                        continue;
+                    }
+                    Atomics.wait(registryLockWaiter, 0, 0, REGISTRY_LOCK_RETRY_MS);
+                }
+            }
+            return action();
         }
         catch (error) {
             throw new SessionPersistenceError(this.file, error);
         }
-        this.entries = entries;
+        finally {
+            if (fd !== undefined) {
+                closeSync(fd);
+                unlinkSync(lock);
+            }
+        }
+    }
+    persist(entries) {
+        const obj = Object.fromEntries(entries);
+        const tmp = `${this.file}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(obj, null, 2), { mode: REGISTRY_FILE_MODE });
+        chmodSync(tmp, REGISTRY_FILE_MODE);
+        renameSync(tmp, this.file);
+    }
+    mutate(change) {
+        this.withRegistryLock(() => {
+            const entries = this.readEntries();
+            if (change(entries))
+                this.persist(entries);
+            this.entries = entries;
+        });
     }
     get(ocSessionId) {
         return this.load().get(ocSessionId);
     }
+    idFor(piSessionId) {
+        return [...this.load()].find(([, entry]) => entry.piSessionId === piSessionId)?.[0];
+    }
     childIds() {
         return [...this.load()]
             .filter(([, entry]) => entry.task !== undefined && entry.parentID !== undefined)
             .map(([id]) => id);
     }
     set(ocSessionId, entry) {
-        const entries = new Map(this.load());
-        entries.set(ocSessionId, entry);
-        this.persist(entries);
+        this.mutate((entries) => {
+            entries.set(ocSessionId, entry);
+            return true;
+        });
     }
     /** Merge a partial update (e.g. title override, updated timestamp). */
     update(ocSessionId, patch) {
-        const map = this.load();
-        const prev = map.get(ocSessionId);
-        if (prev === undefined)
-            return;
-        this.set(ocSessionId, { ...prev, ...patch });
+        this.mutate((entries) => {
+            const previous = entries.get(ocSessionId);
+            if (previous === undefined)
+                return false;
+            entries.set(ocSessionId, { ...previous, ...patch });
+            return true;
+        });
     }
     remove(ocSessionId) {
-        const entries = new Map(this.load());
-        if (entries.delete(ocSessionId))
-            this.persist(entries);
+        this.mutate((entries) => entries.delete(ocSessionId));
     }
     /** Every directory the registry knows about — used to resolve bare session ids. */
     directories() {

package/dist/session-tree.d.ts

@@ -1,8 +1,15 @@
 import { type PiRpcClient } from "./pi-rpc.js";
 import type { ManagedSession } from "./sessions.js";
 import type { OCMessageWithParts } from "./types.js";
+import type { OCPromptPart } from "./types.js";
 export interface SessionTreeState {
     messageEntries: Record<string, string>;
+    /** Published part identities in native content order, keyed by durable message identity. */
+    messageParts?: Record<string, string[]>;
+    /** Original rich user input; native RPC stores only adapted text and images. */
+    promptParts?: Record<string, OCPromptPart[]>;
+    /** Client prompt metadata; native RPC does not store it. */
+    promptMetadata?: Record<string, Record<string, unknown>>;
     /** Actual transport dispatch, not inferred from a card's terminal state. */
     shellDispatch?: Record<string, boolean>;
     /** Identity-only dispatched admissions; never rendered without a native entry. */
@@ -21,6 +28,8 @@ export interface TreeEntry {
     type: string;
     id: string;
     parentId: string | null;
+    customType?: string;
+    details?: unknown;
     message?: {
         role: string;
         clientMessageId?: string;
@@ -48,7 +57,6 @@ export declare function recordTurn(s: ManagedSession): void;
 export declare function branchEntries(tree: Entries, leafId?: string | null): TreeEntry[];
 /** Live ids belong to the UI; restored ids belong to JSONL offsets. Save both. */
 export declare function bindMessageEntries(s: ManagedSession, tree: Entries): void;
-export declare function entryForMessage(s: ManagedSession, tree: Entries, messageID: string): TreeEntry;
 export declare function forkConversation(s: ManagedSession, pi: PiRpcClient, tree: Entries, messageID?: string): Promise<{
     sessionId: string;
     sessionFile: string;
@@ -56,4 +64,3 @@ export declare function forkConversation(s: ManagedSession, pi: PiRpcClient, tre
 export declare function revertConversation(s: ManagedSession, pi: PiRpcClient, tree: Entries, messageID: string): Promise<boolean>;
 export declare function unrevertConversation(s: ManagedSession, pi: PiRpcClient): Promise<boolean>;
 export declare function navigate(pi: PiRpcClient, targetId: string | null, signal?: AbortSignal): Promise<string | null>;
-export declare function revertNotice(s: ManagedSession): OCMessageWithParts | undefined;

package/dist/session-tree.js

@@ -1,5 +1,6 @@
 import { RPC_COMMAND_TIMEOUT_MS } from "./pi-rpc.js";
 import { readFileSync } from "node:fs";
+import { contextMessageID, nativePromptInput } from "./prompt-parts.js";
 export class SessionTreeError extends Error {
 }
 export function durableShellTree(tree) {
@@ -59,19 +60,19 @@ export function branchEntries(tree, leafId = tree.leafId) {
     }
     return branch.reverse();
 }
-/** Live ids belong to the UI; restored ids belong to JSONL offsets. Save both. */
-export function bindMessageEntries(s, tree) {
+function selectedLeafId(s, tree) {
     let leafId = tree.leafId;
     if (!s.tree.revert && s.tree.leafId !== undefined && s.tree.leafId !== null) {
         const selected = branchEntries(tree, s.tree.leafId);
         // A stale snapshot cannot discard a selection or its identity candidates.
         if (selected.length === 0)
-            return;
+            return undefined;
         if (tree.leafId === null || selected.some((entry) => entry.id === tree.leafId))
             leafId = s.tree.leafId;
     }
-    const branch = branchEntries(tree, s.tree.revert ? s.tree.revert.previousLeafId : leafId);
-    const positions = new Map(branch.map((entry, index) => [entry.id, index]));
+    return leafId;
+}
+function pruneStaleShellTurns(s, positions) {
     s.tree.localShellTurns = (s.tree.localShellTurns ?? []).filter((turn) => {
         if (turn.afterEntryId === null || positions.has(turn.afterEntryId))
             return true;
@@ -83,13 +84,54 @@ export function bindMessageEntries(s, tree) {
             delete s.tree.shellDispatch[turn.messages[1].info.id];
         return false;
     });
+}
+function bindOrdinaryEntry(s, entry, messages, cursor) {
+    const text = entry.message?.content
+        ?.filter((part) => part.type === "text")
+        .map((part) => part.text ?? "")
+        .join("");
+    const index = messages.findIndex((message, position) => position >= cursor &&
+        !s.localMessageIds?.has(message.info.id) &&
+        s.tree.messageEntries[message.info.id] === undefined &&
+        message.info.role === entry.message?.role &&
+        (message.info.role !== "user" ||
+            (s.tree.promptParts?.[message.info.id]
+                ? nativePromptInput(message.parts
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n"), s.tree.promptParts[message.info.id] ?? []).message
+                : message.parts
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("")) === text));
+    const message = messages[index];
+    if (message === undefined)
+        return cursor;
+    s.tree.messageEntries[message.info.id] = entry.id;
+    return index + 1;
+}
+/** Live ids belong to the UI; restored ids belong to JSONL offsets. Save both. */
+export function bindMessageEntries(s, tree) {
+    const leafId = selectedLeafId(s, tree);
+    if (leafId === undefined)
+        return;
+    const branch = branchEntries(tree, s.tree.revert ? s.tree.revert.previousLeafId : leafId);
+    const positions = new Map(branch.map((entry, index) => [entry.id, index]));
+    pruneStaleShellTurns(s, positions);
+    // Admitted context carries its OpenChamber id in the native custom message.
+    for (const entry of branch) {
+        const messageID = contextMessageID(entry);
+        if (messageID !== undefined && s.messages?.some((message) => message.info.id === messageID))
+            s.tree.messageEntries[messageID] = entry.id;
+    }
     const entries = branch.filter((entry) => entry.type === "message" &&
         (entry.message?.role === "user" ||
             entry.message?.role === "assistant" ||
             entry.message?.role === "bashExecution"));
+    const localShellTurns = s.tree.localShellTurns ?? [];
     const visible = s.messages ?? [];
     const visibleIds = new Set(visible.map((message) => message.info.id));
-    const candidates = s.tree.localShellTurns
+    const candidates = localShellTurns
         .flatMap((turn) => turn.messages)
         .filter((message) => !visibleIds.has(message.info.id));
     for (const message of candidates)
@@ -167,32 +209,15 @@ export function bindMessageEntries(s, tree) {
             }
             continue;
         }
-        const text = entry.message?.content
-            ?.filter((part) => part.type === "text")
-            .map((part) => part.text ?? "")
-            .join("");
-        const index = messages.findIndex((message, i) => i >= cursor &&
-            !s.localMessageIds?.has(message.info.id) &&
-            s.tree.messageEntries[message.info.id] === undefined &&
-            message.info.role === entry.message?.role &&
-            (message.info.role !== "user" ||
-                message.parts
-                    .filter((part) => part.type === "text")
-                    .map((part) => part.text)
-                    .join("") === text));
-        const message = messages[index];
-        if (message) {
-            s.tree.messageEntries[message.info.id] = entry.id;
-            cursor = index + 1;
-        }
+        cursor = bindOrdinaryEntry(s, entry, messages, cursor);
     }
     // Syncs/agent events preserve an active revert's navigation pin. Only
     // revert/unrevert select it explicitly; prompt clears the pin before branching.
     if (!s.tree.revert)
         s.tree.leafId = leafId;
-    s.tree.localShellTurns = s.tree.localShellTurns.filter((turn) => s.tree.messageEntries[turn.messages[1].info.id] === undefined);
+    s.tree.localShellTurns = localShellTurns.filter((turn) => s.tree.messageEntries[turn.messages[1].info.id] === undefined);
 }
-export function entryForMessage(s, tree, messageID) {
+function entryForMessage(s, tree, messageID) {
     const entryId = s.tree.messageEntries[messageID];
     const entry = tree.entries.find((candidate) => candidate.id === entryId);
     if (!entry || !s.messages?.some((message) => message.info.id === messageID)) {
@@ -285,40 +310,3 @@ export async function navigate(pi, targetId, signal) {
         throw new SessionTreeError("Conversation navigation was cancelled");
     return response.data.leafId;
 }
-export function revertNotice(s) {
-    const revert = s.tree.revert;
-    if (!revert)
-        return undefined;
-    const boundary = s.messages?.find((message) => message.info.id === revert.messageID);
-    const boundaryIndex = s.messages?.findIndex((message) => message.info.id === revert.messageID) ?? 0;
-    const parent = s.messages
-        ?.slice(0, boundaryIndex)
-        .reverse()
-        .find((message) => message.info.role === "user");
-    const messageID = `msg_revert_${revert.messageID}`;
-    const created = (boundary?.info.time.created ?? s.info.time.updated) - 1;
-    return {
-        info: {
-            id: messageID,
-            sessionID: s.info.id,
-            role: "assistant",
-            time: { created, completed: created },
-            parentID: parent?.info.id ?? "",
-            modelID: s.model?.modelID ?? "unknown",
-            providerID: s.model?.providerID ?? "unknown",
-            mode: "info",
-            path: { cwd: s.info.directory, root: s.info.directory },
-            cost: 0,
-            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-        },
-        parts: [
-            {
-                id: `prt_revert_${revert.messageID}`,
-                sessionID: s.info.id,
-                messageID,
-                type: "text",
-                text: "Conversation reverted. Files were not changed.",
-            },
-        ],
-    };
-}

package/dist/sessions.d.ts

@@ -10,7 +10,7 @@ import type { TodoBridge, Todo, TodoUpdated } from "./todo-bridge.js";
 import { type SessionTreeState } from "./session-tree.js";
 import { SubagentBridge } from "./subagents.js";
 import { SessionStore, type TitleSource } from "./session-store.js";
-import type { OCAssistantMessage, OCEvent, OCMessageWithParts, OCModelRef, OCPart, OCSession, OCSessionStatus, OCToolPart } from "./types.js";
+import type { OCAssistantMessage, OCEvent, OCMessageWithParts, OCModelRef, OCPart, OCPromptPart, OCSession, OCSessionStatus, OCToolPart } from "./types.js";
 export { ADAPTER_VERSION } from "./version.js";
 interface StreamingState {
     message: OCAssistantMessage;
@@ -18,6 +18,7 @@ interface StreamingState {
     parts: Map<number, OCPart>;
 }
 export interface ManagedSession extends ThinkingState {
+    interruptRequested?: boolean;
     titleSource?: TitleSource;
     activeUserMessageID?: string;
     inputs?: Map<string, {
@@ -40,6 +41,9 @@ export interface ManagedSession extends ThinkingState {
     /** undefined while dormant; resolved via get_state on create/revive. */
     model: OCModelRef | undefined;
     streaming: StreamingState | undefined;
+    /** A manual compaction started while idle; its end returns the session to idle. */
+    compactingFromIdle?: boolean;
+    compactionID?: string;
     /** Cancels the adapter-owned user bash waiter and its OmO execution. */
     cancelShell?: (interrupted?: boolean) => void;
     /**
@@ -83,8 +87,14 @@ export declare class SessionManager {
     /** freshness of the all-directories scan (see listAll). */
     private scanAllCache;
     constructor(emit: EventSink, store?: SessionStore, defaultDirectory?: string | undefined, lifecycleOptions?: LifecycleOptions);
-    create(directory: string, title?: string, parentID?: string): Promise<OCSession>;
+    create(directory: string, title?: string, parentID?: string, options?: {
+        id?: string;
+        agent?: string;
+        model?: ModelSelection;
+        metadata?: Record<string, unknown>;
+    }): Promise<OCSession>;
     private createLive;
+    private rollbackCreate;
     private applyNativeTitle;
     private refreshNativeTitles;
     private wirePi;
@@ -109,23 +119,32 @@ export declare class SessionManager {
     update(sessionId: string, patch: {
         title?: string | undefined;
         archived?: number | undefined;
-    }): OCSession | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        agent?: string | undefined;
+    }): Promise<OCSession | undefined>;
     messages(sessionId: string): OCMessageWithParts[] | undefined;
     /** Append to canonical history, before the hidden redo branch while reverted. */
     appendMessage(sessionId: string, message: OCMessageWithParts): void;
     private operation;
+    /** Cancellation releases only the caller; the native action keeps its queue lease. */
+    private waitForOperation;
     private syncTree;
     private treeSession;
     fork(sessionId: string, messageID?: string): Promise<OCSession>;
     revert(sessionId: string, messageID: string): Promise<OCSession>;
     unrevert(sessionId: string): Promise<OCSession>;
-    private removeRevertNotice;
     reloadMessages(sessionId: string, signal?: AbortSignal): Promise<OCMessageWithParts[] | undefined>;
     /** Called only within the conversation operation queue, including RPC refreshes. */
     private reloadMessagesLive;
     statuses(): Record<string, OCSessionStatus>;
     todos(sessionId: string): Todo[] | undefined;
-    diff(sessionId: string): Promise<import("./session-diff.js").SessionFileDiff[]>;
+    commitRevert(sessionId: string): Promise<void>;
+    private commitRevertLive;
+    diff(sessionId: string, options?: {
+        from?: string | undefined;
+        to?: string | undefined;
+        context?: number | undefined;
+    }): Promise<import("./session-diff.js").SessionFileDiff[]>;
     private emitDiff;
     abort(sessionId: string): Promise<boolean>;
     permissions(sessionId?: string): PendingPermission[];
@@ -148,8 +167,17 @@ export declare class SessionManager {
      * the next cold start, and tell the UI. Returns whether anything changed.
      */
     private applyPiModel;
-    prompt(sessionId: string, text: string, model?: ModelSelection, noReply?: boolean, messageID?: string, delivery?: "steer" | "queue"): Promise<void>;
+    prompt(sessionId: string, text: string, model?: ModelSelection, noReply?: boolean, messageID?: string, delivery?: "steer" | "queue", parts?: readonly OCPromptPart[], metadata?: Record<string, unknown>): Promise<void>;
+    private preparePrompt;
+    private publishPrompt;
     private promptLive;
+    /**
+     * 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.
+     */
+    private admitContext;
+    private dispatchPrompt;
+    private bindPromptState;
     disposeAll(): Promise<void>;
     /** Spawn pi against the session's JSONL file and adopt it as live. */
     private revive;