@qwen-code/qwen-code 0.20.1-preview.7215 → 0.20.1

package/chunks/{chunk-6EFTQYW7.js → chunk-5I5BM454.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   __qwen_filename,
   init_esbuild_shims

package/chunks/{chunk-GMGDLUC7.js → chunk-6IL7KRLE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   themeManager
-} from "./chunk-AYCDXHZB.js";
+} from "./chunk-7Z6JQEL6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-26LLB6FM.js → chunk-6NHK6HS7.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-FODK6UMO.js";
 import {
   TextTokenizer
-} from "./chunk-MAQQGNQ5.js";
+} from "./chunk-JYS55H6Z.js";
 import {
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-FVS747N7.js → chunk-6PRNSLMB.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-RS7MT2QG.js";
 import {
   formatHistoryGapNotice
-} from "./chunk-CVDW42JT.js";
+} from "./chunk-NNFK277W.js";
 import {
   isGoalStatusKind,
   isTerminalGoalStatusKind
@@ -23,18 +23,18 @@ import {
   setGoalTerminalObserver,
   setLastGoalTerminal,
   unregisterGoalHook
-} from "./chunk-6OH6A5EX.js";
+} from "./chunk-GEB2CGUV.js";
 import {
   apiActivityTracker,
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-ONWW74X6.js";
+} from "./chunk-5G2SK2OO.js";
 import {
   ToolNames
-} from "./chunk-S35ZDXOS.js";
+} from "./chunk-YM3SZTH4.js";
 import {
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -918,6 +918,11 @@ var DefaultTranscriptReplayMachine = class {
     let ordinal = 0;
     for (const pending of [...this.pendingToolCalls.values()]) {
       this.pendingToolCalls.delete(pending.callId);
+      this.report(
+        "missing_tool_result",
+        "A transcript tool call has no persisted result.",
+        pending.sourceRecordId
+      );
       yield {
         sourceRecordId: pending.sourceRecordId,
         ...pending.sourceTimestamp ? { sourceTimestamp: pending.sourceTimestamp } : {},
@@ -2493,7 +2498,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./src-BVROLD6N.js");
+    const { getGitRepoName } = await import("./src-FFXGUTNL.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;

package/chunks/chunk-6PVPNMXU.js

@@ -0,0 +1,29 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/env.ts
+init_esbuild_shims();
+function parsePositiveIntegerEnv(value, fallback) {
+  const trimmed = value?.trim();
+  if (!trimmed || !/^\d+$/.test(trimmed)) {
+    return fallback;
+  }
+  const parsed = Number(trimmed);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+__name(parsePositiveIntegerEnv, "parsePositiveIntegerEnv");
+
+export {
+  parsePositiveIntegerEnv
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-BDBMYST4.js → chunk-6X4GWOPW.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-4ODB7WIB.js → chunk-6ZBPS62S.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolvePath
-} from "./chunk-NIJEXGV6.js";
+} from "./chunk-RVLZCXEE.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-E5GIFWE3.js → chunk-766HLFAG.js}

@@ -1,21 +1,21 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  getInstallationInfo,
-  resolveUpdateCommand
-} from "./chunk-DA7OOKVN.js";
 import {
   performStandaloneUpdate
-} from "./chunk-LZYWWWCZ.js";
+} from "./chunk-3KQSDUK3.js";
 import {
   updateEventEmitter
 } from "./chunk-YAF2MQZ6.js";
 import {
   t
-} from "./chunk-2DXOIVUI.js";
+} from "./chunk-WCFTQD7H.js";
+import {
+  getInstallationInfo,
+  resolveUpdateCommand
+} from "./chunk-KDPIV6WC.js";
 import {
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -34,7 +34,7 @@ var spawnWrapper = spawn;
 // packages/cli/src/utils/handleAutoUpdate.ts
 import os from "node:os";
 var debugLogger = createDebugLogger("AUTO_UPDATE");
-var UPDATE_SUCCESS_MESSAGE = "Update successful! Please restart Qwen Code to use the new version. Switching model providers before restarting may not work correctly.";
+var UPDATE_SUCCESS_MESSAGE = "Update successful! The new version will be used on your next run.";
 var UPDATE_FAILED_MESSAGE = "Automatic update failed. Please try updating manually.";
 function handleAutoUpdate(info, settings, projectRoot, spawnFn = spawnWrapper) {
   if (!info) {
@@ -78,37 +78,56 @@ ${installationInfo.updateMessage}`;
     installationInfo.updateCommand,
     info.update.latest
   );
-  const isWindows = os.platform() === "win32";
-  const shell = isWindows ? "cmd.exe" : "bash";
-  const shellArgs = isWindows ? ["/c", updateCommand] : ["-c", updateCommand];
-  const updateProcess = spawnFn(shell, shellArgs, {
-    stdio: ["pipe", "ignore", "pipe"]
+  const platform = os.platform();
+  const isWindows = platform === "win32";
+  const isManagedNpmUpdate = installationInfo.packageManager === "npm" /* NPM */;
+  const command = isManagedNpmUpdate ? process.execPath : isWindows ? "cmd.exe" : "bash";
+  const commandArgs = isManagedNpmUpdate ? [process.argv[1]] : isWindows ? ["/c", updateCommand] : ["-c", updateCommand];
+  const updateProcess = spawnFn(command, commandArgs, {
+    ...isManagedNpmUpdate ? {
+      detached: true,
+      env: {
+        ...process.env,
+        QWEN_CODE_MANAGED_NPM_UPDATE_VERSION: info.update.latest
+      },
+      stdio: ["ignore", "ignore", "pipe"],
+      windowsHide: true
+    } : { stdio: ["pipe", "ignore", "pipe"] }
   });
   let errorOutput = "";
-  updateProcess.stderr.on("data", (data) => {
+  updateProcess.stderr?.on("data", (data) => {
     errorOutput += data.toString();
   });
-  updateProcess.on("close", (code) => {
-    if (code === 0) {
-      updateEventEmitter.emit("update-success", {
-        message: t(UPDATE_SUCCESS_MESSAGE)
-      });
-    } else {
-      debugLogger.warn(
-        `Automatic update command failed: ${updateCommand}; stderr: ${errorOutput.trim()}`
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = /* @__PURE__ */ __name((error) => {
+      if (settled) return;
+      settled = true;
+      try {
+        if (error) throw error;
+        updateEventEmitter.emit("update-success", {
+          message: t(UPDATE_SUCCESS_MESSAGE)
+        });
+        resolve(true);
+      } catch (error2) {
+        debugLogger.warn("Automatic update failed:", error2);
+        updateEventEmitter.emit("update-failed", {
+          message: t(UPDATE_FAILED_MESSAGE)
+        });
+        resolve(false);
+      }
+    }, "finish");
+    updateProcess.once("close", (code) => {
+      finish(
+        code === 0 ? void 0 : new Error(
+          `Command failed: ${updateCommand}; stderr: ${errorOutput.trim()}`
+        )
       );
-      updateEventEmitter.emit("update-failed", {
-        message: t(UPDATE_FAILED_MESSAGE)
-      });
-    }
-  });
-  updateProcess.on("error", (err) => {
-    debugLogger.warn("Automatic update command failed to start:", err);
-    updateEventEmitter.emit("update-failed", {
-      message: t(UPDATE_FAILED_MESSAGE)
+    });
+    updateProcess.once("error", (error) => {
+      finish(error);
     });
   });
-  return updateProcess;
 }
 __name(handleAutoUpdate, "handleAutoUpdate");
 function setUpdateHandler(addItem, setUpdateInfo, isIdleRef = { current: true }) {
@@ -137,7 +156,9 @@ function setUpdateHandler(addItem, setUpdateInfo, isIdleRef = { current: true })
   const handleUpdateFailed = /* @__PURE__ */ __name((data) => {
     setUpdateInfo(null);
     addItemOrDefer({
-      type: "error" /* ERROR */,
+      // Background update-check failures are emitted with severity 'warning'
+      // (#7049); actual update installation failures stay errors.
+      type: data?.severity === "warning" ? "warning" /* WARNING */ : "error" /* ERROR */,
       text: data?.message ?? t(UPDATE_FAILED_MESSAGE)
     });
   }, "handleUpdateFailed");

package/chunks/{chunk-SDXIH6OA.js → chunk-76OFFG6L.js}

@@ -3,7 +3,7 @@
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace
-} from "./chunk-W7FJ3N32.js";
+} from "./chunk-2RFKHEXL.js";
 import {
   MAX_DAEMON_WORKSPACES
 } from "./chunk-5HBA2Z7V.js";
@@ -124,6 +124,7 @@ __name(resolveWorkspaceInputs, "resolveWorkspaceInputs");
 var SCHEMA_VERSION = 1;
 var MAX_SECONDARY_WORKSPACES = MAX_REGISTERED_WORKSPACES - 1;
 var MAX_STORE_BYTES = 256 * 1024;
+var MAX_WORKSPACE_DISPLAY_NAME_LENGTH = 256;
 var LOCK_OPTIONS = {
   realpath: false,
   stale: 1e4,
@@ -136,6 +137,43 @@ var LOCK_OPTIONS = {
     randomize: true
   }
 };
+var WorkspaceDisplayNameValidationError = class extends Error {
+  static {
+    __name(this, "WorkspaceDisplayNameValidationError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "WorkspaceDisplayNameValidationError";
+  }
+};
+function containsDisplayNameControlCharacter(value) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint <= 31 || codePoint === 127) return true;
+  }
+  return false;
+}
+__name(containsDisplayNameControlCharacter, "containsDisplayNameControlCharacter");
+function normalizeWorkspaceDisplayName(value) {
+  if (typeof value !== "string") {
+    throw new WorkspaceDisplayNameValidationError(
+      "Workspace display name must be a string"
+    );
+  }
+  const trimmed = value.trim();
+  if (trimmed.length > MAX_WORKSPACE_DISPLAY_NAME_LENGTH) {
+    throw new WorkspaceDisplayNameValidationError(
+      `Workspace display name exceeds ${MAX_WORKSPACE_DISPLAY_NAME_LENGTH} characters`
+    );
+  }
+  if (containsDisplayNameControlCharacter(trimmed)) {
+    throw new WorkspaceDisplayNameValidationError(
+      "Workspace display name contains control characters"
+    );
+  }
+  return trimmed.length === 0 ? void 0 : trimmed;
+}
+__name(normalizeWorkspaceDisplayName, "normalizeWorkspaceDisplayName");
 var WorkspaceRegistrationStoreError = class extends Error {
   static {
     __name(this, "WorkspaceRegistrationStoreError");
@@ -196,6 +234,38 @@ function validateWorkspacePath(value, label) {
   return value;
 }
 __name(validateWorkspacePath, "validateWorkspacePath");
+function validateStoredDisplayName(value, label) {
+  let displayName;
+  try {
+    displayName = normalizeWorkspaceDisplayName(value);
+  } catch (err) {
+    throw new WorkspaceRegistrationStoreError(
+      `${label} is invalid: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (displayName === void 0) {
+    throw new WorkspaceRegistrationStoreError(`${label} must not be empty`);
+  }
+  return displayName;
+}
+__name(validateStoredDisplayName, "validateStoredDisplayName");
+function setSnapshotDisplayName(snapshot, registrationId, displayName) {
+  if (displayName === void 0) {
+    if (!snapshot.displayNames || !Object.hasOwn(snapshot.displayNames, registrationId)) {
+      return false;
+    }
+    delete snapshot.displayNames[registrationId];
+    if (Object.keys(snapshot.displayNames).length === 0) {
+      delete snapshot.displayNames;
+    }
+    return true;
+  }
+  if (snapshot.displayNames?.[registrationId] === displayName) return false;
+  snapshot.displayNames ??= {};
+  snapshot.displayNames[registrationId] = displayName;
+  return true;
+}
+__name(setSnapshotDisplayName, "setSnapshotDisplayName");
 function parseSnapshot(raw, primaryWorkspace) {
   let value;
   try {
@@ -252,7 +322,34 @@ function parseSnapshot(raw, primaryWorkspace) {
     seen.add(normalizedWorkspace);
     return workspace;
   });
-  return { schemaVersion: SCHEMA_VERSION, primaryWorkspace, workspaces };
+  const rawDisplayNames = record["displayNames"];
+  let displayNames;
+  if (rawDisplayNames !== void 0) {
+    if (typeof rawDisplayNames !== "object" || rawDisplayNames === null || Array.isArray(rawDisplayNames)) {
+      throw new WorkspaceRegistrationStoreError(
+        "Workspace registration store displayNames must be an object"
+      );
+    }
+    const registrationIds = new Set(workspaces.map(workspaceRegistrationId));
+    for (const [registrationId, value2] of Object.entries(rawDisplayNames)) {
+      if (!registrationIds.has(registrationId)) {
+        throw new WorkspaceRegistrationStoreError(
+          `Workspace registration store displayNames contains unknown registration id ${JSON.stringify(registrationId)}`
+        );
+      }
+      displayNames ??= {};
+      displayNames[registrationId] = validateStoredDisplayName(
+        value2,
+        `displayNames[${JSON.stringify(registrationId)}]`
+      );
+    }
+  }
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    primaryWorkspace,
+    workspaces,
+    ...displayNames ? { displayNames } : {}
+  };
 }
 __name(parseSnapshot, "parseSnapshot");
 var updateChains = /* @__PURE__ */ new Map();
@@ -391,8 +488,9 @@ var WorkspaceRegistrationStore = class {
       await file.close();
     }
   }
-  async add(workspace) {
+  async add(workspace, displayName) {
     validateWorkspacePath(workspace, "workspace");
+    const normalizedDisplayName = displayName === void 0 ? void 0 : normalizeWorkspaceDisplayName(displayName);
     if (normalizedScopePath(workspace) === normalizedScopePath(this.primaryWorkspace)) {
       throw new WorkspaceRegistrationStoreError(
         "Primary workspace cannot be stored as a secondary registration"
@@ -411,30 +509,61 @@ var WorkspaceRegistrationStore = class {
         );
       }
       snapshot.workspaces.push(workspace);
+      if (normalizedDisplayName !== void 0) {
+        snapshot.displayNames ??= {};
+        snapshot.displayNames[workspaceRegistrationId(workspace)] = normalizedDisplayName;
+      }
       return true;
     });
   }
   async removeById(id) {
     return await this.removeByIds([id]) > 0;
   }
+  async setDisplayNameByIds(ids, displayName) {
+    const normalizedDisplayName = displayName === void 0 ? void 0 : normalizeWorkspaceDisplayName(displayName);
+    const requested = new Set(ids);
+    if (requested.size === 0) return 0;
+    let matched = 0;
+    await this.update((snapshot) => {
+      let changed = false;
+      for (const workspace of snapshot.workspaces) {
+        const registrationId = workspaceRegistrationId(workspace);
+        if (!requested.has(registrationId)) continue;
+        matched++;
+        changed = setSnapshotDisplayName(
+          snapshot,
+          registrationId,
+          normalizedDisplayName
+        ) || changed;
+      }
+      return changed;
+    });
+    return matched;
+  }
   async removeByIds(ids) {
     const requested = new Set(ids);
     if (requested.size === 0) return 0;
     let removed = 0;
     await this.update((snapshot) => {
+      const removedIds = /* @__PURE__ */ new Set();
       const retained = snapshot.workspaces.filter((workspace) => {
-        if (!requested.has(workspaceRegistrationId(workspace))) return true;
+        const registrationId = workspaceRegistrationId(workspace);
+        if (!requested.has(registrationId)) return true;
         removed++;
+        removedIds.add(registrationId);
         return false;
       });
       if (removed === 0) return false;
       snapshot.workspaces.splice(0, snapshot.workspaces.length, ...retained);
+      for (const registrationId of removedIds) {
+        setSnapshotDisplayName(snapshot, registrationId, void 0);
+      }
       return true;
     });
     return removed;
   }
   async update(mutate) {
-    const { atomicWriteFile } = await import("./src-BVROLD6N.js");
+    const { atomicWriteFile } = await import("./src-FFXGUTNL.js");
     return withInProcessLock(this.filePath, async () => {
       const lock = await acquireFileLock(this.filePath);
       let committed = false;
@@ -478,6 +607,9 @@ var WorkspaceRegistrationStore = class {
 export {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
+  MAX_WORKSPACE_DISPLAY_NAME_LENGTH,
+  WorkspaceDisplayNameValidationError,
+  normalizeWorkspaceDisplayName,
   WorkspaceRegistrationStoreError,
   WorkspaceRegistrationStoreLimitError,
   WorkspaceRegistrationStoreCommittedError,

package/chunks/{chunk-ANHT55MR.js → chunk-7LH6CHKG.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-BAIEQKR5.js";
+} from "./chunk-Q3GGJDYN.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-Y4CRUWFZ.js → chunk-7NDXG4MB.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-WAX3ITOA.js";
+} from "./chunk-5EA5NVXS.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-B453NMZJ.js";
+} from "./chunk-EFIOE2EH.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,7 +16,13 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-IB35C3IL.js";
+} from "./chunk-3SXF4GMQ.js";
+import {
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError,
+  WorkspaceSkillNotFoundError,
+  WorkspaceSkillNotToggleableError
+} from "./chunk-OA4JVLSA.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS,
   McpServerNotFoundError,
@@ -26,7 +32,7 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-X6YQWCIJ.js";
+} from "./chunk-UH3WSE5L.js";
 import {
   BridgeChannelClosedError,
   SERVE_CONTROL_EXT_METHODS,
@@ -40,32 +46,27 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-WXAXH7IJ.js";
-import {
-  WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError,
-  WorkspaceSkillNotFoundError,
-  WorkspaceSkillNotToggleableError
-} from "./chunk-OA4JVLSA.js";
+} from "./chunk-BWQRDISK.js";
 import {
   getPersistScopeForModelSelection,
   loadSettings
-} from "./chunk-KPZNOZPC.js";
+} from "./chunk-7SWFAKVH.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-MC2DOZS7.js";
+} from "./chunk-S3YQCNJE.js";
 import {
-  writeStderrLine
+  writeStderrLine,
+  writeStderrLineSafe
 } from "./chunk-OWAK7LMW.js";
 import {
   ModelsConfig,
   SkillManager,
   require_yauzl
-} from "./chunk-6OH6A5EX.js";
+} from "./chunk-GEB2CGUV.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1187,11 +1188,11 @@ function createDaemonWorkspaceService(deps) {
       );
     },
     async preheatAcpChild(_ctx, opts) {
-      const startedAt = Date.now();
+      const startedAt = performance.now();
       const channelLive = /* @__PURE__ */ __name(() => isChannelLive?.() ?? false, "channelLive");
       const finish = /* @__PURE__ */ __name((result) => ({
         ...result,
-        durationMs: Date.now() - startedAt
+        durationMs: Math.max(0, Math.round(performance.now() - startedAt))
       }), "finish");
       if (channelLive()) {
         return finish({ ready: true, channelLive: true });
@@ -1201,43 +1202,67 @@ function createDaemonWorkspaceService(deps) {
           ready: false,
           channelLive: false,
           reason: "error",
-          error: "ACP preheat is not wired"
+          error: "ACP preheat is unavailable"
         });
       }
       if (!inFlightAcpPreheat) {
-        inFlightAcpPreheat = preheatAcpChildOnBridge().finally(() => {
-          inFlightAcpPreheat = void 0;
-        });
-        void inFlightAcpPreheat.catch((err) => {
-          writeStderrLine(
-            `qwen serve: ACP preheat failed: ${err instanceof Error ? err.message : String(err)}`
-          );
-        });
+        const promise = Promise.resolve().then(preheatAcpChildOnBridge);
+        inFlightAcpPreheat = promise;
+        void promise.then(
+          () => {
+            if (inFlightAcpPreheat === promise) {
+              inFlightAcpPreheat = void 0;
+            }
+          },
+          (err) => {
+            try {
+              writeStderrLineSafe(
+                `qwen serve: ACP preheat failed: ${err instanceof Error ? err.message : String(err)}`
+              );
+            } finally {
+              if (inFlightAcpPreheat === promise) {
+                inFlightAcpPreheat = void 0;
+              }
+            }
+          }
+        );
       }
+      const sharedPreheat = inFlightAcpPreheat;
       try {
         await withTimeout(
-          inFlightAcpPreheat,
+          sharedPreheat,
           opts?.timeoutMs ?? 5e3,
           "ACP preheat"
         );
       } catch (err) {
         if (err instanceof TimeoutError) {
-          inFlightAcpPreheat = void 0;
-          writeStderrLine(
+          writeStderrLineSafe(
             `qwen serve: ACP preheat timed out after ${opts?.timeoutMs ?? 5e3}ms`
           );
         }
         const live2 = channelLive();
-        const message = err instanceof Error ? err.message : String(err);
+        if (live2) {
+          return finish({ ready: true, channelLive: true });
+        }
         return finish({
-          ready: live2,
-          channelLive: live2,
+          ready: false,
+          channelLive: false,
           reason: err instanceof TimeoutError ? "timeout" : "error",
-          error: message
+          error: err instanceof TimeoutError ? "ACP preheat did not complete before the timeout" : "ACP preheat failed"
         });
       }
       const live = channelLive();
-      return finish({ ready: live, channelLive: live });
+      if (!live) {
+        writeStderrLineSafe(
+          "qwen serve: ACP preheat resolved without a live channel"
+        );
+      }
+      return live ? finish({ ready: true, channelLive: true }) : finish({
+        ready: false,
+        channelLive: false,
+        reason: "error",
+        error: "ACP preheat did not produce a live channel"
+      });
     },
     async getWorkspaceAcpStatus(_ctx) {
       return { channelLive: isChannelLive?.() ?? false };