antechamber 0.2.9 → 0.2.11

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.11] - 2026-10-16
+
+### Fixed
+
+- Keep pending prompts alive while the agent is running or compacting instead of terminating useful work at the
+  ordinary RPC deadline. Silent requests still time out, and prompt admission has a bounded overall wait.
+
+## [0.2.10] - 2026-10-16
+
+### Fixed
+
+- `/btw` on an idle session no longer fails with "Invalid entry ID for
+  forking". Forking before an assistant message (the fork point `/btw` sends)
+  now keeps everything before that reply, matching OpenCode's exclusive fork
+  boundary. Forks are still refused while the session is busy.
+- Running tool cards no longer flash a red "Interrupted" error until they
+  finish. An assistant message is now marked completed only once its tools
+  (including subagent task cards) have settled, as OpenCode does.
+
 ## [0.2.9] - 2026-10-16
 
 ### Fixed

package/dist/catalog.js

@@ -32,7 +32,7 @@ function toOCModel(m) {
             toolcall: true,
             input: { text: modality("text"), audio: false, image: modality("image"), video: false, pdf: false },
             output: { text: true, audio: false, image: false, video: false, pdf: false },
-            interleaved: m.reasoning ? true : false,
+            interleaved: !!m.reasoning,
         },
         cost: {
             input: m.cost?.input ?? 0,

package/dist/misc-routes.js

@@ -15,7 +15,7 @@ export function debugLog(line) {
     if (!envSetting("DEBUG") || loggingDisabled)
         return;
     try {
-        appendFileSync(envSetting("DEBUG_LOG") ?? join(tmpdir(), `antechamber-debug-${process.getuid?.() ?? "user"}.log`), line + "\n", { flag: "a", mode: 0o600 });
+        appendFileSync(envSetting("DEBUG_LOG") ?? join(tmpdir(), `antechamber-debug-${process.getuid?.() ?? "user"}.log`), `${line}\n`, { flag: "a", mode: 0o600 });
     }
     catch (error) {
         loggingDisabled = true;

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

@@ -51,6 +51,8 @@ interface PiEventServices {
 /** Translates per-session events; registry and lifecycle operations stay with SessionManager. */
 export declare class PiEventTranslator {
     private services;
+    /** Ended assistant messages whose completion waits on their tools. */
+    private awaitingTools;
     constructor(services: PiEventServices);
     /** Close dead-runtime UI state before an error or idle event can reach the client. */
     finishInterruptedRun(s: ManagedSession, error: NonNullable<OCAssistantMessage["error"]>): void;
@@ -79,7 +81,11 @@ export declare class PiEventTranslator {
     private onToolcallEvent;
     /** turn_end.toolResults → finalize tool parts (completed / error). */
     private applyToolResults;
+    /** Complete an ended assistant message whose completion waited on its tools; true when it changed. */
+    private completeSettled;
     /** Tool parts that never received a result (abort, crash) must not spin forever. */
     private finalizeDanglingTools;
+    /** Complete every ended message of this session still waiting on its tools. */
+    private completeAwaitingTools;
 }
 export {};

package/dist/pi-event-translation.js

@@ -142,6 +142,8 @@ export function compactionMessages(s, key, summary, created, model) {
 /** Translates per-session events; registry and lifecycle operations stay with SessionManager. */
 export class PiEventTranslator {
     services;
+    /** Ended assistant messages whose completion waits on their tools. */
+    awaitingTools = new WeakSet();
     constructor(services) {
         this.services = services;
     }
@@ -420,6 +422,10 @@ export class PiEventTranslator {
                 const msg = ev.message;
                 if (msg?.role !== "assistant")
                     return; // user message already recorded at prompt()
+                // pi starts the next step only after the previous step's tool results, so
+                // close any earlier step still waiting on cards (e.g. a background task)
+                // before this one opens; v2 clients must never see an ended step reopen.
+                this.completeAwaitingTools(s);
                 // pi stamps the assistant message with the model really serving it.
                 // Trust that over our snapshot, which goes stale whenever pi switches on
                 // its own side (subagent routing, an in-session /model, a resumed file).
@@ -468,7 +474,15 @@ export class PiEventTranslator {
                 }
                 applyUsage(s.streaming.message, ended.usage);
                 Object.assign(s.streaming.message, piStopReason(ended.stopReason, ended.errorMessage));
-                s.streaming.message.time.completed = Date.now();
+                // OpenCode completes an assistant message only after its tools settle, and
+                // OpenChamber marks active tools under a completed message as Interrupted.
+                // pi ends a toolUse message before executing its tool calls, so defer its
+                // completion to the last tool result (applyToolResults), the next step, or
+                // the run end. Errored/aborted messages never run their tools.
+                if (ended.stopReason === "toolUse" && hasActiveTools(s, s.streaming.message.id))
+                    this.awaitingTools.add(s.streaming.message);
+                else
+                    s.streaming.message.time.completed = Date.now();
                 this.services.emit(s.info.directory, { type: "message.updated", properties: { info: s.streaming.message } });
                 this.finishStreaming(s);
                 if (syncSessionCost(s))
@@ -482,6 +496,8 @@ export class PiEventTranslator {
     onCompactionEvent(s, ev) {
         switch (ev.type) {
             case "compaction_start":
+                // An auto-compaction can fall between steps; its summary is a new step.
+                this.completeAwaitingTools(s);
                 s.compactionID = id("compaction");
                 this.services.emit(s.info.directory, {
                     type: "session.compaction.started",
@@ -738,8 +754,12 @@ export class PiEventTranslator {
     applyToolResults(s, results) {
         for (const tr of results) {
             const callID = typeof tr.toolCallId === "string" ? tr.toolCallId : undefined;
-            if (callID !== undefined && this.services.subagents.result(s, callID, tr, true))
+            if (callID !== undefined && this.services.subagents.result(s, callID, tr, true)) {
+                const owner = s.messages?.find((m) => m.parts.some((p) => p.type === "tool" && p.callID === callID));
+                if (owner && this.completeSettled(s, owner.info))
+                    this.services.emit(s.info.directory, { type: "message.updated", properties: { info: owner.info } });
                 continue;
+            }
             const part = callID !== undefined ? s.toolByCallId.get(callID) : undefined;
             if (!part || callID === undefined)
                 continue;
@@ -778,10 +798,20 @@ export class PiEventTranslator {
                 this.services.dirtyDiffs.add(s.info.id);
             this.emitPart(s, part);
             const owner = s.messages?.find((m) => m.info.id === part.messageID);
-            if (owner)
-                this.services.emit(s.info.directory, { type: "message.updated", properties: { info: owner.info } });
+            if (!owner)
+                continue;
+            this.completeSettled(s, owner.info);
+            this.services.emit(s.info.directory, { type: "message.updated", properties: { info: owner.info } });
         }
     }
+    /** Complete an ended assistant message whose completion waited on its tools; true when it changed. */
+    completeSettled(s, info) {
+        if (!this.awaitingTools.has(info) || info.role !== "assistant" || hasActiveTools(s, info.id))
+            return false;
+        this.awaitingTools.delete(info);
+        info.time.completed = Date.now();
+        return true;
+    }
     /** Tool parts that never received a result (abort, crash) must not spin forever. */
     finalizeDanglingTools(s) {
         for (const part of finishProviderToolParts(s.toolByCallId.values(), Date.now()))
@@ -799,5 +829,26 @@ export class PiEventTranslator {
             this.emitPart(s, part);
         }
         s.toolByCallId.clear();
+        this.completeAwaitingTools(s); // the run is over
     }
+    /** Complete every ended message of this session still waiting on its tools. */
+    completeAwaitingTools(s) {
+        const now = Date.now();
+        for (const { info } of s.messages ?? []) {
+            if (!this.awaitingTools.has(info) || info.role !== "assistant")
+                continue;
+            this.awaitingTools.delete(info);
+            info.time.completed = now;
+            this.services.emit(s.info.directory, { type: "message.updated", properties: { info } });
+        }
+    }
+}
+/** A tool part of this message (including subagent task cards) still waiting for its result. */
+function hasActiveTools(s, messageID) {
+    const active = (part) => part.type === "tool" &&
+        part.messageID === messageID &&
+        (part.state.status === "pending" || part.state.status === "running");
+    if ([...s.toolByCallId.values()].some(active))
+        return true;
+    return s.messages?.find((m) => m.info.id === messageID)?.parts.some(active) ?? false;
 }

package/dist/pi-rpc.d.ts

@@ -69,6 +69,8 @@ export declare class PiRpcClient extends EventEmitter {
     private closed;
     private stderrTail;
     private disposing;
+    private agentActive;
+    private compacting;
     get pid(): number | undefined;
     get isBusy(): boolean;
     onEvent(listener: (payload: Record<string, unknown>) => void): this;

package/dist/pi-rpc.js

@@ -21,6 +21,7 @@ export const RPC_COMMAND_TIMEOUT_MS = 60_000;
  * long before a large session finished, leaving the run orphaned.
  */
 export const COMPACT_RPC_TIMEOUT_MS = 31 * 60_000;
+const PROMPT_ADMISSION_TIMEOUT_MS = COMPACT_RPC_TIMEOUT_MS + RPC_COMMAND_TIMEOUT_MS;
 const MAX_JSONL_FRAME_BYTES = 64 * 1024 * 1024;
 export class UpstreamProtocolError extends Error {
     constructor(message) {
@@ -67,6 +68,8 @@ export class PiRpcClient extends EventEmitter {
     closed = false;
     stderrTail = "";
     disposing;
+    agentActive = false;
+    compacting = false;
     get pid() {
         return this.proc.pid;
     }
@@ -235,6 +238,29 @@ export class PiRpcClient extends EventEmitter {
             this.handleExtensionUI(msg);
             return;
         }
+        const wasWorking = this.agentActive || this.compacting;
+        switch (msg.type) {
+            case "agent_start":
+            case "auto_retry_start":
+                this.agentActive = true;
+                break;
+            case "agent_end":
+                if (msg.willRetry !== true)
+                    this.agentActive = false;
+                break;
+            case "agent_idle":
+                this.agentActive = false;
+                break;
+            case "compaction_start":
+                this.compacting = true;
+                break;
+            case "compaction_end":
+                this.compacting = false;
+                break;
+        }
+        if (wasWorking !== (this.agentActive || this.compacting))
+            for (const request of this.pending.values())
+                request.onWorkState?.();
         this.emit("event", msg);
     }
     handleExtensionUI(msg) {
@@ -253,7 +279,7 @@ export class PiRpcClient extends EventEmitter {
     write(obj) {
         if (this.closed)
             return;
-        this.proc.stdin.write(JSON.stringify(obj) + "\n");
+        this.proc.stdin.write(`${JSON.stringify(obj)}\n`);
     }
     failAll(err) {
         for (const p of this.pending.values())
@@ -261,16 +287,21 @@ export class PiRpcClient extends EventEmitter {
         this.pending.clear();
     }
     /** Send a command and wait for its correlated response. */
-    command(cmd, timeoutMs = RPC_COMMAND_TIMEOUT_MS, signal, onDispatch) {
+    command(cmd, timeoutMs, signal, onDispatch) {
         if (this.closed)
             return Promise.reject(new Error("pi process is not running"));
         if (signal?.aborted)
             return Promise.reject(signal.reason);
         const id = randomUUID();
         const expectedCommand = String(cmd.type);
+        const deadlineMs = timeoutMs ?? RPC_COMMAND_TIMEOUT_MS;
+        const waitsForWork = expectedCommand === "prompt" && timeoutMs === undefined;
         return new Promise((resolve, reject) => {
+            let timer;
+            let admissionTimer;
             const cleanup = () => {
                 clearTimeout(timer);
+                clearTimeout(admissionTimer);
                 signal?.removeEventListener("abort", onAbort);
                 this.pending.delete(id);
             };
@@ -281,9 +312,17 @@ export class PiRpcClient extends EventEmitter {
             const onAbort = () => {
                 rejectCommand(signal?.reason);
             };
-            const timer = setTimeout(() => {
-                this.closeForTransportFailure(new Error(`pi command "${expectedCommand}" timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
+            const expire = (duration) => {
+                this.closeForTransportFailure(new Error(`pi command "${expectedCommand}" timed out after ${duration}ms`));
+            };
+            const armDeadline = () => {
+                clearTimeout(timer);
+                if (!waitsForWork || !(this.agentActive || this.compacting))
+                    timer = setTimeout(() => expire(deadlineMs), deadlineMs);
+            };
+            armDeadline();
+            if (waitsForWork)
+                admissionTimer = setTimeout(() => expire(PROMPT_ADMISSION_TIMEOUT_MS), PROMPT_ADMISSION_TIMEOUT_MS);
             this.pending.set(id, {
                 command: expectedCommand,
                 resolve: (r) => {
@@ -292,6 +331,7 @@ export class PiRpcClient extends EventEmitter {
                     resolve(r.success ? { ...r, data: r.data } : r);
                 },
                 reject: rejectCommand,
+                ...(waitsForWork ? { onWorkState: armDeadline } : {}),
             });
             signal?.addEventListener("abort", onAbort, { once: true });
             this.write({ ...cmd, id });

package/dist/pidfd.js

@@ -1,5 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { delimiter, resolve } from "node:path";
+// biome-ignore lint/complexity/noUselessStringRaw: embedded Python must keep any backslashes verbatim.
 const pidfdProbe = String.raw `
 import os, selectors, signal
 fd = os.pidfd_open(os.getpid())

package/dist/session-history.js

@@ -407,7 +407,6 @@ export function parsePiSessionText(s, agentName, raw) {
                         metadata,
                         time: { start: startedAt, end: created },
                     };
-            continue;
         }
         // system / custom entries are not rendered
     }

package/dist/session-hosts.js

@@ -50,6 +50,7 @@ function processInfo(pid) {
 // Node 22 has no pidfd API. This bounded, stdlib-only helper holds all pidfds
 // across TERM, readiness-based death observation, and KILL. -I ignores Python
 // environment customizations. No numeric-PID signal fallback is permitted.
+// biome-ignore lint/complexity/noUselessStringRaw: embedded Python must keep any backslashes verbatim.
 const stopBoundHosts = String.raw `
 import contextlib, json, os, selectors, signal, sys, time
 

package/dist/session-tree.js

@@ -235,13 +235,18 @@ export async function forkConversation(s, pi, tree, messageID) {
         throw new SessionTreeError("Cannot fork an empty conversation");
     const shellUser = entry.message?.role === "bashExecution" &&
         s.messages?.find((message) => message.info.id === messageID)?.info.role === "user";
-    const forkEntryId = shellUser ? entry.parentId : entry.id;
-    if (forkEntryId === null)
-        throw new SessionTreeError("Cannot fork before a root shell entry");
+    // OpenCode forks strictly before any selected message. OmO's default "before"
+    // position only accepts user entries, so other boundaries (an assistant reply,
+    // as /btw sends) fork "at" the entry preceding them.
+    const beforeOther = messageID !== undefined && entry.message?.role !== "user" && entry.message?.role !== "bashExecution";
+    const forkEntryId = shellUser || beforeOther ? entry.parentId : entry.id;
+    if (forkEntryId === null) {
+        throw new SessionTreeError(shellUser ? "Cannot fork before a root shell entry" : "Cannot fork before the first entry");
+    }
     const response = await pi.command({
         type: "fork",
         entryId: forkEntryId,
-        ...(messageID === undefined || entry.message?.role === "bashExecution" ? { position: "at" } : {}),
+        ...(messageID === undefined || beforeOther || entry.message?.role === "bashExecution" ? { position: "at" } : {}),
     });
     if (!response.success)
         throw new SessionTreeError(response.error ?? "OmO fork failed");

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",
@@ -40,7 +40,7 @@
     "CHANGELOG.md"
   ],
   "bin": {
-    "antechamber": "./dist/cli.js"
+    "antechamber": "dist/cli.js"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && node --input-type=module -e \"import { chmodSync } from 'node:fs'; chmodSync('dist/cli.js', 0o755)\" && npm run build:extension",
@@ -60,6 +60,9 @@
     "model-smoke": "tsx contrib/model-consistency.ts",
     "v2-smoke": "tsx contrib/v2-smoke.ts"
   },
+  "allowScripts": {
+    "esbuild@0.28.2": true
+  },
   "engines": {
     "node": ">=22"
   },