antechamber 1.0.24 → 1.0.25

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,6 +151,18 @@ 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;
@@ -316,6 +329,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 +350,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))
@@ -885,7 +902,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 +921,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)

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.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": "1.0.24",
+  "version": "1.0.25",
   "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
 

package/extensions/omo-work/docs/DESIGN.md

@@ -1,7 +1,11 @@
 # OmO Work: design
 
-OmO Work is an OpenChamber 2.x Work Status section for the background work of
-the open session. This document covers its parts, its data, its security
+OmO Work is an OpenChamber 2.x Work Status section for the open session's work
+that OpenChamber has no surface for: the todo list, the goal continuation timer
+and other wake sources. Monitors, eval cells and background terminal sessions
+are OpenChamber's own background commands, reported by antechamber as OpenCode
+shells ([docs/architecture.md](../../../docs/architecture.md#omo-background-work-as-opencode-shells)),
+so the section does not list them. This document covers its parts, its data, its security
 boundary and its limits. Where each field comes from in OmO is documented in
 [docs/architecture.md](../../../docs/architecture.md#omo-work-status-section).
 
@@ -10,7 +14,7 @@ boundary and its limits. Where each field comes from in OmO is documented in
 ```
 OpenChamber Work Status panel
   └─ section frame (status/index.html + status/main.js, sandboxed iframe)
-       │ host.serviceRequest  GET /status, GET /eval, POST /eval/stop, POST /goal/fire
+       │ host.serviceRequest  GET /status, POST /goal/fire
        ▼
 OpenChamber host ── loopback + OPENCHAMBER_SERVICE_TOKEN ──▶ service/main.js (Node, on the host)
                                                               │ reads <state dir>/run/<pid>.json
@@ -18,7 +22,7 @@ OpenChamber host ── loopback + OPENCHAMBER_SERVICE_TOKEN ──▶ service/m
                                                               ▼
                                          antechamber  /antechamber/work-status/<session>[...]
                                                               │ snapshot from its bridges,
-                                                              ▼ eval_cells.* / goal RPC to OmO
+                                                              ▼ goal RPC to OmO
                                                          omo --mode rpc
 ```
 
@@ -42,7 +46,7 @@ OpenChamber host ── loopback + OPENCHAMBER_SERVICE_TOKEN ──▶ service/m
 
 | Field | Content |
 |---|---|
-| `live` | the session's agent process is running; peek, Stop and Fire now need it |
+| `live` | the session's agent process is running; Fire now needs it |
 | `todo` | todo phases in OmO's order, each `{name, tasks: [{content, status}]}`, status `pending`, `in_progress`, `completed` or `cancelled` |
 | `monitors` | live watches (newest first), then the five most recently ended, each with its last 20 matched lines and, once ended, a readable reason |
 | `evalCells` | detached eval cells from `eval_cells.list`, or from the codemode wake source when the list is unavailable (`evalCellsListed: false`) |
@@ -50,27 +54,27 @@ OpenChamber host ── loopback + OPENCHAMBER_SERVICE_TOKEN ──▶ service/m
 | `goal` | the goal continuation timer (`armed`, `kind`, `dueAtMs`) and the wake-source counts it waits on, or `null` |
 | `wakeSources` | other active wake sources without a dedicated view |
 
-The frame checks the envelope (`src/model.ts`) and imports these types from the
-adapter, so a shape change on either side fails the typecheck.
+The frame shows `todo`, `goal` and `wakeSources`. `monitors`, `evalCells` and
+`background` stay in the snapshot, and the adapter keeps its
+`/antechamber/work-status/<session>/eval/<cell>[/stop]` routes, for section
+versions installed before these moved to OpenChamber's background commands
+(ZIP installs never update). The frame checks the envelope (`src/model.ts`) and
+imports these types from the adapter, so a shape change on either side fails
+the typecheck.
 
 ## Refresh
 
 The frame polls `/status` one request at a time:
 
-- every 1.5 s while anything can change on its own (a live monitor, a running
-  or queued cell, a background session, an armed timer, a task in progress);
+- every 1.5 s while anything it shows can change on its own (an armed timer,
+  another wake source, a task in progress);
 - every 5 s otherwise, and while the page is hidden;
 - every 10 s after an error, keeping the last snapshot on screen with the
   error above it.
 
 A session switch bumps a generation counter, so a late answer for the previous
 session is dropped. Elapsed times and countdowns tick every second from the
-snapshot without refetching. An open eval cell's output is re-read on each
-poll while the cell runs, and once more when its state changes, so a finished
-cell shows its last lines.
-
-The adapter caches `eval_cells.list` for one second per session, so several
-open sections cost one RPC.
+snapshot without refetching.
 
 ## Choosing the server
 
@@ -97,21 +101,13 @@ loopback.
 - **Frame**: the sandboxed iframe holds no token. It reaches the service only
   through the host, which adds its own per-service token. All text from OmO is
   inserted with `textContent`, never as HTML.
-- **Inputs**: session IDs must match `ses_[0-9A-Za-z]+` and cell IDs
-  `[\w.:-]{1,128}`, in both the service and the adapter. Output peeks are
-  capped at 64 KiB.
-- **Actions**: Stop and Fire now map to OmO's own RPC requests
-  (`eval_cells.stop`, `goal_continuation_fire_now`). The extension kills no
-  process itself.
+- **Inputs**: session IDs must match `ses_[0-9A-Za-z]+`, in both the service
+  and the adapter.
+- **Actions**: Fire now maps to OmO's own RPC request
+  (`goal_continuation_fire_now`). The extension kills no process itself.
 
 ## Limits
 
-- No Stop for monitors or background terminal sessions, and no continuation
-  holds: OmO exposes neither over RPC.
-- Eval cells need OmO's codemode. Without it, or while the agent process is
-  stopped, the section shows the cells OmO last reported, without output or
-  Stop.
-- Background sessions come from OmO's terminal manifest, which OmO writes on
-  start and exit; their command is shown but not their output.
+- No continuation holds: OmO does not publish them over RPC.
 - The service must run on the machine that runs antechamber, since it reads
   the run records.

package/extensions/omo-work/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-work",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "description": "OpenChamber 2.x Work Status section: OmO todo phases, monitors, eval cells and background work of the current session",
   "private": true,
   "type": "module",

package/extensions/omo-work/service/main.js

@@ -52,7 +52,6 @@ function discoverServers(stateDirs, isAlive = alive) {
 
 // extensions/omo-work/src/service.ts
 var SESSION_ID = /^ses_[0-9A-Za-z]+$/;
-var CELL_ID = /^[\w.:-]{1,128}$/;
 var STATUS_TIMEOUT_MS = 5e3;
 var ACTION_TIMEOUT_MS = 15e3;
 async function call(server, method, path, timeoutMs) {
@@ -131,20 +130,11 @@ function createServer(options) {
     if (!SESSION_ID.test(session)) return fail(res, 400, "session query must be an OpenChamber session id");
     const custom = url.searchParams.get("stateDir")?.trim();
     const stateDirs = custom ? [resolve(expandHome(custom))] : defaultDirs();
-    const cell = url.searchParams.get("cell") ?? "";
     const method = req.method ?? "GET";
     req.resume();
     if (url.pathname === "/status" && method === "GET") return void relayStatus(res, session, stateDirs);
     if (url.pathname === "/goal/fire" && method === "POST")
       return void relayAction(res, session, stateDirs, "POST", "goal/fire");
-    if (url.pathname.startsWith("/eval")) {
-      if (!CELL_ID.test(cell)) return fail(res, 400, "cell query must be an eval cell id");
-      const tail = Number(url.searchParams.get("tailBytes") ?? 8192);
-      if (url.pathname === "/eval" && method === "GET")
-        return void relayAction(res, session, stateDirs, "GET", `eval/${encodeURIComponent(cell)}?tailBytes=${tail}`);
-      if (url.pathname === "/eval/stop" && method === "POST")
-        return void relayAction(res, session, stateDirs, "POST", `eval/${encodeURIComponent(cell)}/stop`);
-    }
     return fail(res, 404, "not-found");
   });
 }