openmausbot 0.1.57 → 0.1.59

package/dist-server/server/drivers/antigravity-acp.js

@@ -48,6 +48,24 @@ function takeLines(buffer) {
     const rest = parts.pop() ?? "";
     return { lines: parts.map((line) => line.replace(/\r$/u, "")), rest };
 }
+/** Only fixed, allowlisted startup hints leave stderr. Native output can
+ * contain OAuth codes and credentials in arbitrary formats, so generic
+ * text redaction is not enough to safely echo a diagnostic tail. */
+function startupHint(line) {
+    if (/no space left|not enough (?:space|disk)|disk (?:is )?full|winerror\s*112/iu.test(line)) {
+        return "The runtime reported insufficient disk space while starting.";
+    }
+    if (/failed to (?:extract|load (?:python|embedded python))|could not load python/iu.test(line)) {
+        return "The runtime reported a problem unpacking or loading its bundled Python runtime.";
+    }
+    if (/permission denied|access is denied|winerror\s*5\b/iu.test(line)) {
+        return "The runtime reported a file or process permission failure.";
+    }
+    if (/address family not supported|failed to create.*(?:socket|listener)|failed to bind/iu.test(line)) {
+        return "The runtime reported a local network listener failure.";
+    }
+    return undefined;
+}
 /** The sign-in link in a server output line, or null for anything else.
  * Google announces it two ways and both land on stderr: it hands the link to
  * $BROWSER — our helper re-emits it JSON-encoded behind a private marker — and
@@ -125,6 +143,10 @@ export class AntigravityAcpClient {
     pending = new Map();
     buffer = "";
     diagnosticBuffer = "";
+    initializationComplete = false;
+    startupOutputBytes = 0;
+    startupDiagnosticBytes = 0;
+    nativeStartupHint;
     closed = false;
     onAuthorizationUrl;
     /** Settles once the runtime process is gone. On Windows a running
@@ -136,16 +158,17 @@ export class AntigravityAcpClient {
         this.child = spawnCli(runtime.executablePath, process.platform === "linux" ? ["--uid="] : [], { cwd, env: profile.environment, stdio: ["pipe", "pipe", "pipe"] });
         this.child.stdout.setEncoding("utf8");
         this.child.stdout.on("data", (chunk) => this.consume(chunk));
-        // Google announces the sign-in link on stderr, not stdout. Scan for that
-        // one line and drop every other byte: stderr also carries authorization
-        // codes, so nothing else is retained or surfaced.
+        // Keep only sign-in announcements and fixed startup failure categories;
+        // never surface raw stderr, which can contain authorization codes.
         this.child.stderr.setEncoding("utf8");
         this.child.stderr.on("data", (chunk) => this.consumeDiagnostics(chunk));
         this.child.once("error", (error) => this.failAll(error));
         this.exited = new Promise((resolve) => {
-            this.child.once("close", (code) => {
+            this.child.once("close", (code, signal) => {
+                this.noteStartupDiagnostic(this.diagnosticBuffer);
+                this.diagnosticBuffer = "";
                 if (!this.closed)
-                    this.failAll(new Error(`Antigravity ACP exited ${code ?? "unexpectedly"}.`));
+                    this.failAll(new Error(`Antigravity ACP exited ${code ?? signal ?? "unexpectedly"}.${this.nativeStartupHint ? ` ${this.nativeStartupHint}` : ""}`));
                 resolve();
             });
             // Failed spawns also emit `close`. An `error` alone can instead mean
@@ -153,6 +176,8 @@ export class AntigravityAcpClient {
         });
     }
     consume(chunk) {
+        if (!this.initializationComplete)
+            this.startupOutputBytes += Buffer.byteLength(chunk);
         this.buffer += chunk;
         if (Buffer.byteLength(this.buffer) > MAX_PROTOCOL_LINE_BYTES) {
             this.failAll(new Error("Antigravity sent a protocol line that is too large."));
@@ -206,11 +231,19 @@ export class AntigravityAcpClient {
      * and released immediately and the tail is capped, so no authorization code
      * is ever held. Draining also keeps the pipe from stalling the server. */
     consumeDiagnostics(chunk) {
+        if (!this.initializationComplete)
+            this.startupDiagnosticBytes += Buffer.byteLength(chunk);
         const { lines, rest } = takeLines(this.diagnosticBuffer + chunk);
         // A partial line already longer than any legal link cannot become one.
         this.diagnosticBuffer = rest.length > MAX_DIAGNOSTIC_LINE_CHARS ? "" : rest;
-        for (const line of lines)
-            this.announceAuthorizationUrl(line);
+        for (const line of lines) {
+            if (!this.announceAuthorizationUrl(line))
+                this.noteStartupDiagnostic(line);
+        }
+    }
+    noteStartupDiagnostic(line) {
+        if (!this.initializationComplete)
+            this.nativeStartupHint ??= startupHint(line);
     }
     failAll(error) {
         for (const pending of this.pending.values()) {
@@ -227,7 +260,16 @@ export class AntigravityAcpClient {
         return new Promise((resolveRequest, reject) => {
             const timer = setTimeout(() => {
                 this.pending.delete(id);
-                reject(new Error(`${method} timed out.`));
+                if (method === "initialize") {
+                    this.noteStartupDiagnostic(this.diagnosticBuffer);
+                    reject(new Error(`Antigravity initialization timed out after ${Math.ceil(timeoutMs / 1_000)} seconds (${process.platform}-${process.arch}). ` +
+                        "The executable was found, but did not finish starting. " +
+                        (this.nativeStartupHint ? `${this.nativeStartupHint} ` : "") +
+                        `Startup output: ${this.startupOutputBytes} bytes; diagnostic output: ${this.startupDiagnosticBytes} bytes. ` +
+                        "Retry setup. If it still fails, share this error and your OpenMausBot version; do not paste Google sign-in links or tokens."));
+                }
+                else
+                    reject(new Error(`${method} timed out.`));
             }, timeoutMs);
             timer.unref?.();
             this.pending.set(id, { resolve: resolveRequest, reject, timer });
@@ -235,11 +277,14 @@ export class AntigravityAcpClient {
         });
     }
     async initialize(timeoutMs = STARTUP_TIMEOUT_MS) {
-        return this.request("initialize", {
+        const initialized = await this.request("initialize", {
             protocolVersion: 1,
             clientInfo: { name: "openmausbot", version: "0.0.0" },
             clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
         }, timeoutMs);
+        this.initializationComplete = true;
+        this.nativeStartupHint = undefined;
+        return initialized;
     }
     close() {
         if (this.closed)
@@ -248,8 +293,7 @@ export class AntigravityAcpClient {
         this.failAll(new Error("Antigravity ACP was closed."));
         killCliTree(this.child);
     }
-    /** Close, then wait (bounded) for the process to be gone. `killCliTree`
-     * on Windows asks taskkill and returns at once; the exit lands later. */
+    /** Close, then wait (bounded) for the process to be gone. */
     async closeAndWait(timeoutMs = 5_000) {
         this.close();
         let timer;
@@ -440,6 +484,12 @@ export async function validateAntigravityRuntime(runtime, expectedVersion) {
             instanceId: `verify-${randomUUID()}`,
             runtime,
             profileDirectory,
+            // Google's Windows one-file executable expands a large Python runtime
+            // into TEMP. Forced shutdown skips its own cleanup. Keep verification's
+            // extraction inside the profile we already remove after confirmed close.
+            baseEnv: process.platform === "win32"
+                ? { ...process.env, TEMP: profileDirectory, TMP: profileDirectory }
+                : undefined,
         });
         client = new AntigravityAcpClient(runtime, profile, profileDirectory);
         const initialized = await client.initialize();

package/dist-server/server/drivers/antigravity-runtime.js

@@ -14,8 +14,8 @@ const DOWNLOAD_TIMEOUT_MS = 45 * 60_000;
 const STAGING_PREFIX = ".install-";
 /** Windows refuses to rename or delete a file something still holds open,
  * with EPERM/EBUSY/EACCES rather than a clear "in use": the runtime the
- * validator just stopped (taskkill is asynchronous) or an antivirus scan of
- * a brand-new executable. Retry briefly; persistent refusals still fail. */
+ * validator just stopped or an antivirus scan of a brand-new executable.
+ * Retry briefly; persistent refusals still fail. */
 export function transientWindowsFileError(error) {
     const code = typeof error === "object" && error !== null ? Reflect.get(error, "code") : undefined;
     return code === "EPERM" || code === "EBUSY" || code === "EACCES" || code === "ENOTEMPTY";

package/dist-server/server/drivers/antigravity.js

@@ -2,6 +2,7 @@ import { createAcpDriver } from "./acp/core.js";
 import { AntigravityAuthController, antigravityProfileAuthenticated, catalogFromAntigravityConfigOptions, prepareAntigravityProfile, probeAntigravityModels, validateAntigravityRuntime, } from "./antigravity-acp.js";
 import { antigravityManagedInstallAvailable, installAntigravityRuntime, resolveAntigravityRuntime, } from "./antigravity-runtime.js";
 import { resolveAntigravityReleaseAsset } from "./antigravity-release.js";
+import { augmentedPath } from "../env-path.js";
 export const STATIC_ANTIGRAVITY_MODELS = {
     default: "gemini-3.8-flash-high",
     options: [
@@ -107,8 +108,11 @@ export const AntigravityDriver = {
     async create(input) {
         const base = await AcpAntigravityDriver.create(input);
         const auth = new AntigravityAuthController();
+        let installFailure;
         const runtimeAndProfile = async () => {
-            const environment = { ...process.env, ...input.environment };
+            // Match the ACP driver's discovery/chat environment. A GUI launch's
+            // raw PATH may omit an official runtime that the model picker found.
+            const environment = { ...process.env, ...input.environment, PATH: augmentedPath() };
             const runtime = await resolveAntigravityRuntime(input.config.cli, environment);
             const profile = await prepareAntigravityProfile({
                 instanceId: input.instanceId,
@@ -122,10 +126,27 @@ export const AntigravityDriver = {
             get models() {
                 return base.models;
             },
+            snapshot: async () => {
+                const snapshot = await base.snapshot();
+                if (snapshot.state === "available")
+                    installFailure = undefined;
+                // A failed first install has no promoted executable yet. Preserve
+                // why it failed across closing/reopening setup in this app session.
+                return snapshot.state === "unavailable" && installFailure
+                    ? { ...snapshot, reason: installFailure }
+                    : snapshot;
+            },
             ...(antigravityManagedInstallAvailable()
                 ? {
                     installRuntime: async () => {
-                        await installAntigravityRuntime({ validate: validateAntigravityRuntime });
+                        installFailure = undefined;
+                        try {
+                            await installAntigravityRuntime({ validate: validateAntigravityRuntime });
+                        }
+                        catch (error) {
+                            installFailure = error instanceof Error ? error.message : String(error);
+                            throw error;
+                        }
                     },
                 }
                 : {}),

package/dist-server/server/drivers/codex-instructions.js

@@ -0,0 +1,66 @@
+// Codex owns history; this receipt only remembers which bot rules it accepted.
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DATA_DIR } from "../config.js";
+import { writeFileAtomic } from "../atomic.js";
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+/** Preserve native configured rules when overriding Codex's developer slot. */
+export function codexDeveloperInstructions(config, botInstructions) {
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+        throw new Error("Codex returned no effective configuration; cannot safely update bot instructions.");
+    }
+    const configured = config.developer_instructions;
+    if (configured != null && typeof configured !== "string") {
+        throw new Error("Codex returned invalid developer instructions; cannot safely update bot instructions.");
+    }
+    // Native rules previously outranked the bot's user-message prefix. Keep
+    // them last in the combined developer block to preserve that precedence.
+    return configured
+        ? `${botInstructions || "No OpenMausBot bot-specific instructions remain."}\n\n${configured}`
+        : botInstructions;
+}
+export async function syncCodexInstructions(key, nativeThreadId, instructions, resumed, request) {
+    const directory = join(DATA_DIR, "codex-instructions");
+    const path = join(directory, `${digest(JSON.stringify([key, nativeThreadId]))}.sha256`);
+    const fingerprint = digest(instructions);
+    let previous;
+    try {
+        previous = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (resumed && previous !== fingerprint) {
+        // thread/resume config overrides are used after compaction, but Codex
+        // 0.153.4 keeps the old initial developer message until then. Append a
+        // developer update ONLY on change (or first adoption of an old session).
+        // inject_items flushes native history before acknowledging; only then
+        // persist our receipt. Unknown-method errors must fail, never lose rules.
+        try {
+            await request("thread/inject_items", {
+                threadId: nativeThreadId,
+                items: [{
+                        type: "message",
+                        role: "developer",
+                        content: [{
+                                type: "input_text",
+                                text: "The following replaces the previous developer instruction block supplied by OpenMausBot, including its native configured rules and bot-specific instructions. Other Codex instructions and permissions still apply.\n\n"
+                                    + (instructions || "No OpenMausBot bot-specific instructions remain."),
+                            }],
+                    }],
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && /method not found|unknown method/i.test(error.message)) {
+                throw new Error(`This Codex version cannot update bot instructions in a resumed session. Update Codex and retry: ${error.message}`, { cause: error });
+            }
+            throw error;
+        }
+    }
+    if (!resumed || previous !== fingerprint) {
+        mkdirSync(directory, { recursive: true });
+        writeFileAtomic(path, fingerprint, { mode: 0o600 });
+    }
+}

package/dist-server/server/drivers/codex.js

@@ -8,7 +8,7 @@
 // codex-cli 0.144.4 by agentcal.
 //
 // resumeCursor is the codex thread id; a later turn tries thread/resume
-// and falls back to a fresh thread/start.
+// and preserves that history or reports a failed resume.
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { stripWorkspaceCredentialEnv } from "../config.js";
@@ -22,6 +22,7 @@ import { codexLocalProviderArgs } from "./local-inject.js";
 import { augmentedPath, splitCliString } from "../env-path.js";
 import { classifyError, computeBackoff, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { appendNative } from "./native.js";
+import { codexDeveloperInstructions, syncCodexInstructions } from "./codex-instructions.js";
 export { decodeCodexSelection, readCodexModelCatalog, STATIC_CODEX_MODELS } from "./codex-catalog.js";
 const DRIVER_KIND = "codex";
 const ASTRA_MODEL_ID = "gpt-6-astra";
@@ -300,18 +301,24 @@ function permissionProfileUnsupported(error) {
     const message = error instanceof Error ? error.message : String(error);
     return /(?:experimental api|invalid params|unknown field|unknown.*permissions|permissions.*(?:unsupported|sandbox)|cannot.*permissions)/i.test(message);
 }
-/** Keep private host paths out of diagnostics while preserving enough of the
- * app-server input shape to debug image delivery. The unmodified request is
+/** Keep native instructions and private host paths out of diagnostics while
+ * preserving enough of the input shape to debug delivery. The unmodified request is
  * still written to the provider immediately after this log copy is made. */
 function codexNativeLogMessage(message) {
     if (!message || typeof message !== "object" || Array.isArray(message))
         return message;
     const record = message;
-    if (record.method !== "turn/start")
-        return message;
     const params = record.params;
     if (!params || typeof params !== "object" || Array.isArray(params))
         return message;
+    if (record.method === "thread/start" || record.method === "thread/resume") {
+        return { ...record, params: { ...params, developerInstructions: "[developer instructions omitted]" } };
+    }
+    if (record.method === "thread/inject_items") {
+        return { ...record, params: { ...params, items: "[developer instruction update omitted]" } };
+    }
+    if (record.method !== "turn/start")
+        return message;
     const input = params.input;
     if (!Array.isArray(input))
         return message;
@@ -547,11 +554,13 @@ export const CodexDriver = {
                     });
                     send({ jsonrpc: "2.0", id, method, params });
                 });
+                let stopping;
+                const terminate = () => stopping ??= killCliTree(child);
                 const stop = () => {
                     stopRequested = true;
-                    killCliTree(child);
+                    return terminate();
                 };
-                const settle = (ok, stopReason) => {
+                const settle = async (ok, stopReason) => {
                     if (state.settled)
                         return;
                     state.settled = true;
@@ -560,9 +569,22 @@ export const CodexDriver = {
                     for (const p of rpcPending.values())
                         p.reject(new Error("turn settled"));
                     rpcPending.clear();
-                    active.delete(threadId);
-                    emit({ ...base(threadId, turnId), type: "turn.completed", ok, stopReason, cost: null, ...(state.usage ? { usage: state.usage } : {}) });
-                    stop(); // the app-server never exits on its own
+                    const complete = () => {
+                        if (active.get(threadId)?.stop !== stop)
+                            return;
+                        active.delete(threadId);
+                        emit({ ...base(threadId, turnId), type: "turn.completed", ok, stopReason, cost: null, ...(state.usage ? { usage: state.usage } : {}) });
+                    };
+                    if (await stop()) {
+                        complete();
+                    }
+                    else {
+                        emit({ ...base(threadId, turnId), type: "runtime.error", message: "codex did not shut down after termination was requested" });
+                        if (child.exitCode !== null || child.signalCode !== null)
+                            complete();
+                        else
+                            child.once("close", complete);
+                    }
                 };
                 // server→client approval request → canonical request.opened
                 // Host-scope tagging mirrors claude.ts: when this turn mounts the real
@@ -789,7 +811,7 @@ export const CodexDriver = {
                         }
                         case "turn/completed": {
                             const t = p.turn ?? {};
-                            settle(t.status === "completed", t.status === "completed" ? null : (t.error?.message ?? t.status ?? "failed"));
+                            void settle(t.status === "completed", t.status === "completed" ? null : (t.error?.message ?? t.status ?? "failed"));
                             break;
                         }
                         case "error":
@@ -808,9 +830,11 @@ export const CodexDriver = {
                 // multibyte characters that straddle two reads and corrupts the text
                 child.stdout.setEncoding("utf8");
                 child.stdout.on("data", (chunk) => {
+                    if (abandoned || state.settled)
+                        return;
                     buf += chunk;
                     let nl;
-                    while ((nl = buf.indexOf("\n")) !== -1) {
+                    while (!state.settled && (nl = buf.indexOf("\n")) !== -1) {
                         const line = buf.slice(0, nl);
                         buf = buf.slice(nl + 1);
                         if (!line.trim())
@@ -852,7 +876,7 @@ export const CodexDriver = {
                     if (abandoned)
                         return;
                     emit({ ...base(threadId, turnId), type: "runtime.error", ...describeSpawnFailure(e, config.cli) });
-                    settle(false, "spawn_error");
+                    void settle(false, "spawn_error");
                 });
                 child.on("close", (code) => {
                     if (abandoned)
@@ -863,7 +887,7 @@ export const CodexDriver = {
                             type: "runtime.error",
                             message: `codex exited ${code} before turn/completed${stderr ? `: ${stderr.trim().slice(-300)}` : ""}`,
                         });
-                        settle(false, "exit_before_result");
+                        void settle(false, "exit_before_result");
                     }
                 });
                 active.set(threadId, { stop, turnId, asks });
@@ -883,26 +907,28 @@ export const CodexDriver = {
                         capabilities: { experimentalApi: true },
                     });
                     send({ jsonrpc: "2.0", method: "initialized", params: {} });
+                    // developerInstructions replaces, rather than appends to, native
+                    // config. Read it for every approval mode so existing rules survive.
+                    // request() already redacts config/read responses from native logs.
+                    let effectiveConfig;
+                    try {
+                        const configured = await request("config/read", {
+                            cwd: turn.cwd ?? homedir(),
+                            includeLayers: false,
+                        });
+                        effectiveConfig = configured?.config;
+                    }
+                    catch {
+                        // Do not expose a possibly secret-bearing native config error or
+                        // overwrite unknown instructions with an empty fallback.
+                        throw new Error("Could not read Codex configuration; cannot safely update bot instructions. Retry after checking Codex.");
+                    }
+                    const developerInstructions = codexDeveloperInstructions(effectiveConfig, turn.system ?? "");
                     let approvalParams;
                     if (approvalMode === "custom") {
                         // config/read returns the effective global + project config for this
                         // cwd. Reasserting those values is essential: simply omitting them
                         // on a resumed thread would keep the previous named mode sticky.
-                        let effectiveConfig;
-                        try {
-                            const configured = await request("config/read", {
-                                cwd: turn.cwd ?? homedir(),
-                                includeLayers: false,
-                            });
-                            effectiveConfig = configured?.config;
-                        }
-                        catch {
-                            // Older app-servers and transient failures cannot prove the
-                            // user's configured sandbox. Fall back to interactive read-only
-                            // instead of inheriting stale Full or silently broadening a
-                            // possibly read-only config to workspace write.
-                            effectiveConfig = {};
-                        }
                         approvalParams = customApprovalParams(effectiveConfig);
                     }
                     else {
@@ -913,6 +939,9 @@ export const CodexDriver = {
                     // mode may synthesize approvals; Custom must preserve the sandbox
                     // boundary from config.toml (for example never + read-only).
                     autoAcceptPermissions = approvalMode === "full";
+                    // Each turn launches a new app-server. Reassert current bot instructions
+                    // on start AND resume so Codex owns their lifetime through compaction.
+                    // Removed bot rules are cleared without dropping native configured rules.
                     const cursor = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
                     let codexThreadId = null;
                     let startedModel = null;
@@ -920,6 +949,7 @@ export const CodexDriver = {
                         try {
                             const resumed = await request("thread/resume", {
                                 threadId: cursor,
+                                developerInstructions,
                                 ...approvalParams.thread,
                             });
                             codexThreadId = resumed?.thread?.id ?? cursor;
@@ -930,23 +960,22 @@ export const CodexDriver = {
                                 // profile selector. Retry the same resume safely rather than
                                 // losing the native thread or inheriting its previous mode.
                                 approvalParams = approvalParams.fallback;
-                                try {
-                                    const resumed = await request("thread/resume", {
-                                        threadId: cursor,
-                                        ...approvalParams.thread,
-                                    });
-                                    codexThreadId = resumed?.thread?.id ?? cursor;
-                                }
-                                catch {
-                                    /* thread gone or resume unsupported — start fresh below */
-                                }
+                                const resumed = await request("thread/resume", {
+                                    threadId: cursor,
+                                    developerInstructions,
+                                    ...approvalParams.thread,
+                                });
+                                codexThreadId = resumed?.thread?.id ?? cursor;
+                            }
+                            else {
+                                throw error;
                             }
-                            /* thread gone or resume unsupported — start fresh below */
                         }
                     }
                     if (!codexThreadId) {
                         const selection = decodeCodexSelection(turn.model);
                         const startThread = () => request("thread/start", {
+                            developerInstructions,
                             cwd: turn.cwd ?? homedir(),
                             model: selection.model,
                             ...(selection.modelProvider ? { modelProvider: selection.modelProvider } : {}),
@@ -966,8 +995,11 @@ export const CodexDriver = {
                         codexThreadId = started?.thread?.id ?? null;
                         startedModel = started?.model ?? null;
                     }
+                    if (!codexThreadId)
+                        throw new Error("Codex did not return a native thread id");
+                    await syncCodexInstructions(threadId, codexThreadId, developerInstructions, Boolean(cursor), request);
                     emit({ ...base(threadId, turnId), type: "session.started", sessionId: codexThreadId, model: startedModel ?? turn.model ?? null });
-                    const promptText = turn.system ? `${turn.system}\n\n${turn.text}` : turn.text;
+                    const promptText = turn.text;
                     const turnInput = [
                         ...(promptText ? [{ type: "text", text: promptText }] : []),
                         ...(turn.images ?? []).map((image) => ({ type: "localImage", path: image.path })),
@@ -1015,7 +1047,10 @@ export const CodexDriver = {
                         // This app-server never exits by itself. Retire the failed attempt
                         // and silence its late handlers before the replacement launches.
                         abandoned = true;
-                        killCliTree(child);
+                        if (!await terminate()) {
+                            void settle(false, "shutdown_timeout");
+                            return;
+                        }
                         await new Promise((resolve) => {
                             const timer = setTimeout(resolve, Math.max(1, Math.round(delayMs * retryScale)));
                             timer.unref?.();
@@ -1024,7 +1059,7 @@ export const CodexDriver = {
                             void launchAttempt(attempt).catch(() => { });
                         }
                         else {
-                            settle(false, "interrupted");
+                            await settle(false, "interrupted");
                         }
                         return;
                     }
@@ -1035,7 +1070,7 @@ export const CodexDriver = {
                             message,
                             ...(needsAuth ? { setup: true } : {}),
                         });
-                        settle(false, needsAuth ? "auth_required" : "rpc_error");
+                        await settle(false, needsAuth ? "auth_required" : "rpc_error");
                     }
                 }
             };
@@ -1087,7 +1122,9 @@ export const CodexDriver = {
                     effortLevels: ["low", "medium", "high", "xhigh", "max"],
                 },
                 sendTurn,
-                interruptTurn: async (threadId) => active.get(threadId)?.stop(),
+                interruptTurn: async (threadId) => {
+                    await active.get(threadId)?.stop();
+                },
                 respondToRequest: async (threadId, requestId, decision) => {
                     const turn = active.get(threadId);
                     const finish = turn?.asks.get(requestId);
@@ -1098,8 +1135,7 @@ export const CodexDriver = {
                 },
                 hasSession: (threadId) => active.has(threadId),
                 stopAll: async () => {
-                    for (const { stop } of active.values())
-                        stop();
+                    await Promise.all([...active.values()].map(({ stop }) => stop()));
                 },
                 onEvent: (listener) => {
                     listeners.add(listener);
@@ -1107,8 +1143,7 @@ export const CodexDriver = {
                 },
             },
             dispose: async () => {
-                for (const { stop } of active.values())
-                    stop();
+                await Promise.all([...active.values()].map(({ stop }) => stop()));
                 listeners.clear();
             },
         };