antechamber 0.2.8 → 0.2.10

package/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [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
+
+- Mobile: sessions whose newest 30 messages contain no user prompt no longer
+  open blank on OpenChamber's mobile surface. v1 `GET /session/{id}/message`
+  now returns `x-next-cursor` and honors `before`, so the client pages back
+  until it finds the start of a turn.
+
 ## [0.2.8] - 2026-10-15
 
 - fix(session): resend bare /<skill> commands as /skill:<name>

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.js

@@ -253,7 +253,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())

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/routes-v1.js

@@ -134,9 +134,24 @@ export async function handleV1(services, req, res, url, path, method, directory)
                 json(res, 200, await services.sessions.remove(sessionId));
                 return;
             case "GET /message": {
+                // OpenCode pages backwards from the newest message: `before` is the
+                // x-next-cursor of the previous page (here, its oldest message ID).
+                // Without the cursor, OpenChamber's loader treats a partial page as the
+                // whole history; mobile's 30-message first page then has no user
+                // message to anchor a turn on, and the transcript renders blank.
                 const messages = services.sessions.messages(sessionId) ?? [];
                 const limit = numberParam(url.searchParams.get("limit"));
-                json(res, 200, limit === undefined ? messages : limit === 0 ? [] : messages.slice(-limit));
+                const before = url.searchParams.get("before");
+                const end = before === null ? messages.length : messages.findIndex((message) => message.info.id === before);
+                if (end < 0 || limit === 0) {
+                    json(res, 200, []);
+                    return;
+                }
+                const start = limit === undefined ? 0 : Math.max(0, end - limit);
+                const page = messages.slice(start, end);
+                if (start > 0 && page[0] !== undefined)
+                    res.setHeader("x-next-cursor", page[0].info.id);
+                json(res, 200, page);
                 return;
             }
             case "GET /children":

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.8",
+  "version": "0.2.10",
   "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.8",
+  "version": "0.2.10",
   "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"
   },