antechamber 1.0.27 → 1.0.29

package/CHANGELOG.md

@@ -7,10 +7,28 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [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)
+
 ## [1.0.27] - 2026-10-28
 
 ### Fixed
 
+- Sign in to an MCP server from OpenChamber without a running OmO session in that directory. The sign-in now runs in
+  an agent started for it alone, which stops once the sign-in completes, is cancelled or expires, and every running
+  session reconnects the server afterwards so it picks up the new token.
 - Find OmO's builtin `/mcp` command when an extension such as `pi-mcp-adapter` also registers `mcp` and OmO renames
   the builtin to `mcp:1`. MCP sign-in used to fail there with "Unknown command /mcp".
 

package/dist/mcp.d.ts

@@ -5,7 +5,10 @@
  * Everything therefore targets the most recently used LIVE session in the directory; a
  * 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.
+ * Authorization in a directory without one runs in an agent spawned for that flow alone
+ * (`--no-session`), disposed once the flow completes, fails, is cancelled or expires.
+ * OmO stores tokens globally, so a completed sign-in reconnects the server in every other
+ * live session.
  *
  * Status comes from the read-only `get_loaded_surfaces` RPC. Authorization drives OmO's
  * documented `/mcp` subcommands (docs/mcp.md "Auth"):
@@ -20,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";
@@ -61,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;
 /**
@@ -69,6 +80,8 @@ export declare function authorizationUrl(text: string, name: string): string | u
  * authorization request's own `redirect_uri` and `state`.
  */
 export declare function redirectInput(authorization: string, input: string): string | undefined;
+/** Stops the agents spawned for sign-ins; live sessions are stopped by their own manager. */
+export declare function disposeMcpAgents(): Promise<void>;
 export declare function mcpRoute(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;
 export declare function mcpRouteV2(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;
 export {};

package/dist/mcp.js

@@ -5,7 +5,10 @@
  * Everything therefore targets the most recently used LIVE session in the directory; a
  * 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.
+ * Authorization in a directory without one runs in an agent spawned for that flow alone
+ * (`--no-session`), disposed once the flow completes, fails, is cancelled or expires.
+ * OmO stores tokens globally, so a completed sign-in reconnects the server in every other
+ * live session.
  *
  * Status comes from the read-only `get_loaded_surfaces` RPC. Authorization drives OmO's
  * documented `/mcp` subcommands (docs/mcp.md "Auth"):
@@ -22,6 +25,7 @@
  */
 import { randomUUID } from "node:crypto";
 import { errorBody } from "./http.js";
+import { PiRpcClient } from "./pi-rpc.js";
 /** Bounds how long an HTTP caller waits on a read-only RPC; the transport keeps its own budget. */
 const MCP_READ_WAIT_MS = 5_000;
 /** OmO announces the authorization URL before it waits for the browser. */
@@ -91,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.
@@ -181,8 +230,8 @@ function runMcpCommand(sessions, s, pi, name, commandName, args, observe = {}) {
     };
     pi.onEvent(onEvent);
     pi.onExtensionUI(onNotify);
-    return sessions.lifecycle
-        .use(s, () => pi.command({ type: "prompt", message: `/${commandName} ${args}`, expandPromptTemplates: true }, MCP_AUTH_COMMAND_TIMEOUT_MS))
+    const send = () => pi.command({ type: "prompt", message: `/${commandName} ${args}`, expandPromptTemplates: true }, MCP_AUTH_COMMAND_TIMEOUT_MS);
+    return (s === undefined ? send() : sessions.lifecycle.use(s, send))
         .then((response) => {
         if (!response.success)
             throw new Error(response.error ?? "OmO rejected the /mcp command");
@@ -200,11 +249,57 @@ function runMcpCommand(sessions, s, pi, name, commandName, args, observe = {}) {
 function announce(services, directory, name) {
     services.broadcast(directory, { type: "mcp.tools.changed", properties: { server: name } });
 }
+/** Other live sessions keep their own connection, which still lacks the new token until it reconnects. */
+function authorized(services, directory, name, flow) {
+    announce(services, directory, name);
+    const reconnects = services.sessions.liveSessions().flatMap((s) => {
+        const pi = s.pi;
+        if (pi === undefined || pi === flow.pi)
+            return [];
+        return [
+            mcpCommandName(pi)
+                .then((commandName) => commandName === undefined
+                ? undefined
+                : runMcpCommand(services.sessions, s, pi, name, commandName, `reconnect ${name}`))
+                .catch((error) => console.error(`[mcp] reconnecting ${name} in session ${s.info.id} failed: ${errorMessage(error)}`)),
+        ];
+    });
+    if (reconnects.length > 0)
+        void Promise.all(reconnects).then(() => announce(services, directory, name));
+}
+function agentCurrent(flow) {
+    return flow.s === undefined ? !flow.released : flow.s.pi === flow.pi;
+}
+function release(flow) {
+    if (flow.s !== undefined)
+        return;
+    flow.released = true;
+    clearTimeout(flow.expiry);
+    void flow.pi
+        .dispose()
+        .catch((error) => console.error(`[mcp] stopping an auth agent failed: ${errorMessage(error)}`));
+}
+/** Stops the agents spawned for sign-ins; live sessions are stopped by their own manager. */
+export async function disposeMcpAgents() {
+    const dedicated = [...flows.values()].filter((flow) => flow.s === undefined && !flow.released);
+    for (const flow of dedicated) {
+        flow.released = true;
+        clearTimeout(flow.expiry);
+    }
+    await Promise.all(dedicated.map((flow) => flow.pi.dispose()));
+}
+async function flowStatus(flow, name) {
+    if (flow.server !== undefined || !agentCurrent(flow))
+        return flow.server;
+    return currentStatus(flow.pi, name);
+}
 function pruneFlows() {
     const now = Date.now();
     for (const [key, flow] of flows)
-        if (!flow.running && (flow.s.pi !== flow.pi || now - flow.created > MCP_AUTH_ATTEMPT_TTL_MS))
+        if (!flow.running && (!agentCurrent(flow) || now - flow.created > MCP_AUTH_ATTEMPT_TTL_MS)) {
             flows.delete(key);
+            release(flow);
+        }
 }
 /** Concurrent clicks share one admission, so a second `/mcp auth` never races the first. */
 function admitFlow(services, directory, name, command) {
@@ -223,26 +318,35 @@ const inProgress = (name) => ({
 async function startFlow(services, directory, name, command) {
     if (!SERVER_NAME.test(name))
         return { error: { status: 400, body: errorBody("InvalidRequestError", "invalid MCP server name") } };
-    const live = liveSession(services.sessions, directory);
-    if (live === undefined)
-        return {
-            error: {
-                status: 400,
-                body: errorBody("McpUnavailableError", "MCP authorization needs a running OmO session in this directory"),
-            },
-        };
-    const { s, pi } = live;
     const key = flowKey(directory, name);
     pruneFlows();
     const existing = flows.get(key);
-    if (existing?.running && existing.pi === pi)
+    if (existing?.running && agentCurrent(existing))
         return existing.command === command ? { flow: existing } : inProgress(name);
-    const servers = await loadedServers(pi);
+    const live = liveSession(services.sessions, directory);
+    const s = live?.s;
+    const pi = live?.pi ?? new PiRpcClient({ cwd: directory, args: ["--no-session"] });
+    const refuse = async (status, error, message) => {
+        if (live === undefined)
+            await pi.dispose();
+        return { error: { status, body: errorBody(error, message) } };
+    };
+    let servers;
+    let commandName;
+    try {
+        // A spawned agent answers its first RPC only once it has started.
+        if (live === undefined)
+            await pi.command({ type: "get_state" });
+        servers = await loadedServers(pi);
+        commandName = await mcpCommandName(pi);
+    }
+    catch (error) {
+        return refuse(400, "McpUnavailableError", `OmO could not start for MCP authorization: ${errorMessage(error)}`);
+    }
     if (!servers.some((server) => server.name === name))
-        return { error: { status: 404, body: errorBody("McpServerNotFoundError", `MCP server not found: ${name}`) } };
-    const commandName = await mcpCommandName(pi);
+        return refuse(404, "McpServerNotFoundError", `MCP server not found: ${name}`);
     if (commandName === undefined)
-        return { error: { status: 400, body: errorBody("UnsupportedError", "This OmO build has no /mcp command") } };
+        return refuse(400, "UnsupportedError", "This OmO build has no /mcp command");
     const url = Promise.withResolvers();
     const flow = {
         s,
@@ -255,7 +359,15 @@ async function startFlow(services, directory, name, command) {
         done: Promise.resolve(),
         running: true,
         authorized: false,
+        released: false,
     };
+    if (live === undefined) {
+        pi.onExit(() => {
+            flow.released = true;
+        });
+        flow.expiry = setTimeout(() => release(flow), MCP_AUTH_ATTEMPT_TTL_MS);
+        flow.expiry.unref();
+    }
     flow.done = runMcpCommand(services.sessions, s, pi, name, commandName, `${command} ${name}`, {
         url: (found) => {
             flow.authorizationUrl ??= found;
@@ -265,12 +377,20 @@ async function startFlow(services, directory, name, command) {
             flow.authorized = true;
         },
     })
-        .then(() => {
-        if (flow.authorized)
-            announce(services, directory, name);
+        .then(async () => {
+        if (!flow.authorized)
+            return;
+        if (live === undefined) {
+            const server = await currentStatus(pi, name).catch(() => undefined);
+            if (server !== undefined)
+                flow.server = server;
+            release(flow);
+        }
+        authorized(services, directory, name, flow);
     })
         .catch((error) => {
         flow.error = errorMessage(error);
+        release(flow);
         throw error;
     })
         .finally(() => {
@@ -278,6 +398,8 @@ async function startFlow(services, directory, name, command) {
     });
     // The caller that started the flow may already have its URL; a later failure is still reported.
     void flow.done.catch((error) => console.error(`[mcp] authorization of ${name} failed: ${errorMessage(error)}`));
+    if (existing !== undefined)
+        release(existing);
     flows.set(key, flow);
     return { flow };
 }
@@ -310,10 +432,12 @@ async function completeFlow(services, directory, name, input) {
     const fail = (status, name_, message) => ({
         error: { status, body: errorBody(name_, message) },
     });
-    if (flow === undefined || flow.s.pi !== flow.pi || Date.now() - flow.created > MCP_AUTH_ATTEMPT_TTL_MS)
+    if (flow === undefined || Date.now() - flow.created > MCP_AUTH_ATTEMPT_TTL_MS)
         return fail(400, "McpAuthError", `No pending authorization for ${name}; start it again`);
     if (flow.authorized)
-        return { server: await currentStatus(flow.pi, name) };
+        return { server: await flowStatus(flow, name) };
+    if (!agentCurrent(flow))
+        return fail(400, "McpAuthError", `No pending authorization for ${name}; start it again`);
     if (flow.error !== undefined)
         return fail(400, "McpAuthError", `Authorization of ${name} failed (${flow.error}); start it again`);
     if (typeof input !== "string" || flow.authorizationUrl === undefined)
@@ -321,11 +445,15 @@ async function completeFlow(services, directory, name, input) {
     const redirect = redirectInput(flow.authorizationUrl, input);
     if (redirect === undefined)
         return fail(400, "InvalidRequestError", "code must be an authorization code or redirect URL");
+    // OmO consumes the pending state on any answer, so a dedicated agent has nothing left to wait for.
+    let attempted = false;
+    let server;
     try {
         if (flow.running && flow.command === "auth") {
             const target = new URL(redirect);
             if (!sameCallback(target, flow.authorizationUrl))
                 return fail(400, "McpAuthError", `OmO is waiting for ${name} on its loopback callback; paste that redirect`);
+            attempted = true;
             const delivered = await fetch(target, { redirect: "manual", signal: AbortSignal.timeout(MCP_READ_WAIT_MS) });
             if (!delivered.ok) {
                 // OmO ends the flow on a rejected callback; settle it so a retry cannot join the dead flow.
@@ -335,21 +463,30 @@ async function completeFlow(services, directory, name, input) {
             await flow.done;
         }
         else {
+            attempted = true;
             await runMcpCommand(services.sessions, flow.s, flow.pi, name, flow.commandName, `auth-complete ${name} ${redirect}`, {
                 authorized: () => {
                     flow.authorized = true;
                 },
             });
-            announce(services, directory, name);
+            if (flow.authorized)
+                authorized(services, directory, name, flow);
+            else
+                announce(services, directory, name);
         }
+        if (!flow.authorized)
+            return fail(400, "McpAuthError", flow.error ?? `MCP server ${name} did not complete authorization`);
+        server = await flowStatus(flow, name);
     }
     catch (error) {
         flow.error = errorMessage(error);
         return fail(400, "McpAuthError", flow.error);
     }
-    if (!flow.authorized)
-        return fail(400, "McpAuthError", flow.error ?? `MCP server ${name} did not complete authorization`);
-    return { server: await currentStatus(flow.pi, name) };
+    finally {
+        if (attempted)
+            release(flow);
+    }
+    return { server };
 }
 function decodeName(raw) {
     try {
@@ -397,7 +534,7 @@ export async function mcpRoute(services, method, path, directory, body) {
                 status: 400,
                 body: errorBody("McpAuthError", `MCP server ${name} is waiting for its authorization code; paste it to finish`),
             };
-        const server = await currentStatus(flow.pi, name);
+        const server = await flowStatus(flow, name);
         return { status: 200, body: server === undefined ? { status: "disabled" } : openCodeMcpStatus(server) };
     }
     const announced = await awaitAuthorizationUrl(flow, name);
@@ -489,8 +626,10 @@ export async function mcpRouteV2(services, method, path, directory, body) {
         return "error" in result ? result.error : { status: 204 };
     }
     if (method === "DELETE") {
-        if (flow !== undefined)
+        if (flow !== undefined) {
             flows.delete(flowKey(directory, name));
+            release(flow);
+        }
         return { status: 204 };
     }
     if (method !== "GET")

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

@@ -1,6 +1,7 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
 import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
+import { disposeMcpAgents } from "./mcp.js";
 import { debugLog } from "./misc-routes.js";
 import { SessionManager } from "./sessions.js";
 import { loadCatalog } from "./catalog.js";
@@ -64,7 +65,7 @@ export class AdapterServer {
             socket.destroy();
         this.webSocketClients.clear();
         try {
-            await this.sessions.disposeAll();
+            await Promise.all([this.sessions.disposeAll(), disposeMcpAgents()]);
         }
         finally {
             // An in-flight HTTP request must not hold shutdown open after teardown.

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/extensions/omo-compat/package.json

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