antechamber 1.0.28 → 1.0.30

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.30] - 2026-10-28
+
+- update
+- update
+- update
+
+## [1.0.29] - 2026-10-28
+
+### Fixed
+
+- Stop OmO from cancelling a `/compact` that revives a session. OmO cancels a running compaction whenever an MCP
+  server's tools register, which a freshly started agent does for about a second, so the chat showed
+  "Compaction failed" twice (OpenChamber 2.5 draws these events as transcript rows) above a compaction that then
+  succeeded. A compaction now waits, at most 10 s, until OmO reports no MCP server still connecting. Cancellations
+  nobody asked for are retried up to four times instead of two, and a retried attempt is no longer reported as a
+  failure; a compaction the user stops still is.
+
 ## [1.0.28] - 2026-10-28
 
 - fix(mcp): sign in to MCP servers without a running OmO session (#79)

package/dist/mcp.d.ts

@@ -23,6 +23,7 @@
  * An extension that registers its own `mcp` command makes OmO rename the builtin (`mcp:1`),
  * so the builtin is found by its source, not by name.
  */
+import { PiRpcClient } from "./pi-rpc.js";
 import type { RouteServices } from "./route-services.js";
 type OCMcpStatus = {
     status: "connected";
@@ -64,6 +65,13 @@ export declare const MCP_AUTH_COMMAND_TIMEOUT_MS: number;
 /** OmO's runtime states fold onto OpenCode's; lazy servers are usable, so they read as connected. */
 export declare function openCodeMcpStatus(server: OmoMcpServer): OCMcpStatus;
 export declare function v2McpStatus(server: OmoMcpServer): V2McpStatus;
+/**
+ * Resolves once no MCP server is still connecting, after `budgetMs`, or on abort. OmO cancels a running
+ * compaction whenever a server's tools register (setActiveTools -> abortCompaction, senpi
+ * chunks/chunk-NNQ7DPUD.js). A probe on 2026-10-28 found three servers connecting when get_state answered,
+ * all connected within about a second, each change announced by `loaded_surfaces_changed`.
+ */
+export declare function waitForMcpServers(pi: PiRpcClient, budgetMs: number, signal?: AbortSignal): Promise<void>;
 /** The URL OmO prints on its own line after naming the server (`auth` and `auth-start` both do). */
 export declare function authorizationUrl(text: string, name: string): string | undefined;
 /**

package/dist/mcp.js

@@ -95,6 +95,51 @@ async function loadedServers(pi) {
         ]
         : []);
 }
+/**
+ * Resolves once no MCP server is still connecting, after `budgetMs`, or on abort. OmO cancels a running
+ * compaction whenever a server's tools register (setActiveTools -> abortCompaction, senpi
+ * chunks/chunk-NNQ7DPUD.js). A probe on 2026-10-28 found three servers connecting when get_state answered,
+ * all connected within about a second, each change announced by `loaded_surfaces_changed`.
+ */
+export async function waitForMcpServers(pi, budgetMs, signal) {
+    const deadline = Date.now() + budgetMs;
+    let changed = false;
+    let wake = () => { };
+    const listener = (ev) => {
+        if (ev.type !== "loaded_surfaces_changed")
+            return;
+        changed = true;
+        wake();
+    };
+    pi.onEvent(listener);
+    try {
+        while (!signal?.aborted) {
+            changed = false;
+            const servers = await loadedServers(pi).catch(() => []);
+            if (!servers.some((server) => server.status === "connecting"))
+                return;
+            if (changed)
+                continue;
+            const left = deadline - Date.now();
+            if (left <= 0)
+                return;
+            await new Promise((resolve) => {
+                const done = () => {
+                    clearTimeout(timer);
+                    signal?.removeEventListener("abort", done);
+                    wake = () => { };
+                    resolve();
+                };
+                const timer = setTimeout(done, left);
+                signal?.addEventListener("abort", done, { once: true });
+                wake = done;
+            });
+        }
+    }
+    finally {
+        pi.off("event", listener);
+    }
+}
 async function directoryServers(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.

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

@@ -76,6 +76,8 @@ export declare class PiEventTranslator {
     private onToolEvent;
     private onMessageEvent;
     private onCompactionEvent;
+    /** Publishes a held compaction cancellation once sessionRpc will not retry it. */
+    releaseCompactionEnd(s: ManagedSession): void;
     private finishStreaming;
     private onMessageUpdate;
     private onProviderTools;

package/dist/pi-event-translation.js

@@ -634,6 +634,11 @@ export class PiEventTranslator {
     onCompactionEvent(s, ev) {
         switch (ev.type) {
             case "compaction_start":
+                // sessionRpc retried a cancelled compaction: the UI still shows the first attempt running.
+                if (s.heldCompactionEnd !== undefined) {
+                    delete s.heldCompactionEnd;
+                    return;
+                }
                 // An auto-compaction can fall between steps; its summary is a new step.
                 this.completeAwaitingTools(s);
                 s.compactionID = id("compaction");
@@ -654,6 +659,11 @@ export class PiEventTranslator {
                 }
                 return;
             case "compaction_end": {
+                const retry = s.compactRetry;
+                if (ev.aborted === true && retry !== undefined && retry.left > 0 && (s.abortRequests ?? 0) === retry.aborts) {
+                    s.heldCompactionEnd = ev;
+                    return;
+                }
                 delete s.info.time.compacting;
                 const result = ev.result;
                 const inputID = s.compactionID ?? id("compaction");
@@ -715,6 +725,14 @@ export class PiEventTranslator {
                 return;
         }
     }
+    /** Publishes a held compaction cancellation once sessionRpc will not retry it. */
+    releaseCompactionEnd(s) {
+        const ev = s.heldCompactionEnd;
+        if (ev === undefined)
+            return;
+        delete s.heldCompactionEnd;
+        this.onCompactionEvent(s, ev);
+    }
     finishStreaming(s) {
         if (s.streaming)
             s.streaming = undefined;

package/dist/pi-rpc.d.ts

@@ -24,6 +24,12 @@ export declare const COMPACT_RPC_TIMEOUT_MS: number;
 export declare class UpstreamProtocolError extends Error {
     constructor(message: string);
 }
+/**
+ * How far above antechamber's own `oom_score_adj` each agent is placed. The agent and everything it starts
+ * (test runners, compilers, OmO's task host) inherit it, so under memory pressure the kernel OOM killer and
+ * earlyoom take a workload before the adapter, whose death stops every session at once.
+ */
+export declare const AGENT_OOM_SCORE_ADJ_MARGIN = 300;
 /** A process's group and kernel start time: with the PID, the identity that survives PID reuse checks. */
 interface ProcessIdentity {
     readonly pid: number;

package/dist/pi-rpc.js

@@ -11,7 +11,7 @@ import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { EventEmitter } from "node:events";
 import { randomUUID } from "node:crypto";
-import { readdirSync, readFileSync } from "node:fs";
+import { readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { constants as osConstants } from "node:os";
 import { systemClock } from "./lifecycle.js";
 import { agentBinary, envSetting } from "./config.js";
@@ -31,6 +31,25 @@ export class UpstreamProtocolError extends Error {
     }
 }
 const PROCESS_KILL_GRACE_MS = 5_000;
+/**
+ * How far above antechamber's own `oom_score_adj` each agent is placed. The agent and everything it starts
+ * (test runners, compilers, OmO's task host) inherit it, so under memory pressure the kernel OOM killer and
+ * earlyoom take a workload before the adapter, whose death stops every session at once.
+ */
+export const AGENT_OOM_SCORE_ADJ_MARGIN = 300;
+/** Linux only: rank the agent above antechamber for the OOM killer. Raising a child's score needs no privilege. */
+function rankAboveAdapterForOom(pid) {
+    if (process.platform !== "linux")
+        return;
+    try {
+        const target = Math.min(1000, Number(readFileSync("/proc/self/oom_score_adj", "utf8")) + AGENT_OOM_SCORE_ADJ_MARGIN);
+        if (Number(readFileSync(`/proc/${pid}/oom_score_adj`, "utf8")) < target)
+            writeFileSync(`/proc/${pid}/oom_score_adj`, String(target));
+    }
+    catch (error) {
+        console.error(`[pi-rpc] could not raise the agent's OOM score: ${error instanceof Error ? error.message : error}`);
+    }
+}
 // Linux /proc. Any read failure (gone, no permission, no /proc) means the identity cannot be
 // verified, and an unverifiable process is never signalled: fail closed.
 const procTable = {
@@ -165,6 +184,8 @@ export class PiRpcClient extends EventEmitter {
             },
             detached: true,
         });
+        if (this.proc.pid !== undefined)
+            rankAboveAdapterForOom(this.proc.pid);
         this.proc.stderr.on("data", (chunk) => {
             this.stderrTail = (this.stderrTail + chunk.toString()).slice(-8192);
         });

package/dist/sessions.d.ts

@@ -51,6 +51,13 @@ export interface ManagedSession extends ThinkingState {
     /** A manual compaction started while idle; its end returns the session to idle. */
     compactingFromIdle?: boolean;
     compactionID?: string;
+    /** Retries sessionRpc still owes a `compact` command that OmO cancels on its own. */
+    compactRetry?: {
+        left: number;
+        aborts: number;
+    };
+    /** A cancelled compaction_end held back while its retry may continue the same compaction. */
+    heldCompactionEnd?: Record<string, unknown>;
     /** Cancels the adapter-owned user bash waiter and its OmO execution. */
     cancelShell?: (interrupted?: boolean) => void;
     /**

package/dist/sessions.js

@@ -20,6 +20,7 @@ import { MonitorSessions } from "./monitor-sessions.js";
 import { WorkStatusBridge } from "./work-status.js";
 import { OmoShells } from "./omo-shells.js";
 import { sessionDiff } from "./session-diff.js";
+import { waitForMcpServers } from "./mcp.js";
 import { announceSessionNotice, noticeMessage, skillCommandText, slashTitlePrompt } from "./session-commands.js";
 import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionFileMeta, } from "./session-store.js";
 import { ADAPTER_VERSION } from "./version.js";
@@ -30,7 +31,11 @@ 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;
+// Real revivals took two cancels before the third attempt committed (OmO compaction.log, 2026-10-27),
+// so two retries left no margin for one more MCP server connecting late.
+const COMPACT_CANCEL_RETRIES = 4;
+/** Longest a compaction waits for connecting MCP servers; a stuck server falls back to the retries. */
+const MCP_SETTLE_WAIT_MS = 10_000;
 /**
  * A dormant session's record as OmO will resume it. OpenChamber 2.x restores a reopened session's effort
  * from this record and resends it, so the model and level come together from the file; the registry only
@@ -829,20 +834,39 @@ export class SessionManager {
                 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;
+            // 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")
+                await waitForMcpServers(pi, MCP_SETTLE_WAIT_MS, signal);
             signal?.throwIfAborted();
             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);
+            // The translator holds back a cancellation this loop may retry, so the UI shows one compaction.
+            if (command.type === "compact")
+                s.compactRetry = { left: COMPACT_CANCEL_RETRIES, aborts: abortsBefore };
+            let response;
+            try {
+                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++) {
+                    if (s.compactRetry)
+                        s.compactRetry.left--;
+                    response = await pi.command(command, timeout);
+                }
+            }
+            finally {
+                if (command.type === "compact") {
+                    delete s.compactRetry;
+                    this.events.releaseCompactionEnd(s);
+                }
+            }
             if (!signal?.aborted && response.success && (command.type === "compact" || command.type === "bash"))
                 await this.reloadMessagesLive(s, signal);
             return response;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 export declare const ADAPTER_VERSION: string;
-export declare const OPENCODE_API_VERSION = "2.1.0";
+export declare const OPENCODE_API_VERSION = "2.999.0";

package/dist/version.js

@@ -11,4 +11,4 @@ export const ADAPTER_VERSION = manifest.version;
 // OpenChamber parses --version as an OpenCode version and requires major 2.
 // This API contract version must not follow the npm package version.
 // OpenChamber 2.5.2 requires 2.1.0, which added top-level `archived` to PATCH /api/session/{id}.
-export const OPENCODE_API_VERSION = "2.1.0";
+export const OPENCODE_API_VERSION = "2.999.0";

package/extensions/omo-compat/package.json

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