antechamber 0.2.10 → 0.2.12

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.12] - 2026-10-16
+
+### Fixed
+
+- Preserve recorded conversation progress when the agent process exits before
+  `agent_end`, and retain successful background compaction across revival.
+  Checkpoints respect reverted selections and do not switch to sibling branches.
+
+## [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

package/dist/pi-event-translation.js

@@ -544,6 +544,7 @@ export class PiEventTranslator {
                         },
                     });
                 if (ev.aborted !== true && typeof result?.summary === "string" && typeof result.firstKeptEntryId === "string") {
+                    recordTurn(s);
                     const messages = this.services.ensureMessages(s);
                     let key;
                     // compaction_end follows persistence, but its result omits the entry ID.
@@ -563,6 +564,7 @@ export class PiEventTranslator {
                         for (const part of message.parts)
                             this.emitPart(s, part);
                     }
+                    this.services.persistMeta(s);
                 }
                 this.services.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
                 if (s.compactingFromIdle) {

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) {
@@ -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/session-tree.d.ts

@@ -52,7 +52,7 @@ export declare class SessionTreeError extends Error {
 export declare function durableShellTree(tree: SessionTreeState): SessionTreeState;
 export declare function getEntries(pi: PiRpcClient, signal?: AbortSignal): Promise<Entries>;
 export declare function readSessionTree(piPath: string): Entries;
-/** agent_end runs after message persistence; no async lease or timing race. */
+/** Checkpoint persisted progress after agent_end, successful compaction, or process exit. */
 export declare function recordTurn(s: ManagedSession): void;
 export declare function branchEntries(tree: Entries, leafId?: string | null): TreeEntry[];
 /** Live ids belong to the UI; restored ids belong to JSONL offsets. Save both. */

package/dist/session-tree.js

@@ -44,10 +44,19 @@ export function readSessionTree(piPath) {
     }
     return { entries, leafId: entries.at(-1)?.id ?? null };
 }
-/** agent_end runs after message persistence; no async lease or timing race. */
+/** Checkpoint persisted progress after agent_end, successful compaction, or process exit. */
 export function recordTurn(s) {
-    if (s.piPath)
-        bindMessageEntries(s, readSessionTree(s.piPath));
+    if (!s.piPath)
+        return;
+    const tree = readSessionTree(s.piPath);
+    // Disk order is not navigation: only a descendant can advance a saved selection.
+    // An ancestor, missing selection, or newer sibling must leave its bindings intact.
+    if (!s.tree.revert &&
+        s.tree.leafId !== undefined &&
+        s.tree.leafId !== null &&
+        !branchEntries(tree).some((entry) => entry.id === s.tree.leafId))
+        return;
+    bindMessageEntries(s, tree);
 }
 export function branchEntries(tree, leafId = tree.leafId) {
     const byId = new Map(tree.entries.map((entry) => [entry.id, entry]));

package/dist/sessions.js

@@ -14,7 +14,7 @@ import { SessionLifecycle } from "./lifecycle.js";
 import { ApprovalBridge, extensionUiRequestFrom } from "./approvals.js";
 import { getAgentName, getExposedAgentNames } from "./agent-name.js";
 import { RequestBodyError } from "./http.js";
-import { bindMessageEntries, durableShellTree, forkConversation, getEntries, navigate, readSessionTree, revertConversation, SessionTreeError, unrevertConversation, } from "./session-tree.js";
+import { bindMessageEntries, durableShellTree, forkConversation, getEntries, navigate, recordTurn, readSessionTree, revertConversation, SessionTreeError, unrevertConversation, } from "./session-tree.js";
 import { SubagentBridge } from "./subagents.js";
 import { MonitorSessions } from "./monitor-sessions.js";
 import { sessionDiff } from "./session-diff.js";
@@ -239,6 +239,13 @@ export class SessionManager {
                 name: "UnknownError",
                 data: { message: `pi process exited (code=${code})` },
             });
+            try {
+                recordTurn(s);
+                this.persistMeta(s);
+            }
+            catch (error) {
+                this.reportPersistenceError(s, error);
+            }
             delete s.interruptRequested;
             this.subagents.stopParent(s.info.id);
             this.monitors.stopParent(s.info.id);

package/extensions/omo-dag/package.json

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