antechamber 1.0.31 → 1.0.33

package/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.33] - 2026-11-02
+
+### Fixed
+
+- Stop showing replies twice, and keep new messages and `!` shell commands at the end of the conversation, in a
+  session that has a shell command OmO never reported back (for example one stopped by the old one-minute deadline).
+  Every read of the conversation re-parsed the session file without the live replies, so each reply read mid-turn
+  gained a second, restored copy, and those copies piled up after newer messages. Restart OpenChamber's adapter to
+  clear copies already in memory.
+
+## [1.0.32] - 2026-10-29
+
+### Fixed
+
+- Stop killing the agent when a shell command run from the composer takes longer than a minute, such as an
+  interactive login. A user shell now runs until its command exits or you press Stop; only a shell that OmO still
+  has not answered a minute after Stop stops the agent.
+- Show a shell command's output live in its card while it runs, so a link or code a command prints before it waits
+  (such as a login URL) can be copied. Before, the card stayed empty until the command ended. A command you stop
+  keeps the output it printed.
+
 ## [1.0.31] - 2026-10-29
 
 ### Fixed

package/dist/pi-rpc.d.ts

@@ -137,6 +137,8 @@ export declare class PiRpcClient extends EventEmitter {
     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>>;
+    /** Asks OmO to stop the user shell; a pending `bash` still unanswered after the ordinary deadline means a hung agent. */
+    abortBash(): void;
     /** Fire-and-forget command (no response correlation). */
     notify(cmd: Omit<PiRpcCommand, "id">): void;
     dispose(): Promise<void>;

package/dist/pi-rpc.js

@@ -403,6 +403,10 @@ export class PiRpcClient extends EventEmitter {
         const expectedCommand = String(cmd.type);
         const deadlineMs = timeoutMs ?? RPC_COMMAND_TIMEOUT_MS;
         const waitsForWork = expectedCommand === "prompt" && timeoutMs === undefined;
+        // A user `bash` answers when its command exits: OmO awaits `executeBash` with no time limit (senpi
+        // 2026.10.25-2, dist/modes/rpc/connection-handler.js `case "bash"`), and an interactive command such as a
+        // login waits on the user. Without a caller deadline it gets one only once `abortBash` asks OmO to stop it.
+        const waitsForShell = expectedCommand === "bash" && timeoutMs === undefined;
         return new Promise((resolve, reject) => {
             let timer;
             let admissionTimer;
@@ -431,7 +435,8 @@ export class PiRpcClient extends EventEmitter {
                 if (!waitsForWork || !(this.agentActive || this.compacting))
                     timer = setTimeout(() => expire(deadlineMs), deadlineMs);
             };
-            armDeadline();
+            if (!waitsForShell)
+                armDeadline();
             if (waitsForWork)
                 admissionTimer = setTimeout(() => expire(PROMPT_ADMISSION_TIMEOUT_MS), PROMPT_ADMISSION_TIMEOUT_MS);
             this.pending.set(id, {
@@ -443,12 +448,19 @@ export class PiRpcClient extends EventEmitter {
                 },
                 reject: rejectCommand,
                 ...(waitsForWork ? { onWorkState: armDeadline } : {}),
+                ...(waitsForShell ? { onAbortBash: () => timer === undefined && armDeadline() } : {}),
             });
             signal?.addEventListener("abort", onAbort, { once: true });
             this.write({ ...cmd, id });
             onDispatch?.();
         });
     }
+    /** Asks OmO to stop the user shell; a pending `bash` still unanswered after the ordinary deadline means a hung agent. */
+    abortBash() {
+        this.write({ type: "abort_bash" });
+        for (const request of this.pending.values())
+            request.onAbortBash?.();
+    }
     /** Fire-and-forget command (no response correlation). */
     notify(cmd) {
         this.write(cmd);

package/dist/session-commands.d.ts

@@ -54,6 +54,8 @@ type CompactResult = {
     kind: "error";
     message: string;
 };
+/** Appends a chunk and keeps the newest `limit` chars, starting at a line boundary when one leaves anything. */
+export declare function appendLiveOutput(previous: string, delta: string, limit?: number): string;
 export declare const unsupportedShare: {
     readonly name: "UnsupportedError";
     readonly data: {

package/dist/session-commands.js

@@ -2,6 +2,22 @@ import { randomUUID } from "node:crypto";
 import { PiRpcClient, UpstreamProtocolError } from "./pi-rpc.js";
 import { getAgentName } from "./agent-name.js";
 import { nativePromptInput, parsePromptParts } from "./prompt-parts.js";
+/**
+ * Live output kept on a running shell card: the newest part. Every snapshot carries all of it, so it is kept small;
+ * the finished card gets OmO's full output.
+ */
+const LIVE_SHELL_OUTPUT_CHARS = 64 * 1024;
+/** Output chunks arriving within this window reach clients as one card snapshot. */
+const LIVE_SHELL_OUTPUT_FLUSH_MS = 100;
+/** Appends a chunk and keeps the newest `limit` chars, starting at a line boundary when one leaves anything. */
+export function appendLiveOutput(previous, delta, limit = LIVE_SHELL_OUTPUT_CHARS) {
+    const output = previous + delta;
+    if (output.length <= limit)
+        return output;
+    const tail = output.slice(output.length - limit);
+    const lineStart = tail.indexOf("\n") + 1;
+    return lineStart > 0 && lineStart < tail.length ? tail.slice(lineStart) : tail;
+}
 // OpenChamber drops rejected Share actions, so emit a visible session notice too.
 export const unsupportedShare = {
     name: "UnsupportedError",
@@ -311,13 +327,35 @@ export async function runShellCommand(context) {
     const afterEntryId = session.tree.leafId ?? null;
     const controller = new AbortController();
     let interrupted = false;
+    // OmO streams user bash output as `bash_execution_update {id: executionId, delta}` frames before its reply
+    // (agent-session.js `executeBash`; real RPC probe on 2026-10-28). Showing them live lets the user act on
+    // output while the command waits, such as a login link.
+    let streaming;
+    let liveOutput = "";
+    let flush;
+    const onOutput = (event) => {
+        const [part] = message.parts;
+        if (event.type !== "bash_execution_update" || event.id !== part.callID || typeof event.delta !== "string")
+            return;
+        if (part.state.status !== "running")
+            return;
+        liveOutput = appendLiveOutput(liveOutput, event.delta);
+        part.state.metadata = { ...part.state.metadata, output: liveOutput };
+        flush ??= setTimeout(() => {
+            flush = undefined;
+            if (part.state.status === "running")
+                shellEvent(context, { type: "message.part.updated", properties: { part } });
+        }, LIVE_SHELL_OUTPUT_FLUSH_MS);
+    };
+    // A stopped card keeps what the command printed, such as a link the user still needs.
+    const streamed = () => (liveOutput === "" ? {} : { output: liveOutput });
     session.cancelShell = (byRestart = false) => {
         interrupted = byRestart;
         delete session.cancelShell;
         // Agent abort does not stop user bash. Dispatch the dedicated RPC first,
         // then release our waiter; a correlated late response is discarded.
         if (dispatch[message.info.id])
-            session.pi?.notify({ type: "abort_bash" });
+            session.pi?.abortBash();
         controller.abort();
     };
     sessions.appendMessage(session.info.id, user);
@@ -332,8 +370,10 @@ export async function runShellCommand(context) {
     });
     try {
         await sessions.update(session.info.id, {});
-        const response = await sessions.sessionRpc(session.info.id, { type: "bash", command }, controller.signal, () => {
+        const response = await sessions.sessionRpc(session.info.id, { type: "bash", command, executionId: message.parts[0].callID }, controller.signal, () => {
             dispatch[message.info.id] = true;
+            streaming = session.pi;
+            streaming?.onEvent(onOutput);
             // Only actual dispatch admissions are durable; queued attempts stay in the live cache.
             (session.tree.localShellTurns ??= []).push({ afterEntryId, messages: [user, message] });
             // A native result can land beyond the last synchronized leaf.
@@ -351,7 +391,11 @@ export async function runShellCommand(context) {
         }
         const result = parseShellResult(response.data);
         if (result.cancelled) {
-            failShellMessage(message, command, "Command cancelled", { cancelled: true, exitCode: result.exitCode });
+            failShellMessage(message, command, "Command cancelled", {
+                ...streamed(),
+                cancelled: true,
+                exitCode: result.exitCode,
+            });
         }
         else {
             completeShellMessage(message, command, result);
@@ -361,7 +405,10 @@ export async function runShellCommand(context) {
     }
     catch (error) {
         if (controller.signal.aborted) {
-            failShellMessage(message, command, interrupted ? "Interrupted by restart" : "Command cancelled", interrupted ? { interrupted: true } : { cancelled: true });
+            failShellMessage(message, command, interrupted ? "Interrupted by restart" : "Command cancelled", {
+                ...streamed(),
+                ...(interrupted ? { interrupted: true } : { cancelled: true }),
+            });
             emitShellMessage(context, message);
             return { kind: "completed", message };
         }
@@ -370,6 +417,8 @@ export async function runShellCommand(context) {
         throw error;
     }
     finally {
+        streaming?.off("event", onOutput);
+        clearTimeout(flush);
         delete session.cancelShell;
         const state = message.parts[0].state;
         const metadata = state.status === "pending" ? undefined : state.metadata;

package/dist/sessions.d.ts

@@ -225,6 +225,7 @@ export declare class SessionManager {
     private reviveLive;
     /** Record, persist and show a stop that no exit handler will report. */
     private reportStop;
+    /** `reparse` rebuilds from the JSONL while `s.messages` stays visible, so the binder can reuse live ids. */
     private ensureMessages;
     /**
      * The stop notice card. Its id derives from the stop time, so the live card and every replay after a

package/dist/sessions.js

@@ -839,7 +839,12 @@ export class SessionManager {
             if (pi === undefined)
                 throw new Error(`session cannot be resumed: ${sessionId}`);
             this.lifecycle.touch(s);
-            const timeout = command.type === "compact" ? COMPACT_RPC_TIMEOUT_MS : RPC_COMMAND_TIMEOUT_MS;
+            // A user shell runs until its command exits or the user stops it (`PiRpcClient.abortBash`).
+            const timeout = command.type === "compact"
+                ? COMPACT_RPC_TIMEOUT_MS
+                : command.type === "bash"
+                    ? undefined
+                    : RPC_COMMAND_TIMEOUT_MS;
             // OmO cancels a compaction whenever an MCP server's tools register, which a freshly revived agent
             // does for about a second; start it once they have. The retries below remain the backstop.
             if (command.type === "compact")
@@ -1319,7 +1324,8 @@ export class SessionManager {
             properties: { sessionID: s.info.id, error: { name: "AgentStoppedError", data: { message } } },
         });
     }
-    ensureMessages(s) {
+    /** `reparse` rebuilds from the JSONL while `s.messages` stays visible, so the binder can reuse live ids. */
+    ensureMessages(s, reparse = false) {
         if (this.subagents.owns(s.info.id))
             return this.subagents.messages(s.info.id);
         if (this.monitors.owns(s.info.id))
@@ -1329,9 +1335,9 @@ export class SessionManager {
         const dormantPath = s.pi === undefined ? s.restored?.piPath : undefined;
         const fileSize = dormantPath === undefined ? undefined : statSync(dormantPath, { throwIfNoEntry: false })?.size;
         const cachedFileSize = s.historyFileSize ?? s.tree.fileSize;
-        if (s.messages !== undefined && fileSize !== undefined && fileSize !== cachedFileSize)
+        if (!reparse && s.messages !== undefined && fileSize !== undefined && fileSize !== cachedFileSize)
             return this.refreshMessageCache(s, true);
-        if (s.messages === undefined) {
+        if (s.messages === undefined || reparse) {
             // A dormant session may have been continued by another OmO client since the last save.
             if (s.pi === undefined && s.restored !== undefined)
                 followExternalAppends(s, s.restored.piPath);
@@ -1388,8 +1394,9 @@ export class SessionManager {
     }
     refreshMessageCache(s, replaceNative = false) {
         const previous = s.messages ?? [];
-        s.messages = undefined;
-        const native = this.ensureMessages(s);
+        // Keep the live list during the re-parse: with a pending shell turn the parse binds entries to visible
+        // messages, and an empty list would give every unbound live reply a second, restored `_r` copy.
+        const native = this.ensureMessages(s, true);
         if (replaceNative) {
             // Legacy compaction IDs can collide; retain every parsed native row.
             let index = 0;

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "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.31",
+  "version": "1.0.33",
   "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.31",
+  "version": "1.0.33",
   "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.31",
+  "version": "1.0.33",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",