@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260711.0ef3a76bd

package/chunks/chunk-F4PFZ7WP.js

@@ -0,0 +1,239 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getExtensionManager
+} from "./chunk-WPHYXKFL.js";
+import {
+  getPlugin,
+  parseChannelConfig,
+  registerPlugin
+} from "./chunk-43XJTCHT.js";
+import {
+  loadSettings
+} from "./chunk-L6GPKRH7.js";
+import {
+  sanitizeLogText
+} from "./chunk-43JB7OF4.js";
+import {
+  writeStderrLine,
+  writeStdoutLine
+} from "./chunk-YUZI3WAC.js";
+import {
+  Storage
+} from "./chunk-J4TSQ5EQ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/commands/channel/runtime.ts
+init_esbuild_shims();
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+function sessionsPath() {
+  return path.join(Storage.getGlobalQwenDir(), "channels", "sessions.json");
+}
+__name(sessionsPath, "sessionsPath");
+function channelLoopPath() {
+  return path.join(Storage.getGlobalQwenDir(), "channels", "cron.json");
+}
+__name(channelLoopPath, "channelLoopPath");
+function loadChannelsConfig(cwd = process.cwd(), settings = loadSettings(cwd)) {
+  const channels = settings.merged.channels;
+  return channels || {};
+}
+__name(loadChannelsConfig, "loadChannelsConfig");
+function resolveExtensionChannelEntrySpecifier(extensionPath, entry) {
+  return pathToFileURL(path.join(extensionPath, entry)).href;
+}
+__name(resolveExtensionChannelEntrySpecifier, "resolveExtensionChannelEntrySpecifier");
+async function loadChannelsFromExtensions() {
+  let loaded = 0;
+  try {
+    const extensionManager = await getExtensionManager();
+    const extensions = extensionManager.getLoadedExtensions().filter((e) => e.isActive && e.channels);
+    for (const ext of extensions) {
+      for (const [channelType, channelDef] of Object.entries(ext.channels)) {
+        if (await getPlugin(channelType)) {
+          writeStderrLine(
+            `[Extensions] Skipping channel "${channelType}" from "${ext.name}": type already registered`
+          );
+          continue;
+        }
+        const entrySpecifier = resolveExtensionChannelEntrySpecifier(
+          ext.path,
+          channelDef.entry
+        );
+        try {
+          const module = await import(entrySpecifier);
+          const plugin = module.plugin;
+          if (!plugin || typeof plugin.createChannel !== "function") {
+            writeStderrLine(
+              `[Extensions] "${ext.name}": channel entry point does not export a valid plugin object`
+            );
+            continue;
+          }
+          if (plugin.channelType !== channelType) {
+            writeStderrLine(
+              `[Extensions] "${ext.name}": channelType mismatch \u2014 manifest says "${channelType}", plugin says "${plugin.channelType}"`
+            );
+            continue;
+          }
+          registerPlugin(plugin);
+          loaded++;
+          writeStdoutLine(
+            `[Extensions] Loaded channel "${channelType}" from "${ext.name}"`
+          );
+        } catch (err) {
+          writeStderrLine(
+            `[Extensions] Failed to load channel "${channelType}" from "${ext.name}": ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    }
+  } catch (err) {
+    writeStderrLine(
+      `[Extensions] Failed to load extensions: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return loaded;
+}
+__name(loadChannelsFromExtensions, "loadChannelsFromExtensions");
+async function createChannel(name, config, bridge, options) {
+  const channelPlugin = await getPlugin(config.type);
+  if (!channelPlugin) {
+    throw new Error(`Unknown channel type: "${config.type}".`);
+  }
+  return channelPlugin.createChannel(name, config, bridge, options);
+}
+__name(createChannel, "createChannel");
+function selectFirstModel(parsed, bridgeLabel) {
+  const models = [
+    ...new Set(
+      parsed.map((channel) => channel.config.model).filter((model) => Boolean(model))
+    )
+  ];
+  if (models.length > 1) {
+    writeStderrLine(
+      `[Channel] Warning: Multiple models configured (${models.join(", ")}). ${bridgeLabel} will use "${models[0]}".`
+    );
+  }
+  return models[0];
+}
+__name(selectFirstModel, "selectFirstModel");
+function registerToolCallDispatch(bridge, router, channels) {
+  bridge.on("toolCall", (event) => {
+    const target = router.getTarget(event.sessionId);
+    if (target) {
+      const channel = channels.get(target.channelName);
+      if (channel) {
+        channel.dispatchToolCall(event);
+      }
+    }
+  });
+}
+__name(registerToolCallDispatch, "registerToolCallDispatch");
+function cancelPermissionRequest(bridge, requestId) {
+  if (!bridge.respondToPermission) {
+    return;
+  }
+  void bridge.respondToPermission(requestId, { outcome: { outcome: "cancelled" } }).catch((err) => {
+    writeStderrLine(
+      `[Channel] Permission cancellation failed for ${sanitizeLogText(requestId, 128)}: ${err instanceof Error ? sanitizeLogText(err.message, 512) : sanitizeLogText(String(err), 512)}`
+    );
+  });
+}
+__name(cancelPermissionRequest, "cancelPermissionRequest");
+function registerPermissionRelay(bridge, router, channels) {
+  bridge.on("permissionRequest", (event) => {
+    const target = router.getTarget(event.sessionId);
+    if (!target) {
+      writeStderrLine(
+        `[Channel] No route for session ${sanitizeLogText(event.sessionId, 128)}; cancelling permission ${sanitizeLogText(event.requestId, 128)}`
+      );
+      cancelPermissionRequest(bridge, event.requestId);
+      return;
+    }
+    const channel = channels.get(target.channelName);
+    if (!channel) {
+      writeStderrLine(
+        `[Channel] No channel "${sanitizeLogText(target.channelName, 64)}" for session ${sanitizeLogText(event.sessionId, 128)}; cancelling permission ${sanitizeLogText(event.requestId, 128)}`
+      );
+      cancelPermissionRequest(bridge, event.requestId);
+      return;
+    }
+    channel.dispatchPermissionRequest(event).catch((err) => {
+      writeStderrLine(
+        `[Channel] Permission relay failed for ${sanitizeLogText(event.requestId, 128)}: ${err instanceof Error ? sanitizeLogText(err.message, 512) : sanitizeLogText(String(err), 512)}`
+      );
+      cancelPermissionRequest(bridge, event.requestId);
+    });
+  });
+  bridge.on("permissionResolved", (event) => {
+    for (const channel of channels.values()) {
+      channel.dispatchPermissionResolved(event);
+    }
+  });
+}
+__name(registerPermissionRelay, "registerPermissionRelay");
+function registerSessionCleanup(bridge, router, channels) {
+  bridge.on("sessionDied", (event) => {
+    const safeId = sanitizeLogText(event.sessionId, 128);
+    const safeReason = event.reason ? sanitizeLogText(event.reason, 512) : "";
+    writeStderrLine(
+      `[Channel] Session ${safeId} died${safeReason ? ` (${safeReason})` : ""}, removing routing state`
+    );
+    const target = router.getTarget(event.sessionId);
+    const channel = target ? channels.get(target.channelName) : void 0;
+    if (channel) {
+      channel.onSessionDied(event.sessionId);
+    } else {
+      router.removeSessionId(event.sessionId);
+    }
+  });
+}
+__name(registerSessionCleanup, "registerSessionCleanup");
+async function parseConfiguredChannels(channelsConfig, selectedNames, opts = {}) {
+  const parsed = [];
+  for (const name of selectedNames) {
+    const rawConfig = channelsConfig[name];
+    if (!rawConfig || typeof rawConfig !== "object") {
+      throw new Error(
+        `Error in channel "${name}": channel is not configured. Add a "${name}" entry under "channels" in settings.json.`
+      );
+    }
+    try {
+      parsed.push({
+        name,
+        config: await parseChannelConfig(
+          name,
+          rawConfig,
+          opts.defaultCwd,
+          { resolveEnvVars: "available" }
+        )
+      });
+    } catch (err) {
+      throw new Error(
+        `Error in channel "${name}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return parsed;
+}
+__name(parseConfiguredChannels, "parseConfiguredChannels");
+
+export {
+  sessionsPath,
+  channelLoopPath,
+  loadChannelsConfig,
+  resolveExtensionChannelEntrySpecifier,
+  loadChannelsFromExtensions,
+  createChannel,
+  selectFirstModel,
+  registerToolCallDispatch,
+  registerPermissionRelay,
+  registerSessionCleanup,
+  parseConfiguredChannels
+};

package/chunks/{chunk-ME3YSROJ.js → chunk-FBSBT7JS.js}

@@ -2,30 +2,33 @@
 "use strict";
 import {
   HEADLESS_YOLO_NO_SANDBOX_WARNING
-} from "./chunk-BJBWRCSK.js";
+} from "./chunk-6H67XLET.js";
 import {
-  normalizeServeChannelSelection
-} from "./chunk-MX2YXRER.js";
+  DEFAULT_RING_SIZE
+} from "./chunk-6RLROE6G.js";
+import {
+  DEFAULT_COMPACTED_REPLAY_MAX_BYTES
+} from "./chunk-COH43MRJ.js";
 import {
   loadSettings
-} from "./chunk-STAZRKOT.js";
+} from "./chunk-L6GPKRH7.js";
 import {
-  DEFAULT_RING_SIZE
-} from "./chunk-G7ZG7CA6.js";
+  normalizeServeChannelSelection
+} from "./chunk-TJTKSVIV.js";
 import {
   writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+} from "./chunk-YUZI3WAC.js";
 import {
   MCP_BUDGET_WARN_FRACTION,
   parsePositiveIntegerEnv
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-UUVCHN62.js";
 import {
   openBrowserSecurely,
   shouldLaunchBrowser
-} from "./chunk-22IFUCVR.js";
+} from "./chunk-JESCGQM3.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -88,6 +91,9 @@ var serveCommand = {
     type: "number",
     default: 20,
     description: "Cap on concurrent live sessions. New spawn requests beyond this return 503; attach to existing sessions still works. Set to 0 to disable."
+  }).option("max-total-sessions", {
+    type: "number",
+    description: "Non-negative integer cap on concurrent live sessions across all workspace runtimes. Set to 0 to disable."
   }).option("max-pending-prompts-per-session", {
     type: "number",
     default: 5,
@@ -96,7 +102,7 @@ var serveCommand = {
     type: "string",
     array: true,
     requiresArg: true,
-    description: "Absolute workspace path this daemon binds to. POST /session requests with a mismatched cwd return 400 workspace_mismatch. Defaults to process.cwd() when omitted. For multi-workspace deployments, run one `qwen serve` per workspace on separate ports (or behind an external orchestrator)."
+    description: "Absolute workspace path this daemon binds to. POST /session requests with a mismatched cwd return 400 workspace_mismatch. Defaults to process.cwd() when omitted. Repeat for sessions-only multi-workspace mode; legacy workspace APIs remain primary-workspace only."
   }).option("max-connections", {
     type: "number",
     default: 256,
@@ -139,10 +145,14 @@ var serveCommand = {
     // one place rather than drifting between CLI and bus.
     default: DEFAULT_RING_SIZE,
     description: "Per-session SSE replay ring depth. Sets the replay backlog available to `GET /session/:id/events` reconnects that send a `Last-Event-ID: N` header. Larger = more reconnect headroom at the cost of a few hundred KB extra RAM per session. Must be a positive finite integer."
+  }).option("compacted-replay-max-bytes", {
+    type: "number",
+    default: DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
+    description: "Per-session in-memory compacted replay snapshot byte cap for `POST /session/:id/load` late attaches. Larger = more recent history in load snapshots at higher heap cost. Must be a positive safe integer no larger than 256 MiB."
   }).option("http-bridge", {
     type: "boolean",
     default: true,
-    description: "Stage 1 mode: one `qwen --acp` child per daemon (the daemon binds to one workspace at boot, multiplexing N sessions onto that child via the agent's native `newSession()`). Stage 2 native in-process mode is not yet implemented; this flag will become opt-in then."
+    description: "HTTP bridge mode: one `qwen --acp` child per registered workspace (sessions-only multi-workspace routing is enabled when multiple --workspace values are supplied). Stage 2 native in-process mode is not yet implemented; this flag will become opt-in then."
   }).option("mcp-client-budget", {
     type: "number",
     description: "Cap on live MCP clients spawned inside the ACP child for the bound workspace. Positive integer. Combine with --mcp-budget-mode to control behavior at the cap. When unset, mode defaults to off (no accounting-driven enforcement, but GET /workspace/mcp still reports `clientCount`). Distinct from claude-code MCP_SERVER_CONNECTION_BATCH_SIZE which gates startup concurrency, not the total client count."
@@ -287,7 +297,7 @@ var serveCommand = {
         process.exit(1);
       }
     }
-    const { runQwenServe } = await import("./run-qwen-serve-5OKADVLE.js");
+    const { runQwenServe } = await import("./run-qwen-serve-O6CMPURG.js");
     try {
       const handle = await runQwenServe({
         port: argv.port,
@@ -295,9 +305,11 @@ var serveCommand = {
         token: argv.token,
         mode: "http-bridge",
         maxSessions: argv["max-sessions"],
+        ...argv["max-total-sessions"] !== void 0 ? { maxTotalSessions: argv["max-total-sessions"] } : {},
         maxPendingPromptsPerSession,
         maxConnections: argv["max-connections"],
         eventRingSize: argv["event-ring-size"],
+        compactedReplayMaxBytes: argv["compacted-replay-max-bytes"],
         workspace: argv.workspace,
         requireAuth: argv["require-auth"],
         enableSessionShell: argv["enable-session-shell"],

package/chunks/{chunk-5IFG2VC4.js → chunk-FCMNKVXT.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name,

package/chunks/{chunk-YDSYD7UI.js → chunk-FD3DA3B4.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-OWVIH4HY.js";
+} from "./chunk-WFHJDT4S.js";
 import {
   parseAndFormatApiError
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-UUVCHN62.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-GL5TV7B5.js → chunk-GL22M2DU.js}

@@ -2,15 +2,15 @@
 "use strict";
 import {
   eastAsianWidth
-} from "./chunk-LGFAYIKX.js";
+} from "./chunk-QHTIBUWB.js";
 import {
   ansiRegex,
   init_ansi_regex,
   stripAnsi
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-UUVCHN62.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name,
@@ -182,6 +182,12 @@ function wrapToVisualLines(text, width) {
 }
 __name(wrapToVisualLines, "wrapToVisualLines");
 var regex = ansiRegex();
+var BARE_C0_CONTROL_CHARS_REGEX = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+var BIDI_OVERRIDE_CHARS_REGEX = /[\u200e\u200f\u202a-\u202e\u2066-\u2069]/g;
+function sanitizeTerminalText(value) {
+  return escapeAnsiCtrlCodes(value).replace(BARE_C0_CONTROL_CHARS_REGEX, "").replace(BIDI_OVERRIDE_CHARS_REGEX, "");
+}
+__name(sanitizeTerminalText, "sanitizeTerminalText");
 function escapeAnsiCtrlCodes(obj) {
   if (typeof obj === "string") {
     if (obj.search(regex) === -1) {
@@ -280,7 +286,8 @@ function sanitizeSensitiveText(text, maxLength = 200) {
 }
 __name(sanitizeSensitiveText, "sanitizeSensitiveText");
 var FILENAME_CONTROL_CHARS_REGEX = /[\x00-\x1f\x7f-\x9f]/g;
-function escapeFilenameControlChar(ch) {
+var MULTILINE_CONTROL_CHARS_REGEX = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g;
+function escapeControlChar(ch) {
   switch (ch) {
     case "\b":
       return "\\b";
@@ -298,14 +305,21 @@ function escapeFilenameControlChar(ch) {
     }
   }
 }
-__name(escapeFilenameControlChar, "escapeFilenameControlChar");
+__name(escapeControlChar, "escapeControlChar");
 function sanitizeFilenameForDisplay(name) {
   return escapeAnsiCtrlCodes(name).replace(
     FILENAME_CONTROL_CHARS_REGEX,
-    escapeFilenameControlChar
+    escapeControlChar
   );
 }
 __name(sanitizeFilenameForDisplay, "sanitizeFilenameForDisplay");
+function sanitizeMultilineForDisplay(text) {
+  return escapeAnsiCtrlCodes(text).replace(
+    MULTILINE_CONTROL_CHARS_REGEX,
+    escapeControlChar
+  );
+}
+__name(sanitizeMultilineForDisplay, "sanitizeMultilineForDisplay");
 
 export {
   stringWidth,
@@ -316,9 +330,11 @@ export {
   stripUnsafeCharacters,
   getCachedStringWidth,
   wrapToVisualLines,
+  sanitizeTerminalText,
   escapeAnsiCtrlCodes,
   sanitizeSensitiveText,
-  sanitizeFilenameForDisplay
+  sanitizeFilenameForDisplay,
+  sanitizeMultilineForDisplay
 };
 /**
  * @license

package/chunks/{chunk-AFOLR6YL.js → chunk-GQ4ZEYMI.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-P7I3D7FM.js";
+} from "./chunk-5OIXALQ5.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-RYFZCUJO.js";
+} from "./chunk-WCUK2QXK.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,18 +16,14 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-ADZG46HR.js";
+} from "./chunk-RRNR5U2U.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError
-} from "./chunk-BMFMJINR.js";
-import {
-  getPersistScopeForModelSelection,
-  loadSettings
-} from "./chunk-STAZRKOT.js";
+} from "./chunk-WL4L7EZH.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
-} from "./chunk-P7M4GA57.js";
+} from "./chunk-OCPBI7J5.js";
 import {
   McpServerNotFoundError,
   McpServerRestartFailedError,
@@ -36,7 +32,7 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-B34OV7K2.js";
+} from "./chunk-IAVB3HM3.js";
 import {
   SERVE_CONTROL_EXT_METHODS,
   SERVE_STATUS_EXT_METHODS,
@@ -49,22 +45,26 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-JF7DFPQ5.js";
+} from "./chunk-TJCEUA3S.js";
+import {
+  getPersistScopeForModelSelection,
+  loadSettings
+} from "./chunk-L6GPKRH7.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-MIG5SQNL.js";
+} from "./chunk-CBKR4Q5K.js";
 import {
   writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+} from "./chunk-YUZI3WAC.js";
 import {
   ModelsConfig
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-UUVCHN62.js";
 import {
   createDebugLogger
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-J4TSQ5EQ.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -328,6 +328,29 @@ async function verifyParentPostOpen(target, wsCanonical, _fh) {
   );
 }
 __name(verifyParentPostOpen, "verifyParentPostOpen");
+var TimeoutError = class extends Error {
+  static {
+    __name(this, "TimeoutError");
+  }
+};
+async function withTimeout(promise, timeoutMs, label) {
+  return await new Promise((resolve2, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new TimeoutError(`${label} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    promise.then(
+      (value) => {
+        clearTimeout(timeout);
+        resolve2(value);
+      },
+      (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      }
+    );
+  });
+}
+__name(withTimeout, "withTimeout");
 function createDaemonWorkspaceService(deps) {
   const {
     boundWorkspace,
@@ -339,12 +362,14 @@ function createDaemonWorkspaceService(deps) {
     persistDisabledTools,
     persistSetting,
     persistSettings,
+    preheatAcpChild: preheatAcpChildOnBridge,
     queryWorkspaceStatus,
     invokeWorkspaceCommand,
     refreshExtensionsForAllSessions: refreshExtensionsForAllSessionsOnBridge,
     publishWorkspaceEvent
   } = deps;
   let lastWorkspaceSkillsStatus;
+  let inFlightAcpPreheat;
   return {
     // -- Status queries (delegate to ACP child via queryWorkspaceStatus) --
     async getWorkspaceMcpStatus(_ctx) {
@@ -396,6 +421,62 @@ function createDaemonWorkspaceService(deps) {
         () => createIdleWorkspaceProvidersStatus(boundWorkspace)
       );
     },
+    async preheatAcpChild(_ctx, opts) {
+      const startedAt = Date.now();
+      const channelLive = /* @__PURE__ */ __name(() => isChannelLive?.() ?? false, "channelLive");
+      const finish = /* @__PURE__ */ __name((result) => ({
+        ...result,
+        durationMs: Date.now() - startedAt
+      }), "finish");
+      if (channelLive()) {
+        return finish({ ready: true, channelLive: true });
+      }
+      if (!preheatAcpChildOnBridge) {
+        return finish({
+          ready: false,
+          channelLive: false,
+          reason: "error",
+          error: "ACP preheat is not wired"
+        });
+      }
+      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)}`
+          );
+        });
+      }
+      try {
+        await withTimeout(
+          inFlightAcpPreheat,
+          opts?.timeoutMs ?? 5e3,
+          "ACP preheat"
+        );
+      } catch (err) {
+        if (err instanceof TimeoutError) {
+          inFlightAcpPreheat = void 0;
+          writeStderrLine(
+            `qwen serve: ACP preheat timed out after ${opts?.timeoutMs ?? 5e3}ms`
+          );
+        }
+        const live2 = channelLive();
+        const message = err instanceof Error ? err.message : String(err);
+        return finish({
+          ready: live2,
+          channelLive: live2,
+          reason: err instanceof TimeoutError ? "timeout" : "error",
+          error: message
+        });
+      }
+      const live = channelLive();
+      return finish({ ready: live, channelLive: live });
+    },
+    async getWorkspaceAcpStatus(_ctx) {
+      return { channelLive: isChannelLive?.() ?? false };
+    },
     async getWorkspaceEnvStatus(_ctx) {
       const acpChannelLive = isChannelLive?.() ?? false;
       if (!statusProvider) {
@@ -873,6 +954,9 @@ function createDaemonWorkspaceService(deps) {
         childError
       };
     },
+    invalidateWorkspaceSkillsStatus() {
+      lastWorkspaceSkillsStatus = void 0;
+    },
     async refreshExtensionsForAllSessions() {
       try {
         if (!refreshExtensionsForAllSessionsOnBridge) {
@@ -884,6 +968,8 @@ function createDaemonWorkspaceService(deps) {
           `qwen serve: refreshExtensionsForAllSessions failed: ${err instanceof Error ? err.message : String(err)}`
         );
         return { refreshed: 0, failed: 1 };
+      } finally {
+        lastWorkspaceSkillsStatus = void 0;
       }
     }
   };

package/chunks/chunk-GRC5HGPI.js

@@ -0,0 +1,13 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+
+// packages/cli/src/serve/acp-session-bridge.ts
+init_esbuild_shims();
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-WMPVYQ4P.js → chunk-GWHYEOV2.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-J4TSQ5EQ.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";