antechamber 0.2.13 → 0.2.15

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.15] - 2026-10-17
+
+### Fixed
+
+- Show saved child-task errors when no transcript is available, and label missing runtime, token and cost statistics
+  as unknown instead of zero.
+
+## [0.2.14] - 2026-10-16
+
+### Fixed
+
+- Retry a manual compaction that OmO cancelled without a user abort. Compacting a dormant session failed with
+  "Compaction cancelled" when its MCP servers finished connecting right after the agent started.
+- List MCP servers for a directory whose sessions are all dormant, from the most recently used live session
+  elsewhere, instead of showing none.
+- Keep OpenChamber 1.24's mobile transcript from opening blank after a long agent turn: a v1 message page with no
+  user message now reaches back to the prompt that opened its turn.
+
+### Added
+
+- `antechamber doctor` reports the installed, latest released and running adapter versions, and warns when the running
+  server is older, since a released fix only goes live after OpenChamber relaunches the adapter.
+
 ## [0.2.13] - 2026-10-16
 
 ### Fixed

package/README.md

@@ -142,7 +142,7 @@ antechamber serve --hostname 127.0.0.1 --port 4096
 |---|---|
 | `antechamber serve` | OpenCode-compatible server; `--hostname`/`--host`, `--port`, `--directory`. Bare `antechamber` also starts the server. |
 | `antechamber setup` | Configure OpenChamber; `--settings <file>`, `--profile <dir>`, `--binary <path>`, `--dry-run`, `--systemd [unit]`, `--pi-binary <path>`, `--restart`, `--auto-update`. |
-| `antechamber doctor` | Read-only Node, backend, agent/state directories, teardown, OpenChamber and auth checks; `--json`, `--settings <file>`, `--profile <dir>`. Exits 1 on any FAIL; warnings do not fail. |
+| `antechamber doctor` | Read-only Node, backend, agent/state directories, teardown, OpenChamber and auth checks, plus the installed, latest released and running adapter versions (a running server older than the install needs an OpenChamber restart); `--json`, `--settings <file>`, `--profile <dir>`. Exits 1 on any FAIL; warnings do not fail. |
 | `antechamber upgrade` | Install the latest release over a global npm or bun install, with the package manager that owns it. Refused for source checkouts and `npx`. |
 | `antechamber version` | Package version plus OpenCode API contract version. `--version`/`-v` deliberately print exactly `opencode v2.0.20` for OpenChamber. |
 | `antechamber help` | Usage and options; also `--help`/`-h`. |

package/dist/cli.js

@@ -61,10 +61,13 @@ try {
         }
         else if (command === "doctor") {
             const { doctor, formatDoctor } = await import("./commands/doctor.js");
+            const { createContext } = await import("./commands/context.js");
+            const { fetchLatestVersion } = await import("./self-update.js");
+            const latest = await fetchLatestVersion().catch((error) => error instanceof Error ? error : new Error(String(error)));
             const report = doctor({
                 ...(values.settings !== undefined ? { settings: values.settings } : {}),
                 ...(values.profile !== undefined ? { profile: values.profile } : {}),
-            });
+            }, createContext(), latest);
             console.log(formatDoctor(report, values.json ?? false));
             process.exitCode = report.exitCode;
         }

package/dist/commands/doctor.d.ts

@@ -9,6 +9,6 @@ interface DoctorReport {
     readonly exitCode: 0 | 1;
 }
 /** Checks capabilities with access/stat only, never creating state or config files. */
-export declare function doctor(options?: SettingsOptions, ctx?: CommandContext): DoctorReport;
+export declare function doctor(options?: SettingsOptions, ctx?: CommandContext, latestVersion?: string | Error): DoctorReport;
 export declare function formatDoctor(report: DoctorReport, json: boolean): string;
 export {};

package/dist/commands/doctor.js

@@ -3,9 +3,12 @@ import { piAgentDir } from "../agent-dir.js";
 import { detectAgentName } from "../agent-name.js";
 import { agentBinary, defaultStateDir, envSetting, isPlainPi } from "../config.js";
 import { findPidfdPython } from "../pidfd.js";
+import { readRunningServers } from "../running-servers.js";
+import { isNewerVersion } from "../self-update.js";
+import { ADAPTER_VERSION } from "../version.js";
 import { autoUpdateLauncherPath, autoUpdateLauncherTarget, createContext, isPackageBinary, readSettings, resolveBinary, settingsPath, } from "./context.js";
 /** Checks capabilities with access/stat only, never creating state or config files. */
-export function doctor(options = {}, ctx = createContext()) {
+export function doctor(options = {}, ctx = createContext(), latestVersion) {
     const checks = [];
     const add = (name, status, message) => {
         checks.push({ name, status, message });
@@ -42,6 +45,22 @@ export function doctor(options = {}, ctx = createContext()) {
     catch (error) {
         add("state-dir", "FAIL", `${stateDir}: ${error instanceof Error ? error.message : String(error)}`);
     }
+    const latest = typeof latestVersion === "string" ? latestVersion : undefined;
+    if (latestVersion instanceof Error)
+        add("version", "INFO", `${ADAPTER_VERSION}; latest unknown (${latestVersion.message})`);
+    else if (latest !== undefined && isNewerVersion(latest, ADAPTER_VERSION))
+        add("version", "WARN", `${ADAPTER_VERSION} installed; ${latest} is released: run antechamber upgrade`);
+    else
+        add("version", "PASS", ADAPTER_VERSION);
+    // A released fix is live only once OpenChamber relaunches the adapter.
+    const running = readRunningServers(stateDir, ctx.fs, (pid) => ctx.platform === "linux" ? ctx.fs.existsSync(`/proc/${pid}`) : true);
+    if (running.length === 0)
+        add("running", "INFO", `no running antechamber server recorded in ${stateDir}`);
+    for (const server of running) {
+        const target = latest !== undefined && isNewerVersion(latest, ADAPTER_VERSION) ? latest : ADAPTER_VERSION;
+        const stale = isNewerVersion(target, server.version);
+        add("running", stale ? "WARN" : "PASS", `pid ${server.pid} at ${server.url} runs ${server.version}${stale ? `; restart OpenChamber to run ${target}` : ""}`);
+    }
     const python = ctx.platform === "linux"
         ? findPidfdPython(ctx.env, (candidate, args) => {
             try {

package/dist/commands/serve.js

@@ -1,6 +1,10 @@
-import { envSetting } from "../config.js";
+import * as fs from "node:fs";
+import { homedir } from "node:os";
+import { defaultStateDir, envSetting } from "../config.js";
+import { recordRunningServer } from "../running-servers.js";
 import { selfUpdate } from "../self-update.js";
 import { AdapterServer, isLoopbackHost, serverPassword } from "../server.js";
+import { ADAPTER_VERSION } from "../version.js";
 export async function serve(options) {
     const { port, host, directory, insecureNoAuth, compatible } = options;
     if (!isLoopbackHost(host) &&
@@ -10,7 +14,9 @@ export async function serve(options) {
         throw new Error(`refusing to bind ${host} without authentication. Set OPENCODE_SERVER_PASSWORD or ANTECHAMBER_SERVER_PASSWORD, or explicitly use --insecure-no-auth (ANTECHAMBER_ALLOW_INSECURE=1).`);
     }
     const server = new AdapterServer({ port, host, defaultDirectory: directory });
+    let forget = () => { };
     const shutdown = () => {
+        forget();
         void server.stop().then(() => process.exit(0), (error) => {
             console.error("antechamber: shutdown failed:", error);
             process.exit(1);
@@ -21,6 +27,13 @@ export async function serve(options) {
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
     await server.start();
+    try {
+        forget = recordRunningServer(envSetting("STATE_DIR") ?? defaultStateDir(homedir(), fs.existsSync), { pid: process.pid, version: ADAPTER_VERSION, url: server.url, started: new Date().toISOString() }, fs);
+    }
+    catch (error) {
+        // Only doctor reads the record; serving must not depend on it.
+        console.error(`antechamber: cannot record the running version: ${error instanceof Error ? error.message : String(error)}`);
+    }
     if (compatible)
         console.log(`opencode server listening on ${server.url}`);
     else {

package/dist/mcp.d.ts

@@ -3,7 +3,9 @@
  *
  * OpenChamber scopes MCP calls by directory only, while OmO owns MCP per session process.
  * Everything therefore targets the most recently used LIVE session in the directory; a
- * dormant session is never revived just to answer an MCP request.
+ * dormant session is never revived just to answer an MCP request. Status reads for a
+ * directory without one fall back to the most recently used live session elsewhere.
+ * Authorization stays scoped to the directory.
  *
  * Status comes from the read-only `get_loaded_surfaces` RPC. Authorization drives OmO's
  * documented `/mcp` subcommands (docs/mcp.md "Auth"):

package/dist/mcp.js

@@ -3,7 +3,9 @@
  *
  * OpenChamber scopes MCP calls by directory only, while OmO owns MCP per session process.
  * Everything therefore targets the most recently used LIVE session in the directory; a
- * dormant session is never revived just to answer an MCP request.
+ * dormant session is never revived just to answer an MCP request. Status reads for a
+ * directory without one fall back to the most recently used live session elsewhere.
+ * Authorization stays scoped to the directory.
  *
  * Status comes from the read-only `get_loaded_surfaces` RPC. Authorization drives OmO's
  * documented `/mcp` subcommands (docs/mcp.md "Auth"):
@@ -87,7 +89,10 @@ async function loadedServers(pi) {
         : []);
 }
 async function directoryServers(sessions, directory) {
-    const live = liveSession(sessions, directory);
+    // A directory whose sessions are all dormant would list nothing. Its servers are mostly
+    // the user's global and built-in ones, so any running session gives a better answer.
+    const fallback = sessions.liveSessions()[0]?.pi;
+    const live = liveSession(sessions, directory) ?? (fallback === undefined ? undefined : { pi: fallback });
     return live === undefined ? [] : loadedServers(live.pi).catch(() => []);
 }
 async function hasMcpCommand(pi) {

package/dist/routes-v1.js

@@ -147,7 +147,15 @@ export async function handleV1(services, req, res, url, path, method, directory)
                     json(res, 200, []);
                     return;
                 }
-                const start = limit === undefined ? 0 : Math.max(0, end - limit);
+                let start = limit === undefined ? 0 : Math.max(0, end - limit);
+                // OpenChamber 1.24 widens a page with no user message only up to 120 messages
+                // (150 on desktop), then renders it with no turn to anchor on: blank. A long agent
+                // turn outgrows that, so a page reaches back to the prompt that opened its turn.
+                if (!messages.slice(start, end).some((message) => message.info.role === "user")) {
+                    const prompt = messages.findLastIndex((message, index) => index < start && message.info.role === "user");
+                    if (prompt >= 0)
+                        start = prompt;
+                }
                 const page = messages.slice(start, end);
                 if (start > 0 && page[0] !== undefined)
                     res.setHeader("x-next-cursor", page[0].info.id);

package/dist/running-servers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Records each `serve` process under `<stateDir>/run/<pid>.json` so `antechamber doctor`
+ * can tell which version is actually running. A merged and released fix does nothing until
+ * OpenChamber relaunches the adapter, and auto-update only installs it for the next launch.
+ */
+import type * as fs from "node:fs";
+export interface RunningServer {
+    readonly pid: number;
+    readonly version: string;
+    readonly url: string;
+    readonly started: string;
+}
+type Fs = Pick<typeof fs, "existsSync" | "mkdirSync" | "readdirSync" | "readFileSync" | "rmSync" | "writeFileSync">;
+/** Writes the record and returns its remover; a crash leaves a stale record that readers skip by PID. */
+export declare function recordRunningServer(stateDir: string, server: RunningServer, files: Fs): () => void;
+/** Records whose process is still alive, newest first. */
+export declare function readRunningServers(stateDir: string, files: Fs, alive: (pid: number) => boolean): RunningServer[];
+export {};

package/dist/running-servers.js

@@ -0,0 +1,35 @@
+import { join } from "node:path";
+const runDir = (stateDir) => join(stateDir, "run");
+/** Writes the record and returns its remover; a crash leaves a stale record that readers skip by PID. */
+export function recordRunningServer(stateDir, server, files) {
+    const path = join(runDir(stateDir), `${server.pid}.json`);
+    files.mkdirSync(runDir(stateDir), { recursive: true, mode: 0o700 });
+    files.writeFileSync(path, `${JSON.stringify(server)}\n`, { mode: 0o600 });
+    return () => files.rmSync(path, { force: true });
+}
+/** Records whose process is still alive, newest first. */
+export function readRunningServers(stateDir, files, alive) {
+    const dir = runDir(stateDir);
+    if (!files.existsSync(dir))
+        return [];
+    return files
+        .readdirSync(dir)
+        .filter((name) => /^\d+\.json$/.test(name))
+        .flatMap((name) => {
+        try {
+            const record = JSON.parse(files.readFileSync(join(dir, name), "utf8"));
+            if (typeof record !== "object" || record === null)
+                return [];
+            const { pid, version, url, started } = record;
+            if (typeof pid !== "number" || typeof version !== "string" || typeof url !== "string")
+                return [];
+            if (typeof started !== "string" || !alive(pid))
+                return [];
+            return [{ pid, version, url, started }];
+        }
+        catch {
+            return []; // A record being written or removed concurrently.
+        }
+    })
+        .sort((a, b) => b.started.localeCompare(a.started));
+}

package/dist/sessions.d.ts

@@ -20,6 +20,8 @@ interface StreamingState {
 }
 export interface ManagedSession extends ThinkingState {
     interruptRequested?: boolean;
+    /** Counts abort requests, so a compaction cancelled by the user is not retried. */
+    abortRequests?: number;
     titleSource?: TitleSource;
     activeUserMessageID?: string;
     inputs?: Map<string, {
@@ -104,8 +106,8 @@ export declare class SessionManager {
     private wirePi;
     /** pi writes `<ts>_<sessionId>.jsonl` at startup — poll briefly for it. */
     private resolvePiFile;
-    /** Sessions with a running agent in `directory`, most recently used first; never revives a dormant one. */
-    liveSessions(directory: string): ManagedSession[];
+    /** Sessions with a running agent (in `directory`, if given), most recently used first; never revives a dormant one. */
+    liveSessions(directory?: string): ManagedSession[];
     list(directory?: string): OCSession[];
     /**
      * Every restorable session on disk (all directories) plus live ones. Backs the

package/dist/sessions.js

@@ -26,6 +26,9 @@ const SESSION_SCAN_CACHE_TTL_MS = 5_000;
 const PI_FILE_RESOLVE_ATTEMPTS = 10;
 const PI_FILE_RESOLVE_RETRY_MS = 200;
 const SESSION_TITLE_MAX_CHARS = 60;
+/** OmO's reply when a compaction is aborted (`CompactionCancelledError`). */
+const OMO_COMPACTION_CANCELLED = "Compaction cancelled";
+const COMPACT_CANCEL_RETRIES = 2;
 export class SessionManager {
     emit;
     defaultDirectory;
@@ -289,12 +292,12 @@ export class SessionManager {
         }
         return undefined;
     }
-    /** Sessions with a running agent in `directory`, most recently used first; never revives a dormant one. */
+    /** Sessions with a running agent (in `directory`, if given), most recently used first; never revives a dormant one. */
     liveSessions(directory) {
         if (this.disposed)
             return [];
         return [...this.sessions.values()]
-            .filter((s) => s.pi !== undefined && s.info.directory === directory)
+            .filter((s) => s.pi !== undefined && (directory === undefined || s.info.directory === directory))
             .sort((a, b) => this.lifecycle.lastUsed(b) - this.lifecycle.lastUsed(a));
     }
     list(directory) {
@@ -688,6 +691,7 @@ export class SessionManager {
         const s = this.get(sessionId);
         if (!s)
             return false;
+        s.abortRequests = (s.abortRequests ?? 0) + 1;
         if (s.pi !== undefined) {
             if (s.status.type !== "idle")
                 s.interruptRequested = true;
@@ -755,7 +759,19 @@ export class SessionManager {
             this.lifecycle.touch(s);
             const timeout = command.type === "compact" ? COMPACT_RPC_TIMEOUT_MS : RPC_COMMAND_TIMEOUT_MS;
             signal?.throwIfAborted();
-            const response = await pi.command(command, timeout, undefined, onDispatch);
+            const abortsBefore = s.abortRequests ?? 0;
+            let response = await pi.command(command, timeout, undefined, onDispatch);
+            // OmO cancels a running compaction whenever its active tool set changes. On a session
+            // just revived for this request, MCP servers finish connecting a moment after startup
+            // and cancel it although nobody asked. Retry unless the user sent an abort meanwhile.
+            for (let retry = 0; retry < COMPACT_CANCEL_RETRIES &&
+                command.type === "compact" &&
+                !response.success &&
+                response.error === OMO_COMPACTION_CANCELLED &&
+                (s.abortRequests ?? 0) === abortsBefore &&
+                !signal?.aborted &&
+                s.pi === pi; retry++)
+                response = await pi.command(command, timeout);
             if (!signal?.aborted && response.success && (command.type === "compact" || command.type === "bash"))
                 await this.reloadMessagesLive(s, signal);
             return response;

package/dist/subagents.js

@@ -639,10 +639,16 @@ export class SubagentBridge {
         const model = typeof data.model === "string"
             ? data.model
             : `${resolved.provider ?? "unknown"}/${resolved.model_id ?? "unknown"}`;
+        const finalResponse = stripTaskSuffix(typeof data.final_response === "string" ? data.final_response : "");
+        const error = terminal(data.status) && data.status !== "completed" && typeof data.error_message === "string"
+            ? data.error_message
+            : undefined;
+        const runtime = stats.runtime_ms ?? data.duration_ms;
         const text = [
-            stripTaskSuffix(typeof data.final_response === "string" ? data.final_response : ""),
-            `Model: ${model}\nRuntime: ${stats.runtime_ms ?? data.duration_ms ?? 0} ms\nTokens: ${stats.total_tokens ?? 0}\nCost: $${stats.cost_usd ?? 0}`,
-            "Full transcript was not retained by OmO.",
+            finalResponse,
+            error && !finalResponse.includes(error) ? error : "",
+            `Model: ${model}\nRuntime: ${runtime === undefined ? "unknown" : `${runtime} ms`}\nTokens: ${stats.total_tokens ?? "unknown"}\nCost: ${stats.cost_usd === undefined ? "unknown" : `$${stats.cost_usd}`}`,
+            "Full transcript is unavailable.",
         ]
             .filter(Boolean)
             .join("\n\n");
@@ -666,6 +672,7 @@ export class SubagentBridge {
                 role: "assistant",
                 provider: resolved.provider ?? model.split("/")[0],
                 model: resolved.model_id ?? model.split("/").slice(1).join("/"),
+                ...(error ? { stopReason: "error", errorMessage: error } : {}),
                 // run_stats tokens are totals across the whole run (every model call),
                 // not one request's context, so only the cost is carried as usage; the
                 // totals stay in the text above. Token counts here read as context fill.

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "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.13",
+  "version": "0.2.15",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",
@@ -58,7 +58,8 @@
     "smoke": "tsx contrib/smoke.ts",
     "omo-smoke": "tsx contrib/omo/omo-smoke.ts",
     "model-smoke": "tsx contrib/model-consistency.ts",
-    "v2-smoke": "tsx contrib/v2-smoke.ts"
+    "v2-smoke": "tsx contrib/v2-smoke.ts",
+    "replay": "tsx contrib/replay/transcripts.ts"
   },
   "allowScripts": {
     "esbuild@0.28.2": true