openmausbot 0.1.83 → 0.1.85

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

@@ -5,6 +5,17 @@
 // argv, auth method, model catalog, sign-in check) live in a small support
 // object. Adding a harness = write server/drivers/acp/<name>.ts.
 //
+// One live agent process per (thread, spawn contract): the ACP handshake
+// (initialize, authenticate) and the native session are established once,
+// and later turns prompt the live session directly instead of paying the
+// full handshake per message. The pool mirrors the Claude driver: a session
+// closes after OMB_ACP_SESSION_IDLE_MS of quiet (default 10 minutes, floored
+// by OMB_ACP_SESSION_IDLE_MIN_MS default 10s), when the spawn contract
+// changes, when the child crashes, when an interrupt's cancel goes
+// unanswered, and on stopAll/dispose. A resume cursor left by an earlier
+// session resumes through session/load|resume when the process had to
+// respawn.
+//
 // ACP has no `turn/completed` notification: the `session/prompt` RPC *result*
 // is the completion signal (it carries stopReason + usage). Permission
 // requests arrive as server→client `session/request_permission` and surface
@@ -17,6 +28,7 @@
 import { homedir } from "node:os";
 import { lstat, mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
+import { createHash } from "node:crypto";
 import { PROVIDER_CREDENTIAL_ENV, WORKSPACE_CREDENTIAL_ENV } from "../../config.js";
 import { decodeInjectId } from "../local-inject.js";
 import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../../procs.js";
@@ -32,11 +44,26 @@ import { augmentedPath } from "../../env-path.js";
 import { supportsApprovalMode } from "../../../shared/approval-mode.js";
 import { appendNative } from "../native.js";
 import { commandSummary, toolDetailPreview } from "../../tool-summary.js";
+import { extractMcpImages } from "../../mcp-tool-images.js";
 const envOr = (key, fallback) => Number(process.env[key] ?? fallback);
 const INIT_TIMEOUT = envOr("OPENMAUS_ACP_INIT_TIMEOUT_MS", 300_000);
 const SESSION_CONFIG_TIMEOUT = envOr("OPENMAUS_ACP_SESSION_CONFIG_TIMEOUT_MS", 300_000); // configureSession's per-request default
 const NEW_SESSION_TIMEOUT = envOr("OPENMAUS_ACP_NEW_SESSION_TIMEOUT_MS", 300_000);
 const LOAD_SESSION_TIMEOUT = envOr("OPENMAUS_ACP_LOAD_SESSION_TIMEOUT_MS", 120_000); // history replay on a long thread is slow
+// Read lazily (not at import) so a test can shorten the window. Unlike the
+// setup calls above, session/prompt legitimately streams for minutes, so a
+// wall-clock deadline would false-positive: this guard only trips when the
+// child sends nothing at all for the whole window (a wedged OpenCode turn
+// streams thought chunks, then goes silent forever and never resolves). 0
+// disables the guard, restoring the pre-fix "hang until the user cancels"
+// behavior.
+const promptIdleTimeoutMs = () => {
+    const raw = process.env.OPENMAUS_ACP_PROMPT_IDLE_TIMEOUT_MS;
+    if (raw === undefined)
+        return 180_000;
+    const ms = Number(raw);
+    return Number.isFinite(ms) && ms > 0 ? ms : 0;
+};
 const CLIENT_FILE_MAX_BYTES = 8 * 1024 * 1024;
 function acpVariantOption(result) {
     const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.type === "select" && typeof entry.id === "string"
@@ -198,6 +225,48 @@ export function createAcpDriver(support) {
                 await refreshModels();
             const listeners = new Set();
             const active = new Map();
+            // One live agent process per thread, kept across turns — the Claude
+            // driver's pool. The ACP handshake (initialize, authenticate) and the
+            // native session are established once; a later turn on the same spawn
+            // contract prompts the live session instead of paying the handshake
+            // again. An idle session closes after SESSION_IDLE_MS of quiet.
+            const sessions = new Map();
+            const configuredIdleMinimum = Number(process.env.OMB_ACP_SESSION_IDLE_MIN_MS);
+            const sessionIdleMinimum = Number.isFinite(configuredIdleMinimum) && configuredIdleMinimum > 0
+                ? configuredIdleMinimum
+                : 10_000;
+            const SESSION_IDLE_MS = Math.max(sessionIdleMinimum, Number(process.env.OMB_ACP_SESSION_IDLE_MS) || 10 * 60_000);
+            const closeSession = (threadId, why) => {
+                const session = sessions.get(threadId);
+                if (!session || session.closing)
+                    return;
+                session.closing = true;
+                if (session.idleTimer)
+                    clearTimeout(session.idleTimer);
+                appendNative(threadId, { dir: "out", source: SOURCE, msg: { close: why } });
+                // a new turn must never adopt a closing session
+                sessions.delete(threadId);
+                session.acp.close();
+                // stdin EOF asks the agent to exit; EOF is not a guaranteed exit
+                // signal for ACP agents, so insist after a grace period
+                try {
+                    session.child.stdin.end();
+                }
+                catch { }
+                const kill = setTimeout(() => {
+                    void killCliTree(session.child);
+                }, 5_000);
+                kill.unref?.();
+            };
+            const armIdle = (threadId) => {
+                const session = sessions.get(threadId);
+                if (!session)
+                    return;
+                if (session.idleTimer)
+                    clearTimeout(session.idleTimer);
+                session.idleTimer = setTimeout(() => closeSession(threadId, "idle"), SESSION_IDLE_MS);
+                session.idleTimer.unref?.();
+            };
             // "Always allow this session", remembered by the driver when the agent
             // offered no `allow_always` of its own: the exact operations (kind,
             // title, command, input, locations) a person allowed for the session,
@@ -297,109 +366,61 @@ export function createAcpDriver(support) {
                 }
                 return servers;
             };
-            const sendTurn = async (turn) => {
-                const { threadId } = turn;
-                if (active.has(threadId))
-                    throw new Error("a turn is already running on this thread");
-                // Provider-instance `fullAuto` predates per-bot approval levels. Every
-                // harness turn now carries the bot's mode, so Ask/Auto must explicitly
-                // put the native agent back into its interactive mode. Otherwise a
-                // legacy Grok bypassPermissions / Cursor --force / Droid auto-high /
-                // Antigravity yolo setting would silently outrank the selector. Calls
-                // that omit approvalMode retain the old adapter-level behavior for
-                // embedders and tests outside the harness.
-                const turnConfig = turn.approvalMode === undefined
-                    ? config
-                    : { ...config, fullAuto: turn.approvalMode === "full" && supportsApprovalMode(DRIVER_KIND, "full") };
-                const controlsHost = turn.integrations?.localComputer?.scope === "local-computer";
-                if (controlsHost && turnConfig.fullAuto && turn.approvalMode !== "full") {
-                    throw new Error("local computer control requires interactive provider approvals");
-                }
-                const turnId = newId();
-                const cwd = turn.cwd ?? turnConfig.workspace ?? homedir();
-                const env = childEnv(turnConfig);
-                if (support.requireAuthenticationBeforeSpawn
-                    && !skipSubscriptionAuthForLocalInject(turn.model)
-                    && !(await support.isAuthenticated(env, turnConfig, instanceId))) {
-                    emit({ ...base(threadId, turnId), type: "turn.started" });
-                    emit({ ...base(threadId, turnId), type: "runtime.error", message: support.loginNote, setup: true });
-                    emit({ ...base(threadId, turnId), type: "turn.completed", ok: false, stopReason: "auth_required", cost: null });
-                    return { turnId };
-                }
-                const resolvedModel = support.resolveTurnModel?.(turn.model, env);
-                support.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true });
-                const cliTurn = resolvedModel !== undefined && resolvedModel !== turn.model
-                    ? { ...turn, model: resolvedModel }
-                    : turn;
-                const mcpServers = acpMcpServers(turn);
-                let launch;
-                try {
-                    launch = support.resolveCommand
-                        ? await support.resolveCommand(env, turnConfig, instanceId)
-                        : { command: turnConfig.cli };
+            /** The one completion path for a turn: the prompt result, a crashed
+             *  child, an unanswered cancel, or an rpc error the turn body throws.
+             *  The child is NOT killed here — a clean settle leaves it pooled for
+             *  the next turn on this contract. */
+            const settle = (threadId, session, ok, stopReason) => {
+                const current = session.current;
+                if (!current || current.state.settled)
+                    return;
+                current.state.settled = true;
+                if (current.interruptTimer)
+                    clearTimeout(current.interruptTimer);
+                for (const finish of current.asks.values())
+                    finish("cancel", "system");
+                session.acp.failAll(new Error("turn settled"));
+                // detach before the final events: a listener that starts the next
+                // turn synchronously must find this session free
+                session.current = null;
+                active.delete(threadId);
+                current.flushAssistantText();
+                emit({ ...base(threadId, current.turnId), type: "turn.completed", ok, stopReason, cost: null });
+                if (session.child.exitCode === null && !session.closing && !session.dead) {
+                    armIdle(threadId);
                 }
-                catch (error) {
-                    emit({ ...base(threadId, turnId), type: "turn.started" });
-                    emit({
-                        ...base(threadId, turnId),
-                        type: "runtime.error",
-                        message: error instanceof Error ? error.message : String(error),
-                        setup: true,
-                    });
-                    emit({ ...base(threadId, turnId), type: "turn.completed", ok: false, stopReason: "setup_required", cost: null });
-                    return { turnId };
+                else if (session.dead && sessions.get(threadId) === session) {
+                    // a dead session is never pooled; the next turn respawns
+                    sessions.delete(threadId);
                 }
-                const child = spawnCli(launch.command, [...(launch.args ?? []), ...support.spawnArgs(turnConfig, cliTurn)], {
+            };
+            /** Spawn the agent process and everything that lives for its whole
+             *  lifetime: the wire connection, native logging, stderr tailing, and
+             *  the server-request/update dispatch. Per-turn state arrives through
+             *  session.current, so a request that lands between turns is answered
+             *  (never brokered) instead of left hanging. */
+            const openSession = (threadId, launch, argv, env, cwd, contractKey) => {
+                const child = spawnCli(launch.command, argv, {
                     cwd,
-                    env: launch.env ?? env,
+                    env,
                     stdio: ["pipe", "pipe", "pipe"],
                 });
-                const state = { settled: false, promptSent: false, text: "" };
-                const asks = new Map();
                 let nextId = 1;
-                let sessionId = null;
-                let sessionConfigResult = null;
-                const modelOf = (result) => {
-                    const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.id === (support.selectModel?.configId ?? "model"));
-                    return typeof option?.currentValue === "string" ? option.currentValue : null;
-                };
-                const receiveModelVariants = (result) => {
-                    sessionConfigResult = result;
-                    if (!support.modelVariants)
-                        return;
-                    const nativeModel = modelOf(result) ?? cliTurn.model;
-                    if (!nativeModel)
-                        return;
-                    const option = acpVariantOption(result);
-                    emit({
-                        ...base(threadId, turnId),
-                        type: "session.model-variants",
-                        model: nativeModel === cliTurn.model ? (turn.model ?? nativeModel) : nativeModel,
-                        variants: {
-                            options: option?.options ?? [],
-                            ...(option?.currentValue !== undefined ? { currentValue: option.currentValue } : {}),
-                        },
-                    });
-                };
-                const requestedVariantOption = () => {
-                    if (!support.modelVariants)
-                        throw new Error(`${support.displayName} does not support model variants`);
-                    const option = acpVariantOption(sessionConfigResult);
-                    if (!option || !option.options.some((entry) => entry.id === turn.variant)) {
-                        throw new Error(`${support.displayName} does not advertise variant ${turn.variant} for this model`);
-                    }
-                    return option;
-                };
-                let interruptTimer = null;
                 const rpcPending = new Map();
                 const send = (obj) => {
+                    // A permission/file response resumes an agent that was waiting on us.
+                    const message = obj;
+                    if (message.id !== undefined && (message.result !== undefined || message.error !== undefined)) {
+                        for (const pending of rpcPending.values())
+                            pending.armIdle();
+                    }
                     try {
                         child.stdin.write(JSON.stringify(obj) + "\n");
                     }
                     catch { }
                     appendNative(threadId, { dir: "out", source: SOURCE, msg: nativeLogMessage(obj) });
                 };
-                const request = (method, params, timeoutMs, receive) => new Promise((resolve, reject) => {
+                const request = (method, params, timeoutMs, receive, idleMs, idleMessage) => new Promise((resolve, reject) => {
                     const id = nextId++;
                     let timer = null;
                     if (timeoutMs) {
@@ -409,16 +430,59 @@ export function createAcpDriver(support) {
                         }, timeoutMs);
                         timer.unref?.();
                     }
+                    // Idle watchdog: unlike a wall-clock timeout, the deadline restarts
+                    // on every inbound line (see the stdout handler), so a long-lived
+                    // streaming agent is never cut off — only one that has gone fully
+                    // silent trips it.
+                    let idleTimer = null;
+                    const armIdle = () => {
+                        if (!(idleMs && idleMs > 0))
+                            return;
+                        if (idleTimer)
+                            clearTimeout(idleTimer);
+                        idleTimer = setTimeout(() => {
+                            // Waiting for a person is not an unresponsive agent.
+                            if (session.current?.asks.size) {
+                                armIdle();
+                                return;
+                            }
+                            rpcPending.delete(id);
+                            const error = new Error(idleMessage ?? `${method} stopped responding`);
+                            Object.assign(error, { acpPromptStall: true });
+                            reject(error);
+                        }, idleMs);
+                        idleTimer.unref?.();
+                    };
+                    armIdle();
                     rpcPending.set(id, {
                         // Consume configuration in wire order: an update following this
                         // response may arrive before the awaiting continuation resumes.
                         resolve: (result) => { receive?.(result); resolve(result); },
                         reject,
                         timer,
+                        get idleTimer() { return idleTimer; },
+                        armIdle,
                     });
                     send({ jsonrpc: "2.0", id, method, params });
                 });
-                const stop = () => killCliTree(child);
+                const acp = {
+                    send,
+                    request,
+                    failAll: (error) => {
+                        for (const p of rpcPending.values()) {
+                            if (p.timer)
+                                clearTimeout(p.timer);
+                            if (p.idleTimer)
+                                clearTimeout(p.idleTimer);
+                            p.reject(error);
+                        }
+                        rpcPending.clear();
+                    },
+                    close: () => {
+                        acp.failAll(new Error("session closed"));
+                        child.stdout.removeAllListeners("data");
+                    },
+                };
                 const resolveClientPath = async (requestPath) => {
                     if (typeof requestPath !== "string" || !isAbsolute(requestPath)) {
                         throw new Error("ACP file paths must be absolute.");
@@ -469,8 +533,8 @@ export function createAcpDriver(support) {
                                 send({ jsonrpc: "2.0", id: msg.id, result: { content } });
                                 return;
                             }
-                            const line = Number.isInteger(params.line) && params.line > 0 ? params.line : 1;
-                            const limit = Number.isInteger(params.limit) && params.limit >= 0 ? params.limit : undefined;
+                            const line = typeof params.line === "number" && Number.isInteger(params.line) && params.line > 0 ? params.line : 1;
+                            const limit = typeof params.limit === "number" && Number.isInteger(params.limit) && params.limit >= 0 ? params.limit : undefined;
                             const lines = content.split("\n");
                             const start = line - 1;
                             send({
@@ -491,35 +555,9 @@ export function createAcpDriver(support) {
                         fail(error);
                     }
                 };
-                /** Emit buffered assistant text as its own item, then clear it. */
-                const flushAssistantText = () => {
-                    const text = state.text;
-                    state.text = "";
-                    if (!text.trim())
-                        return;
-                    emit({ ...base(threadId, turnId), type: "item.completed", itemType: "assistant_text", text });
-                };
-                const settle = (ok, stopReason) => {
-                    if (state.settled)
-                        return;
-                    state.settled = true;
-                    if (interruptTimer)
-                        clearTimeout(interruptTimer);
-                    for (const finish of asks.values())
-                        finish("cancel", "system");
-                    for (const p of rpcPending.values()) {
-                        if (p.timer)
-                            clearTimeout(p.timer);
-                        p.reject(new Error("turn settled"));
-                    }
-                    rpcPending.clear();
-                    active.delete(threadId);
-                    flushAssistantText();
-                    emit({ ...base(threadId, turnId), type: "turn.completed", ok, stopReason, cost: null });
-                    stop(); // the agent process does not exit on its own
-                };
-                // server→client permission request → canonical request.opened
-                const handleServerRequest = (msg) => {
+                // server→client permission request → canonical request.opened,
+                // answered fail-closed for the running turn
+                const handleServerRequest = (msg, current) => {
                     if (msg.method === "fs/read_text_file" || msg.method === "fs/write_text_file") {
                         void handleClientFileRequest(msg);
                         return;
@@ -529,7 +567,7 @@ export function createAcpDriver(support) {
                         return send({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: "method not found" } });
                     }
                     const params = msg.params ?? {};
-                    flushAssistantText();
+                    current.flushAssistantText();
                     const options = Array.isArray(params.options) ? params.options : [];
                     const optionFor = (want) => options.find((o) => o.kind === `${want}_once` && typeof o.optionId === "string")?.optionId
                         ?? options.find((o) => String(o.kind ?? "").startsWith(want) && typeof o.optionId === "string")?.optionId
@@ -537,13 +575,13 @@ export function createAcpDriver(support) {
                     const optionAlways = options.find((o) => o.kind === "allow_always" && typeof o.optionId === "string")?.optionId ?? null;
                     const cancelled = { outcome: { outcome: "cancelled" } };
                     const missing = (want) => emit({
-                        ...base(threadId, turnId),
+                        ...base(threadId, current.turnId),
                         type: "runtime.error",
                         message: `${DRIVER_KIND} offered no "${want}" permission option — cancelling the request instead of guessing`,
                     });
                     const toolCall = params.toolCall ?? {};
                     const isQuestion = String(toolCall.toolCallId ?? "").startsWith("interaction_");
-                    if (turnConfig.fullAuto && turn.approvalMode === undefined && !isQuestion) {
+                    if (current.turnConfig.fullAuto && current.turn.approvalMode === undefined && !isQuestion) {
                         const allow = optionFor("allow");
                         if (!allow)
                             missing("allow");
@@ -555,7 +593,7 @@ export function createAcpDriver(support) {
                     }
                     const kind = String(toolCall.kind ?? "");
                     // an earlier "Always allow this session" on this exact operation
-                    const operationKey = isQuestion || controlsHost ? null : sessionOperationKey(toolCall);
+                    const operationKey = isQuestion || current.controlsHost ? null : sessionOperationKey(toolCall);
                     if (operationKey && sessionAllows.get(threadId)?.has(operationKey)) {
                         const allow = optionFor("allow");
                         if (allow) {
@@ -566,11 +604,11 @@ export function createAcpDriver(support) {
                     const summary = String(toolCall.rawInput?.command ?? toolCall.title ?? tool).slice(0, 200);
                     const requestId = newId();
                     const finish = (behavior, source = "user", message, always) => {
-                        if (!asks.delete(requestId))
+                        if (!current.asks.delete(requestId))
                             return;
                         clearTimeout(timer);
                         const want = behavior === "allow" ? "allow" : "reject";
-                        const forSession = want === "allow" && always === true && !isQuestion && !controlsHost;
+                        const forSession = want === "allow" && always === true && !isQuestion && !current.controlsHost;
                         const named = isQuestion && behavior === "answer"
                             ? options.filter((option) => option.optionId === message || option.name?.trim() === message)
                             : [];
@@ -596,22 +634,22 @@ export function createAcpDriver(support) {
                             result: optionId ? { outcome: { outcome: "selected", optionId } } : cancelled,
                         });
                         emit({
-                            ...base(threadId, turnId),
+                            ...base(threadId, current.turnId),
                             type: "request.resolved",
                             requestId,
                             behavior: optionId && isQuestion ? "answer" : optionId && behavior === "allow" ? "allow" : "deny",
                             source: optionId ? source : "system",
-                            approvalScope: controlsHost ? "local-computer" : undefined,
+                            approvalScope: current.controlsHost ? "local-computer" : undefined,
                         });
                     };
                     const timer = setTimeout(() => {
-                        emit({ ...base(threadId, turnId), type: "runtime.error", message: DENY_TIMEOUT_NOTE });
+                        emit({ ...base(threadId, current.turnId), type: "runtime.error", message: DENY_TIMEOUT_NOTE });
                         finish("deny", "timeout");
                     }, 15 * 60_000);
                     timer.unref?.();
-                    asks.set(requestId, finish);
+                    current.asks.set(requestId, finish);
                     emit({
-                        ...base(threadId, turnId),
+                        ...base(threadId, current.turnId),
                         type: "request.opened",
                         requestId,
                         requestType: isQuestion ? "question" : "permission",
@@ -620,9 +658,9 @@ export function createAcpDriver(support) {
                         choices: isQuestion
                             ? options.flatMap((option) => typeof option.name === "string" && option.name.trim() ? [option.name.trim()] : [])
                             : undefined,
-                        approvalScope: controlsHost ? "local-computer" : undefined,
+                        approvalScope: current.controlsHost ? "local-computer" : undefined,
                         // the driver can honor a session-wide allow either way
-                        allowSession: !isQuestion && !controlsHost ? true : undefined,
+                        allowSession: !isQuestion && !current.controlsHost ? true : undefined,
                     });
                 };
                 const handleNotification = (msg) => {
@@ -633,12 +671,13 @@ export function createAcpDriver(support) {
                     const p = msg.params ?? {};
                     if (p._meta?.isReplay === true)
                         return;
+                    const current = session.current;
                     if (support.modelVariants && p.update?.sessionUpdate === "config_option_update") {
-                        if (!state.settled && sessionId && p.sessionId === sessionId)
-                            receiveModelVariants(p.update);
+                        if (current && !current.state.settled && session.sessionId && p.sessionId === session.sessionId)
+                            current.receiveModelVariants(p.update);
                         return;
                     }
-                    if (!state.promptSent)
+                    if (!current || !current.state.promptSent)
                         return;
                     const u = p.update ?? {};
                     switch (u.sessionUpdate) {
@@ -646,9 +685,9 @@ export function createAcpDriver(support) {
                             const content = u.content;
                             const delta = content?.text;
                             if (content?.type === "image" && typeof content.data === "string" && content.data) {
-                                flushAssistantText();
+                                current.flushAssistantText();
                                 emit({
-                                    ...base(threadId, turnId),
+                                    ...base(threadId, current.turnId),
                                     type: "item.completed",
                                     itemType: "assistant_image",
                                     data: content.data,
@@ -656,22 +695,22 @@ export function createAcpDriver(support) {
                                 });
                             }
                             else if (typeof delta === "string" && delta) {
-                                state.text += delta;
-                                emit({ ...base(threadId, turnId), type: "content.delta", streamKind: "assistant_text", delta });
+                                current.state.text += delta;
+                                emit({ ...base(threadId, current.turnId), type: "content.delta", streamKind: "assistant_text", delta });
                             }
                             break;
                         }
                         case "agent_thought_chunk": {
                             const delta = u.content?.text;
                             if (typeof delta === "string" && delta) {
-                                emit({ ...base(threadId, turnId), type: "content.delta", streamKind: "reasoning_text", delta });
+                                emit({ ...base(threadId, current.turnId), type: "content.delta", streamKind: "reasoning_text", delta });
                             }
                             break;
                         }
                         case "tool_call": {
-                            flushAssistantText();
+                            current.flushAssistantText();
                             emit({
-                                ...base(threadId, turnId),
+                                ...base(threadId, current.turnId),
                                 type: "item.started",
                                 itemType: "tool",
                                 itemId: u.toolCallId,
@@ -684,18 +723,38 @@ export function createAcpDriver(support) {
                         case "tool_call_update": {
                             if (u.status === "completed" || u.status === "failed") {
                                 emit({
-                                    ...base(threadId, turnId),
+                                    ...base(threadId, current.turnId),
                                     type: "item.completed",
                                     itemType: "tool",
                                     itemId: u.toolCallId,
                                     ok: u.status !== "failed",
                                     output: toolDetailPreview(u.rawOutput ?? u.content),
                                 });
+                                for (const img of extractMcpImages(u.content ?? u.rawOutput)) {
+                                    emit({ ...base(threadId, current.turnId), type: "item.completed", itemType: "assistant_image", data: img.data });
+                                }
                             }
                             break;
                         }
                     }
                 };
+                const session = {
+                    child,
+                    acp,
+                    launch,
+                    cwd,
+                    contractKey,
+                    sessionKey: null,
+                    sessionId: null,
+                    sessionConfigResult: null,
+                    initResult: null,
+                    authenticated: false,
+                    idleTimer: null,
+                    closing: false,
+                    dead: false,
+                    stderr: "",
+                    current: null,
+                };
                 let buf = "";
                 // decode as UTF-8 across chunk boundaries — a raw `buf += chunk` splits
                 // multibyte characters that straddle two reads and corrupts the text
@@ -716,12 +775,18 @@ export function createAcpDriver(support) {
                             continue;
                         }
                         appendNative(threadId, { dir: "in", source: SOURCE, msg: nativeLogMessage(msg) });
+                        // Inbound traffic proves the child is alive and making progress,
+                        // so every idle deadline restarts; only total silence trips it.
+                        for (const p of rpcPending.values())
+                            p.armIdle();
                         if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
                             const pend = rpcPending.get(msg.id);
                             if (pend) {
                                 rpcPending.delete(msg.id);
                                 if (pend.timer)
                                     clearTimeout(pend.timer);
+                                if (pend.idleTimer)
+                                    clearTimeout(pend.idleTimer);
                                 if (msg.error) {
                                     const error = new Error(msg.error.message ?? JSON.stringify(msg.error));
                                     Object.assign(error, { code: msg.error.code, data: msg.error.data });
@@ -733,112 +798,348 @@ export function createAcpDriver(support) {
                             }
                         }
                         else if (msg.id !== undefined && msg.method) {
-                            handleServerRequest(msg);
+                            const current = session.current;
+                            if (!current) {
+                                // between turns nothing is brokered: cancel a permission
+                                // request and refuse anything else — the agent must never
+                                // block on an unanswered request
+                                send(msg.method === "session/request_permission"
+                                    ? { jsonrpc: "2.0", id: msg.id, result: { outcome: { outcome: "cancelled" } } }
+                                    : { jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: "method not found" } });
+                            }
+                            else {
+                                handleServerRequest(msg, current);
+                            }
                         }
                         else if (msg.method) {
                             handleNotification(msg);
                         }
                     }
                 });
-                let stderr = "";
                 child.stderr.on("data", (c) => {
                     if (!support.redactStderr)
-                        stderr += c;
-                    if (stderr.length > 8192)
-                        stderr = stderr.slice(-8192);
+                        session.stderr += c;
+                    if (session.stderr.length > 8192)
+                        session.stderr = session.stderr.slice(-8192);
                 });
                 child.on("error", (e) => {
-                    emit({ ...base(threadId, turnId), type: "runtime.error", ...describeSpawnFailure(e, launch.command) });
-                    settle(false, "spawn_error");
+                    session.dead = true;
+                    const current = session.current;
+                    if (!current)
+                        return;
+                    emit({ ...base(threadId, current.turnId), type: "runtime.error", ...describeSpawnFailure(e, launch.command) });
+                    settle(threadId, session, false, "spawn_error");
                 });
                 child.on("close", (code) => {
-                    if (!state.settled) {
+                    session.dead = true;
+                    const current = session.current;
+                    if (current) {
                         emit({
-                            ...base(threadId, turnId),
+                            ...base(threadId, current.turnId),
                             type: "runtime.error",
-                            message: `${DRIVER_KIND} exited ${code} before the prompt result${stderr ? `: ${stderr.trim().slice(-300)}` : ""}`,
+                            message: `${DRIVER_KIND} exited ${code} before the prompt result${session.stderr ? `: ${session.stderr.trim().slice(-300)}` : ""}`,
                         });
-                        settle(false, "exit_before_result");
+                        settle(threadId, session, false, "exit_before_result");
+                    }
+                    else if (sessions.get(threadId) === session) {
+                        // drop the record between turns; a later turn respawns. The
+                        // identity check keeps an old child's exit from unlinking a
+                        // session that already replaced this one.
+                        sessions.delete(threadId);
                     }
                 });
+                return session;
+            };
+            const sendTurn = async (turn) => {
+                const { threadId } = turn;
+                if (active.has(threadId))
+                    throw new Error("a turn is already running on this thread");
+                // Provider-instance `fullAuto` predates per-bot approval levels. Every
+                // harness turn now carries the bot's mode, so Ask/Auto must explicitly
+                // put the native agent back into its interactive mode. Otherwise a
+                // legacy Grok bypassPermissions / Cursor --force / Droid auto-high /
+                // Antigravity yolo setting would silently outrank the selector. Calls
+                // that omit approvalMode retain the old adapter-level behavior for
+                // embedders and tests outside the harness.
+                const turnConfig = turn.approvalMode === undefined
+                    ? config
+                    : { ...config, fullAuto: turn.approvalMode === "full" && supportsApprovalMode(DRIVER_KIND, "full") };
+                const controlsHost = turn.integrations?.localComputer?.scope === "local-computer";
+                if (controlsHost && turnConfig.fullAuto && turn.approvalMode !== "full") {
+                    throw new Error("local computer control requires interactive provider approvals");
+                }
+                const turnId = newId();
+                const cwd = turn.cwd ?? turnConfig.workspace ?? homedir();
+                const env = childEnv(turnConfig);
+                if (support.requireAuthenticationBeforeSpawn
+                    && !skipSubscriptionAuthForLocalInject(turn.model)
+                    && !(await support.isAuthenticated(env, turnConfig, instanceId))) {
+                    emit({ ...base(threadId, turnId), type: "turn.started" });
+                    emit({ ...base(threadId, turnId), type: "runtime.error", message: support.loginNote, setup: true });
+                    emit({ ...base(threadId, turnId), type: "turn.completed", ok: false, stopReason: "auth_required", cost: null });
+                    return { turnId };
+                }
+                const resolvedModel = support.resolveTurnModel?.(turn.model, env);
+                support.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true });
+                const cliTurn = resolvedModel !== undefined && resolvedModel !== turn.model
+                    ? { ...turn, model: resolvedModel }
+                    : turn;
+                const mcpServers = acpMcpServers(turn);
+                let launch;
+                try {
+                    launch = support.resolveCommand
+                        ? await support.resolveCommand(env, turnConfig, instanceId)
+                        : { command: turnConfig.cli };
+                }
+                catch (error) {
+                    emit({ ...base(threadId, turnId), type: "turn.started" });
+                    emit({
+                        ...base(threadId, turnId),
+                        type: "runtime.error",
+                        message: error instanceof Error ? error.message : String(error),
+                        setup: true,
+                    });
+                    emit({ ...base(threadId, turnId), type: "turn.completed", ok: false, stopReason: "setup_required", cost: null });
+                    return { turnId };
+                }
+                // The spawn contract: everything that changes what process a turn
+                // gets. The model rides argv where a support passes -m, and a
+                // selectModel support re-applies it over the wire on the live
+                // session, so the model is not a separate axis; fullAuto covers the
+                // transformEnv-policy supports (opencode). mcpServers are session
+                // establishment inputs — they ride session/new and session/load over
+                // the wire — and the harness mints fresh integration bearer tokens
+                // every turn, so they must not respawn the process; a change instead
+                // re-establishes the session below (see sessionKey).
+                // The env the spawned child actually receives is part of the
+                // contract too, and arrives hashed as envFingerprint for the same
+                // reason.
+                const spawnArgs = support.spawnArgs(turnConfig, cliTurn);
+                const spawnEnv = launch.env ?? env;
+                // Env is part of the spawn contract: a turn that changes auth env
+                // (FACTORY_API_KEY placeholder, a fresh login file) must not keep
+                // riding a child spawned under the old env. Hash it so secrets
+                // never sit in the key itself.
+                const envFingerprint = createHash("sha256").update(JSON.stringify(spawnEnv)).digest("hex").slice(0, 16);
+                const contractKey = JSON.stringify([launch.command, launch.args ?? [], spawnArgs, cwd, turnConfig.fullAuto === true, envFingerprint]);
+                const sessionKey = JSON.stringify(mcpServers);
+                const pooled = sessions.get(threadId);
+                let session;
+                if (pooled && !pooled.dead && !pooled.closing && pooled.contractKey === contractKey) {
+                    // adoption cancels the idle countdown — a running turn is not quiet
+                    if (pooled.idleTimer)
+                        clearTimeout(pooled.idleTimer);
+                    pooled.idleTimer = null;
+                    session = pooled;
+                }
+                else {
+                    if (pooled) {
+                        // a dead child already exited — just drop the record; a live one
+                        // gets the full close (contract changed)
+                        if (pooled.dead)
+                            sessions.delete(threadId);
+                        else
+                            closeSession(threadId, "contract");
+                    }
+                    session = openSession(threadId, launch, [...(launch.args ?? []), ...spawnArgs], spawnEnv, cwd, contractKey);
+                    sessions.set(threadId, session);
+                }
+                // `session` rebinds mid-turn: when the establishment retry below
+                // respawns the child, every wire call must reach the live record, so
+                // nothing captures the connection off it.
+                const request = (method, params, timeoutMs, receive, idleMs, idleMessage) => session.acp.request(method, params, timeoutMs, receive, idleMs, idleMessage);
+                const state = { settled: false, promptSent: false, text: "" };
+                const asks = new Map();
+                const modelOf = (result) => {
+                    const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.id === (support.selectModel?.configId ?? "model"));
+                    return typeof option?.currentValue === "string" ? option.currentValue : null;
+                };
+                const receiveModelVariants = (result) => {
+                    session.sessionConfigResult = result;
+                    if (!support.modelVariants)
+                        return;
+                    const nativeModel = modelOf(result) ?? cliTurn.model;
+                    if (!nativeModel)
+                        return;
+                    const option = acpVariantOption(result);
+                    emit({
+                        ...base(threadId, turnId),
+                        type: "session.model-variants",
+                        model: nativeModel === cliTurn.model ? (turn.model ?? nativeModel) : nativeModel,
+                        variants: {
+                            options: option?.options ?? [],
+                            ...(option?.currentValue !== undefined ? { currentValue: option.currentValue } : {}),
+                        },
+                    });
+                };
+                const requestedVariantOption = () => {
+                    if (!support.modelVariants)
+                        throw new Error(`${support.displayName} does not support model variants`);
+                    const option = acpVariantOption(session.sessionConfigResult);
+                    if (!option || !option.options.some((entry) => entry.id === turn.variant)) {
+                        throw new Error(`${support.displayName} does not advertise variant ${turn.variant} for this model`);
+                    }
+                    return option;
+                };
+                /** Emit buffered assistant text as its own item, then clear it. */
+                const flushAssistantText = () => {
+                    const text = state.text;
+                    state.text = "";
+                    if (!text.trim())
+                        return;
+                    emit({ ...base(threadId, turnId), type: "item.completed", itemType: "assistant_text", text });
+                };
+                const current = {
+                    turnId,
+                    turn: cliTurn,
+                    turnConfig,
+                    controlsHost,
+                    state,
+                    asks,
+                    interruptTimer: null,
+                    flushAssistantText,
+                    receiveModelVariants,
+                };
                 const interrupt = () => {
-                    if (sessionId)
-                        send({ jsonrpc: "2.0", method: "session/cancel", params: { sessionId } });
-                    else
-                        stop();
-                    if (interruptTimer)
-                        clearTimeout(interruptTimer);
-                    interruptTimer = setTimeout(() => settle(true, "cancelled"), 5_000);
-                    interruptTimer.unref?.();
+                    if (session.sessionId) {
+                        session.acp.send({ jsonrpc: "2.0", method: "session/cancel", params: { sessionId: session.sessionId } });
+                        if (current.interruptTimer)
+                            clearTimeout(current.interruptTimer);
+                        current.interruptTimer = setTimeout(() => {
+                            // an agent that ignores session/cancel must not stay pooled
+                            closeSession(threadId, "cancel-timeout");
+                            settle(threadId, session, true, "cancelled");
+                        }, 5_000);
+                        current.interruptTimer.unref?.();
+                    }
+                    else {
+                        // no native session to cancel — the close handler settles
+                        closeSession(threadId, "stop");
+                    }
                 };
-                active.set(threadId, { stop, interrupt, turnId, asks });
+                active.set(threadId, { stop: () => closeSession(threadId, "stop"), interrupt, turnId, asks });
                 emit({ ...base(threadId, turnId), type: "turn.started" });
+                session.current = current;
                 (async () => {
                     try {
-                        const init = await request("initialize", {
-                            protocolVersion: 1,
-                            clientInfo: { name: "openmausbot", version: "0.0.0" },
-                            clientCapabilities: {
-                                fs: {
-                                    readTextFile: support.clientFileSystem === true,
-                                    writeTextFile: support.clientFileSystem === true,
-                                },
-                                terminal: false,
-                            },
-                        }, INIT_TIMEOUT);
-                        const methods = Array.isArray(init?.authMethods) ? init.authMethods : [];
-                        const methodId = support.pickAuthMethod(methods);
-                        if (!skipSubscriptionAuthForLocalInject(turn.model)) {
-                            if (methodId) {
-                                try {
-                                    await request("authenticate", { methodId }, INIT_TIMEOUT);
+                        // The handshake is paid once per process, not once per turn. It
+                        // is a function so the establishment retry below can pay it
+                        // again on a replacement child.
+                        // Returns whether this runtime accepts image prompts, for the
+                        // prompt phase below.
+                        const handshake = async () => {
+                            if (!session.initResult) {
+                                session.initResult = await request("initialize", {
+                                    protocolVersion: 1,
+                                    clientInfo: { name: "openmausbot", version: "0.0.0" },
+                                    clientCapabilities: {
+                                        fs: {
+                                            readTextFile: support.clientFileSystem === true,
+                                            writeTextFile: support.clientFileSystem === true,
+                                        },
+                                        terminal: false,
+                                    },
+                                }, INIT_TIMEOUT);
+                            }
+                            // authenticate is once per process; a turn that skips
+                            // subscription auth neither checks nor marks the flag
+                            if (!skipSubscriptionAuthForLocalInject(turn.model) && !session.authenticated) {
+                                const methods = Array.isArray(session.initResult?.authMethods)
+                                    ? session.initResult.authMethods
+                                    : [];
+                                const methodId = support.pickAuthMethod(methods);
+                                if (methodId) {
+                                    try {
+                                        await request("authenticate", { methodId }, INIT_TIMEOUT);
+                                        session.authenticated = true;
+                                    }
+                                    catch {
+                                        if (support.authFailure === "fail")
+                                            throw new Error(support.loginNote);
+                                        // else: proceed on an ambient login
+                                    }
                                 }
-                                catch {
-                                    if (support.authFailure === "fail")
-                                        throw new Error(support.loginNote);
-                                    // else: proceed on an ambient login
+                                else if (support.authFailure === "fail") {
+                                    throw new Error(support.loginNote);
                                 }
                             }
-                            else if (support.authFailure === "fail") {
-                                throw new Error(support.loginNote);
+                            const images = turn.images ?? [];
+                            const accepts = session.initResult?.agentCapabilities?.promptCapabilities?.image === true ||
+                                support.acceptsUnadvertisedImages?.(session.initResult) === true;
+                            if (images.length && support.images === true && !accepts) {
+                                throw new Error(`${support.displayName} is configured for image attachments, but this installed runtime does not advertise ACP image input. Update the ${support.displayName} CLI or send the message without an image.`);
                             }
-                        }
-                        const images = turn.images ?? [];
-                        const runtimeAcceptsImages = init?.agentCapabilities?.promptCapabilities?.image === true ||
-                            support.acceptsUnadvertisedImages?.(init) === true;
-                        if (images.length && support.images === true && !runtimeAcceptsImages) {
-                            throw new Error(`${support.displayName} is configured for image attachments, but this installed runtime does not advertise ACP image input. Update the ${support.displayName} CLI or send the message without an image.`);
-                        }
-                        // stdio is every agent's baseline; a url server rides only with
-                        // an agent that advertised its transport, so an agent without
-                        // http/sse never sees an entry it would refuse the session over
-                        const sessionServers = mcpServers.filter((server) => !("type" in server) || init?.agentCapabilities?.mcpCapabilities?.[server.type] === true);
+                            return accepts;
+                        };
+                        let runtimeAcceptsImages = await handshake();
+                        let init = session.initResult;
                         const cursor = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
-                        // a fresh native session forgets what the previous one allowed
-                        if (!cursor)
-                            sessionAllows.delete(threadId);
                         let sessionResult = null;
-                        if (cursor) {
-                            try {
-                                sessionResult = await request(support.resumeMethod === "resume" ? "session/resume" : "session/load", { sessionId: cursor, cwd, mcpServers: sessionServers }, LOAD_SESSION_TIMEOUT, (result) => {
-                                    if (result) {
-                                        sessionId = cursor;
-                                        receiveModelVariants(result);
-                                    }
-                                });
+                        for (;;) {
+                            const liveSessionId = session.sessionId;
+                            if (liveSessionId !== null && session.sessionKey === sessionKey && (cursor === null || cursor === liveSessionId)) {
+                                // the pooled session still answers the cursor (or the cursor's
+                                // absence) and was established with these exact session inputs:
+                                // prompt it directly — no session/load replay, no session/new,
+                                // no fresh session bookkeeping
+                                break;
+                            }
+                            // stdio is every agent's baseline; a url server rides only with
+                            // an agent that advertised its transport, so an agent without
+                            // http/sse never sees an entry it would refuse the session over
+                            const sessionServers = mcpServers.filter((server) => !("type" in server) || init?.agentCapabilities?.mcpCapabilities?.[server.type] === true);
+                            let loaded = false;
+                            if (cursor) {
+                                try {
+                                    await request(support.resumeMethod === "resume" ? "session/resume" : "session/load", { sessionId: cursor, cwd, mcpServers: sessionServers }, LOAD_SESSION_TIMEOUT, (result) => {
+                                        if (result) {
+                                            loaded = true;
+                                            session.sessionId = cursor;
+                                            session.sessionKey = sessionKey;
+                                            receiveModelVariants(result);
+                                        }
+                                    });
+                                }
+                                catch {
+                                    /* session gone, load unsupported, or too slow — the
+                                     * fallbacks below choose between one fresh process and a
+                                     * genuinely new session */
+                                }
                             }
-                            catch {
-                                /* session gone, load unsupported, or too slow — start fresh */
+                            if (loaded)
+                                break;
+                            if (cursor && liveSessionId === cursor) {
+                                // The agent refused (or never answered) re-establishing its
+                                // own live session on this process. Continuity outranks the
+                                // saved handshake: close the pooled child and resume the
+                                // recorded session on a fresh one — the pre-pool path every
+                                // agent already supports. A load that fails there too means
+                                // the session is genuinely gone; the loop falls through to
+                                // session/new on the replacement child.
+                                session.current = null;
+                                closeSession(threadId, "reestablish");
+                                session = openSession(threadId, launch, [...(launch.args ?? []), ...spawnArgs], spawnEnv, cwd, contractKey);
+                                sessions.set(threadId, session);
+                                session.current = current;
+                                runtimeAcceptsImages = await handshake();
+                                init = session.initResult;
+                                continue;
                             }
-                        }
-                        if (!sessionId) {
+                            // a genuinely fresh native session forgets what the previous
+                            // one allowed
+                            if (!cursor)
+                                sessionAllows.delete(threadId);
                             sessionResult = await request("session/new", { cwd, mcpServers: sessionServers }, NEW_SESSION_TIMEOUT, (result) => {
-                                sessionId = typeof result?.sessionId === "string" ? result.sessionId : null;
+                                session.sessionId = typeof result?.sessionId === "string" ? result.sessionId : null;
+                                session.sessionKey = sessionKey;
                                 receiveModelVariants(result);
                             });
-                            if (!sessionId)
-                                throw new Error("session/new returned no sessionId");
+                            break;
                         }
+                        // every establishment path leaves a native session id behind
+                        const sessionId = session.sessionId;
+                        if (sessionId === null)
+                            throw new Error("session/new returned no sessionId");
                         let selectedModel = null;
                         let sessionStarted = false;
                         const emitSessionStarted = () => {
@@ -855,10 +1156,10 @@ export function createAcpDriver(support) {
                         try {
                             if (support.selectModel) {
                                 const { configId } = support.selectModel;
-                                selectedModel = modelOf(sessionConfigResult);
+                                selectedModel = modelOf(session.sessionConfigResult);
                                 if (cliTurn.model && cliTurn.model !== selectedModel) {
                                     sessionResult = await request("session/set_config_option", { sessionId, configId, value: cliTurn.model }, INIT_TIMEOUT, receiveModelVariants);
-                                    selectedModel = modelOf(sessionConfigResult);
+                                    selectedModel = modelOf(session.sessionConfigResult);
                                     // an agent that answers OK but keeps its old model is worse than
                                     // one that errors: it burns a paid turn on the wrong thing
                                     if (selectedModel !== cliTurn.model) {
@@ -903,19 +1204,18 @@ export function createAcpDriver(support) {
                                 ? `${turn.system}\n\n${turn.text}`
                                 : turn.text;
                         const imageBlocks = support.images === true && runtimeAcceptsImages
-                            ? await readAcpImageBlocks(images)
+                            ? await readAcpImageBlocks(turn.images ?? [])
                             : [];
-                        if (support.modelVariants && cliTurn.model && modelOf(sessionConfigResult) !== cliTurn.model) {
+                        if (support.modelVariants && cliTurn.model && modelOf(session.sessionConfigResult) !== cliTurn.model) {
                             throw new Error(`${support.displayName} changed model before the prompt`);
                         }
                         if (turn.variant !== undefined && requestedVariantOption().currentValue !== turn.variant) {
                             throw new Error(`${support.displayName} changed variant before the prompt`);
                         }
                         state.promptSent = true;
-                        const result = await request("session/prompt", {
-                            sessionId,
-                            prompt: [{ type: "text", text }, ...imageBlocks],
-                        });
+                        const promptIdleMs = promptIdleTimeoutMs();
+                        const result = await request("session/prompt", { sessionId, prompt: [{ type: "text", text }, ...imageBlocks] }, undefined, undefined, promptIdleMs, `${DRIVER_KIND} went fully silent ${Math.round(promptIdleMs / 1000)} s after the message and the turn was stopped. ` +
+                            "Raise OPENMAUS_ACP_PROMPT_IDLE_TIMEOUT_MS if this model legitimately takes longer to answer.");
                         // opencode 1.18.18 reports usage at the result root; grok and
                         // gemini put it under _meta. Read both rather than lose the count.
                         const usage = result?.usage ?? result?._meta ?? {};
@@ -929,9 +1229,9 @@ export function createAcpDriver(support) {
                         }
                         const reason = result?.stopReason;
                         if (reason === "end_turn")
-                            settle(true, null);
+                            settle(threadId, session, true, null);
                         else if (reason === "cancelled")
-                            settle(true, "cancelled");
+                            settle(threadId, session, true, "cancelled");
                         else {
                             const errorMessage = typeof result?.error === "string" && result.error
                                 ? result.error
@@ -943,7 +1243,7 @@ export function createAcpDriver(support) {
                                 type: "runtime.error",
                                 message: errorMessage,
                             });
-                            settle(false, reason ?? "failed");
+                            settle(threadId, session, false, reason ?? "failed");
                         }
                     }
                     catch (e) {
@@ -961,7 +1261,13 @@ export function createAcpDriver(support) {
                                 message,
                                 ...(needsAuth ? { setup: true } : {}),
                             });
-                            settle(false, needsAuth ? "auth_required" : "rpc_error");
+                            // A prompt that went idle has a wedged child under the RPC — it
+                            // will never answer the next prompt either. Do not leave it
+                            // pooled: close it so the next turn spawns a fresh agent.
+                            if (e?.acpPromptStall === true && session.child.exitCode === null && !session.closing) {
+                                closeSession(threadId, "prompt-stall");
+                            }
+                            settle(threadId, session, false, needsAuth ? "auth_required" : "rpc_error");
                         }
                     }
                 })();
@@ -1024,6 +1330,9 @@ export function createAcpDriver(support) {
                     stopAll: async () => {
                         for (const { stop } of active.values())
                             stop();
+                        // idle pooled sessions have no running turn — close them too
+                        for (const threadId of Array.from(sessions.keys()))
+                            closeSession(threadId, "stopAll");
                     },
                     onEvent: (listener) => {
                         listeners.add(listener);
@@ -1033,6 +1342,8 @@ export function createAcpDriver(support) {
                 dispose: async () => {
                     for (const { stop } of active.values())
                         stop();
+                    for (const threadId of Array.from(sessions.keys()))
+                        closeSession(threadId, "dispose");
                     listeners.clear();
                 },
             };