antechamber 1.0.0 → 1.0.2

package/dist/todo-bridge.js

@@ -3,43 +3,42 @@ import { toolMappers } from "./tool-map.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-export function flattenTodos(sessionID, data) {
+function todoStatus(value) {
+    switch (value) {
+        case "in_progress":
+            return "in_progress";
+        case "completed":
+            return "completed";
+        case "abandoned":
+        case "dropped":
+        case "cancelled":
+            return "cancelled";
+        default:
+            return "pending";
+    }
+}
+/** The `senpi.todo-state` phases, keeping only well-formed phases and tasks. */
+export function todoPhases(data) {
     if (!record(data) || !Array.isArray(data.phases))
         return [];
-    const phases = data.phases.filter(record);
-    return phases.flatMap((phase) => {
+    return data.phases.filter(record).flatMap((phase) => {
         if (typeof phase.name !== "string" || !Array.isArray(phase.tasks))
             return [];
-        return phase.tasks.filter(record).flatMap((task) => {
-            if (typeof task.content !== "string")
-                return [];
-            let status;
-            switch (task.status) {
-                case "in_progress":
-                    status = "in_progress";
-                    break;
-                case "completed":
-                    status = "completed";
-                    break;
-                case "abandoned":
-                case "dropped":
-                case "cancelled":
-                    status = "cancelled";
-                    break;
-                default:
-                    status = "pending";
-            }
-            return [
-                {
-                    id: createHash("md5").update(`${sessionID}|${phase.name}|${task.content}`).digest("hex").slice(0, 16),
-                    content: phases.length === 1 ? task.content : `${phase.name}: ${task.content}`,
-                    status,
-                    priority: "medium",
-                },
-            ];
-        });
+        const tasks = phase.tasks
+            .filter(record)
+            .flatMap((task) => typeof task.content === "string" ? [{ content: task.content, status: todoStatus(task.status) }] : []);
+        return [{ name: phase.name, tasks }];
     });
 }
+export function flattenTodos(sessionID, data) {
+    const phases = todoPhases(data);
+    return phases.flatMap((phase) => phase.tasks.map((task) => ({
+        id: createHash("md5").update(`${sessionID}|${phase.name}|${task.content}`).digest("hex").slice(0, 16),
+        content: phases.length === 1 ? task.content : `${phase.name}: ${task.content}`,
+        status: task.status,
+        priority: "medium",
+    })));
+}
 toolMappers.todo = (args) => ({
     tool: "todowrite",
     input: { todos: Array.isArray(args.todos) ? args.todos : [] },
@@ -49,6 +48,7 @@ toolMappers.todo = (args) => ({
 export class TodoBridge {
     sessionID;
     todos = [];
+    phases = [];
     awaitingState = [];
     constructor(sessionID) {
         this.sessionID = sessionID;
@@ -68,6 +68,7 @@ export class TodoBridge {
         if (!record(entry) || entry.type !== "custom" || entry.customType !== "senpi.todo-state")
             return undefined;
         this.todos = flattenTodos(this.sessionID, entry.data);
+        this.phases = todoPhases(entry.data);
         const part = this.awaitingState.shift();
         if (part !== undefined) {
             part.state.input = { todos: this.todos };

package/dist/v2.js

@@ -282,6 +282,15 @@ export class V2EventTranslator {
                         ? [this.frame(directory, "session.metadata.updated", { sessionID: info.id, metadata: info.metadata })]
                         : []),
                     this.frame(directory, "session.agent.selected", { sessionID: info.id, agent: info.agent ?? getAgentName() }),
+                    ...(info.cost !== undefined
+                        ? [
+                            this.frame(directory, "session.usage.updated", {
+                                sessionID: info.id,
+                                cost: info.cost,
+                                tokens: info.tokens ?? zeroTokens(),
+                            }),
+                        ]
+                        : []),
                 ];
             }
             case "session.diff":
@@ -462,7 +471,6 @@ export class V2EventTranslator {
             return [];
         st.ended = true;
         return [
-            this.frame(directory, "session.usage.updated", { sessionID: st.sessionID, cost: st.cost, tokens: st.tokens }),
             st.finish === "error"
                 ? this.frame(directory, "session.step.failed", {
                     sessionID: st.sessionID,

package/dist/work-status.d.ts

@@ -0,0 +1,87 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { MonitorSessions, MonitorView } from "./monitor-sessions.js";
+import type { ManagedSession, SessionManager } from "./sessions.js";
+import type { TodoPhase } from "./todo-bridge.js";
+export declare const WAKE_SOURCE_STATE_EVENT = "wake_source_state";
+export declare const GOAL_TIMER_STATE_EVENT = "goal_continuation_timer_state";
+export declare const GOAL_SCHEDULED_EVENT = "goal_continuation_scheduled";
+export declare const GOAL_FIRE_NOW_REQUEST = "goal_continuation_fire_now";
+export declare const CODEMODE_WAKE_SOURCE = "senpi-codemode";
+export interface WakeSourceItem {
+    id: string;
+    description: string;
+    startedAtMs: number;
+}
+export interface WakeSource {
+    source: string;
+    activeCount: number;
+    items: WakeSourceItem[];
+}
+export interface EvalCellView {
+    cellId: string;
+    language?: string;
+    state: string;
+    startedAtMs?: number;
+    summary?: string;
+    queuedBehind?: string[];
+}
+export interface BackgroundSessionView {
+    id: string;
+    command: string;
+    startedAtMs: number;
+    pid?: number;
+}
+export interface GoalTimerView {
+    armed: boolean;
+    kind?: string;
+    dueAtMs?: number;
+    /** Live wake-source counts the goal waits on, by source name (`goal_continuation_scheduled`). */
+    wakeSources?: Record<string, number>;
+}
+export interface WorkStatus {
+    version: 1;
+    sessionID: string;
+    /** The agent process is running; eval cells and stop actions need it. */
+    live: boolean;
+    generatedAt: number;
+    todo: TodoPhase[];
+    monitors: MonitorView[];
+    evalCells: EvalCellView[];
+    /** False when the cell list could not be read (agent not running, or codemode absent). */
+    evalCellsListed: boolean;
+    background: BackgroundSessionView[];
+    goal: GoalTimerView | null;
+    /** Other published wake sources, for work this adapter has no dedicated view for. */
+    wakeSources: WakeSource[];
+}
+export declare class WorkStatusError extends Error {
+    readonly status: 400 | 404 | 409 | 502;
+    constructor(status: 400 | 404 | 409 | 502, message: string);
+}
+export declare function parseWakeSource(data: unknown): WakeSource | undefined;
+export declare function parseEvalCell(value: unknown): EvalCellView | undefined;
+/**
+ * Background sessions from the terminal manifest whose process is still alive. OmO writes the
+ * file on start and exit, but a crashed agent leaves its last entries behind.
+ */
+export declare function readBackgroundSessions(sessionFile: string, piSessionId: string, isAlive?: (pid: number) => boolean): BackgroundSessionView[];
+export declare class WorkStatusBridge {
+    private readonly monitors;
+    private readonly work;
+    constructor(monitors: MonitorSessions);
+    private state;
+    observe(s: ManagedSession, ev: Record<string, unknown>): void;
+    /** The agent process exited: its in-process wake sources and timers died with it. */
+    stopParent(sessionID: string): void;
+    snapshot(s: ManagedSession): Promise<WorkStatus>;
+    private listEvalCells;
+    peekEvalCell(s: ManagedSession, cellId: string, tailBytes: number): Promise<Record<string, unknown>>;
+    stopEvalCell(s: ManagedSession, cellId: string): Promise<Record<string, unknown>>;
+    fireGoalContinuation(s: ManagedSession): Promise<void>;
+    private evalCommand;
+}
+/**
+ * `/antechamber/work-status/<session>` and its actions. These are antechamber's own routes, not
+ * OpenCode's: the OmO Work extension service authenticates with the run-record token.
+ */
+export declare function handleWorkStatus(sessions: Pick<SessionManager, "get" | "workStatus">, req: IncomingMessage, res: ServerResponse, url: URL, method: string): Promise<void>;

package/dist/work-status.js

@@ -0,0 +1,308 @@
+/**
+ * Background work of one session for the OmO Work status section (extensions/omo-work):
+ * todo phases, terminal monitors, detached eval cells, background terminal sessions and the
+ * goal continuation timer. OpenChamber 2.x has no native surface for any of these.
+ *
+ * Sources, all from installed omo-ai 5.1.33 / senpi 2026.10.13:
+ * - `wake_source_state` extension events: senpi-codemode publishes its detached cells over RPC
+ *   (senpi-codemode/src/index.ts `emitWakeSourceState`); the terminal extension publishes
+ *   its sources on the in-process bus only (core/extensions/builtin/terminal/extension-state.js).
+ * - `eval_cells.list/peek/stop` RPC commands (senpi-codemode/src/extension/eval-cells-rpc.ts).
+ * - `goal_continuation_timer_state` / `goal_continuation_scheduled` extension events
+ *   (core/extensions/builtin/goal/monitor-continuation.js), and the `goal_continuation_fire_now`
+ *   extension request (goal/rpc-wait-surface.js).
+ * - the terminal manifest `<session dir>/extensions/terminal/<session id>.json`, written on every
+ *   background session start and exit (terminal/terminal-manifest.js), for background sessions.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { errorBody, json } from "./http.js";
+export const WAKE_SOURCE_STATE_EVENT = "wake_source_state";
+export const GOAL_TIMER_STATE_EVENT = "goal_continuation_timer_state";
+export const GOAL_SCHEDULED_EVENT = "goal_continuation_scheduled";
+export const GOAL_FIRE_NOW_REQUEST = "goal_continuation_fire_now";
+export const CODEMODE_WAKE_SOURCE = "senpi-codemode";
+/** Ended watches and matched lines kept per watch in a snapshot. */
+const MAX_ENDED_MONITORS = 5;
+const MAX_MONITOR_LINES = 20;
+/** `eval_cells.list` answers are reused this long, so several open sections cost one RPC. */
+const EVAL_LIST_TTL_MS = 1000;
+const EVAL_RPC_TIMEOUT_MS = 10_000;
+const MAX_PEEK_BYTES = 64 * 1024;
+export class WorkStatusError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "WorkStatusError";
+    }
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function finite(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+export function parseWakeSource(data) {
+    if (!record(data) || typeof data.source !== "string" || data.source === "")
+        return undefined;
+    const activeCount = finite(data.activeCount);
+    if (activeCount === undefined)
+        return undefined;
+    const rawItems = Array.isArray(data.items) ? data.items : Array.isArray(data.monitors) ? data.monitors : [];
+    const items = rawItems.flatMap((item) => {
+        if (!record(item) || typeof item.id !== "string")
+            return [];
+        const startedAtMs = finite(item.startedAtMs);
+        if (startedAtMs === undefined)
+            return [];
+        return [{ id: item.id, description: nonEmpty(item.description) ?? item.id, startedAtMs }];
+    });
+    return { source: data.source, activeCount, items };
+}
+export function parseEvalCell(value) {
+    if (!record(value) || typeof value.cellId !== "string" || typeof value.state !== "string")
+        return undefined;
+    const language = nonEmpty(value.language);
+    const startedAtMs = finite(value.startedAtMs);
+    const summary = nonEmpty(value.summary);
+    const queuedBehind = Array.isArray(value.queuedBehind)
+        ? value.queuedBehind.filter((id) => typeof id === "string")
+        : undefined;
+    return {
+        cellId: value.cellId,
+        state: value.state,
+        ...(language !== undefined ? { language } : {}),
+        ...(startedAtMs !== undefined ? { startedAtMs } : {}),
+        ...(summary !== undefined ? { summary } : {}),
+        ...(queuedBehind !== undefined && queuedBehind.length > 0 ? { queuedBehind } : {}),
+    };
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error instanceof Error && "code" in error && error.code === "EPERM";
+    }
+}
+/**
+ * Background sessions from the terminal manifest whose process is still alive. OmO writes the
+ * file on start and exit, but a crashed agent leaves its last entries behind.
+ */
+export function readBackgroundSessions(sessionFile, piSessionId, isAlive = alive) {
+    let manifest;
+    try {
+        const path = join(dirname(sessionFile), "extensions", "terminal", `${encodeURIComponent(piSessionId)}.json`);
+        manifest = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return []; // Missing (no background session yet), or mid-write: the next poll reads it.
+    }
+    if (!record(manifest) || !Array.isArray(manifest.backgroundSessions))
+        return [];
+    return manifest.backgroundSessions.flatMap((entry) => {
+        if (!record(entry) || typeof entry.id !== "string")
+            return [];
+        const startedAtMs = finite(entry.startedAtMs);
+        if (startedAtMs === undefined)
+            return [];
+        const pid = record(entry.runtime) ? finite(entry.runtime.pid) : undefined;
+        if (pid !== undefined && !isAlive(pid))
+            return [];
+        return [
+            {
+                id: entry.id,
+                command: nonEmpty(entry.command) ?? entry.id,
+                startedAtMs,
+                ...(pid !== undefined ? { pid } : {}),
+            },
+        ];
+    });
+}
+export class WorkStatusBridge {
+    monitors;
+    work = new Map();
+    constructor(monitors) {
+        this.monitors = monitors;
+    }
+    state(sessionID) {
+        let work = this.work.get(sessionID);
+        if (work === undefined) {
+            work = { wakeSources: new Map(), goal: null };
+            this.work.set(sessionID, work);
+        }
+        return work;
+    }
+    observe(s, ev) {
+        if (ev.name === WAKE_SOURCE_STATE_EVENT) {
+            const source = parseWakeSource(ev.data);
+            if (source === undefined)
+                return;
+            const work = this.state(s.info.id);
+            if (source.activeCount > 0)
+                work.wakeSources.set(source.source, source);
+            else
+                work.wakeSources.delete(source.source);
+            if (source.source === CODEMODE_WAKE_SOURCE)
+                delete work.evalList;
+            return;
+        }
+        if (!record(ev.data))
+            return;
+        if (ev.name === GOAL_TIMER_STATE_EVENT) {
+            const work = this.state(s.info.id);
+            const kind = nonEmpty(ev.data.kind);
+            const dueAtMs = finite(ev.data.dueAtMs);
+            work.goal =
+                ev.data.armed === true
+                    ? {
+                        armed: true,
+                        ...(kind !== undefined ? { kind } : {}),
+                        ...(dueAtMs !== undefined ? { dueAtMs } : {}),
+                        ...(work.goal?.wakeSources !== undefined ? { wakeSources: work.goal.wakeSources } : {}),
+                    }
+                    : null;
+        }
+        else if (ev.name === GOAL_SCHEDULED_EVENT && record(ev.data.wakeSources)) {
+            const counts = Object.fromEntries(Object.entries(ev.data.wakeSources).filter((entry) => finite(entry[1]) !== undefined));
+            const work = this.state(s.info.id);
+            work.goal = { ...(work.goal ?? { armed: false }), wakeSources: counts };
+        }
+    }
+    /** The agent process exited: its in-process wake sources and timers died with it. */
+    stopParent(sessionID) {
+        this.work.delete(sessionID);
+    }
+    async snapshot(s) {
+        const work = this.work.get(s.info.id);
+        const live = s.pi !== undefined;
+        const cells = live ? await this.listEvalCells(s) : undefined;
+        const sessionFile = s.piPath ?? s.restored?.piPath;
+        const piSessionId = s.piSessionId ?? s.restored?.piSessionId;
+        const codemode = work?.wakeSources.get(CODEMODE_WAKE_SOURCE);
+        return {
+            version: 1,
+            sessionID: s.info.id,
+            live,
+            generatedAt: Date.now(),
+            todo: s.todoBridge?.phases ?? [],
+            monitors: this.monitors.list(s.info.id, MAX_ENDED_MONITORS, MAX_MONITOR_LINES),
+            // Without the list, the live cells the wake source names are still worth showing.
+            evalCells: cells ??
+                (codemode?.items ?? []).map((item) => ({
+                    cellId: item.id,
+                    state: "running",
+                    startedAtMs: item.startedAtMs,
+                    summary: item.description,
+                })),
+            evalCellsListed: cells !== undefined,
+            background: sessionFile && piSessionId ? readBackgroundSessions(sessionFile, piSessionId) : [],
+            goal: work?.goal ?? null,
+            wakeSources: [...(work?.wakeSources.values() ?? [])].filter((source) => source.source !== CODEMODE_WAKE_SOURCE && source.source !== "terminal-monitors"),
+        };
+    }
+    listEvalCells(s) {
+        const work = this.state(s.info.id);
+        const now = Date.now();
+        if (work.evalList !== undefined && now - work.evalList.at < EVAL_LIST_TTL_MS)
+            return work.evalList.cells;
+        const cells = this.evalCommand(s, { type: "eval_cells.list" }).then((data) => (Array.isArray(data) ? data.flatMap((cell) => parseEvalCell(cell) ?? []) : undefined), () => undefined);
+        work.evalList = { at: now, cells };
+        return cells;
+    }
+    async peekEvalCell(s, cellId, tailBytes) {
+        const bytes = Math.max(0, Math.min(MAX_PEEK_BYTES, Math.trunc(tailBytes)));
+        const data = await this.evalCommand(s, { type: "eval_cells.peek", cellId, tailBytes: bytes });
+        if (!record(data))
+            throw new WorkStatusError(502, "OmO answered eval_cells.peek without a cell");
+        return data;
+    }
+    async stopEvalCell(s, cellId) {
+        const data = await this.evalCommand(s, { type: "eval_cells.stop", cellId });
+        const work = this.work.get(s.info.id);
+        if (work !== undefined)
+            delete work.evalList;
+        if (!record(data))
+            throw new WorkStatusError(502, "OmO answered eval_cells.stop without a cell");
+        return data;
+    }
+    async fireGoalContinuation(s) {
+        const pi = s.pi;
+        if (pi === undefined)
+            throw new WorkStatusError(409, "The agent is not running");
+        const reply = await pi.command({ type: "extension_request", name: GOAL_FIRE_NOW_REQUEST, data: {} }, EVAL_RPC_TIMEOUT_MS);
+        if (!reply.success)
+            throw new WorkStatusError(409, reply.error ?? "OmO refused to fire the goal continuation");
+    }
+    async evalCommand(s, command) {
+        const pi = s.pi;
+        if (pi === undefined)
+            throw new WorkStatusError(409, "The agent is not running");
+        const reply = await pi.command(command, EVAL_RPC_TIMEOUT_MS);
+        if (reply.success)
+            return reply.data;
+        const code = reply.errorCode;
+        if (code === "eval_cell_not_found")
+            throw new WorkStatusError(404, reply.error ?? "Unknown eval cell");
+        if (code === "invalid_eval_cell_request")
+            throw new WorkStatusError(400, reply.error ?? "Invalid eval cell request");
+        throw new WorkStatusError(409, reply.error ?? `OmO refused ${command.type}`);
+    }
+}
+const SESSION_ID = /^ses_[0-9A-Za-z]+$/;
+const CELL_ID = /^[\w.:-]{1,128}$/;
+const DEFAULT_PEEK_BYTES = 8 * 1024;
+/**
+ * `/antechamber/work-status/<session>` and its actions. These are antechamber's own routes, not
+ * OpenCode's: the OmO Work extension service authenticates with the run-record token.
+ */
+export async function handleWorkStatus(sessions, req, res, url, method) {
+    const [sessionID, kind, target, action] = url.pathname
+        .slice("/antechamber/work-status/".length)
+        .split("/")
+        .map((part) => decodeURIComponent(part));
+    if (sessionID === undefined || !SESSION_ID.test(sessionID)) {
+        json(res, 400, errorBody("BadRequestError", "Expected /antechamber/work-status/<session id>"));
+        return;
+    }
+    const s = sessions.get(sessionID);
+    if (s === undefined) {
+        json(res, 404, errorBody("NotFoundError", `Session not found: ${sessionID}`));
+        return;
+    }
+    try {
+        if (kind === undefined && method === "GET") {
+            json(res, 200, await sessions.workStatus.snapshot(s));
+            return;
+        }
+        if (kind === "eval" && target !== undefined && CELL_ID.test(target)) {
+            if (action === undefined && method === "GET") {
+                const tail = Number(url.searchParams.get("tailBytes") ?? DEFAULT_PEEK_BYTES);
+                json(res, 200, await sessions.workStatus.peekEvalCell(s, target, Number.isFinite(tail) ? tail : DEFAULT_PEEK_BYTES));
+                return;
+            }
+            if (action === "stop" && method === "POST") {
+                req.resume();
+                json(res, 200, await sessions.workStatus.stopEvalCell(s, target));
+                return;
+            }
+        }
+        if (kind === "goal" && target === "fire" && action === undefined && method === "POST") {
+            req.resume();
+            await sessions.workStatus.fireGoalContinuation(s);
+            res.writeHead(204).end();
+            return;
+        }
+        json(res, 404, errorBody("NotFoundError", `Unknown work-status route: ${method} ${url.pathname}`));
+    }
+    catch (error) {
+        if (!(error instanceof WorkStatusError))
+            throw error;
+        json(res, error.status, errorBody(error.name, error.message));
+    }
+}

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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.0",
+  "version": "1.0.2",
   "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

@@ -0,0 +1,91 @@
+# OmO Work: OpenChamber extension
+
+An **OmO Work** section in OpenChamber's Work Status panel, for the background
+work of the session you are looking at. It ships with
+[antechamber](../../README.md) and needs OpenChamber **2.3.2 or newer** (web or
+desktop). OpenChamber 1.x has no extension sections, and VS Code and mobile
+load no extensions.
+
+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.
+
+The section sizes itself to its content, up to OpenChamber's 320 px limit, and
+scrolls inside beyond that.
+
+## Install
+
+In OpenChamber, open **Settings → Extensions → Add**:
+
+- **Folder**, when OpenChamber runs on the machine where antechamber is
+  installed: the path `antechamber setup` prints,
+  `$(npm root -g)/antechamber/extensions/omo-work` for npm installs or
+  `<checkout>/extensions/omo-work` after `npm run build`.
+- **URL**:
+  `https://github.com/eliottness/antechamber/releases/latest/download/antechamber-omo-work.zip`.
+- **ZIP file**: the same archive, or
+  `npm run build && npm run pack:work-extension -- antechamber-omo-work.zip`.
+
+Approve its **local service**. The section then appears in the Work Status
+panel; the panel's sections dialog can hide or reorder it.
+
+## Requirements
+
+- antechamber with the `/antechamber/work-status` routes (the release that
+  added this extension or newer), running as OpenChamber's OpenCode server.
+  After upgrading antechamber, restart OpenChamber so it runs the new adapter;
+  `antechamber doctor` reports the running version.
+- The extension service runs on the OpenChamber host and reads antechamber's
+  run records, so antechamber must run on the same machine.
+
+## How it works
+
+```
+section (sandboxed iframe) --serviceRequest /status?session=ses_...--> OpenChamber host
+                                                                     | loopback + host token
+                                                                     v
+                              service/main.js --Bearer <run token>--> antechamber
+                              reads <state dir>/run/<pid>.json        /antechamber/work-status/<session>
+```
+
+`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/architecture.md](../../docs/architecture.md#omo-work-status-section) for
+where each piece of data comes from in OmO.
+
+The state directory defaults to `~/.config/antechamber`, then
+`~/.config/openchamber-pi-connector`. OpenChamber starts extension services
+with a minimal environment, so if your deployment sets `ANTECHAMBER_STATE_DIR`,
+enter the same path under **Data path** in the section header. It is saved in
+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.
+
+## Development
+
+From the repository root: `npm run build:extension` bundles `src/status.ts`
+into `status/main.js` (browser IIFE) and `src/service-main.ts` into
+`service/main.js` (Node ESM); `npm test`, `npm run typecheck`, `npm run lint`
+and `npm run format:check` cover it. `src/model.ts` imports the snapshot types
+from the adapter (`src/work-status.ts`), so a shape change on either side fails
+the typecheck.

package/extensions/omo-work/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "antechamber-omo-work",
+  "version": "1.0.2",
+  "description": "OpenChamber 2.x Work Status section: OmO todo phases, monitors, eval cells and background work of the current session",
+  "private": true,
+  "type": "module",
+  "license": "MIT",
+  "openchamber": {
+    "apiVersion": 1,
+    "engines": {
+      "openchamber": ">=2.3.2"
+    },
+    "contributes": {
+      "panel": {
+        "id": "omo-work",
+        "name": "OmO Work",
+        "icon": "list-check-3"
+      },
+      "statusSection": {
+        "entry": "status/index.html",
+        "title": "OmO Work",
+        "height": 120
+      },
+      "service": {
+        "entry": "service/main.js",
+        "runtime": "host"
+      }
+    }
+  }
+}