antechamber 0.2.34 → 0.2.36

package/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.36] - 2026-10-20
+
+### Fixed
+
+- Keep large sessions usable after their persisted history exceeds the 64 MiB RPC frame limit.
+  History synchronization now reads the persisted prefix locally and requests only the native tail,
+  preserving the selected branch when sending messages or reopening a session.
+
+## [0.2.35] - 2026-10-19
+
+### Fixed
+
+- Keep OmO background subagents running in OpenChamber after the parent turn is stopped or its agent
+  process exits. Child status now follows OmO's `omo.task.updated` snapshots and task records, and a
+  child an older version wrongly marked cancelled recovers from its running record. Stopping the turn
+  no longer unblocks fork and revert while a background subagent runs; the error now names the
+  running subagent instead of asking to stop the turn.
+
 ## [0.2.34] - 2026-10-19
 
 ### Fixed

package/dist/pi-event-translation.js

@@ -310,6 +310,7 @@ export class PiEventTranslator {
                 break;
             case "extension_event":
                 this.services.monitors.observe(s, ev);
+                this.services.subagents.observe(s, ev);
                 break;
             default:
                 break; // turn_start, queue_update — future milestones

package/dist/pi-rpc.d.ts

@@ -71,8 +71,10 @@ export declare class PiRpcClient extends EventEmitter {
     private disposing;
     private agentActive;
     private compacting;
+    private sessionPath;
     get pid(): number | undefined;
     get isBusy(): boolean;
+    get sessionFile(): string | undefined;
     onEvent(listener: (payload: Record<string, unknown>) => void): this;
     onExit(listener: (code: number | null, signal: string | null) => void): this;
     onExtensionUI(listener: (request: Record<string, unknown>) => void): this;

package/dist/pi-rpc.js

@@ -70,12 +70,16 @@ export class PiRpcClient extends EventEmitter {
     disposing;
     agentActive = false;
     compacting = false;
+    sessionPath;
     get pid() {
         return this.proc.pid;
     }
     get isBusy() {
         return this.pending.size > 0;
     }
+    get sessionFile() {
+        return this.sessionPath;
+    }
     onEvent(listener) {
         return super.on("event", listener);
     }
@@ -231,6 +235,13 @@ export class PiRpcClient extends EventEmitter {
                     ...(typeof msg.errorCode === "string" ? { errorCode: msg.errorCode } : {}),
                     ...(msg.errorData !== undefined ? { errorData: msg.errorData } : {}),
                 };
+            if (pending && response.success && msg.command === "get_state") {
+                const data = response.data;
+                this.sessionPath =
+                    typeof data === "object" && data !== null && "sessionFile" in data && typeof data.sessionFile === "string"
+                        ? data.sessionFile
+                        : undefined;
+            }
             pending?.resolve(response);
             return;
         }

package/dist/session-tree.d.ts

@@ -49,6 +49,8 @@ export interface TreeEntry {
 export interface Entries {
     entries: TreeEntry[];
     leafId: string | null;
+    /** A disk prefix is not proof that the live runtime has loaded every entry. */
+    unverifiedPrefix?: true;
 }
 export declare class SessionTreeError extends Error {
 }

package/dist/session-tree.js

@@ -4,6 +4,7 @@ import { contextMessageID, nativePromptInput } from "./prompt-parts.js";
 import { backgroundResult } from "./background-results.js";
 export class SessionTreeError extends Error {
 }
+const INLINE_TREE_BYTES = 32 * 1024 * 1024;
 export function durableShellTree(tree) {
     return {
         ...tree,
@@ -12,10 +13,26 @@ export function durableShellTree(tree) {
     };
 }
 export async function getEntries(pi, signal) {
-    const response = await pi.command({ type: "get_entries" }, RPC_COMMAND_TIMEOUT_MS, signal);
-    if (!response.success || !response.data)
-        throw new SessionTreeError(response.error ?? "OmO returned no session entries");
-    return response.data;
+    const path = pi.sessionFile;
+    const disk = path !== undefined && (statSync(path, { throwIfNoEntry: false })?.size ?? 0) >= INLINE_TREE_BYTES
+        ? readSessionTree(path)
+        : undefined;
+    for (let index = (disk?.entries.length ?? 0) - 1;; index--) {
+        const since = disk?.entries[index]?.id;
+        const response = await pi.command({ type: "get_entries", ...(since === undefined ? {} : { since }) }, RPC_COMMAND_TIMEOUT_MS, signal);
+        // Another client may have appended entries the live runtime has not loaded.
+        if (!response.success && response.errorCode === "not_found" && since !== undefined)
+            continue;
+        if (!response.success || !response.data)
+            throw new SessionTreeError(response.error ?? "OmO returned no session entries");
+        return disk === undefined
+            ? response.data
+            : {
+                entries: [...disk.entries.slice(0, index + 1), ...response.data.entries],
+                leafId: response.data.leafId,
+                unverifiedPrefix: true,
+            };
+    }
 }
 export function readSessionTree(piPath) {
     const lines = readFileSync(piPath, "utf8").trimEnd().split("\n");

package/dist/sessions.js

@@ -251,7 +251,8 @@ export class SessionManager {
             }
             delete s.interruptRequested;
             this.events.settleBackground(s);
-            this.subagents.stopParent(s.info.id);
+            // Its task cards end with the run; the tasks themselves may still run in OmO's shared host.
+            this.subagents.finishCalls(s.info.id, true);
             this.monitors.stopParent(s.info.id);
             void this.lifecycle
                 .dormant(s)
@@ -469,7 +470,7 @@ export class SessionManager {
         if (treeOperation && s.piPath !== undefined) {
             const disk = readSessionTree(s.piPath);
             const known = new Set(tree.entries.map((entry) => entry.id));
-            if (disk.leafId !== tree.leafId || disk.entries.some((entry) => !known.has(entry.id))) {
+            if (tree.unverifiedPrefix || disk.leafId !== tree.leafId || disk.entries.some((entry) => !known.has(entry.id))) {
                 // Only idle user tree operations can replace a stale native runtime.
                 const saved = s.tree.leafId;
                 const response = await pi.command({ type: "switch_session", sessionPath: s.piPath }, RPC_COMMAND_TIMEOUT_MS);
@@ -500,9 +501,13 @@ export class SessionManager {
         if (!s)
             throw new SessionTreeError(`unknown session: ${sessionId}`);
         return this.operation(s, async () => {
-            if (s.status.type !== "idle" || s.hasPendingInteraction() || s.hasRunningChildren()) {
+            if (s.status.type !== "idle" || s.hasPendingInteraction()) {
                 throw new SessionTreeError("Session is busy; stop the turn before changing the conversation");
             }
+            // Stopping the turn does not stop a background subagent; it ends on its own or when cancelled.
+            if (s.hasRunningChildren()) {
+                throw new SessionTreeError("A subagent of this session is still running; wait for it to finish before changing the conversation");
+            }
             if (!s.pi)
                 await this.revive(s);
             const pi = s.pi;
@@ -712,7 +717,8 @@ export class SessionManager {
         }
         s.cancelShell?.();
         s.approvals?.cancelAll();
-        this.subagents.stopParent(sessionId);
+        // Background tasks outlive an abort; OmO itself cancels the ones the turn was waiting on.
+        this.subagents.finishCalls(sessionId, true);
         return true;
     }
     permissions(sessionId) {

package/dist/subagents.d.ts

@@ -57,6 +57,19 @@ export declare class SubagentBridge {
     start(parent: ManagedSession, original: OCToolPart, args: Record<string, unknown>): void;
     result(parent: ManagedSession, callID: string, result: ToolResult, ended: boolean): boolean;
     wake(parent: ManagedSession, event: Record<string, unknown>): void;
+    /**
+     * OmO's task bridge publishes `omo.task.updated` over the RPC extension channel: a replacement
+     * snapshot of every task under the parent, sent on attach (after OmO reconciles detached workers)
+     * and on each task store change (omo-task.js `W6`). A task missing from it is unknown, not ended:
+     * the snapshot is capped at 256 tasks.
+     */
+    observe(parent: ManagedSession, ev: Record<string, unknown>): void;
+    /**
+     * Merge task state reported by OmO (record, snapshot) unless it is older than what is known: an
+     * older update, or a running state that predates a terminal one OmO already reported. Terminal
+     * states are only ever taken from OmO, so nothing the adapter inferred can block a running task.
+     */
+    private applyNative;
     discover(parent: ManagedSession, messages: OCMessageWithParts[]): void;
     private discoverParts;
     private create;
@@ -90,7 +103,18 @@ export declare class SubagentBridge {
     private persist;
     private emitPart;
     private closeWatchers;
+    /**
+     * End the parent's task cards that have no running child. A card whose child runs is left to OmO:
+     * an abort cancels only a task the turn was still waiting on, and OmO reports that cancellation
+     * like any other end (omo-task.js `UZ`, "parent turn aborted"); background tasks keep running.
+     * After an abort the call stays tracked, because its tool result can still arrive.
+     */
     finishCalls(parentID: string, cancelled?: boolean): void;
+    /**
+     * Stop showing a deleted parent's children as live. Their status is not touched: OmO tasks outlive
+     * their parent's turn and process (shared-host workers detach, omo-task.js `DK`/`jK`), so only OmO
+     * can say a task ended.
+     */
     stopParent(parentID: string): void;
     /** Forget a deleted child and leave a registry tombstone; false when `id` is not a child. */
     remove(id: string): boolean;

package/dist/subagents.js

@@ -29,6 +29,22 @@ function active(status) {
 function revivable(details) {
     return (details.residency_state === "resident" && ["completed", "error", "interrupted"].includes(String(details.status)));
 }
+function timestamp(value) {
+    return typeof value === "string" ? Date.parse(value) : Number.NaN;
+}
+/**
+ * The lifecycle fields of an `omo.task.updated` row. `live_progress` changes on every event and is
+ * not task state; a text field OmO cut to its 32 000-character limit (`*_truncated`) must not
+ * replace the full value the task record carries.
+ */
+function snapshotState(row) {
+    const { live_progress: _progress, final_response_truncated: responseCut, error_message_truncated: errorCut, description_truncated: _descriptionCut, ...data } = row;
+    if (responseCut === true)
+        delete data.final_response;
+    if (errorCut === true)
+        delete data.error_message;
+    return data;
+}
 function terminal(status) {
     return ["completed", "failed", "error", "cancelled", "canceled", "killed", "lost", "denied", "plan_error"].includes(String(status));
 }
@@ -371,6 +387,50 @@ export class SubagentBridge {
             this.refresh(child, true, false);
         }
     }
+    /**
+     * OmO's task bridge publishes `omo.task.updated` over the RPC extension channel: a replacement
+     * snapshot of every task under the parent, sent on attach (after OmO reconciles detached workers)
+     * and on each task store change (omo-task.js `W6`). A task missing from it is unknown, not ended:
+     * the snapshot is capped at 256 tasks.
+     */
+    observe(parent, ev) {
+        if (ev.name !== "omo.task.updated" || !record(ev.data) || !Array.isArray(ev.data.tasks))
+            return;
+        for (const row of ev.data.tasks) {
+            if (!record(row) || !taskId(row.task_id))
+                continue;
+            const id = ocIdFor(row.task_id);
+            if (!this.children.has(id))
+                this.restore(id);
+            const child = this.children.get(id);
+            if (!child)
+                continue;
+            const data = snapshotState(row);
+            // OmO re-sends every row ~150 ms after each progress event of any task; only changes matter.
+            if (Object.entries(data).every(([key, value]) => child.task.details[key] === value))
+                continue;
+            this.wire(parent);
+            if (!this.applyNative(child, data))
+                continue;
+            child.live = true;
+            this.refresh(child, true, false);
+        }
+    }
+    /**
+     * Merge task state reported by OmO (record, snapshot) unless it is older than what is known: an
+     * older update, or a running state that predates a terminal one OmO already reported. Terminal
+     * states are only ever taken from OmO, so nothing the adapter inferred can block a running task.
+     */
+    applyNative(child, data) {
+        const updated = timestamp(data.updated_at);
+        const known = timestamp(child.task.details.updated_at);
+        if (updated < known)
+            return false;
+        if (active(data.status) && terminal(child.task.details.status) && updated <= (child.task.terminalAt ?? 0))
+            return false;
+        child.task.details = { ...child.task.details, ...data };
+        return true;
+    }
     discover(parent, messages) {
         this.discoverParts(parent, messages.flatMap((message) => message.parts), false);
     }
@@ -582,8 +642,12 @@ export class SubagentBridge {
     }
     refresh(child, publish, useRecord = true) {
         const archive = this.archive(child.task.id);
-        const found = this.reconcileTaskRecord(child, archive, useRecord);
-        const running = active(child.task.details.status) && (found !== undefined || child.live);
+        const found = this.reconcileTaskRecord(child, useRecord);
+        // OmO stops in-process workers with their parent and leaves them `running` but `persisted_only`
+        // until the revived parent reconciles them (omo-task.js `DK`/`jK`); they are not running.
+        const running = active(child.task.details.status) &&
+            child.task.details.residency_state !== "persisted_only" &&
+            (found !== undefined || child.live);
         const state = {
             previousMessages: child.session.messages ?? [],
             previousStatus: child.session.status.type,
@@ -599,16 +663,13 @@ export class SubagentBridge {
         this.persist(child);
         this.publishRefresh(child, state, publish);
     }
-    reconcileTaskRecord(child, archive, useRecord) {
+    reconcileTaskRecord(child, useRecord) {
         const found = findTask(child.task.id, child.task.parentPiId);
         if (!found)
             return undefined;
         child.recordPath = found.path;
-        const updated = typeof found.data.updated_at === "string" ? Date.parse(found.data.updated_at) : NaN;
-        const retainedTerminal = Math.max(child.task.terminalAt ?? 0, existsSync(archive) ? statSync(archive).mtimeMs : 0);
-        const staleRunning = active(found.data.status) && terminal(child.task.details.status) && updated <= retainedTerminal;
-        if (useRecord && !staleRunning)
-            child.task.details = { ...child.task.details, ...found.data };
+        if (useRecord)
+            this.applyNative(child, found.data);
         const host = found.data.host_session;
         if (record(host) && typeof host.session_path === "string") {
             child.livePath = host.session_path;
@@ -806,15 +867,24 @@ export class SubagentBridge {
             child.watchers.delete(dir);
         }
     }
+    /**
+     * End the parent's task cards that have no running child. A card whose child runs is left to OmO:
+     * an abort cancels only a task the turn was still waiting on, and OmO reports that cancellation
+     * like any other end (omo-task.js `UZ`, "parent turn aborted"); background tasks keep running.
+     * After an abort the call stays tracked, because its tool result can still arrive.
+     */
     finishCalls(parentID, cancelled = false) {
         for (const [key, parts] of this.calls) {
             if (!key.startsWith(`${parentID}|`))
                 continue;
             const parent = this.sessions.get(parentID);
+            let waiting = false;
             for (const part of parts) {
                 const childID = part.state.status !== "pending" ? part.state.metadata?.sessionID : undefined;
-                if (!cancelled && typeof childID === "string" && this.children.get(childID)?.session.status.type === "busy")
+                if (typeof childID === "string" && this.children.get(childID)?.session.status.type === "busy") {
+                    waiting = true;
                     continue;
+                }
                 updateTaskParts([part], {
                     isError: true,
                     details: { status: cancelled ? "cancelled" : "failed" },
@@ -823,19 +893,21 @@ export class SubagentBridge {
                 if (parent)
                     this.emitPart(parent, part);
             }
-            this.calls.delete(key);
+            if (!cancelled || !waiting)
+                this.calls.delete(key);
         }
     }
+    /**
+     * Stop showing a deleted parent's children as live. Their status is not touched: OmO tasks outlive
+     * their parent's turn and process (shared-host workers detach, omo-task.js `DK`/`jK`), so only OmO
+     * can say a task ended.
+     */
     stopParent(parentID) {
         this.finishCalls(parentID, true);
         for (const child of this.children.values()) {
             if (child.session.info.parentID !== parentID)
                 continue;
             this.stopParent(child.session.info.id);
-            if (child.session.status.type === "busy") {
-                child.task.details = { ...child.task.details, status: "cancelled" };
-                this.refresh(child, true, false);
-            }
             this.closeWatchers(child);
         }
     }

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "description": "OpenChamber extension: displays OmO tool calls the way OmO means them when OpenChamber runs on antechamber",
   "private": true,
   "type": "module",

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",