@qwen-code/qwen-code 0.21.11-preview.0 → 0.21.11

package/chunks/{chunk-E2XBEWAK.js → chunk-2AAFGCWP.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-EV3LZGGK.js";
+} from "./chunk-TKAEODJR.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -27,7 +27,7 @@ import {
   SessionRestoreTimeoutError,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-DA4HRSBW.js";
+} from "./chunk-OPBATTFQ.js";
 import {
   ACTIVE_WORK_CLOSE_IF_UNHELD_PARAM,
   ACTIVE_WORK_CLOSE_TIMEOUT_MS,
@@ -43,6 +43,7 @@ import {
   CHANNEL_STARTUP_PROFILE_VERSION,
   DAEMON_CHANNEL_DELIVERY_META_KEY,
   DAEMON_MODEL_PROMPT_META_KEY,
+  DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
   LOAD_REPLAY_BULK_MODE,
   LOAD_REPLAY_HIDE_INHERITED_META_KEY,
   LOAD_REPLAY_META_KEY,
@@ -58,7 +59,7 @@ import {
   WORKTREE_MCP_DEFER_META_KEY,
   clampActiveWorkIntervalMs,
   isValidTrustedModelPrompt
-} from "./chunk-W5UC37EE.js";
+} from "./chunk-HHGQGTJQ.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -102,7 +103,7 @@ import {
   ClientSideConnection,
   PROTOCOL_VERSION,
   RequestError
-} from "./chunk-UDXSXLER.js";
+} from "./chunk-IW6RQPQB.js";
 import {
   SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_TRANSCRIPT_MAX_LIMIT,
@@ -115,16 +116,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-O3VWAZLP.js";
+} from "./chunk-UIZGNLBP.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-4TRQPFDP.js";
+} from "./chunk-BJKREW56.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-YGT2AUJ7.js";
+} from "./chunk-U2JLICUY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -136,6 +137,7 @@ import {
 init_esbuild_shims();
 import { randomBytes, randomUUID as randomUUID2 } from "node:crypto";
 import * as path3 from "node:path";
+import { inspect } from "node:util";
 
 // packages/acp-bridge/src/compactionEngine.ts
 init_esbuild_shims();
@@ -5914,6 +5916,12 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 __name(isRecord3, "isRecord");
+function safeTransportFailureCode(error) {
+  if (!isRecord3(error)) return void 0;
+  const code = error["code"];
+  return typeof code === "string" && /^[a-z0-9_.-]{1,64}$/iu.test(code) ? code : void 0;
+}
+__name(safeTransportFailureCode, "safeTransportFailureCode");
 function sessionSourceRequestMeta(sourceType, sourceId) {
   return sourceType ? {
     [SESSION_SOURCE_META_KEY]: {
@@ -5923,12 +5931,280 @@ function sessionSourceRequestMeta(sourceType, sourceId) {
   } : {};
 }
 __name(sessionSourceRequestMeta, "sessionSourceRequestMeta");
+function getChannelPromptDisplayText(entry, displayText) {
+  return entry.sourceType === "channel" && typeof displayText === "string" ? displayText : void 0;
+}
+__name(getChannelPromptDisplayText, "getChannelPromptDisplayText");
 function isDefinitiveAcpRequestError(error) {
   if (error instanceof RequestError) return true;
   if (!isRecord3(error)) return false;
   return typeof error["code"] === "number" && Number.isInteger(error["code"]) && typeof error["message"] === "string";
 }
 __name(isDefinitiveAcpRequestError, "isDefinitiveAcpRequestError");
+var LogSafeAcpRequestError = class extends RequestError {
+  constructor(code, message, data, reservePreparedResponse) {
+    super(code, message, data);
+    this.reservePreparedResponse = reservePreparedResponse;
+  }
+  static {
+    __name(this, "LogSafeAcpRequestError");
+  }
+  toResult() {
+    const result = super.toResult();
+    if ("error" in result) {
+      Object.defineProperty(result.error, inspect.custom, {
+        configurable: true,
+        value: /* @__PURE__ */ __name(() => ({ code: result.error.code, payloadOmitted: true }), "value")
+      });
+      try {
+        this.reservePreparedResponse?.(result.error);
+      } catch {
+      }
+    }
+    return result;
+  }
+};
+var MAX_LOG_SAFE_ACP_ERROR_DETAILS_CHARS = 1024;
+var MAX_LOG_SAFE_ACP_ERROR_KIND_CHARS = 128;
+var MAX_LOG_SAFE_ACP_ERROR_HINT_CHARS = 512;
+function logSafeAcpErrorDetails(error) {
+  const details = error instanceof Error ? error.message : isRecord3(error) && typeof error["message"] === "string" ? error["message"] : void 0;
+  if (!details) return void 0;
+  return {
+    details: details.length <= MAX_LOG_SAFE_ACP_ERROR_DETAILS_CHARS ? details : `${details.slice(0, MAX_LOG_SAFE_ACP_ERROR_DETAILS_CHARS)}\u2026`
+  };
+}
+__name(logSafeAcpErrorDetails, "logSafeAcpErrorDetails");
+function boundedAcpErrorString(value, maxChars) {
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}\u2026`;
+}
+__name(boundedAcpErrorString, "boundedAcpErrorString");
+function logSafeRequestErrorMessage(code) {
+  switch (code) {
+    case -32700:
+      return "Parse error";
+    case -32600:
+      return "Invalid request";
+    case -32601:
+      return "Method not found";
+    case -32602:
+      return "Invalid params";
+    case -32603:
+      return "Internal error";
+    case -32e3:
+      return "Authentication required";
+    case -32002:
+      return "Resource not found";
+    default:
+      return "ACP client request failed";
+  }
+}
+__name(logSafeRequestErrorMessage, "logSafeRequestErrorMessage");
+function logSafeRequestErrorData(data) {
+  if (!isRecord3(data) || typeof data["errorKind"] !== "string") {
+    return void 0;
+  }
+  const status = data["status"];
+  const hint = data["hint"];
+  return {
+    errorKind: boundedAcpErrorString(
+      data["errorKind"],
+      MAX_LOG_SAFE_ACP_ERROR_KIND_CHARS
+    ),
+    ...typeof status === "number" && Number.isFinite(status) ? { status } : {},
+    ...typeof hint === "string" ? {
+      hint: boundedAcpErrorString(hint, MAX_LOG_SAFE_ACP_ERROR_HINT_CHARS)
+    } : {}
+  };
+}
+__name(logSafeRequestErrorData, "logSafeRequestErrorData");
+var AcpInboundHandlerLimitError = class extends Error {
+  constructor(maxActiveHandlers, maxActiveHandlerBytes, requiredBytes, availableBytes) {
+    super("ACP inbound handler capacity exceeded");
+    this.maxActiveHandlers = maxActiveHandlers;
+    this.maxActiveHandlerBytes = maxActiveHandlerBytes;
+    this.requiredBytes = requiredBytes;
+    this.availableBytes = availableBytes;
+    this.name = "AcpInboundHandlerLimitError";
+  }
+  static {
+    __name(this, "AcpInboundHandlerLimitError");
+  }
+  code = "acp_handler_limit_exceeded";
+};
+function estimateAcpHandlerBytes(value, limitBytes) {
+  let bytes = 0;
+  const stack = [value];
+  const seen = /* @__PURE__ */ new WeakSet();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === null) {
+      bytes += 4;
+    } else if (typeof current === "string") {
+      bytes += Buffer.byteLength(current) + 2;
+    } else if (typeof current === "number") {
+      bytes += 24;
+    } else if (typeof current === "boolean") {
+      bytes += 5;
+    } else if (Array.isArray(current)) {
+      if (seen.has(current)) return limitBytes + 1;
+      seen.add(current);
+      bytes += 2 + Math.max(0, current.length - 1);
+      if (bytes + current.length > limitBytes) return limitBytes + 1;
+      for (let index = current.length - 1; index >= 0; index--) {
+        stack.push(current[index]);
+      }
+    } else if (isRecord3(current)) {
+      if (seen.has(current)) return limitBytes + 1;
+      seen.add(current);
+      const entries = Object.entries(current);
+      bytes += 2 + Math.max(0, entries.length - 1);
+      for (const [key, entryValue] of entries) {
+        bytes += Buffer.byteLength(key) + 3;
+        stack.push(entryValue);
+      }
+    } else {
+      bytes += 4;
+    }
+    if (bytes > limitBytes) return limitBytes + 1;
+  }
+  return Math.max(1, bytes);
+}
+__name(estimateAcpHandlerBytes, "estimateAcpHandlerBytes");
+var AcpInboundHandlerAdmission = class {
+  constructor(guard) {
+    this.guard = guard;
+  }
+  static {
+    __name(this, "AcpInboundHandlerAdmission");
+  }
+  activeHandlers = 0;
+  activeBytes = 0;
+  async run(params, operation) {
+    const envelopeBytes = Math.min(2048, this.guard.maxActiveHandlerBytes);
+    const requiredBytes = envelopeBytes + estimateAcpHandlerBytes(
+      params,
+      Math.max(0, this.guard.maxActiveHandlerBytes - envelopeBytes)
+    );
+    const availableBytes = Math.max(
+      0,
+      this.guard.maxActiveHandlerBytes - this.activeBytes
+    );
+    if (this.activeHandlers >= this.guard.maxActiveHandlers || requiredBytes > availableBytes) {
+      const error = new AcpInboundHandlerLimitError(
+        this.guard.maxActiveHandlers,
+        this.guard.maxActiveHandlerBytes,
+        requiredBytes,
+        availableBytes
+      );
+      this.guard.fail(error);
+      throw error;
+    }
+    this.activeHandlers++;
+    this.activeBytes += requiredBytes;
+    try {
+      return await operation();
+    } finally {
+      this.activeHandlers--;
+      this.activeBytes -= requiredBytes;
+    }
+  }
+};
+async function withLogSafeAcpError(operation, reservePreparedResponse) {
+  try {
+    return await operation();
+  } catch (error) {
+    if (error instanceof RequestError) {
+      const code = Number.isFinite(error.code) ? error.code : -32603;
+      throw new LogSafeAcpRequestError(
+        code,
+        logSafeRequestErrorMessage(code),
+        logSafeRequestErrorData(error.data),
+        reservePreparedResponse
+      );
+    }
+    throw new LogSafeAcpRequestError(
+      -32603,
+      "Internal error",
+      logSafeAcpErrorDetails(error),
+      reservePreparedResponse
+    );
+  }
+}
+__name(withLogSafeAcpError, "withLogSafeAcpError");
+function createLogSafeAcpClient(client, transportGuard) {
+  const admission = new AcpInboundHandlerAdmission(transportGuard);
+  const runNotification = /* @__PURE__ */ __name((params, operation) => withLogSafeAcpError(() => admission.run(params, operation)), "runNotification");
+  const runRequest = /* @__PURE__ */ __name((params, operation) => withLogSafeAcpError(
+    () => admission.run(params, async () => {
+      const result = await operation();
+      transportGuard.reservePreparedResponse(result ?? null);
+      return result;
+    }),
+    transportGuard.reservePreparedResponse
+  ), "runRequest");
+  return {
+    requestPermission: /* @__PURE__ */ __name((params) => runRequest(params, () => client.requestPermission(params)), "requestPermission"),
+    sessionUpdate: /* @__PURE__ */ __name((params) => runNotification(params, () => client.sessionUpdate(params)), "sessionUpdate"),
+    writeTextFile: client.writeTextFile ? (params) => runRequest(params, () => client.writeTextFile(params)) : void 0,
+    readTextFile: client.readTextFile ? (params) => runRequest(params, () => client.readTextFile(params)) : void 0,
+    createTerminal: client.createTerminal ? (params) => runRequest(params, () => client.createTerminal(params)) : void 0,
+    terminalOutput: client.terminalOutput ? (params) => runRequest(params, () => client.terminalOutput(params)) : void 0,
+    releaseTerminal: client.releaseTerminal ? (params) => runRequest(
+      params,
+      async () => await client.releaseTerminal(params) ?? {}
+    ) : void 0,
+    waitForTerminalExit: client.waitForTerminalExit ? (params) => runRequest(params, () => client.waitForTerminalExit(params)) : void 0,
+    killTerminal: client.killTerminal ? (params) => runRequest(
+      params,
+      async () => await client.killTerminal(params) ?? {}
+    ) : void 0,
+    extMethod: client.extMethod ? (method, params) => runRequest(params, () => client.extMethod(method, params)) : void 0,
+    extNotification: client.extNotification ? (method, params) => runNotification(params, () => client.extNotification(method, params)) : void 0
+  };
+}
+__name(createLogSafeAcpClient, "createLogSafeAcpClient");
+var OUTBOUND_GUARDED_CONNECTION_METHODS = /* @__PURE__ */ new Set([
+  "initialize",
+  "newSession",
+  "loadSession",
+  "unstable_forkSession",
+  "unstable_listSessions",
+  "unstable_resumeSession",
+  "setSessionMode",
+  "unstable_setSessionModel",
+  "setSessionConfigOption",
+  "authenticate",
+  "prompt",
+  "cancel",
+  "extMethod",
+  "extNotification"
+]);
+function createOutboundGuardedConnection(connection, transportGuard) {
+  const wrappers = /* @__PURE__ */ new Map();
+  return new Proxy(connection, {
+    get(target, property) {
+      const value = Reflect.get(target, property, target);
+      if (typeof value !== "function" || !OUTBOUND_GUARDED_CONNECTION_METHODS.has(property)) {
+        return value;
+      }
+      let wrapper = wrappers.get(property);
+      if (!wrapper) {
+        wrapper = /* @__PURE__ */ __name(async (...args) => {
+          const release = transportGuard.reserveOutboundOperation(args);
+          try {
+            return await Reflect.apply(value, target, args);
+          } finally {
+            release();
+          }
+        }, "wrapper");
+        wrappers.set(property, wrapper);
+      }
+      return wrapper;
+    }
+  });
+}
+__name(createOutboundGuardedConnection, "createOutboundGuardedConnection");
 function getCanonicalModelId(response, fallback) {
   if (!isRecord3(response) || !isRecord3(response["_meta"])) return fallback;
   const modelSwitch = response["_meta"]["qwenModelSwitch"];
@@ -6135,14 +6411,27 @@ function pickUserInputEchoMeta(meta) {
   return Array.isArray(inputAnnotations) ? { inputAnnotations } : {};
 }
 __name(pickUserInputEchoMeta, "pickUserInputEchoMeta");
-function echoPromptToSessionBus(entry, req, promptId, originatorClientId) {
+function echoPromptToSessionBus(entry, req, promptId, originatorClientId, displayText) {
   const prompt = req.prompt;
   if (!Array.isArray(prompt) || prompt.length === 0) return;
+  let displayTextPublished = false;
   const serverTimestamp = Date.now();
-  const blockCount = Math.min(prompt.length, MAX_ECHO_CONTENT_BLOCKS);
+  const echoPrompt = prompt.slice(0, MAX_ECHO_CONTENT_BLOCKS);
+  if (displayText && !echoPrompt.some((part) => isRecord3(part) && part["type"] === "text")) {
+    const textPart = prompt.slice(MAX_ECHO_CONTENT_BLOCKS).find((part) => isRecord3(part) && part["type"] === "text");
+    if (textPart) echoPrompt[echoPrompt.length - 1] = textPart;
+  }
+  const blockCount = echoPrompt.length;
   for (let i = 0; i < blockCount; i += 1) {
-    const part = prompt[i];
+    const part = echoPrompt[i];
     if (!part || typeof part !== "object" || Array.isArray(part)) continue;
+    let displayPart = part;
+    if (displayText !== void 0 && part.type === "text") {
+      if (displayTextPublished) continue;
+      displayTextPublished = true;
+      if (!displayText) continue;
+      displayPart = { ...part, text: displayText };
+    }
     try {
       entry.events.publish({
         type: "session_update",
@@ -6151,7 +6440,7 @@ function echoPromptToSessionBus(entry, req, promptId, originatorClientId) {
           sessionId: req.sessionId,
           update: {
             sessionUpdate: "user_message_chunk",
-            content: part,
+            content: displayPart,
             // `_meta` lives inside the `update` object rather than at
             // envelope level. `_meta` is a standard JSON-RPC/MCP extension
             // field permitted alongside spec fields, the SDK normalizer
@@ -6718,6 +7007,14 @@ function createAcpSessionBridge(opts) {
     }
   }
   __name(cancelIdleTimer, "cancelIdleTimer");
+  function channelUnavailableReject(channel, context) {
+    const unavailable = channel.transportFailed ? Promise.race([channel.exited, channel.transportFailed]) : channel.exited;
+    const reject = /* @__PURE__ */ __name(() => {
+      throw new BridgeChannelClosedError(context);
+    }, "reject");
+    return unavailable.then(reject, reject);
+  }
+  __name(channelUnavailableReject, "channelUnavailableReject");
   async function killChannelWithLog(ci, context) {
     ci.isDying = true;
     await ci.channel.kill().catch((err) => {
@@ -6924,6 +7221,14 @@ function createAcpSessionBridge(opts) {
   const generationRequests = /* @__PURE__ */ new Map();
   const workspaceGenerationRequests = /* @__PURE__ */ new Map();
   const inFlightExtensionRefreshes = /* @__PURE__ */ new Map();
+  const clearInFlightExtensionRefreshes = /* @__PURE__ */ __name((connection) => {
+    for (const [sessionId, refresh] of inFlightExtensionRefreshes) {
+      if (refresh.connection === connection) {
+        refresh.rejectUnavailable();
+        inFlightExtensionRefreshes.delete(sessionId);
+      }
+    }
+  }, "clearInFlightExtensionRefreshes");
   const toSessionSummary = /* @__PURE__ */ __name((entry) => {
     let isWaitingForPermission = false;
     let isWaitingForUserQuestion = false;
@@ -7172,7 +7477,14 @@ function createAcpSessionBridge(opts) {
             applyActiveWorkSnapshot(currentInfo, snapshot);
           }
         );
-        connection = new ClientSideConnection(() => client, channel.stream);
+        const rawConnection = new ClientSideConnection(
+          () => channel.transportGuard ? createLogSafeAcpClient(client, channel.transportGuard) : client,
+          channel.stream
+        );
+        connection = channel.transportGuard ? createOutboundGuardedConnection(
+          rawConnection,
+          channel.transportGuard
+        ) : rawConnection;
       } catch (error) {
         try {
           channel.killSync();
@@ -7208,11 +7520,26 @@ function createAcpSessionBridge(opts) {
         unsettledAbandonedRestores: /* @__PURE__ */ new Set(),
         restoreSettlementOverdue: false,
         restoreSettlementTimers: /* @__PURE__ */ new Map(),
+        transportFailed: false,
+        transportFailureInitiatedTeardown: false,
         isDying: false,
         isQuarantined: false,
         handshakeComplete: false
       };
       infoRef.current = info;
+      const markTransportFailed = /* @__PURE__ */ __name((error) => {
+        if (!info.isDying) {
+          info.transportFailureInitiatedTeardown = true;
+        }
+        info.transportFailed = true;
+        info.transportFailureCode = safeTransportFailureCode(error);
+        info.isDying = true;
+        clearInFlightExtensionRefreshes(info.connection);
+      }, "markTransportFailed");
+      void channel.transportFailed?.then(
+        markTransportFailed,
+        markTransportFailed
+      );
       aliveChannels.add(info);
       if (aliveChannels.size > 2) {
         writeStderrLine(
@@ -7220,6 +7547,7 @@ function createAcpSessionBridge(opts) {
         );
       }
       void channel.exited.then((exitInfo) => {
+        clearInFlightExtensionRefreshes(info.connection);
         if (channelInfo === info) cancelIdleTimer();
         if (info.workspaceMcpDiscoveryTimer) {
           clearTimeout(info.workspaceMcpDiscoveryTimer);
@@ -7238,7 +7566,7 @@ function createAcpSessionBridge(opts) {
         if (channelInfo === info) channelInfo = void 0;
         const sessions = Array.from(info.sessionIds);
         info.sessionIds.clear();
-        const channelExitExpected = shuttingDown || info.isDying;
+        const channelExitExpected = shuttingDown || info.isDying && !info.transportFailureInitiatedTeardown;
         if (info.handshakeComplete) {
           telemetry.metrics?.channelLifecycle("exit", channelExitExpected);
         }
@@ -7246,10 +7574,15 @@ function createAcpSessionBridge(opts) {
           telemetry.event("channel.exited", {
             "qwen-code.daemon.channel.exit_code": exitInfo?.exitCode ?? -1,
             "qwen-code.daemon.channel.session_count": sessions.length,
+            "qwen-code.daemon.channel.transport_failed": info.transportFailed,
+            "qwen-code.daemon.channel.transport_failure_initiated_teardown": info.transportFailureInitiatedTeardown,
+            ...info.transportFailureCode ? {
+              "qwen-code.daemon.channel.transport_error_code": info.transportFailureCode
+            } : {},
             ...exitInfo?.signalCode ? { "qwen-code.daemon.channel.signal": exitInfo.signalCode } : {}
           });
           writeStderrLine(
-            `qwen serve: channel exited (code=${exitInfo?.exitCode ?? "none"}, signal=${exitInfo?.signalCode ?? "none"}, ${sessions.length} session(s) torn down)`
+            `qwen serve: channel exited (code=${exitInfo?.exitCode ?? "none"}, signal=${exitInfo?.signalCode ?? "none"}, transport=${info.transportFailed ? info.transportFailureCode ?? "failed" : "ok"}, ${sessions.length} session(s) torn down)`
           );
         }
         for (const sid of sessions) {
@@ -7301,26 +7634,29 @@ function createAcpSessionBridge(opts) {
           },
           async () => {
             const response = await withTimeout(
-              connection.initialize({
-                protocolVersion: PROTOCOL_VERSION,
-                _meta: {
-                  [ACTIVE_WORK_HEARTBEAT_META_KEY]: {
-                    v: ACTIVE_WORK_HEARTBEAT_VERSION,
-                    intervalMs: ACTIVE_WORK_HEARTBEAT_INTERVAL_MS
+              Promise.race([
+                connection.initialize({
+                  protocolVersion: PROTOCOL_VERSION,
+                  _meta: {
+                    [ACTIVE_WORK_HEARTBEAT_META_KEY]: {
+                      v: ACTIVE_WORK_HEARTBEAT_VERSION,
+                      intervalMs: ACTIVE_WORK_HEARTBEAT_INTERVAL_MS
+                    },
+                    [CHANNEL_STARTUP_PROFILE_META_KEY]: {
+                      v: CHANNEL_STARTUP_PROFILE_VERSION
+                    },
+                    [PRIVATE_PARENT_CAPABILITY_META_KEY]: privateParentCapability
                   },
-                  [CHANNEL_STARTUP_PROFILE_META_KEY]: {
-                    v: CHANNEL_STARTUP_PROFILE_VERSION
+                  clientCapabilities: {
+                    fs: {
+                      readTextFile: delegateReadTextFileToClient,
+                      writeTextFile: true
+                    }
                   },
-                  [PRIVATE_PARENT_CAPABILITY_META_KEY]: privateParentCapability
-                },
-                clientCapabilities: {
-                  fs: {
-                    readTextFile: delegateReadTextFileToClient,
-                    writeTextFile: true
-                  }
-                },
-                clientInfo: { name: "qwen-serve-bridge", version: "0" }
-              }),
+                  clientInfo: { name: "qwen-serve-bridge", version: "0" }
+                }),
+                channelUnavailableReject(channel, "during initialize")
+              ]),
               initTimeoutMs,
               "initialize"
             );
@@ -7365,6 +7701,11 @@ function createAcpSessionBridge(opts) {
         });
         throw err;
       }
+      if (info.isDying) {
+        await channel.kill().catch(() => {
+        });
+        throw new BridgeChannelClosedError("during initialize");
+      }
       if (shuttingDown) {
         info.isDying = true;
         await channel.kill().catch(() => {
@@ -7394,6 +7735,9 @@ function createAcpSessionBridge(opts) {
       },
       ensureChannel
     );
+    if (ci.isDying) {
+      throw new BridgeChannelClosedError("before newSession");
+    }
     ci.sessionSpawnsInFlight++;
     if (requestedSessionId !== void 0) {
       ci.client.markSessionRegistrationInFlight(requestedSessionId);
@@ -7426,15 +7770,18 @@ function createAcpSessionBridge(opts) {
               } : {}
             });
             const response = await withTimeout(
-              ci.connection.newSession(
-                worktree ? {
-                  ...request,
-                  _meta: {
-                    ...isRecord3(request._meta) ? request._meta : {},
-                    [WORKTREE_MCP_DEFER_META_KEY]: true
-                  }
-                } : request
-              ),
+              Promise.race([
+                ci.connection.newSession(
+                  worktree ? {
+                    ...request,
+                    _meta: {
+                      ...isRecord3(request._meta) ? request._meta : {},
+                      [WORKTREE_MCP_DEFER_META_KEY]: true
+                    }
+                  } : request
+                ),
+                channelUnavailableReject(ci.channel, "during newSession")
+              ]),
               initTimeoutMs,
               "newSession"
             );
@@ -7455,6 +7802,10 @@ function createAcpSessionBridge(opts) {
         }
         throw err;
       }
+      await Promise.resolve();
+      if (ci.isDying) {
+        throw new BridgeChannelClosedError("after newSession");
+      }
       if (shuttingDown) {
         throw new Error("AcpSessionBridge is shutting down");
       }
@@ -7773,13 +8124,25 @@ function createAcpSessionBridge(opts) {
   __name(applyApprovalMode, "applyApprovalMode");
   async function applyApprovalModeForAttach(entry, mode, clientId) {
     try {
-      await applyApprovalMode(entry, mode, false, clientId);
+      const result = await applyApprovalMode(entry, mode, false, clientId);
+      return result.previous;
     } catch (err) {
       await rollbackAttachRegistration(entry, clientId);
       throw err;
     }
   }
   __name(applyApprovalModeForAttach, "applyApprovalModeForAttach");
+  async function rollbackApprovalModeForRejectedAttach(entry, previous, clientId) {
+    if (byId.get(entry.sessionId) !== entry) return;
+    try {
+      await applyApprovalMode(entry, previous, false, clientId);
+    } catch (err) {
+      writeStderrLine(
+        `attach: failed to restore approval mode for session ${entry.sessionId}: ${extractErrorMessage(err)}`
+      );
+    }
+  }
+  __name(rollbackApprovalModeForRejectedAttach, "rollbackApprovalModeForRejectedAttach");
   const cancelPendingForSession = /* @__PURE__ */ __name((sessionId) => {
     permissionMediator.forgetSession(sessionId);
     byId.get(sessionId)?.pendingPermissionIds.clear();
@@ -7787,11 +8150,10 @@ function createAcpSessionBridge(opts) {
   }, "cancelPendingForSession");
   const getTransportClosedReject = /* @__PURE__ */ __name((entry) => {
     if (!entry.transportClosedReject) {
-      entry.transportClosedReject = entry.channel.exited.then(() => {
-        throw new BridgeChannelClosedError(
-          `mid-request (session ${entry.sessionId})`
-        );
-      });
+      entry.transportClosedReject = channelUnavailableReject(
+        entry.channel,
+        `mid-request (session ${entry.sessionId})`
+      );
     }
     return entry.transportClosedReject;
   }, "getTransportClosedReject");
@@ -7819,6 +8181,28 @@ function createAcpSessionBridge(opts) {
     }
     return void 0;
   }, "channelInfoForEntry");
+  const assertAttachableSessionEntry = /* @__PURE__ */ __name((sessionId, entry) => {
+    if (byId.get(sessionId) !== entry) {
+      throw new SessionNotFoundError(
+        sessionId,
+        "The session channel is unavailable; retry after teardown completes"
+      );
+    }
+    if (isClosingOrAuthorizingClose(entry)) {
+      throw new SessionNotFoundError(
+        sessionId,
+        "The session is closing; retry after close completes",
+        "session_closing"
+      );
+    }
+    const owner = channelInfoForEntry(entry);
+    if (!owner || owner.isDying) {
+      throw new SessionNotFoundError(
+        sessionId,
+        "The session channel is unavailable; retry after teardown completes"
+      );
+    }
+  }, "assertAttachableSessionEntry");
   const assertLivePromptEntry = /* @__PURE__ */ __name((sessionId, entry) => {
     const info = channelInfoForEntry(entry);
     if (byId.get(sessionId) !== entry || !info || info.isDying) {
@@ -7827,9 +8211,10 @@ function createAcpSessionBridge(opts) {
   }, "assertLivePromptEntry");
   const getChannelClosedReject = /* @__PURE__ */ __name((info) => {
     if (!info.statusClosedReject) {
-      info.statusClosedReject = info.channel.exited.then(() => {
-        throw new BridgeChannelClosedError("mid-request (workspace status)");
-      });
+      info.statusClosedReject = channelUnavailableReject(
+        info.channel,
+        "mid-request (workspace status)"
+      );
     }
     return info.statusClosedReject;
   }, "getChannelClosedReject");
@@ -8495,6 +8880,7 @@ function createAcpSessionBridge(opts) {
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
         const lastEventId = entry.events.lastEventId;
+        const eventEpoch = entry.events.epoch;
         const seenCursors = /* @__PURE__ */ new Set();
         let emptyPageCount = 0;
         let cursor;
@@ -8515,11 +8901,12 @@ function createAcpSessionBridge(opts) {
           cursor = nextCursor;
           if (cursor !== void 0) seenCursors.add(cursor);
         } while (page.events.length === 0 && page.hasMore && cursor !== void 0 && page.partial !== true && page.replayError === void 0);
-        if (byId.get(entry.sessionId) === entry && !entry.promptActive && entry.events.lastEventId === lastEventId) {
+        if (byId.get(entry.sessionId) === entry && !entry.promptActive && entry.events.epoch === eventEpoch && entry.events.lastEventId === lastEventId) {
           return {
             compactedReplay: page.events,
             liveJournal: [],
             lastEventId,
+            eventEpoch,
             ...page.partial === true ? { partial: true } : {},
             ...page.replayError !== void 0 ? { replayError: page.replayError } : {},
             ...page.hasMore ? { historyHasMore: true } : {}
@@ -8592,30 +8979,30 @@ function createAcpSessionBridge(opts) {
     const hideInheritedHistory = action === "load" && req.hideInheritedHistory === true;
     const existing = byId.get(req.sessionId);
     if (existing) {
-      if (isClosingOrAuthorizingClose(existing)) {
-        throw new SessionNotFoundError(
-          req.sessionId,
-          "The session is closing; retry after close completes",
-          "session_closing"
-        );
-      }
+      assertAttachableSessionEntry(req.sessionId, existing);
       const replayFields = historyPageSize !== void 0 ? await refreshedReplayFieldsFor(existing, historyPageSize) : replayFieldsFor(existing, action);
       const historyAnchorRecordId = action === "load" ? await resolveHistoryAnchorRecordId(existing, replayFields) : void 0;
-      if (byId.get(req.sessionId) !== existing) {
-        throw new SessionNotFoundError(req.sessionId);
-      }
-      if (isClosingOrAuthorizingClose(existing)) {
-        throw new SessionNotFoundError(
-          req.sessionId,
-          "The session is closing; retry after close completes",
-          "session_closing"
-        );
-      }
+      assertAttachableSessionEntry(req.sessionId, existing);
       existing.attachCount++;
       const clientId = registerClient(existing, req.clientId);
       recordAttachRef(existing, clientId);
       if (req.approvalMode) {
-        await applyApprovalModeForAttach(existing, req.approvalMode, clientId);
+        const previousApprovalMode = await applyApprovalModeForAttach(
+          existing,
+          req.approvalMode,
+          clientId
+        );
+        try {
+          assertAttachableSessionEntry(req.sessionId, existing);
+        } catch (error) {
+          await rollbackApprovalModeForRejectedAttach(
+            existing,
+            previousApprovalMode,
+            clientId
+          );
+          await rollbackAttachRegistration(existing, clientId);
+          throw error;
+        }
       }
       return {
         sessionId: existing.sessionId,
@@ -8667,10 +9054,32 @@ function createAcpSessionBridge(opts) {
           "the agent child likely crashed during session restore \u2014 retry to restore the session"
         );
       }
+      try {
+        assertAttachableSessionEntry(restored.sessionId, entry);
+      } catch (error) {
+        inFlight.coalesceState.count--;
+        entry.attachCount = Math.max(0, entry.attachCount - 1);
+        throw error;
+      }
       const clientId = registerClient(entry, req.clientId);
       recordAttachRef(entry, clientId);
       if (req.approvalMode) {
-        await applyApprovalModeForAttach(entry, req.approvalMode, clientId);
+        const previousApprovalMode = await applyApprovalModeForAttach(
+          entry,
+          req.approvalMode,
+          clientId
+        );
+        try {
+          assertAttachableSessionEntry(restored.sessionId, entry);
+        } catch (error) {
+          await rollbackApprovalModeForRejectedAttach(
+            entry,
+            previousApprovalMode,
+            clientId
+          );
+          await rollbackAttachRegistration(entry, clientId);
+          throw error;
+        }
       }
       return {
         ...restored,
@@ -8834,12 +9243,16 @@ function createAcpSessionBridge(opts) {
     const promise = (async () => {
       pendingRestoreEvents.set(req.sessionId, restoreEvents);
       const restoreChannel = await ensureChannel();
+      if (restoreChannel.isDying) {
+        throw new BridgeChannelClosedError(`before session/${action}`);
+      }
       ci = restoreChannel;
       restoreChannel.pendingRestoreIds.add(req.sessionId);
       restoreChannel.client.markRestoreInFlight(req.sessionId);
-      const transportClosed = restoreChannel.channel.exited.then(() => {
-        throw new BridgeChannelClosedError(`during session/${action}`);
-      });
+      const transportClosed = channelUnavailableReject(
+        restoreChannel.channel,
+        `during session/${action}`
+      );
       transportClosed.catch(() => {
       });
       let state;
@@ -8985,24 +9398,20 @@ function createAcpSessionBridge(opts) {
       const racedEntry = byId.get(req.sessionId);
       if (racedEntry) {
         restoreEvents.close();
-        if (isClosingOrAuthorizingClose(racedEntry)) {
-          throw new SessionNotFoundError(
-            req.sessionId,
-            "The session is closing; retry after close completes",
-            "session_closing"
-          );
-        }
+        assertAttachableSessionEntry(req.sessionId, racedEntry);
         racedEntry.attachCount += 1 + coalesceState.count;
         const clientId2 = registerClient(racedEntry, req.clientId);
         recordAttachRef(racedEntry, clientId2);
         if (req.approvalMode) {
+          let previousApprovalMode;
           try {
-            await applyApprovalMode(
+            const result = await applyApprovalMode(
               racedEntry,
               req.approvalMode,
               false,
               clientId2
             );
+            previousApprovalMode = result.previous;
           } catch (err) {
             await rollbackAttachRegistration(
               racedEntry,
@@ -9011,6 +9420,21 @@ function createAcpSessionBridge(opts) {
             );
             throw err;
           }
+          try {
+            assertAttachableSessionEntry(req.sessionId, racedEntry);
+          } catch (error) {
+            await rollbackApprovalModeForRejectedAttach(
+              racedEntry,
+              previousApprovalMode,
+              clientId2
+            );
+            await rollbackAttachRegistration(
+              racedEntry,
+              clientId2,
+              1 + coalesceState.count
+            );
+            throw error;
+          }
         }
         return {
           sessionId: racedEntry.sessionId,
@@ -9077,9 +9501,11 @@ function createAcpSessionBridge(opts) {
         }
         ci.client.drainEarlyEvents(entry.sessionId, entry);
       }
+      assertAttachableSessionEntry(req.sessionId, entry);
       const clientId = registerClient(entry, req.clientId);
       if (req.approvalMode) {
         await applyApprovalModeForAttach(entry, req.approvalMode, clientId);
+        assertAttachableSessionEntry(req.sessionId, entry);
       }
       entry.attachCount = coalesceState.count;
       registeredEntry = entry;
@@ -9465,13 +9891,7 @@ function createAcpSessionBridge(opts) {
       if (effectiveScope === "single") {
         const existing = defaultEntry;
         if (existing) {
-          if (isClosingOrAuthorizingClose(existing)) {
-            throw new SessionNotFoundError(
-              existing.sessionId,
-              "The session is closing; retry after close completes",
-              "session_closing"
-            );
-          }
+          assertAttachableSessionEntry(existing.sessionId, existing);
           existing.attachCount++;
           const clientId = registerClient(existing, req.clientId);
           recordAttachRef(existing, clientId);
@@ -9484,13 +9904,27 @@ function createAcpSessionBridge(opts) {
             ).catch(() => {
             });
           }
+          let previousApprovalMode;
           if (req.approvalMode) {
-            await applyApprovalModeForAttach(
+            previousApprovalMode = await applyApprovalModeForAttach(
               existing,
               req.approvalMode,
               clientId
             );
           }
+          try {
+            assertAttachableSessionEntry(existing.sessionId, existing);
+          } catch (error) {
+            if (previousApprovalMode !== void 0) {
+              await rollbackApprovalModeForRejectedAttach(
+                existing,
+                previousApprovalMode,
+                clientId
+              );
+            }
+            await rollbackAttachRegistration(existing, clientId);
+            throw error;
+          }
           return {
             sessionId: existing.sessionId,
             workspaceCwd: existing.workspaceCwd,
@@ -9507,13 +9941,14 @@ function createAcpSessionBridge(opts) {
         if (inFlight) {
           const session = await inFlight;
           const attachedEntry = byId.get(session.sessionId);
-          if (attachedEntry) attachedEntry.attachCount++;
           if (!attachedEntry) {
             throw new SessionNotFoundError(
               session.sessionId,
               "the agent child likely crashed during initialization \u2014 retry to spawn a new session"
             );
           }
+          assertAttachableSessionEntry(session.sessionId, attachedEntry);
+          attachedEntry.attachCount++;
           const clientId = registerClient(attachedEntry, req.clientId);
           recordAttachRef(attachedEntry, clientId);
           if (req.modelServiceId) {
@@ -9525,13 +9960,27 @@ function createAcpSessionBridge(opts) {
             ).catch(() => {
             });
           }
+          let previousApprovalMode;
           if (req.approvalMode) {
-            await applyApprovalModeForAttach(
+            previousApprovalMode = await applyApprovalModeForAttach(
               attachedEntry,
               req.approvalMode,
               clientId
             );
           }
+          try {
+            assertAttachableSessionEntry(session.sessionId, attachedEntry);
+          } catch (error) {
+            if (previousApprovalMode !== void 0) {
+              await rollbackApprovalModeForRejectedAttach(
+                attachedEntry,
+                previousApprovalMode,
+                clientId
+              );
+            }
+            await rollbackAttachRegistration(attachedEntry, clientId);
+            throw error;
+          }
           return {
             ...session,
             attached: true,
@@ -9680,12 +10129,19 @@ function createAcpSessionBridge(opts) {
           );
         }
       }
+      const channelDisplayText = getChannelPromptDisplayText(
+        entry,
+        context?.promptDisplayText
+      );
+      const pendingText = channelDisplayText === void 0 ? extractPromptText(req.prompt) : channelDisplayText || (req.prompt.some(
+        (block) => isRecord3(block) && block["type"] === "image"
+      ) ? "[image]" : "");
       const pendingEntry = {
         promptId,
         queuedAt,
         ...originatorClientId !== void 0 ? { originatorClientId } : {},
         ...isPromotedMidTurn ? { promotedMidTurn: true } : {},
-        text: extractPromptText(req.prompt),
+        text: pendingText,
         abortController: pendingAbort,
         state: isQueued ? "queued" : "running"
       };
@@ -9823,11 +10279,13 @@ function createAcpSessionBridge(opts) {
                   delete copy.retry;
                   delete copy.delivery;
                   const meta = copy._meta && typeof copy._meta === "object" ? { ...copy._meta } : {};
+                  const promptDisplayText = channelDisplayText;
                   delete meta[DAEMON_RETRY_META_KEY];
                   delete meta[INVOCATION_CONTEXT_META_KEY];
                   delete meta[PRIVATE_PARENT_CAPABILITY_META_KEY];
                   delete meta[DAEMON_CONTINUE_META_KEY];
                   delete meta[DAEMON_CHANNEL_DELIVERY_META_KEY];
+                  delete meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
                   delete meta[DAEMON_MODEL_PROMPT_META_KEY];
                   if (isRetry) {
                     meta[DAEMON_RETRY_META_KEY] = true;
@@ -9838,6 +10296,9 @@ function createAcpSessionBridge(opts) {
                   if (context?.channelDelivery) {
                     meta[DAEMON_CHANNEL_DELIVERY_META_KEY] = context.channelDelivery;
                   }
+                  if (promptDisplayText !== void 0) {
+                    meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] = promptDisplayText;
+                  }
                   if (modelPrompt !== void 0) {
                     meta[DAEMON_MODEL_PROMPT_META_KEY] = modelPrompt;
                   }
@@ -9867,7 +10328,8 @@ function createAcpSessionBridge(opts) {
                       entry,
                       promptRequest,
                       pendingEntry.promptId,
-                      originatorClientId
+                      originatorClientId,
+                      channelDisplayText
                     );
                   }
                 } catch (echoErr) {
@@ -10226,16 +10688,20 @@ function createAcpSessionBridge(opts) {
           releaseFreshSessionReservation(admission);
         }, "releaseAdmissionOnce");
         try {
-          const ci = await ensureChannel();
+          assertLivePromptEntry(sessionId, entry);
+          const ci = channelInfoForEntry(entry);
           const result = await withTimeout(
-            ci.connection.extMethod(
-              isSideTask ? SERVE_CONTROL_EXT_METHODS.sessionSideTask : SERVE_CONTROL_EXT_METHODS.sessionBranch,
-              {
-                sessionId,
-                cwd: boundWorkspace,
-                name: req.name
-              }
-            ),
+            Promise.race([
+              ci.connection.extMethod(
+                isSideTask ? SERVE_CONTROL_EXT_METHODS.sessionSideTask : SERVE_CONTROL_EXT_METHODS.sessionBranch,
+                {
+                  sessionId,
+                  cwd: boundWorkspace,
+                  name: req.name
+                }
+              ),
+              getTransportClosedReject(entry)
+            ]),
             initTimeoutMs,
             isSideTask ? "createSideTaskSession" : "branchSession"
           );
@@ -10271,10 +10737,25 @@ function createAcpSessionBridge(opts) {
               `qwen serve: branchSession load failed for ${result.newSessionId}, attempting cleanup...`
             );
             try {
-              await ci.connection.extMethod(
-                SERVE_CONTROL_EXT_METHODS.sessionClose,
-                { sessionId: result.newSessionId, cwd: boundWorkspace }
-              );
+              if (!ci.isDying) {
+                await withTimeout(
+                  Promise.race([
+                    ci.connection.extMethod(
+                      SERVE_CONTROL_EXT_METHODS.sessionClose,
+                      {
+                        sessionId: result.newSessionId,
+                        cwd: boundWorkspace
+                      }
+                    ),
+                    channelUnavailableReject(
+                      ci.channel,
+                      "during branchSession cleanup"
+                    )
+                  ]),
+                  initTimeoutMs,
+                  "branchSession cleanup"
+                );
+              }
             } catch (cleanupErr) {
               writeStderrLine(
                 `qwen serve: branchSession cleanup of ${result.newSessionId} failed: ${cleanupErr instanceof Error ? cleanupErr.message : cleanupErr}`
@@ -10370,16 +10851,16 @@ function createAcpSessionBridge(opts) {
         if (entry.promptActive) {
           throw new CdWhilePromptActiveError(sessionId);
         }
-        const ci = await ensureChannel();
-        const raw = await ci.connection.extMethod(
-          SERVE_CONTROL_EXT_METHODS.sessionCd,
-          {
+        assertLivePromptEntry(sessionId, entry);
+        const raw = await Promise.race([
+          entry.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionCd, {
             sessionId,
             path: req.path,
             ...req.allowedRoots ? { allowedRoots: req.allowedRoots } : {},
             ...req.managedRelocation ? { managedRelocation: req.managedRelocation } : {}
-          }
-        );
+          }),
+          getTransportClosedReject(entry)
+        ]);
         const extResult = raw;
         if (typeof extResult?.previousCwd !== "string" || typeof extResult?.newCwd !== "string" || !Array.isArray(extResult?.warnings)) {
           throw new Error(
@@ -10912,6 +11393,7 @@ function createAcpSessionBridge(opts) {
       const bootstrapRefreshConnections = /* @__PURE__ */ new Set();
       const refreshSession = /* @__PURE__ */ __name(async (entry, refreshBootstrap) => {
         let inFlight = inFlightExtensionRefreshes.get(entry.sessionId);
+        let created = false;
         if (!inFlight || inFlight.connection !== entry.connection || refreshBootstrap && !inFlight.refreshBootstrap) {
           const promise = (async () => {
             await entry.connection.extMethod(
@@ -10922,27 +11404,36 @@ function createAcpSessionBridge(opts) {
               }
             );
           })();
+          let rejectUnavailable;
+          const unavailable = new Promise((_resolve, reject) => {
+            rejectUnavailable = /* @__PURE__ */ __name(() => reject(
+              new BridgeChannelClosedError("refreshExtensionsForAllSessions")
+            ), "rejectUnavailable");
+          });
           inFlight = {
             connection: entry.connection,
             promise,
+            wait: Promise.race([
+              withTimeout(
+                promise,
+                3e4,
+                SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh
+              ),
+              unavailable
+            ]),
+            rejectUnavailable,
             refreshBootstrap
           };
           inFlightExtensionRefreshes.set(entry.sessionId, inFlight);
-          const clear = /* @__PURE__ */ __name(() => {
-            if (inFlightExtensionRefreshes.get(entry.sessionId) === inFlight) {
-              inFlightExtensionRefreshes.delete(entry.sessionId);
-            }
-          }, "clear");
-          void promise.then(clear, clear);
+          created = true;
         }
-        await Promise.race([
-          withTimeout(
-            inFlight.promise,
-            3e4,
-            SERVE_CONTROL_EXT_METHODS.workspaceExtensionsRefresh
-          ),
-          getTransportClosedReject(entry)
-        ]);
+        const clear = /* @__PURE__ */ __name(() => {
+          if (inFlightExtensionRefreshes.get(entry.sessionId) === inFlight) {
+            inFlightExtensionRefreshes.delete(entry.sessionId);
+          }
+        }, "clear");
+        if (created) void inFlight.promise.then(clear, clear);
+        await inFlight.wait;
       }, "refreshSession");
       const results = await Promise.all(
         sessions.map(async (entry) => {
@@ -11069,6 +11560,29 @@ function createAcpSessionBridge(opts) {
       }
       return response;
     },
+    async setSessionConfigOption(sessionId, req) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const info = channelInfoForEntry(entry);
+      if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
+      const normalized = { ...req, sessionId };
+      const transportClosed = getTransportClosedReject(entry);
+      const work = entry.modelChangeQueue.then(
+        () => Promise.race([
+          withTimeout(
+            entry.connection.setSessionConfigOption(normalized),
+            initTimeoutMs,
+            "setSessionConfigOption"
+          ),
+          transportClosed
+        ])
+      );
+      entry.modelChangeQueue = work.then(
+        () => void 0,
+        () => void 0
+      );
+      return await work;
+    },
     async setSessionLanguage(sessionId, params, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -11677,9 +12191,16 @@ function createAcpSessionBridge(opts) {
         });
         const historyOutput = output.length > MAX_SHELL_OUTPUT_FOR_HISTORY ? output.substring(0, MAX_SHELL_OUTPUT_FOR_HISTORY) + "\n... (truncated)" : output;
         try {
-          await entry.connection.extMethod(
-            SERVE_CONTROL_EXT_METHODS.sessionShellHistory,
-            { sessionId, command, output: historyOutput, exitCode }
+          await withTimeout(
+            Promise.race([
+              entry.connection.extMethod(
+                SERVE_CONTROL_EXT_METHODS.sessionShellHistory,
+                { sessionId, command, output: historyOutput, exitCode }
+              ),
+              getTransportClosedReject(entry)
+            ]),
+            initTimeoutMs,
+            "sessionShellHistory"
           );
         } catch (err) {
           writeServeDebugLine(