antechamber 1.0.24 → 1.0.26

package/dist/pi-event-translation.js

@@ -2,6 +2,7 @@
 import { randomUUID } from "node:crypto";
 import { evalAgentSession } from "./subagents.js";
 import { MONITOR_NOTIFICATION } from "./monitor-sessions.js";
+import { terminalShellId } from "./omo-shells.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";
@@ -150,11 +151,28 @@ export function compactionMessages(s, key, summary, created, model, thinkingLeve
         },
     ];
 }
+/**
+ * Events after which OmO's background work may have started or ended: monitor and wake-source snapshots,
+ * tool results that launch work, and the custom messages OmO sends when a background session finishes.
+ */
+const SHELL_SYNC_EVENTS = new Set([
+    "extension_event",
+    "tool_execution_end",
+    "turn_end",
+    "agent_end",
+    "agent_idle",
+    "message_end",
+]);
 /** Translates per-session events; registry and lifecycle operations stay with SessionManager. */
 export class PiEventTranslator {
     services;
     /** Ended assistant messages whose completion waits on their tools. */
     awaitingTools = new WeakSet();
+    /**
+     * Errored assistant messages held open until agent_end says whether OmO retries them. OpenChamber prints a
+     * completed message's error as "failed to send message", and v2 cannot retract a `session.step.failed`.
+     */
+    heldFailures = new WeakMap();
     constructor(services) {
         this.services = services;
     }
@@ -316,6 +334,8 @@ export class PiEventTranslator {
             default:
                 break; // turn_start, queue_update — future milestones
         }
+        if (SHELL_SYNC_EVENTS.has(String(ev.type)))
+            this.services.shells.sync(s);
     }
     onTodoEntry(s, ev) {
         s.todoBridge ??= new TodoBridge(s.info.id);
@@ -335,9 +355,11 @@ export class PiEventTranslator {
         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 part = completeBackgroundEval(messages, result, created, s.pi?.startedAtMs);
         const prefix = `msg_background_${result.key}_`;
         const unbound = messages.findLast((message) => message.info.id.startsWith(prefix) && s.tree.messageEntries[message.info.id] === undefined);
+        if (source === "message")
+            this.services.shells.noteEnding(s, result);
         // 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))
@@ -377,8 +399,11 @@ export class PiEventTranslator {
                 this.setStatus(s, { type: "busy" });
                 return;
             case "agent_end":
-                if (ev.willRetry === true)
-                    return; // auto-retry keeps the session busy
+                if (ev.willRetry === true) {
+                    // auto-retry keeps the session busy, and the failed step it retries is not a failure to report.
+                    this.completeHeldFailures(s, false);
+                    return;
+                }
                 if (s.interruptRequested)
                     this.finishInterruptedRun(s, { name: "MessageAbortedError", data: { message: "Cancelled" } });
                 s.approvals?.finishTurn();
@@ -582,15 +607,19 @@ export class PiEventTranslator {
                     s.streaming.message.modelID = s.model.modelID;
                 }
                 applyUsage(s.streaming.message, ended.usage);
-                Object.assign(s.streaming.message, piStopReason(ended.stopReason, ended.errorMessage));
+                const stop = piStopReason(ended.stopReason, ended.errorMessage);
+                if (ended.stopReason === "error")
+                    this.heldFailures.set(s.streaming.message, stop);
+                else
+                    Object.assign(s.streaming.message, stop);
                 // OpenCode completes an assistant message only after its tools settle, and
                 // OpenChamber marks active tools under a completed message as Interrupted.
                 // pi ends a toolUse message before executing its tool calls, so defer its
                 // completion to the last tool result (applyToolResults), the next step, or
-                // the run end. Errored/aborted messages never run their tools.
+                // the run end. Errored/aborted messages never run their tools; an errored one completes at agent_end.
                 if (ended.stopReason === "toolUse" && hasActiveTools(s, s.streaming.message.id))
                     this.awaitingTools.add(s.streaming.message);
-                else
+                else if (ended.stopReason !== "error")
                     s.streaming.message.time.completed = Date.now();
                 this.services.emit(s.info.directory, { type: "message.updated", properties: { info: s.streaming.message } });
                 this.finishStreaming(s);
@@ -885,7 +914,7 @@ export class PiEventTranslator {
                 continue;
             s.toolByCallId.delete(callID);
             s.todoBridge?.finish(part, toolFailed(tr));
-            finishToolPart(part, tr, callID, Date.now());
+            finishToolPart(part, tr, callID, Date.now(), s.pi?.startedAtMs);
             if (touchedFiles([part]).length > 0)
                 this.services.dirtyDiffs.add(s.info.id);
             this.emitPart(s, part);
@@ -904,6 +933,11 @@ export class PiEventTranslator {
     onNestedTools(s, parent, details) {
         const nested = nestedToolParts(parent, details, {
             monitor: (args) => this.services.monitors.findChild(s.info.id, args),
+            monitorShell: (childID) => {
+                const bashId = this.services.monitors.terminalId(childID);
+                const epoch = s.pi?.startedAtMs;
+                return bashId !== undefined && epoch !== undefined ? terminalShellId(epoch, bashId) : undefined;
+            },
             agent: (args, claimed, after) => evalAgentSession(s.piSessionId ?? s.restored?.piSessionId, args, claimed, after),
         });
         if (nested.length === 0)
@@ -946,8 +980,23 @@ export class PiEventTranslator {
         s.toolByCallId.clear();
         this.completeAwaitingTools(s); // the run is over
     }
+    /** Complete held errored messages: with their error when the run failed, without it when OmO retries the step. */
+    completeHeldFailures(s, failed) {
+        const now = Date.now();
+        for (const { info } of s.messages ?? []) {
+            const stop = this.heldFailures.get(info);
+            if (stop === undefined || info.role !== "assistant")
+                continue;
+            this.heldFailures.delete(info);
+            if (failed)
+                Object.assign(info, stop);
+            info.time.completed = now;
+            this.services.emit(s.info.directory, { type: "message.updated", properties: { info } });
+        }
+    }
     /** Complete every ended message of this session still waiting on its tools. */
     completeAwaitingTools(s) {
+        this.completeHeldFailures(s, true);
         const now = Date.now();
         for (const { info } of s.messages ?? []) {
             if (!this.awaitingTools.has(info) || info.role !== "assistant")

package/dist/routes-v2.js

@@ -14,6 +14,8 @@ import { getAgentName } from "./agent-name.js";
 import { vcsRead, VcsError } from "./vcs.js";
 import { announceSessionError, compactSession, getCommands, unsupportedShare } from "./session-commands.js";
 import { defaultV2Model, flattenModels, toV2Message, toV2Session } from "./v2.js";
+import { SHELL_CANCELLATION_KEY } from "./omo-shells.js";
+import { WorkStatusError } from "./work-status.js";
 import { agentDescriptors, modelRefFromBody, numberParam, OPENCODE_COMPAT_VERSION, promptAsync, runSessionShell, runSessionSlash, sessionDirectory, sessionMetadata, } from "./route-services.js";
 async function v2Agents(services) {
     return (await agentDescriptors(services)).map(({ model, variant, ...agent }) => ({
@@ -169,6 +171,41 @@ async function handleV2Bootstrap(services, res, path, method, directory) {
     }
     return false;
 }
+/** Shell ids named by OpenChamber's stop note (background-shell.ts `shellCancellationNote`). */
+function cancelledShells(metadata) {
+    const note = metadata?.[SHELL_CANCELLATION_KEY];
+    if (note === null || typeof note !== "object")
+        return [];
+    const ids = "shellIDs" in note ? note.shellIDs : "shellID" in note ? [note.shellID] : [];
+    return Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : [];
+}
+async function handleShell(services, res, id, output, method, url, withLocation) {
+    const shells = services.sessions.shells;
+    const info = shells.get(id);
+    if (info === undefined) {
+        json(res, 404, errorBody("NotFoundError", `Shell not found: ${id}`));
+        return;
+    }
+    try {
+        if (method === "DELETE") {
+            await shells.stop(id);
+            res.writeHead(204).end();
+        }
+        else if (output) {
+            const cursor = numberParam(url.searchParams.get("cursor"));
+            const limit = numberParam(url.searchParams.get("limit"));
+            // @opencode/client returns the body and OpenChamber reads `.data` (lib/opencode/client.ts readShellOutput).
+            json(res, 200, withLocation(await shells.output(id, cursor, limit)));
+        }
+        else
+            json(res, 200, withLocation(info));
+    }
+    catch (error) {
+        if (!(error instanceof WorkStatusError))
+            throw error;
+        json(res, error.status, errorBody(error.status === 404 ? "NotFoundError" : "UnsupportedError", error.message));
+    }
+}
 export async function handleV2(services, req, res, url, path, method, directory) {
     const location = { directory };
     const withLocation = (data) => ({ location, data });
@@ -235,10 +272,18 @@ export async function handleV2(services, req, res, url, path, method, directory)
         });
         return;
     }
-    // Read-only inventories OpenChamber loads at bootstrap. OmO has no OpenCode-style shells or
-    // web-search providers, so each is an honest empty list (mutations stay 400);
-    // OmO monitors appear in the OmO Work status section instead (work-status.ts).
-    if ((path === "/api/shell" || path === "/api/websearch/provider") && method === "GET") {
+    // OmO's background work (monitors, background terminal sessions, detached eval cells) as OpenCode shells.
+    if (path === "/api/shell" && method === "GET") {
+        json(res, 200, withLocation(services.sessions.shells.list(directory)));
+        return;
+    }
+    const shellMatch = path.match(/^\/api\/shell\/([^/]+)(\/output)?$/);
+    if (shellMatch && (method === "GET" || (method === "DELETE" && shellMatch[2] === undefined))) {
+        await handleShell(services, res, decodeURIComponent(shellMatch[1]), shellMatch[2] !== undefined, method, url, withLocation);
+        return;
+    }
+    // OmO has no web-search providers: an honest empty list.
+    if (path === "/api/websearch/provider" && method === "GET") {
         json(res, 200, withLocation([]));
         return;
     }
@@ -666,6 +711,13 @@ export async function handleV2(services, req, res, url, path, method, directory)
                     return;
                 }
                 const metadata = sessionMetadata(body.metadata);
+                const unstoppable = cancelledShells(metadata).filter((id) => !services.sessions.shells.stoppable(id));
+                if (unstoppable.length > 0) {
+                    // OpenChamber sends this note before it removes the shells and stops nothing when the note fails:
+                    // refuse it rather than tell the agent about a stop that cannot happen.
+                    json(res, 400, errorBody("UnsupportedError", `OmO cannot stop ${unstoppable.join(", ")}: only eval cells can be stopped`));
+                    return;
+                }
                 const messageID = typeof body.id === "string" && body.id !== "" ? body.id : `msg_${randomUUID().replaceAll("-", "")}`;
                 const text = body.text;
                 promptAsync(services, managed, text, undefined, true, messageID, body.delivery ?? "steer", undefined, metadata);

package/dist/sessions.d.ts

@@ -11,6 +11,7 @@ import { type SessionTreeState } from "./session-tree.js";
 import { SubagentBridge } from "./subagents.js";
 import { MonitorSessions } from "./monitor-sessions.js";
 import { WorkStatusBridge } from "./work-status.js";
+import { OmoShells } from "./omo-shells.js";
 import { SessionStore, type TitleSource } from "./session-store.js";
 import type { OCAssistantMessage, OCEvent, OCMessageWithParts, OCModelRef, OCPart, OCPromptPart, OCSession, OCSessionStatus, OCToolPart } from "./types.js";
 export { ADAPTER_VERSION } from "./version.js";
@@ -75,6 +76,8 @@ export interface ManagedSession extends ThinkingState {
     hasBackgroundWork?: () => boolean;
     /** Live wake sources OmO publishes over RPC (detached eval cells), which also block idle eviction. */
     hasWakeSources?: () => boolean;
+    /** antechamber stopped the agent process itself (lifecycle `dormant`): its in-process work died with it. */
+    onDormant?: () => void;
     /** Why the agent last stopped on its own; persisted and replayed as a notice until the next prompt. */
     lastStop?: {
         message: string;
@@ -101,6 +104,7 @@ export declare class SessionManager {
     readonly subagents: SubagentBridge;
     readonly monitors: MonitorSessions;
     readonly workStatus: WorkStatusBridge;
+    readonly shells: OmoShells;
     /** directory → last scan freshness (pi dir mtime + wall clock). */
     private scanCache;
     /** freshness of the all-directories scan (see listAll). */
@@ -229,6 +233,8 @@ export declare class SessionManager {
     /** Adopt every restorable pi session on disk, regardless of directory. */
     private ensureAllScanned;
     private adopt;
+    /** The same cleanup as an agent exit, for a process antechamber disposed after unwiring its exit handler. */
+    private wireDormant;
     /** Resolve a bare session id (e.g. deep link after restart) via known directories. */
     private resolveRestored;
     /** Registry write for adapter-owned metadata (title override, pi path). */

package/dist/sessions.js

@@ -18,6 +18,7 @@ import { bindMessageEntries, branchEntries, durableShellTree, followExternalAppe
 import { SubagentBridge } from "./subagents.js";
 import { MonitorSessions } from "./monitor-sessions.js";
 import { WorkStatusBridge } from "./work-status.js";
+import { OmoShells } from "./omo-shells.js";
 import { sessionDiff } from "./session-diff.js";
 import { announceSessionNotice, noticeMessage, skillCommandText, slashTitlePrompt } from "./session-commands.js";
 import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionFileMeta, } from "./session-store.js";
@@ -64,6 +65,7 @@ export class SessionManager {
     subagents;
     monitors;
     workStatus;
+    shells;
     /** directory → last scan freshness (pi dir mtime + wall clock). */
     scanCache = new Map();
     /** freshness of the all-directories scan (see listAll). */
@@ -76,11 +78,13 @@ export class SessionManager {
         this.subagents = new SubagentBridge(this.store, this.sessions, this.emit, (session, raw) => parsePiSessionText(session, getAgentName(), raw));
         this.monitors = new MonitorSessions(this.sessions, this.emit);
         this.workStatus = new WorkStatusBridge(this.monitors);
+        this.shells = new OmoShells(this.sessions, this.monitors, this.workStatus, this.emit);
         this.events = new PiEventTranslator({
             emit: this.emit,
             subagents: this.subagents,
             monitors: this.monitors,
             workStatus: this.workStatus,
+            shells: this.shells,
             store: this.store,
             dirtyDiffs: this.dirtyDiffs,
             ensureMessages: (s) => this.ensureMessages(s),
@@ -152,6 +156,7 @@ export class SessionManager {
             this.subagents.wire(managed);
             this.monitors.wire(managed);
             this.workStatus.wire(managed);
+            this.wireDormant(managed);
             this.lifecycle.touch(managed);
             this.wirePi(managed, pi);
             if (options.model !== undefined)
@@ -291,6 +296,7 @@ export class SessionManager {
             this.subagents.finishCalls(s.info.id, true);
             this.monitors.stopParent(s.info.id);
             this.workStatus.stopParent(s.info.id);
+            this.shells.stopParent(s.info.id);
             void this.lifecycle
                 .dormant(s)
                 .catch((error) => console.error("[lifecycle] exit cleanup failed:", error));
@@ -401,6 +407,7 @@ export class SessionManager {
         const child = this.subagents.remove(sessionId);
         this.monitors.remove(sessionId);
         this.workStatus.stopParent(sessionId);
+        this.shells.stopParent(sessionId);
         if (piPath !== undefined) {
             try {
                 unlinkSync(piPath);
@@ -1484,8 +1491,17 @@ export class SessionManager {
         this.subagents.wire(managed);
         this.monitors.wire(managed);
         this.workStatus.wire(managed);
+        this.wireDormant(managed);
         return managed;
     }
+    /** The same cleanup as an agent exit, for a process antechamber disposed after unwiring its exit handler. */
+    wireDormant(s) {
+        s.onDormant = () => {
+            this.monitors.stopParent(s.info.id);
+            this.workStatus.stopParent(s.info.id);
+            this.shells.stopParent(s.info.id);
+        };
+    }
     /** Resolve a bare session id (e.g. deep link after restart) via known directories. */
     resolveRestored(sessionId) {
         const reg = this.store.get(sessionId);

package/dist/tool-map.d.ts

@@ -32,6 +32,8 @@ export declare function mapTool(omoName: string, args: unknown, result?: ToolRes
 export interface NestedSessions {
     /** The monitor child session for a recorded `monitor` call. */
     monitor?: (args: Record<string, unknown>) => string | undefined;
+    /** The OpenCode shell id of a monitor child session's watch while it runs (omo-shells.ts). */
+    monitorShell?: (sessionID: string) => string | undefined;
     /** The subagent a recorded `agent()` call started; `claimed` keeps repeated calls apart. */
     agent?: (args: Record<string, unknown>, claimed: Set<string>, after: number) => EvalAgent | null | undefined;
 }

package/dist/tool-map.js

@@ -200,6 +200,9 @@ export function nestedToolParts(parent, details, sessions = {}) {
             const command = typeof args.command === "string" ? args.command : "";
             const label = typeof args.description === "string" && args.description !== "" ? args.description : command;
             mapped = nestedSubagent({ title: "Monitor", subtitle: label }, { description: `Monitor: ${label}`, prompt: command, type: "monitor" }, sessionID);
+            const shellID = sessions.monitorShell?.(sessionID);
+            if (shellID !== undefined)
+                mapped.metadata = { ...mapped.metadata, backgroundShellID: shellID };
         }
         else if (entry.name === "task") {
             const text = (value) => (typeof value === "string" && value !== "" ? value : undefined);

package/dist/types.d.ts

@@ -231,6 +231,24 @@ export type OCSessionStatus = {
     message: string;
     next: number;
 };
+export type OCShellStatus = "running" | "exited" | "timeout" | "killed";
+/** OpenCode 2.x `Shell.Info` (@opencode/schema 2.1.4 shell.js); `metadata.sessionID` ties it to a session. */
+export interface OCShellInfo {
+    id: string;
+    status: OCShellStatus;
+    command: string;
+    cwd: string;
+    shell: string;
+    file: string;
+    exit?: number;
+    metadata: {
+        sessionID: string;
+    } & Record<string, unknown>;
+    time: {
+        started: number;
+        completed?: number;
+    };
+}
 export type OCEvent = {
     type: "session.inbox.enqueued";
     properties: {
@@ -356,6 +374,18 @@ export type OCEvent = {
             truncated: boolean;
         };
     };
+} | {
+    type: "shell.created";
+    properties: {
+        info: OCShellInfo;
+    };
+} | {
+    type: "shell.exited";
+    properties: {
+        id: string;
+        status: OCShellStatus;
+        exit?: number;
+    };
 } | {
     type: "session.deleted";
     properties: {

package/dist/v2.js

@@ -184,6 +184,25 @@ export function toV2AssistantMessage(info) {
 function v2ToolName(tool) {
     return tool === "bash" ? "shell" : tool;
 }
+/**
+ * A card whose call left OmO work running (background-results.ts `backgroundShellID`), as OpenCode 2.x settles a
+ * call it moved to the background: completed at once with `{status: "running", shellID}` in its metadata, so
+ * OpenChamber 2.x draws the row from the shell (background-shell.ts `readBackgroundShellID`) and lists the shell
+ * as a background command. A card still waiting on that work is running here, with its result already known.
+ */
+function backgroundShell(part) {
+    const st = part.state;
+    if (st.status !== "running" && st.status !== "completed")
+        return undefined;
+    const { backgroundShellID: shellID, backgroundWaits, backgroundFailed, output, ...metadata } = st.metadata ?? {};
+    if (typeof shellID !== "string")
+        return undefined;
+    if (st.status === "completed")
+        return { output: st.output, metadata: { ...metadata, status: "running", shellID } };
+    if (backgroundFailed !== false || !Array.isArray(backgroundWaits))
+        return undefined;
+    return { output: typeof output === "string" ? output : "", metadata: { ...metadata, status: "running", shellID } };
+}
 function toolContent(part) {
     const st = part.state;
     const name = v2ToolName(part.tool);
@@ -202,9 +221,21 @@ function toolContent(part) {
             ...(end !== undefined ? { completed: end } : {}),
         },
     };
+    const background = st.status === "running" ? backgroundShell(part) : undefined;
     if (st.status === "pending") {
         base.state = { status: "streaming", input: st.raw ?? "", metadata: {} };
     }
+    else if (background !== undefined) {
+        base.time = { created: st.time.start, ran: st.time.start, completed: st.time.start };
+        base.state = {
+            status: "completed",
+            input: st.input,
+            content: background.output !== "" ? [{ type: "text", text: background.output }] : [],
+            output: background.output,
+            title: st.status === "running" ? (st.title ?? part.tool) : part.tool,
+            metadata: background.metadata,
+        };
+    }
     else if (st.status === "running") {
         base.state = {
             status: "running",
@@ -220,7 +251,7 @@ function toolContent(part) {
             content: st.output !== "" ? [{ type: "text", text: st.output }] : [],
             output: st.output,
             title: st.title,
-            metadata: st.metadata ?? {},
+            metadata: backgroundShell(part)?.metadata ?? st.metadata ?? {},
         };
     }
     else {
@@ -256,6 +287,8 @@ export class V2EventTranslator {
             case "session.compaction.failed":
             case "session.shell.started":
             case "session.shell.ended":
+            case "shell.created":
+            case "shell.exited":
                 return [this.frame(directory, ev.type, ev.properties)];
             case "message.removed":
                 return [
@@ -610,6 +643,19 @@ export class V2EventTranslator {
             ts.called = true;
             frames.push(this.frame(directory, "session.tool.called", { ...base, input: state.input, executed: false }));
         }
+        const background = backgroundShell(part);
+        if (background !== undefined) {
+            if (!ts.ended) {
+                ts.ended = true;
+                frames.push(this.frame(directory, "session.tool.success", {
+                    ...base,
+                    content: background.output !== "" ? [{ type: "text", text: background.output }] : [],
+                    metadata: background.metadata,
+                    executed: false,
+                }));
+            }
+            return frames;
+        }
         // `called` carries no metadata (eval card headers, live output); 2.x reads it while running only from progress.
         if (state.status === "running" && state.metadata !== undefined) {
             const metadata = safeJson(state.metadata);

package/dist/work-status.d.ts

@@ -80,6 +80,8 @@ export declare class WorkStatusBridge {
      */
     wire(s: ManagedSession): void;
     observe(s: ManagedSession, ev: Record<string, unknown>): void;
+    /** Detached eval cells codemode reports running or queued. */
+    liveCells(sessionID: string): WakeSourceItem[];
     /** The agent process exited: its in-process wake sources and timers died with it. */
     stopParent(sessionID: string): void;
     snapshot(s: ManagedSession): Promise<WorkStatus>;

package/dist/work-status.js

@@ -194,6 +194,10 @@ export class WorkStatusBridge {
             work.goal = { ...(work.goal ?? { armed: false }), wakeSources: counts };
         }
     }
+    /** Detached eval cells codemode reports running or queued. */
+    liveCells(sessionID) {
+        return this.work.get(sessionID)?.wakeSources.get(CODEMODE_WAKE_SOURCE)?.items ?? [];
+    }
     /** The agent process exited: its in-process wake sources and timers died with it. */
     stopParent(sessionID) {
         this.work.delete(sessionID);

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "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": "1.0.24",
+  "version": "1.0.26",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/extensions/omo-work/README.md

@@ -10,16 +10,14 @@ For the open session it shows:
 
 - **Todo**: OmO's todo list grouped by phase, with progress per phase. The
   phase in progress is open; click any phase to open or close it.
-- **Monitors**: each terminal monitor with its state, age and event count.
-  Click one for its command, filter, deadline and latest matched lines. On
-  OpenChamber 2.x, monitors appear here instead of as subagent sessions.
-- **Eval cells**: detached eval cells with their language, state and running
-  time. Click one to follow its output; **Stop** stops a running or queued
-  cell.
-- **Background**: background terminal sessions that are still running.
 - **Goal**: the goal continuation timer, what it waits on, and **Fire now**.
 - **Other activity**: any other wake source OmO reports.
 
+Terminal monitors, detached eval cells and background terminal sessions are not
+listed here: antechamber reports them to OpenChamber as background commands,
+so the session reads as working while they run and OpenChamber lists them above
+the composer with their output (and Stop, for eval cells).
+
 The section sizes itself to its content, up to OpenChamber's 320 px limit, and
 scrolls inside beyond that.
 
@@ -64,7 +62,7 @@ section (sandboxed iframe) --serviceRequest /status?session=ses_...--> OpenChamb
 `antechamber serve` writes `<state dir>/run/<pid>.json` (mode 0600) with its
 URL and a random token that opens only the `/antechamber/work-status` routes. The service
 picks the running server whose agent holds the session and relays the snapshot
-and the Stop and Fire now actions. It keeps no state. See [docs/DESIGN.md](docs/DESIGN.md) for the snapshot, refresh,
+and the Fire now action. It keeps no state. See [docs/DESIGN.md](docs/DESIGN.md) for the snapshot, refresh,
 server choice and security boundary, and
 [docs/architecture.md](../../docs/architecture.md#omo-work-status-section) for
 where each piece of data comes from in OmO.
@@ -77,13 +75,8 @@ the extension's OpenChamber storage.
 
 ## Limitations
 
-OmO does not expose these over RPC, so the section cannot offer them:
-
-- stopping a monitor or a background terminal session;
-- continuation holds (the loop guard publishes them in-process only).
-
-Eval cells need OmO's codemode. Without it, or while the agent process is not
-running, the section lists the cells OmO last reported, without output or Stop.
+OmO does not publish continuation holds over RPC (the loop guard keeps them
+in-process), so the section cannot show them.
 
 ## Development