antechamber 0.2.34 → 0.2.35

package/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [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/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)
@@ -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.35",
   "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.35",
   "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.35",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",