antechamber 0.2.23 → 0.2.25

package/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.25] - 2026-10-17
+
+- feat(tools): show subagents and monitors started inside eval (#30)
+
+## [0.2.24] - 2026-10-17
+
+### Fixed
+
+- Show completed background bash output and detached eval results in OpenChamber, including after reloading history.
+  A card that started background work keeps running until that work finishes.
+
+### Added
+
+- Show subagents and monitors started inside an eval cell as subagent cards that open their session, live and after
+  reloading history. A failed `agent()` call keeps its error.
+
 ## [0.2.23] - 2026-10-17
 
 - feat(monitors): show matched lines in monitor sessions (#32)

package/dist/background-results.d.ts

@@ -0,0 +1,51 @@
+import type { ManagedSession } from "./sessions.js";
+import type { OCMessageWithParts, OCModelRef, OCToolPart } from "./types.js";
+import { type ToolResult } from "./tool-map.js";
+export interface BackgroundResult {
+    /** Content hash; identical notifications are told apart by `backgroundID`'s occurrence index. */
+    readonly key: string;
+    readonly kind: "terminal" | "eval";
+    readonly callID: string;
+    readonly title: string;
+    readonly output: string;
+    readonly failed: boolean;
+}
+/** Raw RPC capture of installed omo-ai 5.1.33 / senpi runtime, 2026-10-17. */
+export declare function backgroundResult(customType: unknown, content: unknown): BackgroundResult | undefined;
+/** Retain only the command needed to label a later terminal completion. */
+export declare function backgroundCommands(result: ToolResult): {
+    backgroundCommands?: Record<string, string>;
+};
+export declare function launchedShells(text: string): string[];
+/**
+ * What a tool result leaves running: the background shells it started, and the eval cell
+ * itself when it detached. The card keeps running until each one reports finishing.
+ */
+export declare function backgroundWaits(callID: string, text: string, commands?: Record<string, unknown>): string[];
+interface Final {
+    output: string;
+    failed: boolean;
+}
+/** Keep a finished card running, with its result already shown, until `waits` report finishing. */
+export declare function holdForBackground(part: OCToolPart, waits: string[], final: Final): void;
+/** `id` finished at `at`: drop it from every card waiting on it; cards left with nothing to wait on end. */
+export declare function releaseBackground(messages: readonly OCMessageWithParts[], id: string, at: number): OCToolPart[];
+/** Nothing can still be running (the agent exited, or history is rebuilt): end every waiting card. */
+export declare function settleBackground(messages: readonly OCMessageWithParts[], at: number): OCToolPart[];
+export declare function completeBackgroundEval(messages: readonly OCMessageWithParts[], result: BackgroundResult, completed: number): OCToolPart | undefined;
+/** A tool result finishes its card at `at`; a result that left work running keeps it running. */
+export declare function finishToolPart(part: OCToolPart, result: ToolResult, callID: string, at: number): void;
+/**
+ * OmO persists these notifications but sends no entry_appended frame for them, so the live
+ * path never learns the native entry ID (raw RPC capture of installed omo-ai 5.1.33 / senpi
+ * runtime, 2026-10-17). Live, history and entry binding all derive the same ID from the
+ * content and its occurrence count in conversation order instead.
+ */
+export declare function backgroundID(messages: readonly OCMessageWithParts[], result: BackgroundResult): string;
+export declare function backgroundMessage(s: Pick<ManagedSession, "info" | "messages">, result: BackgroundResult, entry: {
+    id: string;
+    created: number;
+    model: OCModelRef;
+    agent: string;
+}): OCMessageWithParts;
+export {};

package/dist/background-results.js

@@ -0,0 +1,277 @@
+import { createHash } from "node:crypto";
+import { resultMetadata, resultText, toolFailed } from "./tool-map.js";
+/** Raw RPC capture of installed omo-ai 5.1.33 / senpi runtime, 2026-10-17. */
+export function backgroundResult(customType, content) {
+    if (customType !== "senpi-terminal:notification" && customType !== "senpi-codemode:notification")
+        return undefined;
+    const raw = typeof content === "string" ? content : resultText(content);
+    const key = createHash("sha256").update(`${customType}\n${raw}`).digest("hex").slice(0, 16);
+    const text = raw.replaceAll(/<\/?system-reminder>/g, "").replace(/^\n/, "");
+    const newline = text.indexOf("\n");
+    const header = newline < 0 ? text : text.slice(0, newline);
+    const body = newline < 0 ? "" : text.slice(newline + 1);
+    if (customType === "senpi-terminal:notification") {
+        const match = /^Background terminal session (\S+) finished: (.+?)\.?$/.exec(header);
+        if (match?.[1] === undefined || match[2] === undefined)
+            return undefined;
+        return {
+            key,
+            kind: "terminal",
+            callID: match[1],
+            title: `${match[1]} finished: ${match[2]}`,
+            output: body.replace(/^Final output:\r?\n?/, ""),
+            failed: false,
+        };
+    }
+    const match = /^Detached eval cell (\S+)(?: \([^)]+\))? (completed|failed|error)\b.*$/i.exec(header);
+    if (match?.[1] === undefined || match[2] === undefined)
+        return undefined;
+    return {
+        key,
+        kind: "eval",
+        callID: match[1],
+        title: header.replace(/^Detached eval cell /, "").replace(/\.$/, ""),
+        output: body,
+        failed: match[2].toLowerCase() !== "completed",
+    };
+}
+/** Retain only the command needed to label a later terminal completion. */
+export function backgroundCommands(result) {
+    const details = result.details;
+    if (details === null || typeof details !== "object" || !("toolCalls" in details))
+        return {};
+    if (!Array.isArray(details.toolCalls))
+        return {};
+    const commands = {};
+    for (const call of details.toolCalls) {
+        if (call?.name !== "bash" || typeof call.resultPreview !== "string" || typeof call.args?.command !== "string")
+            continue;
+        for (const id of launchedShells(call.resultPreview))
+            commands[id] = call.args.command;
+    }
+    return Object.keys(commands).length === 0 ? {} : { backgroundCommands: commands };
+}
+/**
+ * Background shells a result says it left running (raw RPC captures, 2026-10-17). A cell's output is
+ * trimmed to its tail, which can cut the "with ID" line and leave only the bash_output hint.
+ */
+const LAUNCHED = /\b(?:running in background|auto-detached to background) with ID:\s*(bash_\d+)\b|Use bash_output\(\{ bash_id: "(bash_\d+)" \}\) only to peek/g;
+export function launchedShells(text) {
+    return [...new Set([...text.matchAll(LAUNCHED)].map((match) => match[1] ?? match[2] ?? "").filter(Boolean))];
+}
+/**
+ * What a tool result leaves running: the background shells it started, and the eval cell
+ * itself when it detached. The card keeps running until each one reports finishing.
+ */
+export function backgroundWaits(callID, text, commands = {}) {
+    const waits = new Set();
+    for (const id of launchedShells(text))
+        waits.add(id);
+    for (const id of Object.keys(commands))
+        waits.add(id);
+    if (/^Eval cell \S+ detached and is running/.test(text))
+        waits.add(callID);
+    return [...waits];
+}
+function waitsOf(part) {
+    const waits = part.state.status === "running" ? part.state.metadata?.backgroundWaits : undefined;
+    return Array.isArray(waits) ? waits.filter((id) => typeof id === "string") : [];
+}
+/** Keep a finished card running, with its result already shown, until `waits` report finishing. */
+export function holdForBackground(part, waits, final) {
+    const state = part.state;
+    if (state.status === "pending" || waits.length === 0)
+        return;
+    const title = state.status === "running" || state.status === "completed" ? state.title : undefined;
+    part.state = {
+        status: "running",
+        input: state.input,
+        ...(title !== undefined ? { title } : {}),
+        metadata: { ...state.metadata, output: final.output, backgroundWaits: waits, backgroundFailed: final.failed },
+        time: { start: state.time.start },
+    };
+}
+function finish(part, final, at) {
+    const state = part.state;
+    if (state.status === "pending")
+        return;
+    const { backgroundWaits: _waits, backgroundFailed: _failed, output: _output, ...metadata } = state.metadata ?? {};
+    const time = { start: state.time.start, end: Math.max(at, state.time.start) };
+    const title = state.status === "running" || state.status === "completed" ? (state.title ?? part.tool) : part.tool;
+    part.state = final.failed
+        ? { status: "error", input: state.input, error: final.output || `tool ${part.tool} failed`, metadata, time }
+        : { status: "completed", input: state.input, output: final.output, title, metadata, time };
+}
+function finalOf(part) {
+    const metadata = part.state.status === "running" ? part.state.metadata : undefined;
+    if (typeof metadata?.backgroundFailed !== "boolean")
+        return undefined;
+    return { output: typeof metadata.output === "string" ? metadata.output : "", failed: metadata.backgroundFailed };
+}
+/** `id` finished at `at`: drop it from every card waiting on it; cards left with nothing to wait on end. */
+export function releaseBackground(messages, id, at) {
+    const changed = [];
+    for (const message of messages) {
+        for (const part of message.parts) {
+            if (part.type !== "tool" || part.state.status !== "running")
+                continue;
+            const waits = waitsOf(part);
+            if (!waits.includes(id))
+                continue;
+            const left = waits.filter((wait) => wait !== id);
+            const final = finalOf(part);
+            if (left.length > 0 || final === undefined)
+                part.state.metadata = { ...part.state.metadata, backgroundWaits: left };
+            else
+                finish(part, final, at);
+            changed.push(part);
+        }
+    }
+    return changed;
+}
+/** Nothing can still be running (the agent exited, or history is rebuilt): end every waiting card. */
+export function settleBackground(messages, at) {
+    const changed = [];
+    for (const message of messages) {
+        for (const part of message.parts) {
+            if (part.type !== "tool")
+                continue;
+            const final = finalOf(part);
+            if (final === undefined)
+                continue;
+            finish(part, final, at);
+            changed.push(part);
+        }
+    }
+    return changed;
+}
+export function completeBackgroundEval(messages, result, completed) {
+    if (result.kind !== "eval")
+        return undefined;
+    for (const message of messages) {
+        const part = message.parts.find((part) => part.type === "tool" && part.callID === result.callID);
+        if (part === undefined)
+            continue;
+        const final = { output: result.output, failed: result.failed };
+        // The cell is done; shells it moved to the background may still run.
+        const waits = [
+            ...waitsOf(part).filter((wait) => wait !== result.callID),
+            ...backgroundWaits(result.callID, result.output),
+        ];
+        const remaining = [...new Set(waits)];
+        if (part.state.status !== "pending" && remaining.length > 0) {
+            holdForBackground(part, remaining, final);
+        }
+        else
+            finish(part, final, completed);
+        return part;
+    }
+    return undefined;
+}
+/** A tool result finishes its card at `at`; a result that left work running keeps it running. */
+export function finishToolPart(part, result, callID, at) {
+    const state = part.state;
+    const text = resultText(result.content);
+    const commands = backgroundCommands(result);
+    const metadata = {
+        ...(state.status !== "pending" ? state.metadata : {}),
+        ...resultMetadata(part.tool, result),
+        ...commands,
+    };
+    const time = { start: state.status !== "pending" ? state.time.start : at, end: at };
+    const title = state.status === "running" || state.status === "completed" ? (state.title ?? part.tool) : part.tool;
+    const failed = toolFailed(result);
+    part.state = failed
+        ? { status: "error", input: state.input ?? {}, error: text || `tool ${part.tool} failed`, metadata, time }
+        : { status: "completed", input: state.input ?? {}, output: text, title, metadata, time };
+    const waits = backgroundWaits(callID, text, commands.backgroundCommands);
+    if (waits.length > 0)
+        holdForBackground(part, waits, { output: text, failed });
+}
+/**
+ * OmO persists these notifications but sends no entry_appended frame for them, so the live
+ * path never learns the native entry ID (raw RPC capture of installed omo-ai 5.1.33 / senpi
+ * runtime, 2026-10-17). Live, history and entry binding all derive the same ID from the
+ * content and its occurrence count in conversation order instead.
+ */
+export function backgroundID(messages, result) {
+    const prefix = `msg_background_${result.key}_`;
+    return `${result.key}_${messages.filter((message) => message.info.id.startsWith(prefix)).length}`;
+}
+export function backgroundMessage(s, result, entry) {
+    const messages = s.messages ?? [];
+    let command = result.callID;
+    // The card that launched the command started it, so the finished card shows the real run time.
+    let started = entry.created;
+    if (result.kind === "terminal") {
+        // Newest first, stopping at an earlier finish of the same id: OmO numbers shells from bash_1 again
+        // after its process restarts, so an older launch of that id is not this command's.
+        search: for (const message of messages.toReversed()) {
+            for (const part of message.parts.toReversed()) {
+                if (part.type !== "tool" || part.state.status === "pending")
+                    continue;
+                if (part.callID.startsWith("call_background_") &&
+                    part.state.input.command?.toString().split("\n")[0] === result.callID)
+                    break search;
+                const commands = part.state.metadata?.backgroundCommands;
+                const nested = commands !== null && typeof commands === "object" && result.callID in commands
+                    ? Reflect.get(commands, result.callID)
+                    : undefined;
+                const held = part.state.metadata?.output;
+                const output = part.state.status === "completed"
+                    ? part.state.output
+                    : part.state.status === "error"
+                        ? part.state.error
+                        : typeof held === "string"
+                            ? held
+                            : "";
+                const original = typeof nested === "string"
+                    ? nested
+                    : launchedShells(output).includes(result.callID)
+                        ? (part.state.input.command ?? part.state.input.code)
+                        : undefined;
+                if (typeof original === "string") {
+                    command += `\n${original}`;
+                    started = Math.min(part.state.time.start, entry.created);
+                    break search;
+                }
+            }
+        }
+    }
+    const sessionID = s.info.id;
+    const messageID = `msg_background_${entry.id}`;
+    return {
+        info: {
+            id: messageID,
+            sessionID,
+            role: "assistant",
+            parentID: messages.findLast((message) => message.info.role === "user")?.info.id ?? "",
+            time: { created: entry.created, completed: entry.created },
+            modelID: entry.model.modelID,
+            providerID: entry.model.providerID,
+            mode: entry.agent,
+            path: { cwd: s.info.directory, root: s.info.directory },
+            cost: 0,
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+            finish: "stop",
+        },
+        parts: [
+            {
+                id: `prt_background_${entry.id}`,
+                sessionID,
+                messageID,
+                type: "tool",
+                tool: "bash",
+                callID: `call_background_${entry.id}`,
+                state: {
+                    status: "completed",
+                    input: { command },
+                    output: result.output,
+                    title: result.title,
+                    metadata: {},
+                    time: { start: started, end: entry.created },
+                },
+            },
+        ],
+    };
+}

package/dist/monitor-sessions.d.ts

@@ -37,6 +37,12 @@ export declare class MonitorSessions {
     observe(parent: ManagedSession, ev: Record<string, unknown>): void;
     /** A hidden `senpi-monitor:notification` custom message: append its lines to each watch it names. */
     notify(parent: ManagedSession, message: Record<string, unknown>): void;
+    /**
+     * The child session of the newest watch a parent started with these monitor arguments.
+     * A monitor call recorded inside eval keeps only its arguments, not the `bash_N` id the
+     * child is keyed by, so command and description identify it.
+     */
+    findChild(parentID: string, args: Record<string, unknown>): string | undefined;
     /** The agent process is gone: OmO's in-process watches died with it. */
     stopParent(parentID: string): void;
     /** Forget a deleted child, or every child of a deleted parent. */

package/dist/monitor-sessions.js

@@ -120,6 +120,24 @@ export class MonitorSessions {
             this.publish(watch);
         }
     }
+    /**
+     * The child session of the newest watch a parent started with these monitor arguments.
+     * A monitor call recorded inside eval keeps only its arguments, not the `bash_N` id the
+     * child is keyed by, so command and description identify it.
+     */
+    findChild(parentID, args) {
+        let found;
+        for (const watch of this.watches.values()) {
+            const { monitor } = watch;
+            if (watch.session.info.parentID !== parentID || monitor.command !== args.command)
+                continue;
+            if (typeof args.description === "string" && monitor.description !== args.description)
+                continue;
+            if (found === undefined || monitor.startedAtMs > found.monitor.startedAtMs)
+                found = watch;
+        }
+        return found?.session.info.id;
+    }
     /** The agent process is gone: OmO's in-process watches died with it. */
     stopParent(parentID) {
         for (const watch of this.watches.values()) {

package/dist/pi-event-translation.d.ts

@@ -2,7 +2,7 @@
 import type { OCAssistantMessage, OCMessageWithParts, OCModelRef, OCEvent, OCSessionStatus, OCPart } from "./types.js";
 import type { ManagedSession } from "./sessions.js";
 import type { SessionStore } from "./session-store.js";
-import type { SubagentBridge } from "./subagents.js";
+import { type SubagentBridge } from "./subagents.js";
 import { type MonitorSessions } from "./monitor-sessions.js";
 import { type TodoUpdated } from "./todo-bridge.js";
 export interface PiUsage {
@@ -62,6 +62,7 @@ export declare class PiEventTranslator {
     private reconcileUser;
     onPiEvent(s: ManagedSession, ev: Record<string, unknown>): void;
     private onTodoEntry;
+    private onBackgroundEntry;
     private onLifecycleEvent;
     private onToolEvent;
     private onMessageEvent;
@@ -81,6 +82,9 @@ export declare class PiEventTranslator {
     private onToolcallEvent;
     /** turn_end.toolResults → finalize tool parts (completed / error). */
     private applyToolResults;
+    /** The agent process is gone, and its background shells with it: end cards still waiting on them. */
+    settleBackground(s: ManagedSession): void;
+    private onNestedTools;
     /** Complete an ended assistant message whose completion waited on its tools; true when it changed. */
     private completeSettled;
     /** Tool parts that never received a result (abort, crash) must not spin forever. */

package/dist/pi-event-translation.js

@@ -1,7 +1,8 @@
 /** Pi message/part translation and the live event bridge, with explicit manager services. */
 import { randomUUID } from "node:crypto";
+import { evalAgentSession } from "./subagents.js";
 import { MONITOR_NOTIFICATION } from "./monitor-sessions.js";
-import { applyProviderToolResults, finishProviderToolParts, mapTool, providerToolParts, resultMetadata, resultText, toolFailed, } from "./tool-map.js";
+import { applyProviderToolResults, finishProviderToolParts, mapTool, nestedToolParts, providerToolParts, resultText, toolFailed, } from "./tool-map.js";
 import { TodoBridge } from "./todo-bridge.js";
 import { readSessionTree, recordTurn } from "./session-tree.js";
 import { touchedFiles } from "./session-diff.js";
@@ -9,6 +10,7 @@ import { getAgentName } from "./agent-name.js";
 import { userMessageModel } from "./thinking-levels.js";
 import { debugLog } from "./misc-routes.js";
 import { envSetting } from "./config.js";
+import { backgroundID, backgroundMessage, backgroundResult, completeBackgroundEval, finishToolPart, releaseBackground, settleBackground, } from "./background-results.js";
 export function id(prefix) {
     return `${prefix}_${randomUUID().replaceAll("-", "")}`;
 }
@@ -191,7 +193,7 @@ export class PiEventTranslator {
         });
         if (status.type === "idle") {
             s.info.time.idle = Date.now();
-            const last = s.messages?.findLast((message) => message.info.role === "assistant");
+            const last = s.messages?.findLast((message) => message.info.role === "assistant" && !message.info.id.startsWith("msg_background_"));
             s.info.outcome =
                 s.interruptRequested || (last?.info.role === "assistant" && last.info.error?.name === "MessageAbortedError")
                     ? "interrupted"
@@ -269,6 +271,7 @@ export class PiEventTranslator {
         switch (ev.type) {
             case "entry_appended":
                 this.onTodoEntry(s, ev);
+                this.onBackgroundEntry(s, ev.entry, "entry");
                 break;
             case "session_info_changed":
                 this.services.applyNativeTitle(s, ev.name);
@@ -308,6 +311,54 @@ export class PiEventTranslator {
         if (event !== undefined)
             this.services.emit(s.info.directory, event);
     }
+    onBackgroundEntry(s, value, source = "message") {
+        if (value === null || typeof value !== "object")
+            return;
+        if (!("customType" in value) || !("content" in value))
+            return;
+        const result = backgroundResult(value.customType, value.content);
+        if (result === undefined)
+            return;
+        const messages = this.services.ensureMessages(s);
+        const timestamp = "timestamp" in value ? value.timestamp : undefined;
+        const parsed = typeof timestamp === "string" ? Date.parse(timestamp) : timestamp;
+        const created = typeof parsed === "number" && Number.isFinite(parsed) ? parsed : Date.now();
+        const part = completeBackgroundEval(messages, result, created);
+        const prefix = `msg_background_${result.key}_`;
+        const unbound = messages.findLast((message) => message.info.id.startsWith(prefix) && s.tree.messageEntries[message.info.id] === undefined);
+        // A finished shell also ends the wait of the card that launched it (once, from the live message).
+        if (result.kind === "terminal" && source === "message")
+            for (const waiting of releaseBackground(messages, result.callID, created))
+                this.emitPart(s, waiting);
+        if (part !== undefined)
+            this.emitPart(s, part);
+        else if (source === "entry" && unbound !== undefined) {
+            // The live custom message already created this card; the entry only supplies its native ID.
+            if ("id" in value && typeof value.id === "string")
+                s.tree.messageEntries[unbound.info.id] = value.id;
+        }
+        else {
+            const message = backgroundMessage(s, result, {
+                id: backgroundID(messages, result),
+                created,
+                model: s.model ?? { providerID: "unknown", modelID: "unknown" },
+                agent: getAgentName(),
+            });
+            if (messages.some((existing) => existing.info.id === message.info.id))
+                return;
+            if ("id" in value && typeof value.id === "string")
+                s.tree.messageEntries[message.info.id] = value.id;
+            const boundary = messages.findIndex((item) => item.info.id === s.tree.revert?.messageID);
+            messages.splice(boundary < 0 ? messages.length : boundary, 0, message);
+            this.services.emit(s.info.directory, { type: "message.updated", properties: { info: message.info } });
+            for (const part of message.parts)
+                this.emitPart(s, part);
+        }
+        if ("id" in value && typeof value.id === "string") {
+            recordTurn(s);
+            this.services.persistMeta(s);
+        }
+    }
     onLifecycleEvent(s, ev) {
         switch (ev.type) {
             case "agent_start":
@@ -426,6 +477,7 @@ export class PiEventTranslator {
                 if (output.trim() !== "")
                     part.state.metadata = { ...part.state.metadata, output };
                 this.emitPart(s, part);
+                this.onNestedTools(s, part, partial !== null && typeof partial === "object" && "details" in partial ? partial.details : undefined);
                 return;
             }
             case "tool_execution_end": {
@@ -449,6 +501,13 @@ export class PiEventTranslator {
                     this.services.monitors.notify(s, custom);
                     return;
                 }
+                if (ev.message !== null &&
+                    typeof ev.message === "object" &&
+                    "role" in ev.message &&
+                    ev.message.role === "custom") {
+                    this.onBackgroundEntry(s, ev.message);
+                    return;
+                }
                 const msg = ev.message;
                 if (msg?.role !== "assistant")
                     return; // user message already recorded at prompt()
@@ -695,8 +754,11 @@ export class PiEventTranslator {
             // Task expansion replaces the streaming placeholder with one or more
             // cards sharing its callID. Order those cards without reconstructing it.
             const indices = new Map([...streaming.parts].map(([index, part]) => [part.type === "tool" ? part.callID : part.id, index]));
-            owner.parts.sort((a, b) => (indices.get(a.type === "tool" ? a.callID : a.id) ?? Infinity) -
-                (indices.get(b.type === "tool" ? b.callID : b.id) ?? Infinity));
+            const order = (part) => {
+                const parent = part.type === "tool" && part.state.status !== "pending" ? part.state.metadata?.parentCallID : undefined;
+                return (indices.get(typeof parent === "string" ? parent : part.type === "tool" ? part.callID : part.id) ?? Infinity);
+            };
+            owner.parts.sort((a, b) => order(a) - order(b));
         }
     }
     /**
@@ -793,39 +855,17 @@ export class PiEventTranslator {
                 continue;
             }
             const part = callID !== undefined ? s.toolByCallId.get(callID) : undefined;
+            const parent = part ??
+                s.messages
+                    ?.flatMap((message) => message.parts)
+                    .find((item) => item.type === "tool" && item.callID === callID);
+            if (parent !== undefined)
+                this.onNestedTools(s, parent, tr.details);
             if (!part || callID === undefined)
                 continue;
             s.toolByCallId.delete(callID);
             s.todoBridge?.finish(part, toolFailed(tr));
-            const text = resultText(tr.content);
-            const startedAt = part.state.status !== "pending" ? part.state.time.start : Date.now();
-            const input = part.state.input ?? {};
-            const metadata = {
-                ...(part.state.status !== "pending" ? part.state.metadata : {}),
-                ...resultMetadata(part.tool, tr),
-            };
-            const title = part.state.status === "running" || part.state.status === "completed"
-                ? (part.state.title ?? part.tool)
-                : part.tool;
-            if (toolFailed(tr)) {
-                part.state = {
-                    status: "error",
-                    input,
-                    error: text || `tool ${part.tool} failed`,
-                    metadata,
-                    time: { start: startedAt, end: Date.now() },
-                };
-            }
-            else {
-                part.state = {
-                    status: "completed",
-                    input,
-                    output: text,
-                    title,
-                    metadata,
-                    time: { start: startedAt, end: Date.now() },
-                };
-            }
+            finishToolPart(part, tr, callID, Date.now());
             if (touchedFiles([part]).length > 0)
                 this.services.dirtyDiffs.add(s.info.id);
             this.emitPart(s, part);
@@ -836,6 +876,29 @@ export class PiEventTranslator {
             this.services.emit(s.info.directory, { type: "message.updated", properties: { info: owner.info } });
         }
     }
+    /** The agent process is gone, and its background shells with it: end cards still waiting on them. */
+    settleBackground(s) {
+        for (const part of settleBackground(s.messages ?? [], Date.now()))
+            this.emitPart(s, part);
+    }
+    onNestedTools(s, parent, details) {
+        const nested = nestedToolParts(parent, details, {
+            monitor: (args) => this.services.monitors.findChild(s.info.id, args),
+            agent: (args, claimed, after) => evalAgentSession(s.piSessionId ?? s.restored?.piSessionId, args, claimed, after),
+        });
+        if (nested.length === 0)
+            return;
+        const owner = s.messages?.find((message) => message.info.id === parent.messageID);
+        if (owner === undefined)
+            return;
+        for (const [index, part] of nested.entries()) {
+            const existing = owner.parts.findIndex((item) => item.id === part.id);
+            if (existing >= 0)
+                owner.parts.splice(existing, 1);
+            owner.parts.splice(owner.parts.indexOf(parent) + 1 + index, 0, part);
+            this.emitPart(s, part);
+        }
+    }
     /** Complete an ended assistant message whose completion waited on its tools; true when it changed. */
     completeSettled(s, info) {
         if (!this.awaitingTools.has(info) || info.role !== "assistant" || hasActiveTools(s, info.id))

package/dist/session-history.js

@@ -1,13 +1,14 @@
 /** Reconstruct OpenCode history from pi JSONL session files. */
 import { readFileSync } from "node:fs";
-import { applyProviderToolResults, finishProviderToolParts, mapTool, providerToolParts, resultMetadata, resultText, toolFailed, } from "./tool-map.js";
+import { applyProviderToolResults, finishProviderToolParts, mapTool, nestedToolParts, providerToolParts, } from "./tool-map.js";
 import { TodoBridge } from "./todo-bridge.js";
 import { userMessageModel } from "./thinking-levels.js";
 import { contextMessageID } from "./prompt-parts.js";
 import { bindMessageEntries } from "./session-tree.js";
-import { taskParts, updateTaskParts, taskCompletions } from "./subagents.js";
+import { evalAgentSession, taskParts, updateTaskParts, taskCompletions } from "./subagents.js";
 import { shellTitle, shellUserMessage } from "./session-commands.js";
 import { compactionMessages, piModelId, piStopReason, textOf } from "./pi-event-translation.js";
+import { backgroundID, backgroundMessage, backgroundResult, completeBackgroundEval, finishToolPart, releaseBackground, settleBackground, } from "./background-results.js";
 function entryTime(e) {
     if (typeof e.timestamp === "number")
         return e.timestamp;
@@ -139,7 +140,9 @@ export function parsePiSessionText(s, agentName, raw) {
         finishProviderToolParts([...toolParts.values()].flat(), entryTime(runAssistant), runAssistant.message?.stopReason === "aborted" ? "Cancelled" : "No result");
         runAssistant = undefined;
     };
+    let lastAt = 0;
     for (const e of chain) {
+        lastAt = Math.max(lastAt, entryTime(e));
         if (e.type === "model_change" && typeof e.provider === "string" && typeof e.modelId === "string") {
             currentModel = { providerID: e.provider, modelID: e.modelId };
             continue;
@@ -153,6 +156,22 @@ export function parsePiSessionText(s, agentName, raw) {
             out.push(...compactionMessages(s, e.id ?? `r${indexOf.get(e) ?? 0}`, e.summary, entryTime(e), currentModel, currentThinkingLevel));
             continue;
         }
+        if (e.type === "custom_message") {
+            const result = backgroundResult(e.customType, e.content);
+            if (result?.kind === "terminal")
+                releaseBackground(out, result.callID, entryTime(e));
+            if (result !== undefined && completeBackgroundEval(out, result, entryTime(e)) === undefined) {
+                const message = backgroundMessage({ info: s.info, messages: out }, result, {
+                    id: backgroundID(out, result),
+                    created: entryTime(e),
+                    model: currentModel,
+                    agent: agentName,
+                });
+                if (e.id !== undefined)
+                    s.tree.messageEntries[message.info.id] = e.id;
+                out.push(message);
+            }
+        }
         const contextID = contextMessageID(e);
         if (contextID !== undefined) {
             endRun();
@@ -386,32 +405,20 @@ export function parsePiSessionText(s, agentName, raw) {
                 updateTaskParts(matching, m, true, created);
                 continue;
             }
-            const text = resultText(m.content) ?? "";
-            const startedAt = part.state.status !== "pending" ? part.state.time.start : created;
-            const input = part.state.input ?? {};
-            const metadata = {
-                ...(part.state.status !== "pending" ? part.state.metadata : {}),
-                ...resultMetadata(part.tool, m),
-            };
-            const title = part.state.status === "running" || part.state.status === "completed"
-                ? (part.state.title ?? part.tool)
-                : part.tool;
-            part.state = toolFailed(m)
-                ? {
-                    status: "error",
-                    input,
-                    error: text !== "" ? text : `tool ${part.tool} failed`,
-                    metadata,
-                    time: { start: startedAt, end: created },
+            if (callID !== undefined)
+                finishToolPart(part, m, callID, created);
+            const nested = nestedToolParts(part, m.details, {
+                agent: (args, claimed, after) => evalAgentSession(s.piSessionId ?? s.restored?.piSessionId, args, claimed, after),
+            });
+            const owner = out.find((message) => message.info.id === part.messageID);
+            if (owner !== undefined) {
+                for (const card of nested) {
+                    const existing = owner.parts.findIndex((item) => item.id === card.id);
+                    if (existing >= 0)
+                        owner.parts.splice(existing, 1);
                 }
-                : {
-                    status: "completed",
-                    input,
-                    output: text,
-                    title,
-                    metadata,
-                    time: { start: startedAt, end: created },
-                };
+                owner.parts.splice(owner.parts.indexOf(part) + 1, 0, ...nested);
+            }
         }
         // system / custom entries are not rendered
     }
@@ -480,12 +487,17 @@ export function parsePiSessionText(s, agentName, raw) {
                 sessionID,
                 messageID: message.info.id,
             }));
-        const identities = s.tree.messageParts?.[message.info.id];
-        for (const [index, part] of message.parts.entries()) {
+        const nestedIDs = new Set(message.parts.flatMap((part) => part.type === "tool" && part.state.status !== "pending" && part.state.metadata?.nested === true
+            ? [part.id]
+            : []));
+        const identities = s.tree.messageParts?.[message.info.id]?.filter((identity) => !nestedIDs.has(identity));
+        for (const [index, part] of message.parts.filter((part) => !nestedIDs.has(part.id)).entries()) {
             const identity = identities?.[index];
             if (identity !== undefined)
                 part.id = identity;
         }
     }
+    // The agent that ran these shells is gone by the time history is rebuilt.
+    settleBackground(out, lastAt);
     return out;
 }

package/dist/session-tree.d.ts

@@ -31,6 +31,7 @@ export interface TreeEntry {
     id: string;
     parentId: string | null;
     customType?: string;
+    content?: unknown;
     details?: unknown;
     message?: {
         role: string;

package/dist/session-tree.js

@@ -1,6 +1,7 @@
 import { RPC_COMMAND_TIMEOUT_MS } from "./pi-rpc.js";
 import { readFileSync, statSync } from "node:fs";
 import { contextMessageID, nativePromptInput } from "./prompt-parts.js";
+import { backgroundResult } from "./background-results.js";
 export class SessionTreeError extends Error {
 }
 export function durableShellTree(tree) {
@@ -132,6 +133,7 @@ function bindOrdinaryEntry(s, entry, messages, cursor) {
             .join("");
     const index = messages.findIndex((message, position) => position >= cursor &&
         !s.localMessageIds?.has(message.info.id) &&
+        !message.info.id.startsWith("msg_background_") &&
         s.tree.messageEntries[message.info.id] === undefined &&
         message.info.role === entry.message?.role &&
         (message.info.role !== "user" ||
@@ -158,6 +160,20 @@ export function bindMessageEntries(s, tree) {
     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);
+    // Background completion cards carry no native ID live; recompute their content key in branch order.
+    const seen = new Map();
+    for (const entry of branch) {
+        if (entry.type !== "custom_message")
+            continue;
+        const result = backgroundResult(entry.customType, entry.content);
+        if (result === undefined)
+            continue;
+        const occurrence = seen.get(result.key) ?? 0;
+        seen.set(result.key, occurrence + 1);
+        const messageID = `msg_background_${result.key}_${occurrence}`;
+        if (s.messages?.some((message) => message.info.id === messageID))
+            s.tree.messageEntries[messageID] = entry.id;
+    }
     // Admitted context carries its OpenChamber id in the native custom message.
     for (const entry of branch) {
         const messageID = contextMessageID(entry);

package/dist/sessions.js

@@ -250,6 +250,7 @@ export class SessionManager {
                 this.reportPersistenceError(s, error);
             }
             delete s.interruptRequested;
+            this.events.settleBackground(s);
             this.subagents.stopParent(s.info.id);
             this.monitors.stopParent(s.info.id);
             void this.lifecycle

package/dist/subagents.d.ts

@@ -14,6 +14,12 @@ export declare function findTaskBySession(sessionId: string): {
     path: string;
     data: Record<string, unknown>;
 } | undefined;
+/**
+ * The session of a subagent an eval cell started with `agent()`. The recorded call keeps only its
+ * arguments, so the task record is found by parent, prompt and label: the oldest one created since
+ * the cell started and not yet claimed by an earlier call of the same cell.
+ */
+export declare function evalAgentSession(parentPiId: string | undefined, args: Record<string, unknown>, claimed: Set<string>, after: number): string | undefined;
 export declare function findTask(id: string, parentPiId: string): {
     path: string;
     data: Record<string, unknown>;

package/dist/subagents.js

@@ -193,6 +193,38 @@ export function findTaskBySession(sessionId) {
     }
     return undefined;
 }
+/**
+ * The session of a subagent an eval cell started with `agent()`. The recorded call keeps only its
+ * arguments, so the task record is found by parent, prompt and label: the oldest one created since
+ * the cell started and not yet claimed by an earlier call of the same cell.
+ */
+export function evalAgentSession(parentPiId, args, claimed, after) {
+    if (parentPiId === undefined || typeof args.prompt !== "string")
+        return undefined;
+    let best;
+    for (const { id, path } of taskFiles()) {
+        if (claimed.has(id))
+            continue;
+        const data = childRecord(id, path);
+        if (data?.parent_session_id !== parentPiId)
+            continue;
+        const spec = record(data.spawn_spec) ? data.spawn_spec : {};
+        if (spec.prompt !== args.prompt)
+            continue;
+        if (typeof args.label === "string" && data.name !== args.label)
+            continue;
+        const created = typeof data.created_at === "string" ? Date.parse(data.created_at) : Number.NaN;
+        // The cell's start is taken when its card opens, a moment after OmO starts it.
+        if (!Number.isFinite(created) || created < after - 5_000)
+            continue;
+        if (best === undefined || created < best.created)
+            best = { id, created };
+    }
+    if (best === undefined)
+        return undefined;
+    claimed.add(best.id);
+    return ocIdFor(best.id);
+}
 export function findTask(id, parentPiId) {
     if (!taskId(id))
         return undefined;

package/dist/tool-map.d.ts

@@ -25,6 +25,21 @@ export declare function resultText(content: unknown): string;
 /** Only edit cards need patch metadata; write cards already preview input.content. */
 export declare function resultMetadata(tool: string, result: ToolResult): Record<string, unknown>;
 export declare function mapTool(omoName: string, args: unknown, result?: ToolResult): MappedTool;
+/**
+ * What an eval cell started that has a session of its own. Its other calls are not shown:
+ * the cell's output already holds what it printed, and OmO records only a one-line preview.
+ */
+export interface NestedSessions {
+    /** The monitor child session for a recorded `monitor` call. */
+    monitor?: (args: Record<string, unknown>) => string | undefined;
+    /** The subagent session for a recorded `agent()` call; `claimed` keeps repeated calls apart. */
+    agent?: (args: Record<string, unknown>, claimed: Set<string>, after: number) => string | undefined;
+}
+/**
+ * Finished eval calls, from the raw RPC capture of installed omo-ai 5.1.33 / senpi runtime, 2026-10-17.
+ * Monitors and `agent()` calls (recorded as `__agent__`) become subagent cards; everything else is skipped.
+ */
+export declare function nestedToolParts(parent: OCToolPart, details: unknown, sessions?: NestedSessions): OCToolPart[];
 /** One card at each call's original block index; result blocks are not cards.
  * Shared by RPC snapshots and history so ids and renderer state survive reloads.
  */

package/dist/tool-map.js

@@ -134,6 +134,77 @@ export function mapTool(omoName, args, result) {
         ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
     };
 }
+/** A subagent-style card, as OpenChamber draws `task`: it opens `sessionID` when there is one. */
+function nestedSubagent(description, prompt, type, sessionID) {
+    return {
+        tool: "task",
+        input: { description, prompt, subagent_type: type },
+        title: description.slice(0, 60),
+        metadata: sessionID !== undefined ? { sessionID } : {},
+    };
+}
+/**
+ * Finished eval calls, from the raw RPC capture of installed omo-ai 5.1.33 / senpi runtime, 2026-10-17.
+ * Monitors and `agent()` calls (recorded as `__agent__`) become subagent cards; everything else is skipped.
+ */
+export function nestedToolParts(parent, details, sessions = {}) {
+    if (!record(details) || !Array.isArray(details.toolCalls))
+        return [];
+    const parts = [];
+    const start = parent.state.status === "pending" ? 0 : parent.state.time.start;
+    const claimed = new Set();
+    details.toolCalls.forEach((entry, index) => {
+        if (!record(entry) ||
+            (entry.name !== "monitor" && entry.name !== "__agent__") ||
+            typeof entry.ok !== "boolean" ||
+            typeof entry.durationMs !== "number" ||
+            !Number.isFinite(entry.durationMs) ||
+            entry.durationMs < 0)
+            return;
+        const args = record(entry.args) ? entry.args : {};
+        let mapped;
+        if (entry.name === "monitor") {
+            const sessionID = entry.ok ? sessions.monitor?.(args) : undefined;
+            if (sessionID === undefined)
+                return; // nothing to open; the cell's code already shows the call
+            const command = typeof args.command === "string" ? args.command : "";
+            const label = typeof args.description === "string" && args.description !== "" ? args.description : command;
+            mapped = nestedSubagent(`Monitor: ${label}`, command, "monitor", sessionID);
+        }
+        else {
+            const prompt = typeof args.prompt === "string" ? args.prompt : "";
+            const label = [args.label, args.description, prompt.split("\n")[0]].find((value) => typeof value === "string" && value !== "");
+            const sessionID = entry.ok ? sessions.agent?.(args, claimed, start) : undefined;
+            const type = typeof args.agent === "string" && args.agent !== "" ? args.agent : "subagent";
+            mapped = nestedSubagent(label ?? "subagent", prompt, type, sessionID);
+        }
+        const key = typeof entry.callId === "string" ? `id:${encodeURIComponent(entry.callId)}` : `index:${index}`;
+        const callID = `${encodeURIComponent(parent.callID)}:${key}`;
+        const state = {
+            input: mapped.input,
+            title: mapped.title,
+            output: "",
+            metadata: { ...mapped.metadata, nested: true, parentCallID: parent.callID, durationMs: entry.durationMs },
+            time: { start, end: start + entry.durationMs },
+        };
+        parts.push({
+            id: `prt_${parent.sessionID}_nested_${callID}`,
+            sessionID: parent.sessionID,
+            messageID: parent.messageID,
+            type: "tool",
+            callID: `nested:${callID}`,
+            tool: mapped.tool,
+            state: entry.ok
+                ? { ...state, status: "completed" }
+                : {
+                    ...state,
+                    status: "error",
+                    error: typeof entry.error === "string" && entry.error !== "" ? entry.error : "failed",
+                },
+        });
+    });
+    return parts;
+}
 /** JSON first, then the literal-only Python repr used by older session files.
  * Never execute provider content; invalid or incomplete literals are skipped.
  */

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "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.23",
+  "version": "0.2.25",
   "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.23",
+  "version": "0.2.25",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",