antechamber 1.0.23 → 1.0.25

package/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.25] - 2026-10-27
+
+### Added
+
+- Show OmO's background work as background commands in OpenChamber 2.x. While a terminal monitor, a detached eval
+  cell or a background terminal session runs, the session reads as working ("Background command") after its turn
+  ends, the turn timer keeps running, and the commands are listed above the composer with their output (work no card
+  started, such as a watch a revived agent restored, is listed after a reload). Stop works
+  for eval cells; OmO offers no way to stop a monitor or a background terminal session, so their Stop fails without
+  telling the agent anything. A card that left such work running now settles at once and follows the command, as
+  OpenCode's own background calls do.
+
+### Changed
+
+- The OmO Work section no longer lists monitors, eval cells or background terminal sessions, which OpenChamber now
+  shows itself. It keeps the todo list, the goal timer and other activity.
+
+## [1.0.24] - 2026-10-27
+
+### Fixed
+
+- Keep each reply in its own turn in OpenChamber 2.x after history is reloaded. A reply's request can start a few
+  milliseconds before OmO writes its prompt, so a restored reply sorted ahead of its prompt: the first turn's replies
+  vanished and each later turn's first reply was drawn in the turn before.
+
 ## [1.0.23] - 2026-10-27
 
 ### Fixed

package/dist/background-results.d.ts

@@ -27,14 +27,14 @@ interface Final {
     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;
+export declare function holdForBackground(part: OCToolPart, waits: string[], final: Final, agentStartedAtMs?: number): 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;
+export declare function completeBackgroundEval(messages: readonly OCMessageWithParts[], result: BackgroundResult, completed: number, agentStartedAtMs?: 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;
+export declare function finishToolPart(part: OCToolPart, result: ToolResult, callID: string, at: number, agentStartedAtMs?: 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

package/dist/background-results.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { resultMetadata, resultText, toolFailed } from "./tool-map.js";
+import { evalShellId, terminalShellId } from "./omo-shells.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")
@@ -77,17 +78,34 @@ function waitsOf(part) {
     const waits = part.state.status === "running" ? part.state.metadata?.backgroundWaits : undefined;
     return Array.isArray(waits) ? waits.filter((id) => typeof id === "string") : [];
 }
+/**
+ * The OpenCode shell (omo-shells.ts) a card stands for while its work runs: the detached cell itself, else the
+ * first background session it launched. OpenChamber 2.x ties one shell to a card.
+ */
+function backgroundShellID(callID, waits, agentStartedAtMs) {
+    if (waits.includes(callID))
+        return evalShellId(callID);
+    const shell = waits.find((id) => /^bash_\d+$/.test(id));
+    return shell !== undefined && agentStartedAtMs !== undefined ? terminalShellId(agentStartedAtMs, shell) : undefined;
+}
 /** Keep a finished card running, with its result already shown, until `waits` report finishing. */
-export function holdForBackground(part, waits, final) {
+export function holdForBackground(part, waits, final, agentStartedAtMs) {
     const state = part.state;
     if (state.status === "pending" || waits.length === 0)
         return;
     const title = state.status === "running" || state.status === "completed" ? state.title : undefined;
+    const shellID = backgroundShellID(part.callID, waits, agentStartedAtMs);
     part.state = {
         status: "running",
         input: state.input,
         ...(title !== undefined ? { title } : {}),
-        metadata: { ...state.metadata, output: final.output, backgroundWaits: waits, backgroundFailed: final.failed },
+        metadata: {
+            ...state.metadata,
+            output: final.output,
+            backgroundWaits: waits,
+            backgroundFailed: final.failed,
+            ...(shellID !== undefined ? { backgroundShellID: shellID } : {}),
+        },
         time: { start: state.time.start },
     };
 }
@@ -95,7 +113,7 @@ 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 { backgroundWaits: _waits, backgroundFailed: _failed, backgroundShellID: _shell, 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
@@ -145,7 +163,7 @@ export function settleBackground(messages, at) {
     }
     return changed;
 }
-export function completeBackgroundEval(messages, result, completed) {
+export function completeBackgroundEval(messages, result, completed, agentStartedAtMs) {
     if (result.kind !== "eval")
         return undefined;
     for (const message of messages) {
@@ -160,7 +178,7 @@ export function completeBackgroundEval(messages, result, completed) {
         ];
         const remaining = [...new Set(waits)];
         if (part.state.status !== "pending" && remaining.length > 0) {
-            holdForBackground(part, remaining, final);
+            holdForBackground(part, remaining, final, agentStartedAtMs);
         }
         else
             finish(part, final, completed);
@@ -169,14 +187,16 @@ export function completeBackgroundEval(messages, result, completed) {
     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) {
+export function finishToolPart(part, result, callID, at, agentStartedAtMs) {
     const state = part.state;
     const text = resultText(result.content);
     const commands = backgroundCommands(result);
+    const monitor = monitorShellID(part, result, agentStartedAtMs);
     const metadata = {
         ...(state.status !== "pending" ? state.metadata : {}),
         ...resultMetadata(part.tool, result),
         ...commands,
+        ...(monitor !== undefined ? { backgroundShellID: monitor } : {}),
     };
     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;
@@ -186,7 +206,19 @@ export function finishToolPart(part, result, callID, at) {
         : { 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 });
+        holdForBackground(part, waits, { output: text, failed }, agentStartedAtMs);
+}
+/**
+ * A `monitor` call returns at once with the watch's terminal id: `details: {monitor_id, bash_id, monitor: true}`
+ * (senpi core/extensions/builtin/terminal/tools/monitor.js, installed 2026-10-27).
+ */
+function monitorShellID(part, result, agentStartedAtMs) {
+    if (part.tool !== "monitor" || toolFailed(result) || agentStartedAtMs === undefined)
+        return undefined;
+    const details = result.details;
+    if (details === null || typeof details !== "object" || !("bash_id" in details))
+        return undefined;
+    return typeof details.bash_id === "string" ? terminalShellId(agentStartedAtMs, details.bash_id) : undefined;
 }
 /**
  * OmO persists these notifications but sends no entry_appended frame for them, so the live

package/dist/lifecycle.js

@@ -109,6 +109,8 @@ export class SessionLifecycle {
         }
         s.unwirePi?.();
         s.pi = undefined; // Old exit listeners must not mutate a revived session.
+        // Unwired, the exit handler will not run: end what died with the process here.
+        s.onDormant?.();
         const disposing = pi.dispose();
         this.disposing.add(disposing);
         try {

package/dist/monitor-sessions.d.ts

@@ -41,6 +41,13 @@ export declare class MonitorSessions {
     constructor(sessions: Map<string, ManagedSession>, emit: (directory: string, event: OCEvent) => void);
     wire(parent: ManagedSession): void;
     owns(id: string): boolean;
+    /** Matched lines of a parent's watch received after the first `seen`, as far as they are still kept. */
+    linesSince(parentID: string, terminalId: string, seen: number): {
+        lines: string[];
+        total: number;
+    } | undefined;
+    /** OmO's terminal id (`bash_N`) of a child's watch while it runs. */
+    terminalId(id: string): string | undefined;
     /** A parent's watches, live first then the newest ended ones, with their latest matched lines. */
     list(parentID: string, maxEnded: number, maxLines: number): MonitorView[];
     messages(id: string): OCMessageWithParts[];

package/dist/monitor-sessions.js

@@ -88,6 +88,19 @@ export class MonitorSessions {
     owns(id) {
         return this.watches.has(id);
     }
+    /** Matched lines of a parent's watch received after the first `seen`, as far as they are still kept. */
+    linesSince(parentID, terminalId, seen) {
+        const watch = this.watches.get(ocIdFor(`${parentID}/monitor/${terminalId}`));
+        if (watch === undefined)
+            return undefined;
+        const fresh = Math.max(0, watch.lineCount - seen);
+        return { lines: fresh === 0 ? [] : watch.lines.slice(-fresh), total: watch.lineCount };
+    }
+    /** OmO's terminal id (`bash_N`) of a child's watch while it runs. */
+    terminalId(id) {
+        const watch = this.watches.get(id);
+        return watch !== undefined && watch.ending === undefined ? watch.monitor.id : undefined;
+    }
     /** A parent's watches, live first then the newest ended ones, with their latest matched lines. */
     list(parentID, maxEnded, maxLines) {
         const watches = [...this.watches.values()].filter((watch) => watch.session.info.parentID === parentID);
@@ -131,6 +144,7 @@ export class MonitorSessions {
             if (!watch)
                 continue;
             watch.lines = [...watch.lines, ...lines].slice(-MAX_EVENT_LINES);
+            watch.lineCount += lines.length;
             this.publish(watch);
         }
     }
@@ -251,7 +265,7 @@ export class MonitorSessions {
             hasPendingInteraction: () => false,
             hasRunningChildren: () => false,
         };
-        const watch = { session, monitor, lines: [] };
+        const watch = { session, monitor, lines: [], lineCount: 0 };
         this.watches.set(id, watch);
         this.sessions.set(id, session);
         this.emit(session.info.directory, { type: "session.created", properties: { info: session.info } });

package/dist/omo-shells.d.ts

@@ -0,0 +1,80 @@
+/**
+ * OmO background work as OpenCode 2.x shells, so OpenChamber 2.x shows it the way it shows OpenCode's
+ * own background commands: the session reads as working ("Background command") while its turn is idle,
+ * the turn timer holds, the chat lists the commands with their output, and a turn's card follows its
+ * command. OpenChamber derives all of it from `GET /api/shell` and the `shell.created` / `shell.exited`
+ * events, keyed by `metadata.sessionID` (packages/ui/src/sync/background-shells.ts and
+ * global-session-status.ts, OpenChamber 2.5.2).
+ *
+ * Sources, all already followed for idle eviction and the OmO Work section:
+ * - terminal monitors (`terminal_monitor_state`, monitor-sessions.ts);
+ * - background terminal sessions (the terminal manifest, work-status.ts `readBackgroundSessions`);
+ * - detached eval cells (the codemode wake source, work-status.ts).
+ *
+ * Monitors and background sessions share OmO's `bash_N` numbering, which restarts with each agent
+ * process, so their shell id carries the process start: `sh_t<start base36>_<bash_N>`. Eval cells are
+ * keyed by their cell id, which is the eval tool call's id: `sh_e_<cellId>`. OpenCode's schema requires
+ * the `sh_` prefix (Shell.ID).
+ */
+import type { MonitorSessions } from "./monitor-sessions.js";
+import type { ManagedSession } from "./sessions.js";
+import type { BackgroundResult } from "./background-results.js";
+import type { OCEvent, OCShellInfo } from "./types.js";
+import { type WorkStatusBridge } from "./work-status.js";
+/** Metadata key OpenChamber puts on the note it sends before stopping commands (background-shell.ts). */
+export declare const SHELL_CANCELLATION_KEY = "openchamberShellCancellation";
+export type OmoShellKind = "monitor" | "background" | "eval";
+export declare function terminalShellId(agentStartedAtMs: number, bashId: string): string;
+export declare function evalShellId(cellId: string): string;
+export interface ShellOutputPage {
+    output: string;
+    cursor: number;
+    size: number;
+    truncated: boolean;
+}
+/**
+ * Turns successive windows of a growing text (OmO only ever exposes a tail) into the append-only byte
+ * stream OpenCode's `cursor` reads. A window continues the known output where the known output's end
+ * matches the window's start; a window that shares nothing with it is appended whole.
+ */
+export declare class OutputLog {
+    private bytes;
+    /** Absolute offset of `bytes[0]`. */
+    private start;
+    get size(): number;
+    update(window: string): void;
+    /** Text known to follow what is already logged (a source that reports increments, not tails). */
+    append(text: string): void;
+    private add;
+    /** Bytes at the start of `next` that the known output already ends with: the longest such overlap. */
+    private overlap;
+    /** Pages end on a character boundary, so a client that decodes each page alone never splits one. */
+    read(cursor: number, limit: number): ShellOutputPage;
+}
+export declare class OmoShells {
+    private readonly sessions;
+    private readonly monitors;
+    private readonly work;
+    private readonly emit;
+    private readonly live;
+    private readonly ended;
+    constructor(sessions: Map<string, ManagedSession>, monitors: MonitorSessions, work: WorkStatusBridge, emit: (directory: string, event: OCEvent) => void);
+    sync(s: ManagedSession): void;
+    /** OmO's finished notification for a background session or a cell: keep its status for the shell's end. */
+    noteEnding(s: ManagedSession, result: BackgroundResult): void;
+    /** The agent process exited, or the session was removed: everything it ran is gone. */
+    stopParent(sessionID: string): void;
+    list(directory: string): OCShellInfo[];
+    get(id: string): OCShellInfo | undefined;
+    /** Only eval cells can be stopped: OmO registers no RPC request to stop a monitor or a background session. */
+    stoppable(id: string): boolean;
+    output(id: string, cursor: number | undefined, limit: number | undefined): Promise<ShellOutputPage | undefined>;
+    /** Stop a running eval cell through codemode; the cell's own completion then ends the shell. */
+    stop(id: string): Promise<void>;
+    private desired;
+    private start;
+    private end;
+    /** Lines matched since the last read, counted, so a sliding window of matched lines never repeats. */
+    private appendLines;
+    private refreshOutput;
+}

package/dist/omo-shells.js

@@ -0,0 +1,333 @@
+import { readBackgroundSessions, WorkStatusError } from "./work-status.js";
+/** Metadata key OpenChamber puts on the note it sends before stopping commands (background-shell.ts). */
+export const SHELL_CANCELLATION_KEY = "openchamberShellCancellation";
+/** Ended shells kept for `GET /api/shell/:id` and their output; OpenCode keeps 25 per directory. */
+const MAX_ENDED = 25;
+/** Output kept per shell; older bytes are dropped and reported as skipped. */
+const MAX_OUTPUT_BYTES = 256 * 1024;
+/** codemode's own peek cap (senpi-codemode src/extension/eval-cells-rpc.ts MAX_TAIL_BYTES). */
+const EVAL_PEEK_BYTES = 64 * 1024;
+/** Leading bytes of a new window searched for in the known output to find where it continues it. */
+const PROBE_BYTES = 32;
+const MAX_MONITOR_LINES = 200;
+const BACKGROUND_NOTICE = "OmO does not expose a background terminal session's output to antechamber; the agent reads it with bash_output.\n";
+export function terminalShellId(agentStartedAtMs, bashId) {
+    return `sh_t${Math.trunc(agentStartedAtMs).toString(36)}_${bashId}`;
+}
+export function evalShellId(cellId) {
+    return `sh_e_${cellId}`;
+}
+/**
+ * Turns successive windows of a growing text (OmO only ever exposes a tail) into the append-only byte
+ * stream OpenCode's `cursor` reads. A window continues the known output where the known output's end
+ * matches the window's start; a window that shares nothing with it is appended whole.
+ */
+export class OutputLog {
+    bytes = Buffer.alloc(0);
+    /** Absolute offset of `bytes[0]`. */
+    start = 0;
+    get size() {
+        return this.start + this.bytes.length;
+    }
+    update(window) {
+        const next = Buffer.from(window, "utf8");
+        this.add(next.subarray(this.overlap(next)));
+    }
+    /** Text known to follow what is already logged (a source that reports increments, not tails). */
+    append(text) {
+        this.add(Buffer.from(text, "utf8"));
+    }
+    add(added) {
+        if (added.length === 0)
+            return;
+        this.bytes = Buffer.concat([this.bytes, added]);
+        const excess = this.bytes.length - MAX_OUTPUT_BYTES;
+        if (excess > 0) {
+            this.bytes = this.bytes.subarray(excess);
+            this.start += excess;
+        }
+    }
+    /** Bytes at the start of `next` that the known output already ends with: the longest such overlap. */
+    overlap(next) {
+        const known = this.bytes;
+        const from = Math.max(0, known.length - next.length);
+        const probe = next.subarray(0, Math.min(PROBE_BYTES, next.length));
+        const matches = (at) => known.subarray(at).equals(next.subarray(0, known.length - at));
+        if (probe.length === 0)
+            return 0;
+        for (let at = known.indexOf(probe, from); at !== -1; at = known.indexOf(probe, at + 1)) {
+            if (matches(at))
+                return known.length - at;
+        }
+        // Overlaps shorter than the probe cannot be found by indexOf.
+        for (let at = Math.max(from, known.length - probe.length + 1); at < known.length; at++) {
+            if (matches(at))
+                return known.length - at;
+        }
+        return 0;
+    }
+    /** Pages end on a character boundary, so a client that decodes each page alone never splits one. */
+    read(cursor, limit) {
+        const size = this.size;
+        const continuation = (at) => at < size && ((this.bytes[at - this.start] ?? 0) & 0xc0) === 0x80;
+        let from = Math.min(Math.max(cursor, this.start), size);
+        while (continuation(from))
+            from++;
+        let to = Math.min(size, from + limit);
+        while (to > from && continuation(to))
+            to--;
+        // A limit smaller than the next character still returns that whole character.
+        if (to === from && from < size) {
+            to = from + 1;
+            while (continuation(to))
+                to++;
+        }
+        return {
+            output: this.bytes.subarray(from - this.start, to - this.start).toString("utf8"),
+            cursor: to,
+            size,
+            truncated: cursor < this.start,
+        };
+    }
+}
+function monitorHeader(view) {
+    const { monitor } = view;
+    const filter = monitor.filter !== null ? `filter: ${monitor.filter}\n` : "";
+    return `$ ${monitor.command ?? monitor.description}\n${filter}\n`;
+}
+/**
+ * How OmO says a background session or a detached cell finished (background-results.ts `backgroundResult`):
+ * "bash_2 finished: killed (exit code 1)". A failed cell has no exit code; it reads as exit 1.
+ */
+function resultEnd(result) {
+    if (result.kind === "eval")
+        return result.failed ? { status: "exited", exit: 1 } : { status: "exited", exit: 0 };
+    const status = result.title.slice(result.title.indexOf("finished:") + "finished:".length);
+    const exit = /exit code (-?\d+)/.exec(status)?.[1];
+    const code = exit !== undefined ? { exit: Number(exit) } : {};
+    if (/\bkill|signal/i.test(status))
+        return { status: "killed", ...code };
+    if (/time(d)? ?out/i.test(status))
+        return { status: "timeout", ...code };
+    return { status: "exited", ...code };
+}
+function endStatus(view) {
+    switch (view?.ending?.reason) {
+        case "exit":
+            return view.ending.exitCode === null ? { status: "exited" } : { status: "exited", exit: view.ending.exitCode };
+        case "timeout":
+            return { status: "timeout" };
+        case "killed":
+        case "agent-exit":
+            return { status: "killed" };
+        default:
+            return { status: "exited" };
+    }
+}
+export class OmoShells {
+    sessions;
+    monitors;
+    work;
+    emit;
+    live = new Map();
+    ended = new Map();
+    constructor(sessions, monitors, work, emit) {
+        this.sessions = sessions;
+        this.monitors = monitors;
+        this.work = work;
+        this.emit = emit;
+    }
+    sync(s) {
+        const desired = this.desired(s);
+        const now = Date.now();
+        for (const [id, tracked] of this.live) {
+            if (tracked.info.metadata.sessionID !== s.info.id || desired.has(id))
+                continue;
+            const view = tracked.kind === "monitor"
+                ? this.monitors.list(s.info.id, Number.MAX_SAFE_INTEGER, 0).find((item) => item.monitor.id === tracked.source)
+                : undefined;
+            this.end(id, tracked, tracked.ending ?? endStatus(view), now);
+        }
+        for (const [id, want] of desired) {
+            const tracked = this.live.get(id);
+            if (tracked === undefined)
+                this.start(s, id, want);
+            else if (tracked.kind === "monitor")
+                this.appendLines(s.info.id, tracked);
+        }
+    }
+    /** OmO's finished notification for a background session or a cell: keep its status for the shell's end. */
+    noteEnding(s, result) {
+        const epoch = s.pi?.startedAtMs;
+        const id = result.kind === "eval"
+            ? evalShellId(result.callID)
+            : epoch !== undefined
+                ? terminalShellId(epoch, result.callID)
+                : undefined;
+        const tracked = id !== undefined ? this.live.get(id) : undefined;
+        if (tracked !== undefined)
+            tracked.ending ??= resultEnd(result);
+    }
+    /** The agent process exited, or the session was removed: everything it ran is gone. */
+    stopParent(sessionID) {
+        const now = Date.now();
+        for (const [id, tracked] of this.live) {
+            if (tracked.info.metadata.sessionID === sessionID)
+                this.end(id, tracked, { status: "killed" }, now);
+        }
+    }
+    list(directory) {
+        for (const s of this.sessions.values())
+            if (s.info.directory === directory && s.pi !== undefined)
+                this.sync(s);
+        return [...this.live.values()]
+            .filter((tracked) => tracked.directory === directory)
+            .map((tracked) => tracked.info)
+            .sort((a, b) => a.time.started - b.time.started || a.id.localeCompare(b.id));
+    }
+    get(id) {
+        return (this.live.get(id) ?? this.ended.get(id))?.info;
+    }
+    /** Only eval cells can be stopped: OmO registers no RPC request to stop a monitor or a background session. */
+    stoppable(id) {
+        return this.live.get(id)?.kind === "eval";
+    }
+    async output(id, cursor, limit) {
+        const tracked = this.live.get(id) ?? this.ended.get(id);
+        if (tracked === undefined)
+            return undefined;
+        if (this.live.has(id))
+            await this.refreshOutput(tracked);
+        return tracked.output.read(cursor ?? 0, limit ?? Number.MAX_SAFE_INTEGER);
+    }
+    /** Stop a running eval cell through codemode; the cell's own completion then ends the shell. */
+    async stop(id) {
+        const tracked = this.live.get(id);
+        const s = tracked && this.sessions.get(tracked.info.metadata.sessionID);
+        if (tracked === undefined || s === undefined)
+            throw new WorkStatusError(404, `Unknown shell: ${id}`);
+        if (tracked.kind !== "eval")
+            throw new WorkStatusError(400, "OmO cannot stop a monitor or a background terminal session over RPC");
+        await this.work.stopEvalCell(s, tracked.source);
+        tracked.ending = { status: "killed" };
+        this.sync(s);
+    }
+    desired(s) {
+        const out = new Map();
+        const epoch = s.pi?.startedAtMs;
+        if (s.pi === undefined || epoch === undefined)
+            return out;
+        for (const view of this.monitors.list(s.info.id, 0, MAX_MONITOR_LINES)) {
+            if (view.ending !== undefined)
+                continue;
+            const { monitor } = view;
+            out.set(terminalShellId(epoch, monitor.id), {
+                kind: "monitor",
+                source: monitor.id,
+                command: monitor.command ?? monitor.description,
+                startedAtMs: monitor.startedAtMs,
+                monitor: view,
+            });
+        }
+        if (s.piPath !== undefined && s.piSessionId !== undefined) {
+            // Same rule as idle eviction (work-status.ts `wire`): a leftover entry of an earlier process is not ours.
+            for (const shell of readBackgroundSessions(s.piPath, s.piSessionId)) {
+                if (shell.pid === undefined || shell.startedAtMs < epoch)
+                    continue;
+                out.set(terminalShellId(epoch, shell.id), {
+                    kind: "background",
+                    source: shell.id,
+                    command: shell.command,
+                    startedAtMs: shell.startedAtMs,
+                });
+            }
+        }
+        for (const cell of this.work.liveCells(s.info.id)) {
+            out.set(evalShellId(cell.id), {
+                kind: "eval",
+                source: cell.id,
+                command: `eval: ${cell.description}`,
+                startedAtMs: cell.startedAtMs,
+            });
+        }
+        return out;
+    }
+    start(s, id, want) {
+        const info = {
+            id,
+            status: "running",
+            command: want.command,
+            cwd: s.info.directory,
+            shell: want.kind === "eval" ? "eval" : "bash",
+            file: "",
+            metadata: { sessionID: s.info.id, omo: { kind: want.kind, id: want.source } },
+            time: { started: want.startedAtMs },
+        };
+        const tracked = {
+            info,
+            directory: s.info.directory,
+            kind: want.kind,
+            source: want.source,
+            output: new OutputLog(),
+            seenLines: 0,
+        };
+        if (want.monitor !== undefined) {
+            tracked.output.append(monitorHeader(want.monitor));
+            this.appendLines(s.info.id, tracked);
+        }
+        else if (want.kind === "background")
+            tracked.output.append(BACKGROUND_NOTICE);
+        this.live.set(id, tracked);
+        this.ended.delete(id);
+        this.emit(tracked.directory, { type: "shell.created", properties: { info } });
+    }
+    end(id, tracked, end, at) {
+        this.live.delete(id);
+        tracked.info = {
+            ...tracked.info,
+            status: end.status,
+            ...(end.exit !== undefined ? { exit: end.exit } : {}),
+            time: { ...tracked.info.time, completed: at },
+        };
+        this.ended.set(id, tracked);
+        for (const key of this.ended.keys()) {
+            if (this.ended.size <= MAX_ENDED)
+                break;
+            this.ended.delete(key);
+        }
+        this.emit(tracked.directory, {
+            type: "shell.exited",
+            properties: { id, status: end.status, ...(end.exit !== undefined ? { exit: end.exit } : {}) },
+        });
+    }
+    /** Lines matched since the last read, counted, so a sliding window of matched lines never repeats. */
+    appendLines(parentID, tracked) {
+        const next = this.monitors.linesSince(parentID, tracked.source, tracked.seenLines);
+        if (next === undefined)
+            return;
+        if (next.lines.length > 0)
+            tracked.output.append(`${next.lines.join("\n")}\n`);
+        tracked.seenLines = next.total;
+    }
+    async refreshOutput(tracked) {
+        const s = this.sessions.get(tracked.info.metadata.sessionID);
+        if (s === undefined)
+            return;
+        if (tracked.kind === "monitor") {
+            this.appendLines(s.info.id, tracked);
+            return;
+        }
+        if (tracked.kind !== "eval")
+            return;
+        try {
+            const peek = await this.work.peekEvalCell(s, tracked.source, EVAL_PEEK_BYTES);
+            if (typeof peek.outputTail === "string")
+                tracked.output.update(peek.outputTail);
+        }
+        catch (error) {
+            // A cell that just settled, or a stopped agent: what is already known stays readable.
+            if (!(error instanceof WorkStatusError))
+                throw error;
+        }
+    }
+}

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

@@ -5,6 +5,7 @@ import type { SessionStore } from "./session-store.js";
 import { type SubagentBridge } from "./subagents.js";
 import { type MonitorSessions } from "./monitor-sessions.js";
 import type { WorkStatusBridge } from "./work-status.js";
+import { type OmoShells } from "./omo-shells.js";
 import { type TodoUpdated } from "./todo-bridge.js";
 export interface PiUsage {
     input?: number;
@@ -42,6 +43,7 @@ interface PiEventServices {
     readonly subagents: SubagentBridge;
     readonly monitors: MonitorSessions;
     readonly workStatus: Pick<WorkStatusBridge, "observe">;
+    readonly shells: Pick<OmoShells, "sync" | "noteEnding">;
     readonly store: Pick<SessionStore, "update">;
     readonly dirtyDiffs: Set<string>;
     readonly ensureMessages: (s: ManagedSession) => OCMessageWithParts[];