antechamber 1.0.14 → 1.0.16

package/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.16] - 2026-10-23
+
+### Fixed
+
+- Stop OmO Work's status poll from killing the agent. Its 10-second `eval_cells.list` lost the race with a large
+  session's cold start, the timeout stopped the agent, and the user's prompt failed with
+  `pi command "eval_cells.list" timed out` while the resend could not start a reply. OmO Work's eval cell requests
+  now fail alone on timeout; conversation operations still stop the agent, which keeps their order.
+- Say why the agent stopped whenever it stops on its own: a command timeout (which command, which deadline), a
+  broken pipe, an oversized frame, or a crash (exit code or signal). The transcript gets a notice card and the
+  interrupted reply carries the same error, instead of a bare `pi process exited (code=null)` toast or
+  "OpenCode did not start a reply". The notice survives an adapter restart until the next prompt.
+
+## [1.0.15] - 2026-10-23
+
+### Fixed
+
+- Stop reaping a session while detached eval cells are still running: idle eviction killed the agent process and
+  every cell in its kernels once the session had been quiet for `ANTECHAMBER_IDLE_TIMEOUT_MS`. A session now stays
+  live while senpi-codemode reports detached cells, and its idle window restarts when the last one settles.
+
 ## [1.0.14] - 2026-10-22
 
 ### Fixed

package/dist/lifecycle.js

@@ -56,6 +56,7 @@ export class SessionLifecycle {
             !s.hasPendingInteraction() &&
             !s.hasRunningChildren() &&
             !s.hasBackgroundWork?.() &&
+            !s.hasWakeSources?.() &&
             s.piSessionId !== undefined &&
             s.piPath !== undefined);
     }

package/dist/mcp.js

@@ -74,7 +74,7 @@ function liveSession(sessions, directory) {
     return s?.pi === undefined ? undefined : { s, pi: s.pi };
 }
 async function loadedServers(pi) {
-    const response = await pi.command({ type: "get_loaded_surfaces" }, undefined, AbortSignal.timeout(MCP_READ_WAIT_MS));
+    const response = await pi.probe({ type: "get_loaded_surfaces" }, undefined, AbortSignal.timeout(MCP_READ_WAIT_MS));
     // Older OmO builds have no loaded-surfaces RPC: report no servers rather than a failure.
     if (!response.success || !isRecord(response.data) || !Array.isArray(response.data.mcpServers))
         return [];
@@ -96,7 +96,7 @@ async function directoryServers(sessions, directory) {
     return live === undefined ? [] : loadedServers(live.pi).catch(() => []);
 }
 async function hasMcpCommand(pi) {
-    const response = await pi.command({ type: "get_commands" }, undefined, AbortSignal.timeout(MCP_READ_WAIT_MS));
+    const response = await pi.probe({ type: "get_commands" }, undefined, AbortSignal.timeout(MCP_READ_WAIT_MS));
     if (!response.success || !isRecord(response.data) || !Array.isArray(response.data.commands))
         return false;
     return response.data.commands.some((command) => isRecord(command) && command.name === "mcp" && command.source === "extension");

package/dist/pi-rpc.d.ts

@@ -35,6 +35,31 @@ export interface ProcessTable {
     identity(pid: number): ProcessIdentity | undefined;
     groupMembers(group: number): ProcessIdentity[];
 }
+/** Why the agent stopped without antechamber disposing it on purpose (eviction, delete, shutdown). */
+export type PiStopReason = {
+    readonly kind: "timeout";
+    readonly command: string;
+    readonly ms: number;
+} | {
+    readonly kind: "frame-overflow";
+} | {
+    readonly kind: "spawn";
+    readonly detail: string;
+} | {
+    readonly kind: "transport";
+    readonly detail: string;
+} | {
+    readonly kind: "exit";
+    readonly code: number | null;
+    readonly signal: string | null;
+};
+/** The user-facing explanation OpenChamber shows when the agent stops. */
+export declare function describeStop(reason: PiStopReason): string;
+/** Rejects every command pending when the agent stopped; the exit handler is what shows it to the user. */
+export declare class PiStoppedError extends Error {
+    readonly reason: PiStopReason;
+    constructor(reason: PiStopReason, cause?: Error);
+}
 export type PiRpcResponse<T = unknown> = {
     readonly id: string;
     readonly type: "response";
@@ -69,18 +94,25 @@ export declare class PiRpcClient extends EventEmitter {
     private closed;
     private stderrTail;
     private disposing;
+    private disposeRequested;
+    private stopped;
+    private outputClosed;
+    private sentSignals;
     private agentActive;
     private compacting;
     private sessionPath;
     get pid(): number | undefined;
     get isBusy(): boolean;
     get sessionFile(): string | undefined;
+    /** Set once the agent stopped for a reason other than a requested dispose; read it from exit listeners. */
+    get stopReason(): PiStopReason | undefined;
     onEvent(listener: (payload: Record<string, unknown>) => void): this;
     onExit(listener: (code: number | null, signal: string | null) => void): this;
     onExtensionUI(listener: (request: Record<string, unknown>) => void): this;
     constructor(options: PiRpcClientOptions);
     private drain;
     private frameOverflow;
+    private ownSignal;
     /** Node has reaped the leader, so its PID (and group ID) may already belong to another process. */
     private reaped;
     private closeForTransportFailure;
@@ -89,8 +121,14 @@ export declare class PiRpcClient extends EventEmitter {
     respondExtensionUI(response: Record<string, unknown>): void;
     private write;
     private failAll;
-    /** Send a command and wait for its correlated response. */
-    command<T = unknown>(cmd: Omit<PiRpcCommand, "id">, timeoutMs?: number, signal?: AbortSignal, onDispatch?: () => void): Promise<PiRpcResponse<T>>;
+    /**
+     * A read whose late answer changes nothing (status polls, listings): its timeout rejects only itself and
+     * the agent keeps running. OmO handles RPC lines concurrently, so anything that orders the conversation
+     * must use `command`, whose timeout stops the agent rather than let a late reply overlap the next operation.
+     */
+    probe<T = unknown>(cmd: Omit<PiRpcCommand, "id">, timeoutMs?: number, signal?: AbortSignal): Promise<PiRpcResponse<T>>;
+    /** Send a command and wait for its correlated response. A timeout stops the agent unless `stopOnTimeout` is false. */
+    command<T = unknown>(cmd: Omit<PiRpcCommand, "id">, timeoutMs?: number, signal?: AbortSignal, onDispatch?: () => void, stopOnTimeout?: boolean): Promise<PiRpcResponse<T>>;
     /** Fire-and-forget command (no response correlation). */
     notify(cmd: Omit<PiRpcCommand, "id">): void;
     dispose(): Promise<void>;

package/dist/pi-rpc.js

@@ -12,6 +12,7 @@ import { StringDecoder } from "node:string_decoder";
 import { EventEmitter } from "node:events";
 import { randomUUID } from "node:crypto";
 import { readdirSync, readFileSync } from "node:fs";
+import { constants as osConstants } from "node:os";
 import { systemClock } from "./lifecycle.js";
 import { agentBinary, envSetting } from "./config.js";
 export const RPC_COMMAND_TIMEOUT_MS = 60_000;
@@ -58,6 +59,44 @@ const procTable = {
             .filter((member) => member.group === group);
     },
 };
+function duration(ms) {
+    if (ms % 60_000 === 0)
+        return `${ms / 60_000} min`;
+    if (ms % 1_000 === 0)
+        return `${ms / 1_000} s`;
+    return `${ms} ms`;
+}
+/** The user-facing explanation OpenChamber shows when the agent stops. */
+export function describeStop(reason) {
+    const restart = "Anything in progress did not finish; send a message to start the agent again.";
+    switch (reason.kind) {
+        case "timeout":
+            return `antechamber stopped the agent: its "${reason.command}" command got no reply within ${duration(reason.ms)}. ${restart}`;
+        case "frame-overflow":
+            return `antechamber stopped the agent: it sent a JSONL frame over the ${MAX_JSONL_FRAME_BYTES}-byte limit. ${restart}`;
+        case "spawn":
+            return `antechamber could not run the agent (${reason.detail}). ${restart}`;
+        case "transport":
+            return `antechamber lost its connection to the agent (${reason.detail}) and stopped it. ${restart}`;
+        case "exit": {
+            const status = reason.code !== null
+                ? `exit code ${reason.code}`
+                : reason.signal !== null
+                    ? `signal ${reason.signal}`
+                    : "no status";
+            return `The agent exited unexpectedly (${status}). ${restart}`;
+        }
+    }
+}
+/** Rejects every command pending when the agent stopped; the exit handler is what shows it to the user. */
+export class PiStoppedError extends Error {
+    reason;
+    constructor(reason, cause) {
+        super(describeStop(reason), cause === undefined ? undefined : { cause });
+        this.reason = reason;
+        this.name = "AgentStoppedError";
+    }
+}
 export class PiRpcClient extends EventEmitter {
     options;
     proc;
@@ -68,6 +107,10 @@ export class PiRpcClient extends EventEmitter {
     closed = false;
     stderrTail = "";
     disposing;
+    disposeRequested = false;
+    stopped;
+    outputClosed = false;
+    sentSignals = new Set();
     agentActive = false;
     compacting = false;
     sessionPath;
@@ -80,6 +123,10 @@ export class PiRpcClient extends EventEmitter {
     get sessionFile() {
         return this.sessionPath;
     }
+    /** Set once the agent stopped for a reason other than a requested dispose; read it from exit listeners. */
+    get stopReason() {
+        return this.stopped;
+    }
     onEvent(listener) {
         return super.on("event", listener);
     }
@@ -120,7 +167,7 @@ export class PiRpcClient extends EventEmitter {
             this.stderrTail = (this.stderrTail + chunk.toString()).slice(-8192);
         });
         this.proc.stdin?.on("error", (error) => {
-            this.closeForTransportFailure(error);
+            this.closeForTransportFailure({ kind: "transport", detail: error.message }, error);
         });
         this.proc.stdout.on("data", (chunk) => {
             const text = typeof chunk === "string" ? chunk : this.decoder.write(chunk);
@@ -133,16 +180,26 @@ export class PiRpcClient extends EventEmitter {
             this.buffer += text;
             this.bufferBytes += Buffer.byteLength(text);
             this.drain();
-            this.closeForTransportFailure(new Error("pi process closed stdout"));
+            this.outputClosed = true;
+            this.closeForTransportFailure({ kind: "transport", detail: "the agent closed its output" });
         });
+        // ChildProcess "error": the binary could not be spawned, or signalling it failed.
         this.proc.on("error", (err) => {
-            this.closeForTransportFailure(err);
+            this.closeForTransportFailure({ kind: "spawn", detail: err.message }, err);
         });
         this.proc.on("exit", (code, signal) => {
             this.closed = true;
+            if (this.stopped === undefined && !this.disposeRequested)
+                this.stopped = { kind: "exit", code, signal };
+            // A crashing agent closes stdout just before it exits. Name the crash, not the closed pipe, unless the
+            // status comes from a signal antechamber sent while closing: OmO traps SIGTERM and exits 128 + 15.
+            else if (this.stopped?.kind === "transport" && this.outputClosed && !this.ownSignal(code, signal))
+                this.stopped = { kind: "exit", code, signal };
             console.error(`[pi-rpc] process exited code=${code} signal=${signal}` +
                 (envSetting("DEBUG") && this.stderrTail ? `\n[pi-rpc] stderr tail:\n${this.stderrTail}` : ""));
-            this.failAll(new Error(`pi exited (code=${code} signal=${signal})`));
+            this.failAll(this.stopped !== undefined
+                ? new PiStoppedError(this.stopped)
+                : new Error(`pi exited (code=${code} signal=${signal})`));
             this.emit("exit", code, signal);
         });
     }
@@ -170,26 +227,34 @@ export class PiRpcClient extends EventEmitter {
         }
     }
     frameOverflow() {
-        const error = new Error(`pi JSONL frame exceeded ${MAX_JSONL_FRAME_BYTES} bytes`);
+        this.stopped ??= { kind: "frame-overflow" };
         this.closed = true;
         this.buffer = "";
         this.bufferBytes = 0;
-        this.failAll(error);
+        this.failAll(new PiStoppedError(this.stopped));
         this.proc.stdout?.destroy();
         if (this.proc.pid === undefined)
             this.proc.kill("SIGKILL");
         else if (!this.reaped())
             process.kill(-this.proc.pid, "SIGKILL");
     }
+    ownSignal(code, signal) {
+        if (signal !== null)
+            return [...this.sentSignals].includes(signal);
+        if (code === null)
+            return true;
+        return [...this.sentSignals].some((sent) => code === 128 + osConstants.signals[sent]);
+    }
     /** Node has reaped the leader, so its PID (and group ID) may already belong to another process. */
     reaped() {
         return this.proc.exitCode !== null || this.proc.signalCode !== null;
     }
-    closeForTransportFailure(error) {
+    closeForTransportFailure(reason, cause) {
         if (this.closed)
             return;
         this.closed = true;
-        this.failAll(error);
+        this.stopped ??= reason;
+        this.failAll(new PiStoppedError(reason, cause));
         void this.dispose().catch((disposeError) => {
             const message = disposeError instanceof Error ? disposeError.message : String(disposeError);
             console.error(`[pi-rpc] failed to dispose after transport failure: ${message}`);
@@ -297,8 +362,16 @@ export class PiRpcClient extends EventEmitter {
             p.reject(err);
         this.pending.clear();
     }
-    /** Send a command and wait for its correlated response. */
-    command(cmd, timeoutMs, signal, onDispatch) {
+    /**
+     * A read whose late answer changes nothing (status polls, listings): its timeout rejects only itself and
+     * the agent keeps running. OmO handles RPC lines concurrently, so anything that orders the conversation
+     * must use `command`, whose timeout stops the agent rather than let a late reply overlap the next operation.
+     */
+    probe(cmd, timeoutMs, signal) {
+        return this.command(cmd, timeoutMs, signal, undefined, false);
+    }
+    /** Send a command and wait for its correlated response. A timeout stops the agent unless `stopOnTimeout` is false. */
+    command(cmd, timeoutMs, signal, onDispatch, stopOnTimeout = true) {
         if (this.closed)
             return Promise.reject(new Error("pi process is not running"));
         if (signal?.aborted)
@@ -323,8 +396,12 @@ export class PiRpcClient extends EventEmitter {
             const onAbort = () => {
                 rejectCommand(signal?.reason);
             };
-            const expire = (duration) => {
-                this.closeForTransportFailure(new Error(`pi command "${expectedCommand}" timed out after ${duration}ms`));
+            // A probe's late response finds no pending entry and is dropped.
+            const expire = (ms) => {
+                if (stopOnTimeout)
+                    this.closeForTransportFailure({ kind: "timeout", command: expectedCommand, ms });
+                else
+                    rejectCommand(new Error(`pi command "${expectedCommand}" timed out after ${ms}ms`));
             };
             const armDeadline = () => {
                 clearTimeout(timer);
@@ -356,6 +433,7 @@ export class PiRpcClient extends EventEmitter {
     async dispose() {
         if (this.disposing !== undefined)
             return this.disposing;
+        this.disposeRequested = true;
         this.closed = true;
         this.failAll(new Error("pi process disposed"));
         const pid = this.proc.pid;
@@ -366,6 +444,7 @@ export class PiRpcClient extends EventEmitter {
         const signal = (target, sig) => {
             try {
                 process.kill(target, sig);
+                this.sentSignals.add(sig);
             }
             catch (error) {
                 const code = error instanceof Error && "code" in error ? error.code : undefined;

package/dist/route-services.js

@@ -5,6 +5,7 @@ import { getAgentName, getExposedAgentNames } from "./agent-name.js";
 import { agentDefaults } from "./catalog.js";
 import { announceSessionError, parseShellCommand, parseSlashCommand, runShellCommand, runSlashCommand, } from "./session-commands.js";
 import { envSetting } from "./config.js";
+import { PiStoppedError } from "./pi-rpc.js";
 // This connector is not opencode — it only implements an OpenCode API subset.
 // OpenChamber reads /global/health's `version` as the installed opencode version
 // and offers an update when it trails the latest release. Advertising the SDK
@@ -55,6 +56,9 @@ export function promptAsync(services, session, text, model, noReply = false, mes
     void services.sessions
         .prompt(session.info.id, text, model, noReply, messageID, delivery, parts, metadata)
         .catch((error) => {
+        // The agent stopped: the session's exit handler already shows why, once.
+        if (error instanceof PiStoppedError)
+            return;
         announceSessionError({ sessions: services.sessions, session, emit: services.broadcast }, error instanceof Error ? error.name : "UnknownError", error instanceof Error ? error.message : String(error));
     });
 }

package/dist/session-commands.d.ts

@@ -26,6 +26,10 @@ type ShellUserMessage = OCMessageWithParts & {
     info: OCUserMessage;
     parts: [OCTextPart];
 };
+type ShareNoticeMessage = OCMessageWithParts & {
+    info: OCAssistantMessage;
+    parts: [OCTextPart];
+};
 type ShellExecution = {
     kind: "completed";
     message: ShellMessage;
@@ -79,6 +83,8 @@ export declare function runSlashCommand(sessions: SessionManager, sessionId: str
 export declare function parseShellCommand(value: unknown): string | undefined;
 export declare function createShellMessage(session: ManagedSession, command: string): ShellMessage;
 export declare function shellUserMessage(message: ShellMessage): ShellUserMessage;
+/** An adapter-authored notice card; `created` places a replayed notice at its original time. */
+export declare function noticeMessage(session: ManagedSession, messageText: string, error?: OCAssistantMessage["error"], created?: number): ShareNoticeMessage;
 export declare function announceSessionNotice(context: ShareNoticeContext, messageText: string, error?: OCAssistantMessage["error"]): void;
 export declare function announceSessionError(context: ShareNoticeContext, errorName: string, messageText: string): void;
 export declare function completeShellMessage(message: ShellMessage, command: string, result: ShellResult): void;

package/dist/session-commands.js

@@ -225,13 +225,12 @@ export function shellUserMessage(message) {
         ],
     };
 }
-export function announceSessionNotice(context, messageText, error) {
-    const { session, sessions, emit } = context;
-    if (!sessions.messages(session.info.id))
-        return;
+/** An adapter-authored notice card; `created` places a replayed notice at its original time. */
+export function noticeMessage(session, messageText, error, created) {
     const info = assistantMessage(session);
-    const created = info.time.created;
-    info.time.completed = created;
+    if (created !== undefined)
+        info.time.created = created;
+    info.time.completed = info.time.created;
     if (error)
         info.error = error;
     const part = {
@@ -240,9 +239,17 @@ export function announceSessionNotice(context, messageText, error) {
         messageID: info.id,
         type: "text",
         text: messageText,
-        time: { start: created, end: created },
+        time: { start: info.time.created, end: info.time.created },
     };
-    const message = { info, parts: [part] };
+    return { info, parts: [part] };
+}
+export function announceSessionNotice(context, messageText, error) {
+    const { session, sessions, emit } = context;
+    if (!sessions.messages(session.info.id))
+        return;
+    const message = noticeMessage(session, messageText, error);
+    const [part] = message.parts;
+    const { info } = message;
     sessions.appendMessage(session.info.id, message);
     emit(session.info.directory, { type: "message.updated", properties: { info } });
     emit(session.info.directory, { type: "message.part.updated", properties: { part } });

package/dist/session-store.d.ts

@@ -68,6 +68,11 @@ export interface SessionRegistryEntry {
         modelID: string;
         variant?: string;
     };
+    /** Why the agent last stopped on its own, shown again after a restart until the session runs again. */
+    lastStop?: {
+        message: string;
+        at: number;
+    };
     created: number;
     updated: number;
 }

package/dist/session-store.js

@@ -459,6 +459,12 @@ function registryEntry(value) {
     if (value.model !== undefined &&
         (!record(value.model) || typeof value.model.providerID !== "string" || typeof value.model.modelID !== "string"))
         return false;
+    if (value.lastStop !== undefined &&
+        (!record(value.lastStop) ||
+            typeof value.lastStop.message !== "string" ||
+            typeof value.lastStop.at !== "number" ||
+            !Number.isFinite(value.lastStop.at)))
+        return false;
     return true;
 }
 /**

package/dist/sessions.d.ts

@@ -73,6 +73,13 @@ export interface ManagedSession extends ThinkingState {
     hasRunningChildren: () => boolean;
     /** Live OmO background work (monitors) that keeps the agent process from idle eviction. */
     hasBackgroundWork?: () => boolean;
+    /** Live wake sources OmO publishes over RPC (detached eval cells), which also block idle eviction. */
+    hasWakeSources?: () => boolean;
+    /** Why the agent last stopped on its own; persisted and replayed as a notice until the next prompt. */
+    lastStop?: {
+        message: string;
+        at: number;
+    };
 }
 type EventSink = (directory: string, event: OCEvent | TodoUpdated) => void;
 export declare class SessionManager {
@@ -83,6 +90,8 @@ export declare class SessionManager {
     private operations;
     /** Connector-created session trees, including persisted ownership after restart. */
     private createdSessions;
+    /** Clients whose stop onExit already showed, so a failing revival does not show it again. */
+    private stopShown;
     private hostShutdown;
     private sessions;
     private dirtyDiffs;
@@ -201,7 +210,17 @@ export declare class SessionManager {
     /** Spawn pi against the session's JSONL file and adopt it as live. */
     private revive;
     private reviveLive;
+    /** Record, persist and show a stop that no exit handler will report. */
+    private reportStop;
     private ensureMessages;
+    /**
+     * The stop notice card. Its id derives from the stop time, so the live card and every replay after a
+     * history re-parse are one message, never duplicates.
+     */
+    private stopNotice;
+    private showStop;
+    /** Show the last unexplained stop again after a history re-parse or adapter restart, where it happened. */
+    private replayStop;
     private refreshMessageCache;
     /** pi paths/ids already represented in memory — shared by both scans. */
     private knownSessionKeys;

package/dist/sessions.js

@@ -7,7 +7,7 @@ import { parsePiSessionFile, parsePiSessionText } from "./session-history.js";
 import { CONTEXT_MESSAGE_TYPE, nativePromptInput, v2PromptAttachments } from "./prompt-parts.js";
 import { existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { COMPACT_RPC_TIMEOUT_MS, PiRpcClient, RPC_COMMAND_TIMEOUT_MS, } from "./pi-rpc.js";
+import { COMPACT_RPC_TIMEOUT_MS, describeStop, PiRpcClient, PiStoppedError, RPC_COMMAND_TIMEOUT_MS, } from "./pi-rpc.js";
 import { stopSessionHosts } from "./session-hosts.js";
 import { setThinkingLevel, userMessageModel } from "./thinking-levels.js";
 import { SessionLifecycle } from "./lifecycle.js";
@@ -19,7 +19,7 @@ import { SubagentBridge } from "./subagents.js";
 import { MonitorSessions } from "./monitor-sessions.js";
 import { WorkStatusBridge } from "./work-status.js";
 import { sessionDiff } from "./session-diff.js";
-import { announceSessionNotice, skillCommandText, slashTitlePrompt } from "./session-commands.js";
+import { announceSessionNotice, noticeMessage, skillCommandText, slashTitlePrompt } from "./session-commands.js";
 import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionFileMeta, } from "./session-store.js";
 import { ADAPTER_VERSION } from "./version.js";
 export { ADAPTER_VERSION } from "./version.js";
@@ -53,6 +53,8 @@ export class SessionManager {
     operations = new Map();
     /** Connector-created session trees, including persisted ownership after restart. */
     createdSessions = new Map();
+    /** Clients whose stop onExit already showed, so a failing revival does not show it again. */
+    stopShown = new WeakSet();
     hostShutdown;
     sessions = new Map();
     dirtyDiffs = new Set();
@@ -149,6 +151,7 @@ export class SessionManager {
             published = true;
             this.subagents.wire(managed);
             this.monitors.wire(managed);
+            this.workStatus.wire(managed);
             this.lifecycle.touch(managed);
             this.wirePi(managed, pi);
             if (options.model !== undefined)
@@ -262,13 +265,19 @@ export class SessionManager {
             if (extensionRequest !== undefined)
                 s.approvals?.handle(extensionRequest);
         };
-        const onExit = (code) => {
+        const onExit = (code, signal) => {
             if (s.pi !== pi)
                 return;
-            this.events.finishInterruptedRun(s, {
-                name: "UnknownError",
-                data: { message: `pi process exited (code=${code})` },
-            });
+            // An agent that stopped on its own (timeout, broken pipe, crash) must say why: a notice card in the
+            // transcript, the same error on the reply it interrupted, and a replay after an adapter restart.
+            // Pending commands reject with the same PiStoppedError; prompt admission leaves it to this handler.
+            // Without a stop reason antechamber disposed the process itself and keeps the plain notice.
+            const reason = pi.stopReason;
+            const message = reason === undefined ? `pi process exited (code=${code} signal=${signal})` : describeStop(reason);
+            const error = { name: reason === undefined ? "UnknownError" : "AgentStoppedError", data: { message } };
+            this.events.finishInterruptedRun(s, error);
+            if (reason !== undefined)
+                s.lastStop = { message, at: Date.now() };
             try {
                 recordTurn(s);
                 this.persistMeta(s);
@@ -285,13 +294,11 @@ export class SessionManager {
             void this.lifecycle
                 .dormant(s)
                 .catch((error) => console.error("[lifecycle] exit cleanup failed:", error));
-            this.emit(s.info.directory, {
-                type: "session.error",
-                properties: {
-                    sessionID: s.info.id,
-                    error: { name: "UnknownError", data: { message: `pi process exited (code=${code})` } },
-                },
-            });
+            if (s.lastStop !== undefined && reason !== undefined) {
+                this.stopShown.add(pi);
+                this.showStop(s, s.lastStop);
+            }
+            this.emit(s.info.directory, { type: "session.error", properties: { sessionID: s.info.id, error } });
             this.events.setStatus(s, { type: "idle" });
         };
         pi.onEvent(onEvent);
@@ -977,6 +984,9 @@ export class SessionManager {
         };
         if (metadata !== undefined)
             (s.tree.promptMetadata ??= {})[userMsg.id] = metadata;
+        // The user moved on: the stop notice stays in this adapter's memory but is not replayed after a restart.
+        if (!context)
+            delete s.lastStop;
         const parts = (inputParts ?? [{ type: "text", text }]).map((part) => ({
             ...part,
             id: part.id ?? id("prt"),
@@ -1250,9 +1260,28 @@ export class SessionManager {
             s.pi = undefined;
             delete s.approvals;
             await pi.dispose();
+            // Unwired above, so onExit cannot report a stop that ended the revival (crash, cold-start timeout).
+            // Read the reason after dispose: a closed stdout is corrected to the exit status once the exit arrives.
+            if (error instanceof PiStoppedError && !this.stopShown.has(pi))
+                this.reportStop(s, describeStop(pi.stopReason ?? error.reason));
             throw error;
         }
     }
+    /** Record, persist and show a stop that no exit handler will report. */
+    reportStop(s, message) {
+        s.lastStop = { message, at: Date.now() };
+        try {
+            this.persistMeta(s);
+        }
+        catch (error) {
+            this.reportPersistenceError(s, error);
+        }
+        this.showStop(s, s.lastStop);
+        this.emit(s.info.directory, {
+            type: "session.error",
+            properties: { sessionID: s.info.id, error: { name: "AgentStoppedError", data: { message } } },
+        });
+    }
     ensureMessages(s) {
         if (this.subagents.owns(s.info.id))
             return this.subagents.messages(s.info.id);
@@ -1271,6 +1300,8 @@ export class SessionManager {
                 followExternalAppends(s, s.restored.piPath);
             const admissions = s.tree.localShellTurns?.length;
             s.messages = parsePiSessionFile(s, getAgentName());
+            if (s.lastStop !== undefined)
+                this.replayStop(s, s.messages, s.lastStop);
             if (fileSize !== undefined)
                 s.historyFileSize = fileSize;
             this.subagents.discover(s, s.messages);
@@ -1281,6 +1312,43 @@ export class SessionManager {
         }
         return s.messages;
     }
+    /**
+     * The stop notice card. Its id derives from the stop time, so the live card and every replay after a
+     * history re-parse are one message, never duplicates.
+     */
+    stopNotice(s, stop) {
+        const notice = noticeMessage(s, stop.message, { name: "AgentStoppedError", data: { message: stop.message } }, stop.at);
+        notice.info.id = `msg_agentstop_${stop.at}`;
+        for (const part of notice.parts) {
+            part.id = `prt_agentstop_${stop.at}`;
+            part.messageID = notice.info.id;
+        }
+        return notice;
+    }
+    showStop(s, stop) {
+        const messages = this.ensureMessages(s);
+        let notice = messages.find((message) => message.info.id === `msg_agentstop_${stop.at}`);
+        if (notice === undefined) {
+            notice = this.stopNotice(s, stop);
+            this.appendMessage(s.info.id, notice);
+        }
+        this.emit(s.info.directory, { type: "message.updated", properties: { info: notice.info } });
+        for (const part of notice.parts)
+            this.events.emitPart(s, part);
+    }
+    /** Show the last unexplained stop again after a history re-parse or adapter restart, where it happened. */
+    replayStop(s, messages, stop) {
+        if (messages.some((message) => message.info.id === `msg_agentstop_${stop.at}`))
+            return;
+        // Like appendMessage: never inside the hidden redo branch while reverted.
+        const boundary = messages.findIndex((message) => message.info.id === s.tree.revert?.messageID);
+        const later = messages.findIndex((message) => message.info.time.created > stop.at);
+        const at = Math.min(later < 0 ? messages.length : later, boundary < 0 ? messages.length : boundary);
+        const notice = this.stopNotice(s, stop);
+        notice.info.parentID = messages.slice(0, at).findLast((message) => message.info.role === "user")?.info.id ?? "";
+        (s.localMessageIds ??= new Set()).add(notice.info.id);
+        messages.splice(at, 0, notice);
+    }
     refreshMessageCache(s, replaceNative = false) {
         const previous = s.messages ?? [];
         s.messages = undefined;
@@ -1408,12 +1476,14 @@ export class SessionManager {
             restored: { piSessionId: sc.piSessionId, piPath: sc.piPath },
             hasPendingInteraction: () => false,
             hasRunningChildren: () => false,
+            ...(reg?.lastStop !== undefined ? { lastStop: reg.lastStop } : {}),
         };
         this.sessions.set(ocId, managed);
         if (reg?.connectorOwned === true)
             this.createdSessions.set(sc.piSessionId, sc.directory);
         this.subagents.wire(managed);
         this.monitors.wire(managed);
+        this.workStatus.wire(managed);
         return managed;
     }
     /** Resolve a bare session id (e.g. deep link after restart) via known directories. */
@@ -1477,6 +1547,7 @@ export class SessionManager {
             ...(s.info.parentID !== undefined ? { parentID: s.info.parentID } : {}),
             ...(s.info.parentMessageID !== undefined ? { parentMessageID: s.info.parentMessageID } : {}),
             ...(s.model !== undefined ? { model: { providerID: s.model.providerID, modelID: s.model.modelID } } : {}),
+            ...(s.lastStop !== undefined ? { lastStop: s.lastStop } : {}),
             created: s.info.time.created,
             updated: s.info.time.updated,
         });

package/dist/work-status.d.ts

@@ -70,6 +70,8 @@ export declare class WorkStatusBridge {
     private readonly work;
     constructor(monitors: MonitorSessions);
     private state;
+    /** Evicting the agent process would kill its detached eval cells, so a live wake source keeps it. */
+    wire(s: ManagedSession): void;
     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;

package/dist/work-status.js

@@ -138,6 +138,10 @@ export class WorkStatusBridge {
         }
         return work;
     }
+    /** Evicting the agent process would kill its detached eval cells, so a live wake source keeps it. */
+    wire(s) {
+        s.hasWakeSources = () => (this.work.get(s.info.id)?.wakeSources.size ?? 0) > 0;
+    }
     observe(s, ev) {
         if (ev.name === WAKE_SOURCE_STATE_EVENT) {
             const source = parseWakeSource(ev.data);
@@ -243,7 +247,8 @@ export class WorkStatusBridge {
         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);
+        // A slow cold start must not cost the session: an eval_cells timeout fails only the request.
+        const reply = await pi.probe(command, EVAL_RPC_TIMEOUT_MS);
         if (reply.success)
             return reply.data;
         const code = reply.errorCode;

package/extensions/omo-compat/package.json

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

package/extensions/omo-work/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-work",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",