@qwen-code/qwen-code 0.19.3-nightly.20260701.a974594d7 → 0.19.4

package/chunks/{run-qwen-serve-PQV7QOHZ.js → run-qwen-serve-AGLZ642J.js}

@@ -1,5 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  findCliEntryPath
+} from "./chunk-AHNXYU4O.js";
 import {
   RUNTIME_STARTUP_CANCELLED_MESSAGE
 } from "./chunk-GHOTR7HL.js";
@@ -17,23 +20,31 @@ import {
   getRateLimiter,
   getServeProtocolVersions,
   hostAllowlist,
-  isLoopbackBind,
   listenerMaxConnections,
   parseAllowOriginPatterns,
   parseDaemonStatusDetail,
   positiveFiniteOrNull,
   require_express,
   resolveWebShellDir
-} from "./chunk-MTJVHQDP.js";
+} from "./chunk-B7KGXIPZ.js";
+import {
+  isLoopbackBind
+} from "./chunk-RNBYOUGV.js";
 import "./chunk-3HX5LZ6R.js";
 import "./chunk-7RYW5LQV.js";
 import {
   getCliVersion
-} from "./chunk-HIYUAXBG.js";
+} from "./chunk-W6X4FGWX.js";
 import "./chunk-EWALXUAD.js";
 import {
   canonicalizeWorkspace
 } from "./chunk-SEZC2725.js";
+import {
+  QWEN_SERVER_TOKEN_ENV
+} from "./chunk-EDAGQADF.js";
+import {
+  channelSelectionNames
+} from "./chunk-MX2YXRER.js";
 import {
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
@@ -352,7 +363,6 @@ function initDaemonLogger(opts) {
 __name(initDaemonLogger, "initDaemonLogger");
 
 // packages/cli/src/serve/run-qwen-serve.ts
-var QWEN_SERVER_TOKEN_ENV = "QWEN_SERVER_TOKEN";
 var QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV = "QWEN_SERVE_CLIENT_MCP_OVER_WS";
 var QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV = "QWEN_SERVE_CDP_TUNNEL_OVER_WS";
 var QWEN_SERVE_PROMPT_DEADLINE_MS_ENV = "QWEN_SERVE_PROMPT_DEADLINE_MS";
@@ -401,6 +411,18 @@ function parseDeadlineEnv(envName, raw) {
   return parsed;
 }
 __name(parseDeadlineEnv, "parseDeadlineEnv");
+function envFlagDisabled(raw) {
+  if (raw === void 0) return false;
+  const normalized = raw.trim().toLowerCase();
+  return normalized === "0" || normalized === "false";
+}
+__name(envFlagDisabled, "envFlagDisabled");
+function hasChromeExtensionOrigin(origins) {
+  return origins?.some(
+    (origin) => origin.trim().toLowerCase().startsWith("chrome-extension://")
+  ) === true;
+}
+__name(hasChromeExtensionOrigin, "hasChromeExtensionOrigin");
 function createDaemonTelemetryRuntimeConfig(telemetry, cliVersion, daemonSessionId, defaults) {
   return {
     getTelemetryEnabled: /* @__PURE__ */ __name(() => telemetry.enabled ?? false, "getTelemetryEnabled"),
@@ -471,6 +493,14 @@ function formatHostForUrl(host) {
   return host;
 }
 __name(formatHostForUrl, "formatHostForUrl");
+function formatChannelWorkerDaemonUrl(host, port) {
+  const normalized = host.trim().toLowerCase();
+  if (normalized === "" || normalized === "0.0.0.0" || normalized === "::" || normalized === "[::]") {
+    return `http://127.0.0.1:${port}`;
+  }
+  return `http://${formatHostForUrl(host)}:${port}`;
+}
+__name(formatChannelWorkerDaemonUrl, "formatChannelWorkerDaemonUrl");
 function extractContextFilename(value) {
   if (typeof value === "string") {
     const trimmed = value.trim();
@@ -496,6 +526,52 @@ function withSettingsLock(workspace, fn) {
   return next;
 }
 __name(withSettingsLock, "withSettingsLock");
+var channelWorkerRuntimePromise;
+async function loadChannelWorkerRuntime() {
+  channelWorkerRuntimePromise ??= Promise.all([
+    import("./channel-worker-supervisor-A74FV522.js"),
+    import("./pidfile-AWTL4C63.js")
+  ]).then(([supervisor, pidfile]) => ({
+    createChannelWorkerSupervisor: supervisor.createChannelWorkerSupervisor,
+    channelServicePidfile: pidfile
+  })).catch((err) => {
+    channelWorkerRuntimePromise = void 0;
+    throw err;
+  });
+  return channelWorkerRuntimePromise;
+}
+__name(loadChannelWorkerRuntime, "loadChannelWorkerRuntime");
+function createDisabledChannelWorkerSupervisor() {
+  const snapshot = {
+    enabled: false,
+    state: "disabled",
+    channels: []
+  };
+  return {
+    async start() {
+    },
+    async stop() {
+    },
+    killAllSync() {
+    },
+    snapshot: /* @__PURE__ */ __name(() => ({ ...snapshot, channels: [] }), "snapshot")
+  };
+}
+__name(createDisabledChannelWorkerSupervisor, "createDisabledChannelWorkerSupervisor");
+function writeServeChannelReservation(channelServicePidfile, channels) {
+  channelServicePidfile.reserveServeServiceInfo({
+    channels,
+    servePid: process.pid
+  });
+}
+__name(writeServeChannelReservation, "writeServeChannelReservation");
+function channelServicePidfileConflictError(info) {
+  const owner = info.owner === "serve" ? "qwen serve" : "qwen channel start";
+  return new Error(
+    `Channel service is already running under ${owner} (PID ${info.pid}). Stop it before starting qwen serve --channel.`
+  );
+}
+__name(channelServicePidfileConflictError, "channelServicePidfileConflictError");
 function normalizeInstallModelIds(req, provider, getDefaultModelIds) {
   const fromRequest = req.modelIds?.map((id) => id.trim()).filter((id) => id.length > 0);
   const modelIds = fromRequest && fromRequest.length > 0 ? fromRequest : getDefaultModelIds(provider);
@@ -525,7 +601,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-PNZYGM3R.js");
+  coreRuntimePromise ??= import("./src-OVZLTVVM.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -555,9 +631,9 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-DFTYMJYF.js"),
-    import("./loadedSettingsAdapter-H27JMTLU.js"),
-    import("./trustedFolders-SJRXNHZE.js")
+    import("./settings-DR4V6L5Y.js"),
+    import("./loadedSettingsAdapter-OKMQFGGG.js"),
+    import("./trustedFolders-TEPGM5YL.js")
   ]).then(([settings, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     loadedSettingsAdapter,
@@ -576,13 +652,13 @@ async function loadServeRuntimeModules() {
     daemonStatusProviderModule,
     workspaceProvidersStatusModule
   ] = await Promise.all([
-    import("./server-P4YIH35I.js"),
-    import("./bridge-HZVAUTMX.js"),
-    import("./spawnChannel-DHRIMDVL.js"),
-    import("./workspace-service-34C7SUBU.js"),
+    import("./server-4AGEK2HC.js"),
+    import("./bridge-AUHNFOUS.js"),
+    import("./spawnChannel-VN5LJV7Z.js"),
+    import("./workspace-service-VKBI2KZD.js"),
     import("./types-QX5C3CHJ.js"),
-    import("./daemon-status-provider-42JEXENZ.js"),
-    import("./workspace-providers-status-GOCWYDMK.js")
+    import("./daemon-status-provider-V5UY7O7J.js"),
+    import("./workspace-providers-status-DM2XANVB.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -775,6 +851,7 @@ function createBootstrapServeApp(input) {
     sessionShellCommandEnabled,
     permissionPolicy,
     getRuntimeError,
+    getChannelWorkerSnapshot,
     onHealthServed
   } = input;
   const app = (0, import_express.default)();
@@ -829,6 +906,7 @@ function createBootstrapServeApp(input) {
       return;
     }
     const runtimeError = getRuntimeError();
+    const channelWorker = getChannelWorkerSnapshot();
     const runtimeFailed = runtimeError !== void 0;
     const issue = runtimeError ? {
       code: "daemon_runtime_failed",
@@ -895,6 +973,7 @@ function createBootstrapServeApp(input) {
           policy: permissionPolicy ?? "first-responder"
         },
         channel: { live: false },
+        channelWorker,
         transport: {
           restSseActive: 0,
           acp: {
@@ -1021,21 +1100,78 @@ async function runQwenServe(optsIn, deps = {}) {
     QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV,
     process.env[QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV]
   );
+  const clientMcpOverWsEnv = process.env[QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV];
+  const cdpTunnelOverWsEnv = process.env[QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV];
+  const chromeExtensionOriginAllowed = hasChromeExtensionOrigin(
+    optsIn.allowOrigins
+  );
   const opts = {
     ...optsIn,
     token,
     promptDeadlineMs,
     writerIdleTimeoutMs,
-    // Reverse tool channel (issue #5626, Phase 2). Opt-in via env until the
-    // public contract settles — the WS `mcp_register` / `mcp_message` frames
-    // and the child↔parent `client_mcp/message` round-trip stay dormant
-    // otherwise. An explicit `clientMcpOverWs` in `optsIn` (embedded callers)
-    // still wins.
-    clientMcpOverWs: optsIn.clientMcpOverWs ?? process.env[QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV] === "1",
-    // CDP tunnel (Plan C, issue #5626). Opt-in via env until the contract
-    // settles; an explicit `cdpTunnelOverWs` in `optsIn` still wins.
-    cdpTunnelOverWs: optsIn.cdpTunnelOverWs ?? process.env[QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV] === "1"
+    clientMcpOverWs: optsIn.clientMcpOverWs ?? (!envFlagDisabled(clientMcpOverWsEnv) && clientMcpOverWsEnv !== void 0),
+    cdpTunnelOverWs: optsIn.cdpTunnelOverWs ?? (!envFlagDisabled(cdpTunnelOverWsEnv) && (cdpTunnelOverWsEnv !== void 0 || chromeExtensionOriginAllowed))
   };
+  const channelRuntime = opts.channelSelection ? await loadChannelWorkerRuntime() : void 0;
+  const channelServicePidfile = deps.channelServicePidfile ?? channelRuntime?.channelServicePidfile;
+  let channelPidfileReserved = false;
+  const removeCurrentServePidfile = /* @__PURE__ */ __name(() => {
+    if (!opts.channelSelection || !channelServicePidfile) return;
+    if (!channelPidfileReserved) return;
+    if (channelServicePidfile.removeServeServiceInfo) {
+      if (channelServicePidfile.removeServeServiceInfo(process.pid)) {
+        channelPidfileReserved = false;
+      }
+      return;
+    }
+    const info = channelServicePidfile.readServiceInfo();
+    if (info?.owner === "serve" && info.pid === process.pid && info.servePid === process.pid) {
+      channelServicePidfile.removeServiceInfo();
+      channelPidfileReserved = false;
+    }
+  }, "removeCurrentServePidfile");
+  const reserveChannelServicePidfile = /* @__PURE__ */ __name(() => {
+    if (!opts.channelSelection) return;
+    if (!channelServicePidfile) {
+      throw new Error("Channel service pidfile runtime is not available.");
+    }
+    const channelPidfileNames = channelSelectionNames(opts.channelSelection);
+    const existingChannelService = channelServicePidfile.readServiceInfo();
+    if (existingChannelService) {
+      throw channelServicePidfileConflictError(existingChannelService);
+    }
+    try {
+      writeServeChannelReservation(channelServicePidfile, channelPidfileNames);
+      channelPidfileReserved = true;
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err) {
+        const code = err.code;
+        if (code === "EEXIST") {
+          const info = channelServicePidfile.readServiceInfo();
+          if (info) {
+            throw channelServicePidfileConflictError(info);
+          }
+          try {
+            writeServeChannelReservation(
+              channelServicePidfile,
+              channelPidfileNames
+            );
+            channelPidfileReserved = true;
+            return;
+          } catch (retryErr) {
+            if (retryErr && typeof retryErr === "object" && "code" in retryErr && retryErr.code === "EEXIST") {
+              throw new Error(
+                "Channel service is already starting. Retry after the current startup finishes."
+              );
+            }
+            throw retryErr;
+          }
+        }
+      }
+      throw err;
+    }
+  }, "reserveChannelServicePidfile");
   validateRateLimitOptions(opts);
   if (!opts.hostname.startsWith("[") && opts.hostname.split(":").length === 2) {
     const [host, port] = opts.hostname.split(":");
@@ -1215,21 +1351,7 @@ async function runQwenServe(optsIn, deps = {}) {
   const childEnvOverrides = {
     QWEN_SERVE_MCP_CLIENT_BUDGET: opts.mcpClientBudget !== void 0 ? String(opts.mcpClientBudget) : void 0,
     QWEN_SERVE_MCP_BUDGET_MODE: opts.mcpBudgetMode,
-    // CDP tunnel (Plan C, #5626): forward the flag + bound port so the spawned
-    // ACP child can auto-register chrome-devtools-mcp against this `/cdp`
-    // endpoint. Only meaningful with a fixed `--port`: the override map is frozen
-    // at bridge construction, so an ephemeral `--port 0` (resolved only after
-    // `listen`) can't be threaded here. Leave the port unset in that case so the
-    // child surfaces a clear diagnostic instead of a bogus port "0".
-    QWEN_SERVE_CDP_TUNNEL_OVER_WS: opts.cdpTunnelOverWs ? "1" : void 0,
-    QWEN_SERVE_CDP_TUNNEL_PORT: opts.cdpTunnelOverWs && opts.port > 0 ? String(opts.port) : void 0,
-    // Tell the child whether `/cdp` requires bearer auth. The ACP child can't
-    // inherit QWEN_SERVER_TOKEN (the spawn path scrubs it) and chrome-devtools-
-    // mcp is launched with `--wsEndpoint` only, so it can't authenticate against
-    // an auth-gated `/cdp`. The child uses this flag to skip auto-registering the
-    // browser tools (with a diagnostic) instead of registering tools that can't
-    // connect. See buildCdpTunnelMcpServer in acpAgent.ts.
-    QWEN_SERVE_CDP_TUNNEL_AUTH_REQUIRED: opts.cdpTunnelOverWs && (token || opts.requireAuth) ? "1" : void 0
+    QWEN_SERVE_CDP_TUNNEL_OVER_WS: opts.cdpTunnelOverWs ? "1" : void 0
   };
   const cliVersionPromise = getCliVersion();
   let cliVersion;
@@ -1273,6 +1395,23 @@ async function runQwenServe(optsIn, deps = {}) {
   });
   void runtimeReady.catch(() => {
   });
+  let channelWorker = createDisabledChannelWorkerSupervisor();
+  const getChannelWorkerSnapshot = /* @__PURE__ */ __name(() => channelWorker.snapshot(), "getChannelWorkerSnapshot");
+  const writeChannelWorkerPidfile = /* @__PURE__ */ __name(() => {
+    if (!opts.channelSelection || !channelServicePidfile) return;
+    const snapshot = channelWorker.snapshot();
+    try {
+      channelServicePidfile.writeServeServiceInfo({
+        channels: snapshot.channels,
+        servePid: process.pid,
+        workerPid: snapshot.pid
+      });
+    } catch (err) {
+      daemonLog.warn(
+        `failed to write channel worker pidfile metadata: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }, "writeChannelWorkerPidfile");
   const handleBridge = deps.bridge ?? createLazyBridgeProxy(
     () => bridgeRef,
     () => runtimeStartupError
@@ -1492,6 +1631,7 @@ async function runQwenServe(optsIn, deps = {}) {
       startup,
       fsFactory,
       daemonLog,
+      getChannelWorkerSnapshot,
       workspace: workspaceService,
       // Reverse tool channel (#5626): the SAME registry wired into `bridge` above,
       // so the WS provider and the child-answering bridge share one sender map.
@@ -1544,8 +1684,10 @@ async function runQwenServe(optsIn, deps = {}) {
     runtimeAppForCleanup = runtime.app;
     runtimeApp = runtime.app;
     bridgeRef = runtime.bridge;
-    runtimeStartupSettled = true;
-    markRuntimeReady();
+    if (!opts.channelSelection) {
+      runtimeStartupSettled = true;
+      markRuntimeReady();
+    }
   }
   cliVersion ??= await cliVersionPromise;
   const bootstrapApp = createBootstrapServeApp({
@@ -1558,6 +1700,7 @@ async function runQwenServe(optsIn, deps = {}) {
     sessionShellCommandEnabled,
     permissionPolicy,
     getRuntimeError: /* @__PURE__ */ __name(() => runtimeStartupError, "getRuntimeError"),
+    getChannelWorkerSnapshot,
     onHealthServed: deferRuntimeUntilFirstHealth ? () => startRuntimeAfterHealth?.() : void 0
   });
   const app = runtimeApp ?? createDelegatingServeApp(bootstrapApp, () => runtimeApp, {
@@ -1581,6 +1724,7 @@ async function runQwenServe(optsIn, deps = {}) {
       `Invalid maxConnections: ${opts.maxConnections}. Must be >= 0 (0 / Infinity = unlimited).`
     );
   }
+  reserveChannelServicePidfile();
   return await new Promise((resolve, reject) => {
     const server = app.listen(opts.port, listenHostname, () => {
       startup.listenerReadyAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -1597,6 +1741,42 @@ async function runQwenServe(optsIn, deps = {}) {
       const addr = server.address();
       actualPort = typeof addr === "object" && addr ? addr.port : opts.port;
       const url = `http://${formatHostForUrl(opts.hostname)}:${actualPort}`;
+      try {
+        if (opts.channelSelection) {
+          const createSupervisor = deps.channelWorkerSupervisorFactory ?? channelRuntime?.createChannelWorkerSupervisor;
+          if (!createSupervisor) {
+            throw new Error(
+              "Channel worker supervisor runtime is not available."
+            );
+          }
+          channelWorker = createSupervisor({
+            cliEntryPath: findCliEntryPath(),
+            daemonUrl: formatChannelWorkerDaemonUrl(opts.hostname, actualPort),
+            ...token ? { daemonToken: token } : {},
+            workspace: boundWorkspace,
+            selection: opts.channelSelection,
+            onExit: /* @__PURE__ */ __name((snapshot) => {
+              daemonLog.warn(
+                `channel worker exited (state=${snapshot.state}, pid=${snapshot.pid ?? "unknown"}, code=${snapshot.exitCode ?? "null"}, signal=${snapshot.signal ?? "null"}, error=${snapshot.error ?? "none"})`
+              );
+              removeCurrentServePidfile();
+            }, "onExit")
+          });
+        }
+      } catch (err) {
+        removeCurrentServePidfile();
+        const error = err instanceof Error ? err : new Error(String(err));
+        server.close((closeErr) => {
+          if (closeErr) {
+            daemonLog.error(
+              "server close after channel worker setup error failed",
+              closeErr
+            );
+          }
+          reject(error);
+        });
+        return;
+      }
       writeStdoutLine(
         `qwen serve listening on ${url} (mode=${opts.mode}, workspace=${boundWorkspace})`
       );
@@ -1610,6 +1790,11 @@ async function runQwenServe(optsIn, deps = {}) {
         writeStderrLine(
           `qwen serve: bearer auth disabled (loopback default). Set ${QWEN_SERVER_TOKEN_ENV} to enable.`
         );
+        if (opts.clientMcpOverWs === true) {
+          writeStderrLine(
+            `qwen serve: client-hosted MCP tools are accepted over the WebSocket without auth. Set ${QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV}=0 to disable.`
+          );
+        }
       } else if (opts.requireAuth) {
         writeStderrLine(
           "qwen serve: --require-auth enabled (bearer token mandatory on every route, including loopback /health)."
@@ -1664,6 +1849,14 @@ async function runQwenServe(optsIn, deps = {}) {
           }
         }
       }, "shutdownBridgeAfterFailedStartup");
+      const stopChannelWorkerAfterFailedStartup = /* @__PURE__ */ __name(async () => {
+        await channelWorker.stop().catch((stopErr) => {
+          daemonLog.error(
+            "channel worker stop after runtime startup error failed",
+            stopErr instanceof Error ? stopErr : null
+          );
+        });
+      }, "stopChannelWorkerAfterFailedStartup");
       const failRuntimeStartup = /* @__PURE__ */ __name(async (err, bridgeForCleanup) => {
         const error = err instanceof Error ? err : new Error(String(err));
         if (runtimeStartupSettled) {
@@ -1680,9 +1873,34 @@ async function runQwenServe(optsIn, deps = {}) {
         }
         writeStderrLine(`qwen serve: runtime startup failed: ${message}`);
         daemonLog.error("runtime startup failed", error);
-        markRuntimeFailed(error);
+        await stopChannelWorkerAfterFailedStartup();
+        removeCurrentServePidfile();
         await shutdownBridgeAfterFailedStartup(bridgeForCleanup ?? bridgeRef);
+        markRuntimeFailed(error);
       }, "failRuntimeStartup");
+      const armRuntimeStartupTimer = /* @__PURE__ */ __name(() => {
+        if (runtimeStartupTimeoutMs <= 0 || runtimeStartupTimer) return;
+        runtimeStartupTimer = setTimeout(() => {
+          void failRuntimeStartup(
+            new Error(
+              `Daemon runtime startup timed out after ${runtimeStartupTimeoutMs}ms.`
+            )
+          );
+        }, runtimeStartupTimeoutMs);
+        runtimeStartupTimer.unref();
+      }, "armRuntimeStartupTimer");
+      const completeRuntimeStartup = /* @__PURE__ */ __name(async () => {
+        if (runtimeStartupSettled) return;
+        if (opts.channelSelection) {
+          await channelWorker.start();
+          if (runtimeStartupSettled) return;
+          writeChannelWorkerPidfile();
+        }
+        if (runtimeStartupSettled) return;
+        runtimeStartupSettled = true;
+        clearRuntimeStartupTimer();
+        markRuntimeReady();
+      }, "completeRuntimeStartup");
       const startBridgePreheat = /* @__PURE__ */ __name((bridge) => {
         startup.preheat.status = "running";
         const preheatStartedAt = performance.now();
@@ -1705,6 +1923,7 @@ async function runQwenServe(optsIn, deps = {}) {
       }, "startBridgePreheat");
       const startRuntime = /* @__PURE__ */ __name(() => {
         if (runtimeStarting) return;
+        armRuntimeStartupTimer();
         clearRuntimeStartAfterHealthTimer();
         clearRuntimeStartFallbackTimer();
         runtimeStarting = buildRuntime().then(async (runtime) => {
@@ -1727,20 +1946,8 @@ async function runQwenServe(optsIn, deps = {}) {
           if (shouldPreheat) {
             startBridgePreheat(runtime.bridge);
           }
-          runtimeStartupSettled = true;
-          clearRuntimeStartupTimer();
-          markRuntimeReady();
+          await completeRuntimeStartup();
         }).catch((err) => failRuntimeStartup(err));
-        if (runtimeStartupTimeoutMs > 0) {
-          runtimeStartupTimer = setTimeout(() => {
-            void failRuntimeStartup(
-              new Error(
-                `Daemon runtime startup timed out after ${runtimeStartupTimeoutMs}ms.`
-              )
-            );
-          }, runtimeStartupTimeoutMs);
-          runtimeStartupTimer.unref();
-        }
       }, "startRuntime");
       startRuntimeForRequest = startRuntime;
       const scheduleRuntimeStartFallback = /* @__PURE__ */ __name(() => {
@@ -1777,7 +1984,9 @@ async function runQwenServe(optsIn, deps = {}) {
         if (shuttingDown) {
           daemonLog.warn(`received ${signal} during drain \u2014 forcing exit`);
           try {
+            channelWorker.killAllSync();
             bridgeRef?.killAllSync();
+            removeCurrentServePidfile();
           } catch (err) {
             daemonLog.error(
               "force-kill error",
@@ -1801,6 +2010,11 @@ async function runQwenServe(optsIn, deps = {}) {
           process.exit(1);
         }
       }, "onSignal");
+      const onUncaughtExceptionMonitor = /* @__PURE__ */ __name(() => {
+        if (process.listenerCount("uncaughtException") === 0) {
+          removeCurrentServePidfile();
+        }
+      }, "onUncaughtExceptionMonitor");
       const handle = {
         server,
         url,
@@ -1822,6 +2036,10 @@ async function runQwenServe(optsIn, deps = {}) {
               settled = true;
               process.removeListener("SIGINT", onSignal);
               process.removeListener("SIGTERM", onSignal);
+              process.removeListener(
+                "uncaughtExceptionMonitor",
+                onUncaughtExceptionMonitor
+              );
               void (coreRuntimePromise ? coreRuntimePromise.then((core) => core.shutdownTelemetry()) : Promise.resolve()).catch((telemetryErr) => {
                 writeStderrLine(
                   `qwen serve: telemetry shutdown error: ${telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr)}`
@@ -1869,6 +2087,13 @@ async function runQwenServe(optsIn, deps = {}) {
                 rl.setDraining(true);
                 rl.dispose();
               }
+              await channelWorker.stop().catch((err) => {
+                daemonLog.error(
+                  "channel worker stop error",
+                  err instanceof Error ? err : null
+                );
+              });
+              removeCurrentServePidfile();
               const bridgeForShutdown = bridgeRef;
               if (bridgeForShutdown) {
                 await bridgeForShutdown.shutdown().catch((err) => {
@@ -1908,6 +2133,7 @@ async function runQwenServe(optsIn, deps = {}) {
       };
       process.on("SIGINT", onSignal);
       process.on("SIGTERM", onSignal);
+      process.on("uncaughtExceptionMonitor", onUncaughtExceptionMonitor);
       server.removeAllListeners("error");
       server.on("error", (err) => {
         daemonLog.error("server error", err instanceof Error ? err : null);
@@ -1918,6 +2144,12 @@ async function runQwenServe(optsIn, deps = {}) {
         if (shouldPreheat) {
           startBridgePreheat(bridgeRef);
         }
+        if (opts.channelSelection && !runtimeStartupSettled) {
+          armRuntimeStartupTimer();
+          runtimeStarting = completeRuntimeStartup().catch(
+            (err) => failRuntimeStartup(err, bridgeRef)
+          );
+        }
       } else if (deferRuntimeUntilFirstHealth) {
         scheduleRuntimeStartFallback();
       } else {
@@ -1941,7 +2173,10 @@ async function runQwenServe(optsIn, deps = {}) {
         );
       }
     });
-    server.once("error", reject);
+    server.once("error", (err) => {
+      removeCurrentServePidfile();
+      reject(err);
+    });
   });
 }
 __name(runQwenServe, "runQwenServe");
@@ -1949,6 +2184,7 @@ export {
   InvalidPolicyConfigError,
   createLazyBridgeProxy,
   extractContextFilename,
+  formatChannelWorkerDaemonUrl,
   resolveRuntimeStartupTimeoutMs,
   runQwenServe,
   validatePolicyConfig,

package/chunks/{scheduler-OS3R5MGU.js → scheduler-TURO7NGY.js}

@@ -6,36 +6,38 @@ import {
 import {
   FILE_HISTORY_DIR,
   getSubagentsRootDir
-} from "./chunk-35FH347N.js";
-import "./chunk-K5PGHDBN.js";
+} from "./chunk-BFG6OZN7.js";
 import "./chunk-5P5XGNYH.js";
+import "./chunk-K5PGHDBN.js";
 import "./chunk-SKAZWEV5.js";
-import "./chunk-ESVSWG6Z.js";
-import "./chunk-CA4ML3VH.js";
-import "./chunk-HWG4XLD7.js";
-import "./chunk-YCRTJYSQ.js";
-import "./chunk-FZY7NH37.js";
+import "./chunk-QOMAHFYI.js";
+import "./chunk-G7OQ3RFJ.js";
+import "./chunk-LKWAVAB5.js";
+import "./chunk-MEQWZGK5.js";
+import "./chunk-UANCYOOQ.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
 import "./chunk-SJBIFVD2.js";
 import "./chunk-MLZQVCF3.js";
+import "./chunk-S5EQPDTM.js";
 import "./chunk-LQ7TMOCE.js";
-import "./chunk-LD2XBG6Z.js";
+import "./chunk-E5A7LHNN.js";
+import "./chunk-GO6LNQXT.js";
 import "./chunk-B236XPGF.js";
 import "./chunk-YXK4GPYO.js";
 import "./chunk-TOAUDIS7.js";
 import "./chunk-NPQWQYU6.js";
-import "./chunk-B5MPZI4K.js";
-import "./chunk-3PJXIDKI.js";
+import "./chunk-HJDF3ZVU.js";
+import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
 import "./chunk-MOUXUCXQ.js";
 import "./chunk-BZHLWC6T.js";
-import "./chunk-E5I6YSNO.js";
-import "./chunk-JV7A66DR.js";
-import "./chunk-LXGWLOCM.js";
-import "./chunk-QHHNFG22.js";
+import "./chunk-UQFP2FEF.js";
+import "./chunk-4VZH35PN.js";
+import "./chunk-TENOUWY2.js";
+import "./chunk-GLPV75ES.js";
 import "./chunk-22IFUCVR.js";
 import "./chunk-T42ACHFI.js";
 import "./chunk-YTFBURQD.js";
@@ -46,7 +48,7 @@ import "./chunk-55ZMG67I.js";
 import "./chunk-H6BD2ELD.js";
 import "./chunk-5IFG2VC4.js";
 import "./chunk-64WXLC72.js";
-import "./chunk-FQDMX5IL.js";
+import "./chunk-D5KISTLW.js";
 import {
   Storage,
   createDebugLogger

package/chunks/{send-message-DKGHWSTF.js → send-message-3S2NYS3O.js}

@@ -1,16 +1,18 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  LEADER_NAME,
+  LEADER_NAME
+} from "./chunk-E5A7LHNN.js";
+import {
   getAgentName,
   isTeammate
-} from "./chunk-LD2XBG6Z.js";
+} from "./chunk-GO6LNQXT.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-JV7A66DR.js";
+} from "./chunk-4VZH35PN.js";
 import "./chunk-AVQDCKNF.js";
 import "./chunk-Z2Z3GUXZ.js";
 import {