antechamber 0.2.23 → 0.2.24

package/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [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.
+
 ## [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/pi-event-translation.d.ts

@@ -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,8 @@ 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;
     /** 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,7 @@
 /** Pi message/part translation and the live event bridge, with explicit manager services. */
 import { randomUUID } from "node:crypto";
 import { MONITOR_NOTIFICATION } from "./monitor-sessions.js";
-import { applyProviderToolResults, finishProviderToolParts, mapTool, providerToolParts, resultMetadata, resultText, toolFailed, } from "./tool-map.js";
+import { applyProviderToolResults, finishProviderToolParts, mapTool, 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 +9,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 +192,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 +270,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 +310,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":
@@ -449,6 +499,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()
@@ -797,35 +854,7 @@ export class PiEventTranslator {
                 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 +865,11 @@ 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);
+    }
     /** 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,6 +1,6 @@
 /** 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, providerToolParts } from "./tool-map.js";
 import { TodoBridge } from "./todo-bridge.js";
 import { userMessageModel } from "./thinking-levels.js";
 import { contextMessageID } from "./prompt-parts.js";
@@ -8,6 +8,7 @@ import { bindMessageEntries } from "./session-tree.js";
 import { 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,8 @@ 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 },
-                }
-                : {
-                    status: "completed",
-                    input,
-                    output: text,
-                    title,
-                    metadata,
-                    time: { start: startedAt, end: created },
-                };
+            if (callID !== undefined)
+                finishToolPart(part, m, callID, created);
         }
         // system / custom entries are not rendered
     }
@@ -487,5 +482,7 @@ export function parsePiSessionText(s, agentName, raw) {
                 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/extensions/omo-compat/package.json

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