@qwen-code/qwen-code 0.19.8 → 0.19.9-preview.0

package/chunks/{run-qwen-serve-JK2DL7PI.js → run-qwen-serve-DGW5AFDJ.js}

@@ -3,15 +3,13 @@
 import {
   DaemonMetricsRing,
   computeCpuPercent
-} from "./chunk-II73RK2S.js";
-import {
-  findCliEntryPath
-} from "./chunk-AHNXYU4O.js";
+} from "./chunk-HGT6JR3U.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
   ClientMcpSenderRegistry,
   PathMutexRegistry,
   SERVE_CAPABILITY_REGISTRY,
+  WorkspaceVoiceCoordinator,
   allowOriginCors,
   allowOriginMode,
   bearerAuth,
@@ -22,71 +20,92 @@ import {
   getRateLimiter,
   getServeProtocolVersions,
   hostAllowlist,
+  isBrowserAutomationMcpAvailable,
   listenerMaxConnections,
   parseAllowOriginPatterns,
   parseDaemonStatusDetail,
   positiveFiniteOrNull,
   require_express,
   resolveWebShellDir
-} from "./chunk-YKZIAK7C.js";
+} from "./chunk-MO7O5722.js";
 import {
   isLoopbackBind
-} from "./chunk-RNBYOUGV.js";
-import "./chunk-3HX5LZ6R.js";
-import "./chunk-7RYW5LQV.js";
+} from "./chunk-RXFQM6FQ.js";
 import {
   RUNTIME_STARTUP_CANCELLED_MESSAGE
-} from "./chunk-GHOTR7HL.js";
+} from "./chunk-QUPXZXLV.js";
 import {
   LOAD_REPLAY_META_KEY
-} from "./chunk-AGHU5VRK.js";
+} from "./chunk-PZL23GTM.js";
 import {
   DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
   normalizeCompactedReplayMaxBytes
-} from "./chunk-GLE2YUPU.js";
+} from "./chunk-COH43MRJ.js";
+import "./chunk-WBL3FJEU.js";
 import {
-  canonicalizeWorkspace
-} from "./chunk-ER3BKOLB.js";
+  resolveChannelCwd
+} from "./chunk-4QZADKJS.js";
 import {
-  loadServeFastPathSettings,
-  preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-FBET5XZ2.js";
+  MAX_REGISTERED_WORKSPACES,
+  resolveWorkspaceInputs,
+  workspaceRegistrationId
+} from "./chunk-WMC6HH7Y.js";
+import {
+  canonicalizeWorkspace
+} from "./chunk-W7FJ3N32.js";
+import "./chunk-3MX7D6QN.js";
 import {
   QWEN_SERVER_TOKEN_ENV
-} from "./chunk-S6RLAIUR.js";
+} from "./chunk-GYTKQYDB.js";
 import {
   channelSelectionNames
-} from "./chunk-MX2YXRER.js";
+} from "./chunk-TJTKSVIV.js";
+import "./chunk-5HBA2Z7V.js";
+import {
+  ChannelWebhookEnqueueError
+} from "./chunk-OJAMDVF5.js";
+import "./chunk-T2NCM2ET.js";
+import {
+  sanitizeLogText
+} from "./chunk-AU4R7ACM.js";
+import "./chunk-UDXSXLER.js";
+import {
+  loadServeFastPathSettings,
+  preResolveServeFastPathHomeEnvOverrides
+} from "./chunk-PEJWA3QQ.js";
+import "./chunk-GOXKNSDZ.js";
 import {
   getGlobalQwenDirLite,
   resolveConfigPathLite
-} from "./chunk-O2YT7VB4.js";
-import "./chunk-Z3I3QJK3.js";
+} from "./chunk-IDS7MSUP.js";
+import "./chunk-QRUIS3DN.js";
+import "./chunk-ALGGS7UH.js";
 import {
-  getCliVersion
-} from "./chunk-UXEW557D.js";
-import "./chunk-43W4YSO6.js";
+  isWithinRoot
+} from "./chunk-MR3PXB6E.js";
 import {
   writeStderrLine,
   writeStdoutLine
-} from "./chunk-Y6Z2O3WR.js";
+} from "./chunk-YUZI3WAC.js";
 import {
-  isWithinRoot
-} from "./chunk-QYUE6W3T.js";
-import "./chunk-5P5XGNYH.js";
-import "./chunk-SKAZWEV5.js";
-import "./chunk-UWCTAVOD.js";
-import "./chunk-SYCJMSIJ.js";
+  getCliVersion
+} from "./chunk-2J4ZWME4.js";
+import "./chunk-VJNBRRZG.js";
+import "./chunk-H6XPXXMH.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-E2UVIFI2.js";
+import "./chunk-CR3C7WXL.js";
+import "./chunk-XWRJCPHC.js";
 import {
   finalizeStartupProfile,
   profileCheckpoint
-} from "./chunk-ITOGNELQ.js";
-import "./chunk-FXGLL2HL.js";
-import "./chunk-QN5NZ3UQ.js";
-import "./chunk-BR4QREVK.js";
+} from "./chunk-QSWDGAIC.js";
+import "./chunk-Q7YDKOGY.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name,
   __toESM
@@ -95,99 +114,13 @@ import {
 // packages/cli/src/serve/run-qwen-serve.ts
 init_esbuild_shims();
 var import_express = __toESM(require_express(), 1);
-import { X509Certificate } from "node:crypto";
+import { X509Certificate, createHash as createHash2, timingSafeEqual } from "node:crypto";
 import * as fs from "node:fs";
 import * as https from "node:https";
 import * as path from "node:path";
 import * as os from "node:os";
 import { monitorEventLoopDelay, performance } from "node:perf_hooks";
 
-// packages/cli/src/serve/workspace-inputs.ts
-init_esbuild_shims();
-var DuplicateWorkspaceInputError = class extends Error {
-  static {
-    __name(this, "DuplicateWorkspaceInputError");
-  }
-  constructor(workspace) {
-    super(
-      `Duplicate --workspace value resolves to ${JSON.stringify(workspace)}. Pass distinct --workspace values.`
-    );
-    this.name = "DuplicateWorkspaceInputError";
-  }
-};
-var NestedWorkspaceInputError = class extends Error {
-  static {
-    __name(this, "NestedWorkspaceInputError");
-  }
-  constructor(parent, child) {
-    super(
-      `Nested --workspace values are not supported yet: ${JSON.stringify(child)} is inside ${JSON.stringify(parent)}. Pass non-nested --workspace values.`
-    );
-    this.name = "NestedWorkspaceInputError";
-  }
-};
-var MissingWorkspaceInputError = class extends Error {
-  static {
-    __name(this, "MissingWorkspaceInputError");
-  }
-  constructor() {
-    super("--workspace requires a value.");
-    this.name = "MissingWorkspaceInputError";
-  }
-};
-function normalizeWorkspaceInputs(workspace) {
-  if (Array.isArray(workspace)) {
-    if (workspace.length === 0) {
-      throw new MissingWorkspaceInputError();
-    }
-    return workspace.map((value) => String(value));
-  }
-  if (workspace === void 0) return [process.cwd()];
-  return [String(workspace)];
-}
-__name(normalizeWorkspaceInputs, "normalizeWorkspaceInputs");
-function isNestedWorkspace(parent, child) {
-  return parent !== child && isWithinRoot(child, parent);
-}
-__name(isNestedWorkspace, "isNestedWorkspace");
-function rejectDuplicateOrNestedWorkspaceInputs(workspaces) {
-  if (workspaces.length <= 1) return;
-  let canonicalWorkspaces;
-  try {
-    canonicalWorkspaces = workspaces.map(
-      (workspace) => canonicalizeWorkspace(workspace)
-    );
-  } catch {
-    return;
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const workspace of canonicalWorkspaces) {
-    if (seen.has(workspace)) {
-      throw new DuplicateWorkspaceInputError(workspace);
-    }
-    seen.add(workspace);
-  }
-  for (let i = 0; i < canonicalWorkspaces.length; i++) {
-    for (let j = i + 1; j < canonicalWorkspaces.length; j++) {
-      const first = canonicalWorkspaces[i];
-      const second = canonicalWorkspaces[j];
-      if (isNestedWorkspace(first, second)) {
-        throw new NestedWorkspaceInputError(first, second);
-      }
-      if (isNestedWorkspace(second, first)) {
-        throw new NestedWorkspaceInputError(second, first);
-      }
-    }
-  }
-}
-__name(rejectDuplicateOrNestedWorkspaceInputs, "rejectDuplicateOrNestedWorkspaceInputs");
-function resolveWorkspaceInputs(workspace) {
-  const workspaces = normalizeWorkspaceInputs(workspace);
-  rejectDuplicateOrNestedWorkspaceInputs(workspaces);
-  return workspaces;
-}
-__name(resolveWorkspaceInputs, "resolveWorkspaceInputs");
-
 // packages/cli/src/serve/permission-audit.ts
 init_esbuild_shims();
 var DEFAULT_PERMISSION_AUDIT_RING_SIZE = 512;
@@ -885,6 +818,120 @@ function asRecord(value) {
 }
 __name(asRecord, "asRecord");
 
+// packages/cli/src/serve/channel-workspace-grouping.ts
+init_esbuild_shims();
+function resolveChannelOwnerCwd(rawCwd, workspaceCwd) {
+  return canonicalizeWorkspace(resolveChannelCwd(rawCwd, workspaceCwd));
+}
+__name(resolveChannelOwnerCwd, "resolveChannelOwnerCwd");
+function rawChannelCwd(entry) {
+  if (!entry || typeof entry !== "object") return void 0;
+  const cwd = entry.cwd;
+  return typeof cwd === "string" && cwd.length > 0 ? cwd : void 0;
+}
+__name(rawChannelCwd, "rawChannelCwd");
+function resolveChannelWorkspaceGroups(input) {
+  const { workspaces, selection, loadChannelsConfig } = input;
+  const primary = workspaces.find((workspace) => workspace.primary);
+  if (!primary) {
+    return {
+      ok: false,
+      error: {
+        code: "no_primary_workspace",
+        message: "No primary workspace is registered."
+      }
+    };
+  }
+  if (selection.mode === "all") {
+    if (!primary.trusted) {
+      return {
+        ok: false,
+        error: {
+          code: "untrusted_workspace",
+          message: `Primary workspace "${primary.workspaceCwd}" is not trusted; cannot host channels.`
+        }
+      };
+    }
+    return {
+      ok: true,
+      groups: [
+        { workspaceCwd: primary.workspaceCwd, selection: { mode: "all" } }
+      ]
+    };
+  }
+  const channelsConfigByWorkspace = /* @__PURE__ */ new Map();
+  for (const workspace of workspaces) {
+    channelsConfigByWorkspace.set(
+      workspace.workspaceCwd,
+      loadChannelsConfig(workspace.workspaceCwd)
+    );
+  }
+  const namesByWorkspace = /* @__PURE__ */ new Map();
+  for (const name of selection.names) {
+    const owners = [];
+    for (const workspace of workspaces) {
+      const entry = (channelsConfigByWorkspace.get(workspace.workspaceCwd) ?? {})[name];
+      if (!entry || typeof entry !== "object") continue;
+      let ownerCwd;
+      try {
+        ownerCwd = resolveChannelOwnerCwd(
+          rawChannelCwd(entry),
+          workspace.workspaceCwd
+        );
+      } catch {
+        continue;
+      }
+      if (ownerCwd === workspace.workspaceCwd) {
+        owners.push(workspace);
+      }
+    }
+    if (owners.length === 0) {
+      return {
+        ok: false,
+        error: {
+          code: "channel_workspace_mismatch",
+          channel: name,
+          message: `Channel "${name}" is not configured in any registered workspace, or its "cwd" points outside them.`
+        }
+      };
+    }
+    if (owners.length > 1) {
+      return {
+        ok: false,
+        error: {
+          code: "ambiguous_channel_workspace",
+          channel: name,
+          message: `Channel "${name}" is configured in multiple registered workspaces (${owners.map((owner2) => owner2.workspaceCwd).join(
+            ", "
+          )}). Define it in one workspace's settings or set an explicit "cwd".`
+        }
+      };
+    }
+    const owner = owners[0];
+    if (!owner.trusted) {
+      return {
+        ok: false,
+        error: {
+          code: "untrusted_workspace",
+          channel: name,
+          message: `Channel "${name}" targets untrusted workspace "${owner.workspaceCwd}".`
+        }
+      };
+    }
+    const names = namesByWorkspace.get(owner.workspaceCwd) ?? [];
+    names.push(name);
+    namesByWorkspace.set(owner.workspaceCwd, names);
+  }
+  return {
+    ok: true,
+    groups: [...namesByWorkspace.entries()].map(([workspaceCwd, names]) => ({
+      workspaceCwd,
+      selection: { mode: "names", names }
+    }))
+  };
+}
+__name(resolveChannelWorkspaceGroups, "resolveChannelWorkspaceGroups");
+
 // packages/cli/src/serve/run-qwen-serve.ts
 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";
@@ -1074,6 +1121,10 @@ function extractContextFilename(value) {
   return void 0;
 }
 __name(extractContextFilename, "extractContextFilename");
+function sessionArtifactsPersistenceAvailableFromSettings(settings) {
+  return settings?.general?.chatRecording !== false;
+}
+__name(sessionArtifactsPersistenceAvailableFromSettings, "sessionArtifactsPersistenceAvailableFromSettings");
 var settingsWriteLocks = /* @__PURE__ */ new Map();
 function withSettingsLock(workspace, fn) {
   const prev = settingsWriteLocks.get(workspace) ?? Promise.resolve();
@@ -1085,12 +1136,29 @@ __name(withSettingsLock, "withSettingsLock");
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-NZQUOEFJ.js"),
-    import("./pidfile-NZYSCFRK.js")
-  ]).then(([supervisor, pidfile]) => ({
-    createChannelWorkerSupervisor: supervisor.createChannelWorkerSupervisor,
-    channelServicePidfile: pidfile
-  })).catch((err) => {
+    import("./channel-worker-supervisor-QCKIOYZD.js"),
+    import("./pidfile-AUMGYIOK.js"),
+    import("./runtime-NYUSLBEZ.js"),
+    import("./cli-entry-path-4VJ3Y6T2.js"),
+    import("./channel-worker-group-K7QKH6IG.js"),
+    import("./channel-worker-manager-YSFB4HUU.js")
+  ]).then(
+    ([
+      supervisor,
+      pidfile,
+      channelRuntime,
+      cliEntryPath,
+      workerGroup,
+      workerManager
+    ]) => ({
+      createChannelWorkerSupervisor: supervisor.createChannelWorkerSupervisor,
+      channelServicePidfile: pidfile,
+      loadChannelsConfig: channelRuntime.loadChannelsConfig,
+      createChannelWorkerGroup: workerGroup.createChannelWorkerGroup,
+      createChannelWorkerManager: workerManager.createChannelWorkerManager,
+      findCliEntryPath: cliEntryPath.findCliEntryPath
+    })
+  ).catch((err) => {
     channelWorkerRuntimePromise = void 0;
     throw err;
   });
@@ -1108,9 +1176,18 @@ function createDisabledChannelWorkerSupervisor() {
     },
     async stop() {
     },
+    async restart() {
+      return { ...snapshot, channels: [] };
+    },
     killAllSync() {
     },
-    snapshot: /* @__PURE__ */ __name(() => ({ ...snapshot, channels: [] }), "snapshot")
+    snapshot: /* @__PURE__ */ __name(() => ({ ...snapshot, channels: [] }), "snapshot"),
+    async enqueueWebhookTask() {
+      throw new ChannelWebhookEnqueueError(
+        "channel_worker_unavailable",
+        "Channel worker is not running."
+      );
+    }
   };
 }
 __name(createDisabledChannelWorkerSupervisor, "createDisabledChannelWorkerSupervisor");
@@ -1123,11 +1200,23 @@ function writeServeChannelReservation(channelServicePidfile, channels) {
 __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.`
+  return Object.assign(
+    new Error(
+      `Channel service is already running under ${owner} (PID ${info.pid}). Stop it before enabling daemon-managed channels.`
+    ),
+    { code: "channel_service_conflict", owner: info.owner, pid: info.pid }
   );
 }
 __name(channelServicePidfileConflictError, "channelServicePidfileConflictError");
+function channelServiceStartingConflictError() {
+  return Object.assign(
+    new Error(
+      "Channel service is already starting. Retry after the current startup finishes."
+    ),
+    { code: "channel_service_conflict" }
+  );
+}
+__name(channelServiceStartingConflictError, "channelServiceStartingConflictError");
 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);
@@ -1157,7 +1246,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-BBQSM46M.js");
+  coreRuntimePromise ??= import("./src-YDBNMIIM.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -1187,10 +1276,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-3MI4XXP6.js"),
-    import("./environment-ATFTYMLZ.js"),
-    import("./loadedSettingsAdapter-LL5PSFKX.js"),
-    import("./trustedFolders-LAZZPZ3D.js")
+    import("./settings-X24RYEED.js"),
+    import("./environment-OYA3ZVEL.js"),
+    import("./loadedSettingsAdapter-V4ZTRKUO.js"),
+    import("./trustedFolders-JF265CRI.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -1200,6 +1289,21 @@ function loadSettingsRuntimeModules() {
   return settingsRuntimePromise;
 }
 __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
+var channelWebhookConfigRuntimePromise;
+function loadChannelWebhookConfigRuntime() {
+  channelWebhookConfigRuntimePromise ??= Promise.all([
+    import("./runtime-NYUSLBEZ.js"),
+    import("./config-utils-XSHOMMK4.js")
+  ]).then(([channelRuntime, configUtils]) => ({
+    loadChannelsConfig: channelRuntime.loadChannelsConfig,
+    parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
+  })).catch((err) => {
+    channelWebhookConfigRuntimePromise = void 0;
+    throw err;
+  });
+  return channelWebhookConfigRuntimePromise;
+}
+__name(loadChannelWebhookConfigRuntime, "loadChannelWebhookConfigRuntime");
 async function loadServeRuntimeModules() {
   const [
     serverModule,
@@ -1213,16 +1317,16 @@ async function loadServeRuntimeModules() {
     totalSessionAdmissionModule,
     workspaceRegistryModule
   ] = await Promise.all([
-    import("./server-SGNPKX2O.js"),
-    import("./bridge-NA3ZQQKJ.js"),
-    import("./spawnChannel-UNV6W4DU.js"),
-    import("./workspace-service-CZRQZ4Q4.js"),
-    import("./types-QX5C3CHJ.js"),
-    import("./daemon-status-provider-GJRXY5EN.js"),
-    import("./workspace-providers-status-3W7E7DFW.js"),
-    import("./workspace-skills-status-K7WFREPD.js"),
-    import("./total-session-admission-ULXJWXFV.js"),
-    import("./workspace-registry-SXJZNN3O.js")
+    import("./server-VUHSYSUV.js"),
+    import("./bridge-HKEWPNB5.js"),
+    import("./spawnChannel-RFAAO44J.js"),
+    import("./workspace-service-PUYIZ3J4.js"),
+    import("./types-ML3TRJQ5.js"),
+    import("./daemon-status-provider-KFL3LRTP.js"),
+    import("./workspace-providers-status-LMBLBNR7.js"),
+    import("./workspace-skills-status-CJ7J2KPP.js"),
+    import("./total-session-admission-2WIH72I3.js"),
+    import("./workspace-registry-BVMPYRLN.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -1233,11 +1337,13 @@ async function loadServeRuntimeModules() {
     createSpawnChannelFactory: spawnChannelModule.createSpawnChannelFactory,
     createDaemonWorkspaceService: workspaceModule.createDaemonWorkspaceService,
     WorkspaceSettingsPartialPersistError: workspaceTypesModule.WorkspaceSettingsPartialPersistError,
+    WorkspaceSkillNotToggleableError: workspaceTypesModule.WorkspaceSkillNotToggleableError,
     createDaemonStatusProvider: daemonStatusProviderModule.createDaemonStatusProvider,
     createWorkspaceProvidersStatusProvider: workspaceProvidersStatusModule.createWorkspaceProvidersStatusProvider,
     createWorkspaceSkillsStatusProvider: workspaceSkillsStatusModule.createWorkspaceSkillsStatusProvider,
     createTotalSessionAdmissionController: totalSessionAdmissionModule.createTotalSessionAdmissionController,
-    createWorkspaceRegistry: workspaceRegistryModule.createWorkspaceRegistry
+    createWorkspaceRegistry: workspaceRegistryModule.createWorkspaceRegistry,
+    createWorkspaceSessionOwnerIndex: workspaceRegistryModule.createWorkspaceSessionOwnerIndex
   };
 }
 __name(loadServeRuntimeModules, "loadServeRuntimeModules");
@@ -1261,7 +1367,7 @@ function sessionIdleTimeoutMs(value) {
   return value !== void 0 ? channelIdleTimeoutMs(value) : DEFAULT_SESSION_IDLE_TIMEOUT_MS;
 }
 __name(sessionIdleTimeoutMs, "sessionIdleTimeoutMs");
-function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled) {
+function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled, sessionArtifactsPersistenceAvailable, env) {
   return getAdvertisedServeFeatures(void 0, {
     requireAuth: opts.requireAuth === true,
     mcpPoolActive: opts.mcpPoolActive !== false,
@@ -1270,12 +1376,18 @@ function currentServeFeaturesForRunQwenServe(opts, sessionShellCommandEnabled) {
     ...opts.writerIdleTimeoutMs !== void 0 ? { writerIdleTimeoutMs: opts.writerIdleTimeoutMs } : {},
     persistSettingAvailable: true,
     sessionShellCommandEnabled,
+    sessionArtifactsPersistenceAvailable,
     rateLimit: opts.rateLimit === true,
     reloadAvailable: true,
+    channelReloadAvailable: opts.channelSelection !== void 0,
+    channelControlAvailable: true,
+    persistentWorkspaceRegistrationAvailable: true,
+    workspaceRuntimeRemovalAvailable: true,
     // Advertise the same WS feature flags as the runtime path (serve-features.ts)
     // so the bootstrap `/capabilities` window doesn't briefly under-report them.
     clientMcpOverWsEnabled: opts.clientMcpOverWs === true,
-    cdpTunnelOverWsEnabled: opts.cdpTunnelOverWs === true
+    cdpTunnelOverWsEnabled: opts.cdpTunnelOverWs === true,
+    browserAutomationMcpAvailable: isBrowserAutomationMcpAvailable(opts, env)
   });
 }
 __name(currentServeFeaturesForRunQwenServe, "currentServeFeaturesForRunQwenServe");
@@ -1287,7 +1399,9 @@ function createBootstrapCapabilities(input) {
     mode: input.opts.mode,
     features: currentServeFeaturesForRunQwenServe(
       input.opts,
-      input.sessionShellCommandEnabled
+      input.sessionShellCommandEnabled,
+      input.sessionArtifactsPersistenceAvailable,
+      input.env
     ),
     modelServices: [],
     workspaceCwd: input.boundWorkspace,
@@ -1432,10 +1546,12 @@ function createBootstrapServeApp(input) {
     daemonLog,
     qwenCodeVersion,
     sessionShellCommandEnabled,
+    sessionArtifactsPersistenceAvailable,
     permissionPolicy,
     multiWorkspaceCapabilitiesRequireRuntime,
     getRuntimeError,
     getChannelWorkerSnapshot,
+    getChannelWorkerSnapshots,
     onHealthServed
   } = input;
   const app = (0, import_express.default)();
@@ -1487,7 +1603,9 @@ function createBootstrapServeApp(input) {
         boundWorkspace,
         qwenCodeVersion,
         sessionShellCommandEnabled,
-        permissionPolicy
+        sessionArtifactsPersistenceAvailable,
+        permissionPolicy,
+        env: process.env
       })
     );
   });
@@ -1502,6 +1620,7 @@ function createBootstrapServeApp(input) {
     }
     const runtimeError = getRuntimeError();
     const channelWorker = getChannelWorkerSnapshot();
+    const channelWorkers = getChannelWorkerSnapshots();
     const runtimeFailed = runtimeError !== void 0;
     const issue = runtimeError ? {
       code: "daemon_runtime_failed",
@@ -1558,7 +1677,9 @@ function createBootstrapServeApp(input) {
         protocolVersions: getServeProtocolVersions(),
         features: currentServeFeaturesForRunQwenServe(
           opts,
-          sessionShellCommandEnabled
+          sessionShellCommandEnabled,
+          sessionArtifactsPersistenceAvailable,
+          process.env
         )
       },
       runtime: {
@@ -1571,6 +1692,7 @@ function createBootstrapServeApp(input) {
         },
         channel: { live: false },
         channelWorker,
+        ...channelWorkers.length > 0 ? { channelWorkers } : {},
         transport: {
           restSseActive: 0,
           acp: {
@@ -1630,13 +1752,12 @@ function createDelegatingServeApp(bootstrapApp, getRuntimeApp, options = {}) {
     const dispatch = /* @__PURE__ */ __name(async () => {
       let target = getRuntimeApp();
       if (!target && options.waitForDeferredRuntimeRoutes === true && !isBootstrapServeRoute(req) && !isCorsPreflightRequest(req) && options.startRuntime && options.runtimeReady) {
-        if (options.authenticateDeferredRuntimeRequest && !runSynchronousRequestGate(
-          options.authenticateDeferredRuntimeRequest,
-          req,
-          res,
-          next
-        )) {
-          return;
+        const webhookRequest = isChannelWebhookRequest(req);
+        const authGate = webhookRequest ? options.authenticateDeferredChannelWebhookRequest ?? options.authenticateDeferredRuntimeRequest : options.authenticateDeferredRuntimeRequest;
+        if (authGate) {
+          if (!runSynchronousRequestGate(authGate, req, res, next)) {
+            return;
+          }
         }
         options.startRuntime();
         try {
@@ -1658,6 +1779,83 @@ function isBootstrapServeRoute(req) {
   return BOOTSTRAP_SERVE_PATHS.has(path2);
 }
 __name(isBootstrapServeRoute, "isBootstrapServeRoute");
+function isChannelWebhookRequest(req) {
+  return req.method === "POST" && /^\/channels\/[^/]+\/webhooks\/[^/]+\/?$/u.test(req.path);
+}
+__name(isChannelWebhookRequest, "isChannelWebhookRequest");
+function createDeferredChannelWebhookAuth(resolveSource, runtime, daemonLog) {
+  return (req, res, next) => {
+    const match = /^\/channels\/([^/]+)\/webhooks\/([^/]+)\/?$/u.exec(req.path);
+    const channelName = decodeDeferredWebhookPathSegment(match?.[1]);
+    const source = decodeDeferredWebhookPathSegment(match?.[2]);
+    if (!channelName || !source) {
+      daemonLog.warn("deferred webhook auth failed", {
+        channelName: channelName ?? "unknown",
+        source: source ?? "unknown",
+        reason: "invalid webhook path"
+      });
+      res.status(401).json({ error: "Invalid webhook secret" });
+      return;
+    }
+    const configSource = resolveSource(channelName);
+    const secret = readDeferredWebhookSecret(
+      runtime,
+      configSource.workspaceCwd,
+      channelName,
+      source,
+      configSource.env
+    );
+    if (!matchesWebhookSecret(req.get("x-qwen-webhook-secret"), secret)) {
+      daemonLog.warn("deferred webhook auth failed", {
+        channelName,
+        source,
+        reason: secret ? "secret mismatch" : "source not configured"
+      });
+      res.status(401).json({ error: "Invalid webhook secret" });
+      return;
+    }
+    next();
+  };
+}
+__name(createDeferredChannelWebhookAuth, "createDeferredChannelWebhookAuth");
+function decodeDeferredWebhookPathSegment(segment) {
+  if (segment === void 0) return void 0;
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return void 0;
+  }
+}
+__name(decodeDeferredWebhookPathSegment, "decodeDeferredWebhookPathSegment");
+function readDeferredWebhookSecret(runtime, workspace, channelName, source, env) {
+  try {
+    const rawConfig = runtime.loadChannelsConfig(workspace)[channelName];
+    if (typeof rawConfig !== "object" || rawConfig === null) {
+      return void 0;
+    }
+    return runtime.parseChannelWebhookConfig(
+      channelName,
+      rawConfig,
+      env
+    )?.sources[source]?.secret;
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    writeStderrLine(
+      `[webhook-secret] failed to read deferred webhook secret for ${sanitizeLogText(channelName, 128)}/${sanitizeLogText(source, 128)}: ${sanitizeLogText(reason, 512)}`
+    );
+    return void 0;
+  }
+}
+__name(readDeferredWebhookSecret, "readDeferredWebhookSecret");
+function matchesWebhookSecret(candidate, expected) {
+  if (typeof candidate !== "string" || typeof expected !== "string" || expected.length === 0) {
+    return false;
+  }
+  const expectedDigest = createHash2("sha256").update(expected).digest();
+  const candidateDigest = createHash2("sha256").update(candidate).digest();
+  return timingSafeEqual(expectedDigest, candidateDigest);
+}
+__name(matchesWebhookSecret, "matchesWebhookSecret");
 function isCorsPreflightRequest(req) {
   return req.method === "OPTIONS" && Boolean(req.headers.origin) && Boolean(
     req.headers["access-control-request-method"] || req.headers["access-control-request-headers"]
@@ -1723,30 +1921,42 @@ async function runQwenServe(optsIn, deps = {}) {
     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 channelRuntime = opts.channelSelection ? await loadChannelWorkerRuntime() : void 0;
+  let channelServicePidfile = deps.channelServicePidfile ?? channelRuntime?.channelServicePidfile;
+  const ensureChannelRuntime = /* @__PURE__ */ __name(async () => {
+    channelRuntime ??= await loadChannelWorkerRuntime();
+    channelServicePidfile ??= channelRuntime.channelServicePidfile;
+    return channelRuntime;
+  }, "ensureChannelRuntime");
   let channelPidfileReserved = false;
   const removeCurrentServePidfile = /* @__PURE__ */ __name(() => {
-    if (!opts.channelSelection || !channelServicePidfile) return;
+    if (!channelServicePidfile) return;
     if (!channelPidfileReserved) return;
     if (channelServicePidfile.removeServeServiceInfo) {
       if (channelServicePidfile.removeServeServiceInfo(process.pid)) {
         channelPidfileReserved = false;
+      } else {
+        const info2 = channelServicePidfile.readServiceInfo();
+        if (!info2 || info2.owner !== "serve" || info2.pid !== process.pid || info2.servePid !== process.pid) {
+          channelPidfileReserved = false;
+        }
       }
       return;
     }
     const info = channelServicePidfile.readServiceInfo();
     if (info?.owner === "serve" && info.pid === process.pid && info.servePid === process.pid) {
       channelServicePidfile.removeServiceInfo();
+      const remaining = channelServicePidfile.readServiceInfo();
+      channelPidfileReserved = remaining?.owner === "serve" && remaining.pid === process.pid && remaining.servePid === process.pid;
+    } else {
       channelPidfileReserved = false;
     }
   }, "removeCurrentServePidfile");
-  const reserveChannelServicePidfile = /* @__PURE__ */ __name(() => {
-    if (!opts.channelSelection) return;
+  const reserveChannelServicePidfile = /* @__PURE__ */ __name((selection) => {
     if (!channelServicePidfile) {
       throw new Error("Channel service pidfile runtime is not available.");
     }
-    const channelPidfileNames = channelSelectionNames(opts.channelSelection);
+    const channelPidfileNames = channelSelectionNames(selection);
     const existingChannelService = channelServicePidfile.readServiceInfo();
     if (existingChannelService) {
       throw channelServicePidfileConflictError(existingChannelService);
@@ -1771,9 +1981,7 @@ async function runQwenServe(optsIn, deps = {}) {
             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 channelServiceStartingConflictError();
             }
             throw retryErr;
           }
@@ -1892,7 +2100,9 @@ async function runQwenServe(optsIn, deps = {}) {
   }, "validateAndCanonicalizeWorkspace");
   const workspaceInputs = rawWorkspaces.map((workspace) => ({
     raw: workspace,
-    cwd: validateAndCanonicalizeWorkspace(workspace)
+    cwd: validateAndCanonicalizeWorkspace(workspace),
+    removable: false,
+    registrationIds: []
   }));
   const boundWorkspace = workspaceInputs[0].cwd;
   const seenCanonicalWorkspaces = /* @__PURE__ */ new Set();
@@ -1924,6 +2134,71 @@ async function runQwenServe(optsIn, deps = {}) {
       }
     }
   }
+  if (workspaceInputs.length > MAX_REGISTERED_WORKSPACES) {
+    throw new Error(
+      `At most ${MAX_REGISTERED_WORKSPACES} --workspace values may be registered.`
+    );
+  }
+  let workspaceRegistrationStore = deps.workspaceRegistrationStore;
+  if (workspaceRegistrationStore === void 0 && process.env["QWEN_SERVE_NO_PERSISTENT_REGISTRATION"] !== "1") {
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-VV2S4MSV.js");
+    workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
+  }
+  if (workspaceRegistrationStore) {
+    try {
+      const stored = await workspaceRegistrationStore.read();
+      for (const storedWorkspace of stored.workspaces) {
+        const registrationId = workspaceRegistrationId(storedWorkspace);
+        let cwd;
+        try {
+          cwd = validateAndCanonicalizeWorkspace(storedWorkspace);
+        } catch (err) {
+          writeStderrLine(
+            `qwen serve: skipping persisted workspace registration ${JSON.stringify(
+              storedWorkspace
+            )}: ${err instanceof Error ? err.message : String(err)}`
+          );
+          continue;
+        }
+        const existingInput = workspaceInputs.find(
+          (workspace) => workspace.cwd === cwd
+        );
+        if (existingInput) {
+          existingInput.registrationIds.push(registrationId);
+          continue;
+        }
+        const nested = workspaceInputs.some(
+          (workspace) => isWithinRoot(cwd, workspace.cwd) || isWithinRoot(workspace.cwd, cwd)
+        );
+        if (nested) {
+          writeStderrLine(
+            `qwen serve: skipping persisted workspace registration ${JSON.stringify(
+              storedWorkspace
+            )}: path nests with an explicit or earlier restored workspace`
+          );
+          continue;
+        }
+        if (workspaceInputs.length >= MAX_REGISTERED_WORKSPACES) {
+          writeStderrLine(
+            `qwen serve: skipping persisted workspace registration ${JSON.stringify(
+              storedWorkspace
+            )}: workspace limit reached`
+          );
+          continue;
+        }
+        workspaceInputs.push({
+          raw: storedWorkspace,
+          cwd,
+          removable: true,
+          registrationIds: [registrationId]
+        });
+      }
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: failed to read persisted workspace registrations: ${err instanceof Error ? err.message : String(err)}; continuing with explicit workspaces only`
+      );
+    }
+  }
   if (workspaceInputs.length > 1 && deps.bridge) {
     throw new Error(
       "Injected bridge dependencies are only supported with a single workspace; multiple --workspace values require runQwenServe to construct one bridge per workspace."
@@ -1933,8 +2208,10 @@ async function runQwenServe(optsIn, deps = {}) {
   let permissionPolicy;
   let permissionConsensusQuorum;
   let bootSettings;
+  let sessionArtifactsPersistenceAvailable = true;
   try {
     bootSettings = deps.bootSettings ?? loadServeFastPathSettings(boundWorkspace);
+    sessionArtifactsPersistenceAvailable = sessionArtifactsPersistenceAvailableFromSettings(bootSettings);
     contextFilenameForInit = extractContextFilename(
       bootSettings.context?.fileName
     );
@@ -2107,20 +2384,139 @@ async function runQwenServe(optsIn, deps = {}) {
   void runtimeReady.catch(() => {
   });
   const disposeDaemonEventLoopMonitor = /* @__PURE__ */ __name(() => {
-    daemonEventLoopMonitor?.dispose();
+    const eventLoopMonitor = daemonEventLoopMonitor;
     daemonEventLoopMonitor = void 0;
-    daemonMetricsSampler?.dispose();
+    const metricsSampler = daemonMetricsSampler;
     daemonMetricsSampler = void 0;
+    try {
+      eventLoopMonitor?.dispose();
+    } catch (err) {
+      daemonLog.warn(
+        `event loop monitor dispose error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    try {
+      metricsSampler?.dispose();
+    } catch (err) {
+      daemonLog.warn(
+        `metrics sampler dispose error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
   }, "disposeDaemonEventLoopMonitor");
-  let channelWorker = createDisabledChannelWorkerSupervisor();
-  const getChannelWorkerSnapshot = /* @__PURE__ */ __name(() => channelWorker.snapshot(), "getChannelWorkerSnapshot");
-  const writeChannelWorkerPidfile = /* @__PURE__ */ __name((snapshot = channelWorker.snapshot(), options = {}) => {
-    if (!opts.channelSelection || !channelServicePidfile) return;
+  let channelWorkerManager;
+  let channelWorkerManagerStarting;
+  let channelControlDraining = false;
+  let channelWorkspaceGroups;
+  const channelWebhookEnvByWorkspace = /* @__PURE__ */ new Map();
+  let channelWebhookConfigVersion = 0;
+  let refreshChannelWebhookConfigs;
+  let ensureChannelWorkerManager;
+  const getChannelWebhookConfigSources = /* @__PURE__ */ __name(() => {
+    const app2 = runtimeApp ?? runtimeAppForCleanup;
+    const registry = app2?.locals?.["workspaceRegistry"];
+    return (channelWorkspaceGroups ?? []).map((group) => {
+      const env = registry?.getByWorkspaceCwd(group.workspaceCwd)?.env.effectiveEnv ?? channelWebhookEnvByWorkspace.get(group.workspaceCwd);
+      return {
+        workspaceCwd: group.workspaceCwd,
+        ...group.selection.mode === "names" ? { channelNames: group.selection.names } : {},
+        ...env ? { env } : {}
+      };
+    });
+  }, "getChannelWebhookConfigSources");
+  const resolveChannelWebhookConfigSource = /* @__PURE__ */ __name((channelName) => {
+    const source = getChannelWebhookConfigSources().find(
+      (source2) => !source2.channelNames || source2.channelNames.includes(channelName)
+    );
+    if (source) return source;
+    const env = channelWebhookEnvByWorkspace.get(boundWorkspace);
+    return {
+      workspaceCwd: boundWorkspace,
+      ...env ? { env } : {}
+    };
+  }, "resolveChannelWebhookConfigSource");
+  let closeServerAfterChannelWorkerStartupFailure = false;
+  let runtimeFailureListenerClose;
+  const getChannelWorkerSnapshot = /* @__PURE__ */ __name(() => channelWorkerManager?.primarySnapshot() ?? {
+    enabled: false,
+    state: "disabled",
+    channels: []
+  }, "getChannelWorkerSnapshot");
+  const getChannelWorkerSnapshots = /* @__PURE__ */ __name(() => channelWorkerManager?.snapshots() ?? [], "getChannelWorkerSnapshots");
+  const getChannelWorkerControl = /* @__PURE__ */ __name(() => channelWorkerManager?.state() ?? {
+    enabled: false,
+    selection: null,
+    transition: "idle",
+    workers: []
+  }, "getChannelWorkerControl");
+  const daemonDrainingError = /* @__PURE__ */ __name(() => Object.assign(new Error("Daemon is shutting down."), {
+    code: "daemon_draining"
+  }), "daemonDrainingError");
+  const setChannelWorkerSelection = /* @__PURE__ */ __name(async (selection) => {
+    if (channelControlDraining) throw daemonDrainingError();
+    const manager = await ensureChannelWorkerManager?.();
+    if (!manager) throw new Error("Channel worker manager is unavailable.");
+    if (channelControlDraining) {
+      await manager.shutdown().catch(() => void 0);
+      throw daemonDrainingError();
+    }
+    return manager.setSelection(selection);
+  }, "setChannelWorkerSelection");
+  const stopChannelWorker = /* @__PURE__ */ __name(async () => {
+    if (channelControlDraining) throw daemonDrainingError();
+    const manager = channelWorkerManager ?? await channelWorkerManagerStarting;
+    if (channelControlDraining) {
+      await manager?.shutdown().catch(() => void 0);
+      throw daemonDrainingError();
+    }
+    if (!manager) {
+      return { changed: false, state: getChannelWorkerControl() };
+    }
+    return manager.stopSelection();
+  }, "stopChannelWorker");
+  const reloadChannelWorker = /* @__PURE__ */ __name(async () => {
+    if (channelControlDraining) throw daemonDrainingError();
+    const manager = channelWorkerManager ?? await channelWorkerManagerStarting;
+    if (channelControlDraining) {
+      await manager?.shutdown().catch(() => void 0);
+      throw daemonDrainingError();
+    }
+    if (!manager) {
+      return { enabled: false, state: "disabled", channels: [] };
+    }
+    try {
+      return await manager.reload();
+    } finally {
+      writeChannelWorkerPidfile();
+    }
+  }, "reloadChannelWorker");
+  const isLiveWorker = /* @__PURE__ */ __name((snapshot) => snapshot.state === "running" || snapshot.state === "starting", "isLiveWorker");
+  let channelWorkerPidfileUsesWorkers = workspaceInputs.length > 1;
+  const writeChannelWorkerPidfile = /* @__PURE__ */ __name(() => {
+    if (runtimeStartupError !== void 0) return;
+    if (!channelPidfileReserved || !channelServicePidfile) return;
+    const snapshots = getChannelWorkerSnapshots();
+    const workers = snapshots.map((snapshot) => ({
+      workspaceId: snapshot.workspaceId,
+      workspaceCwd: snapshot.workspaceCwd,
+      channels: snapshot.channels,
+      // Drop a stale pid (worker exited/failed/stopped) so readers never signal
+      // a dead process — mirrors the pre-4b clear-on-exit behavior.
+      ...isLiveWorker(snapshot) && snapshot.pid !== void 0 ? { workerPid: snapshot.pid } : {}
+    }));
+    const channels = [
+      ...new Set(snapshots.flatMap((snapshot) => snapshot.channels))
+    ];
+    const primary = snapshots.find((snapshot) => snapshot.primary);
+    if (workers.length > 1 || snapshots.some((snapshot) => !snapshot.primary)) {
+      channelWorkerPidfileUsesWorkers = true;
+    }
+    const includeWorkers = channelWorkerPidfileUsesWorkers && workers.length > 0;
     try {
       channelServicePidfile.writeServeServiceInfo({
-        channels: snapshot.channels,
+        channels,
         servePid: process.pid,
-        ...!options.clearWorkerPid && snapshot.pid !== void 0 ? { workerPid: snapshot.pid } : {}
+        ...primary && isLiveWorker(primary) && primary.pid !== void 0 ? { workerPid: primary.pid } : {},
+        ...includeWorkers ? { workers } : {}
       });
     } catch (err) {
       daemonLog.warn(
@@ -2133,11 +2529,83 @@ async function runQwenServe(optsIn, deps = {}) {
     () => runtimeStartupError
   );
   const shutdownBridges = /* @__PURE__ */ new WeakSet();
+  const disposedRuntimeApps = /* @__PURE__ */ new WeakSet();
+  const stoppedRuntimeAppProducers = /* @__PURE__ */ new WeakSet();
+  const stoppedExtensionReconcilers = /* @__PURE__ */ new WeakSet();
+  const stopExtensionReconciler = /* @__PURE__ */ __name((app2) => {
+    if (!app2 || stoppedExtensionReconcilers.has(app2)) return;
+    stoppedExtensionReconcilers.add(app2);
+    const stopExtensionGenerationReconciler = app2.locals?.["stopExtensionGenerationReconciler"];
+    try {
+      stopExtensionGenerationReconciler?.();
+    } catch (err) {
+      daemonLog.warn(
+        `extension generation reconciler dispose error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }, "stopExtensionReconciler");
+  const stopRuntimeAppProducers = /* @__PURE__ */ __name((app2) => {
+    if (!app2 || stoppedRuntimeAppProducers.has(app2)) return;
+    stoppedRuntimeAppProducers.add(app2);
+    const locals = app2.locals;
+    const stopSafely = /* @__PURE__ */ __name((name, stop) => {
+      try {
+        stop?.();
+      } catch (err) {
+        daemonLog.warn(
+          `${name} dispose error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }, "stopSafely");
+    stopSafely("scheduled-task keepalive", locals.stopScheduledTaskKeepalive);
+    stopSafely("workspace git state", locals.stopWorkspaceGitState);
+    for (const stop of locals.subSessionStoppers ?? []) {
+      stopSafely("sub-session launcher", stop);
+    }
+    stopExtensionReconciler(app2);
+  }, "stopRuntimeAppProducers");
+  const disposeRuntimeAppResources = /* @__PURE__ */ __name((app2) => {
+    if (!app2 || disposedRuntimeApps.has(app2)) return;
+    disposedRuntimeApps.add(app2);
+    stopRuntimeAppProducers(app2);
+    const deviceFlowRegistry = getDeviceFlowRegistry(app2);
+    if (deviceFlowRegistry) {
+      try {
+        deviceFlowRegistry.dispose();
+      } catch (err) {
+        daemonLog.warn(
+          `device-flow registry dispose error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    const acpHandle = app2.locals?.["acpHandle"];
+    if (acpHandle?.dispose) {
+      try {
+        acpHandle.dispose();
+      } catch (err) {
+        daemonLog.warn(
+          `ACP handle dispose error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    const rateLimiter = getRateLimiter(app2);
+    if (rateLimiter) {
+      try {
+        rateLimiter.setDraining(true);
+        rateLimiter.dispose();
+      } catch (err) {
+        daemonLog.warn(
+          `rate limiter dispose error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    disposeDaemonEventLoopMonitor();
+  }, "disposeRuntimeAppResources");
   const getRuntimeBridgesForCleanup = /* @__PURE__ */ __name(() => {
     const appForCleanup = runtimeApp ?? runtimeAppForCleanup;
     const registry = appForCleanup?.locals?.["workspaceRegistry"];
     const bridges = [
-      ...registry ? registry.list().map((runtime) => runtime.bridge) : [],
+      ...registry ? registry.listManaged().map((runtime) => runtime.bridge) : [],
       ...bridgeRef ? [bridgeRef] : [],
       ...internalRuntimeBridgesForCleanup
     ];
@@ -2319,12 +2787,15 @@ async function runQwenServe(optsIn, deps = {}) {
         // `agent_message_chunk._meta` (`usage` + `durationMs`) at the bridge's
         // single session/update fan-in. Increments (not cumulative), so the ring
         // sums tokens per window (token-burn chart) and pools the round-trip times
-        // for the LLM-latency percentiles.
-        tokenUsage(inputTokens, outputTokens, durationMs) {
+        // for the LLM-latency percentiles. `apiErrors` / `apiRetries` ride the
+        // same frame (per-round increments, 0 when none) and window into the
+        // model-API-health chart.
+        tokenUsage(inputTokens, outputTokens, durationMs, apiErrors, apiRetries) {
           metricsRing.recordTokens(inputTokens, outputTokens);
           if (typeof durationMs === "number") {
             metricsRing.recordLlmDuration(durationMs);
           }
+          metricsRing.recordApiActivity(apiErrors ?? 0, apiRetries ?? 0);
         }
       };
       return telemetry;
@@ -2414,6 +2885,7 @@ async function runQwenServe(optsIn, deps = {}) {
         getBridges: /* @__PURE__ */ __name(() => runtimeBridges.length > 0 ? runtimeBridges : bridgeRef ? [bridgeRef] : [], "getBridges")
       }
     );
+    const sessionOwnerIndex = runtime.createWorkspaceSessionOwnerIndex();
     const persistDisabledToolsFn = /* @__PURE__ */ __name((workspace, toolName, enabled) => withSettingsLock(workspace, async () => {
       const fresh = settingsRuntime.settings.loadSettings(workspace);
       const wsScope = fresh.forScope(WORKSPACE_SETTING_SCOPE).settings;
@@ -2428,6 +2900,63 @@ async function runQwenServe(optsIn, deps = {}) {
         [...next].sort()
       );
     }), "persistDisabledToolsFn");
+    const persistDisabledSkillsFn = /* @__PURE__ */ __name((workspace, skillName, enabled) => withSettingsLock(workspace, async () => {
+      const fresh = settingsRuntime.settings.loadSettings(workspace);
+      const normalizedName = skillName.trim().toLowerCase();
+      const disabledNames = /* @__PURE__ */ __name((value) => Array.isArray(value) ? value.filter(
+        (entry) => typeof entry === "string"
+      ) : [], "disabledNames");
+      const lockedScopes = [
+        ["system", fresh.system.settings.skills?.disabled],
+        ["user", fresh.user.settings.skills?.disabled],
+        ["systemDefaults", fresh.systemDefaults.settings.skills?.disabled]
+      ];
+      for (const [scope, names] of lockedScopes) {
+        if (disabledNames(names).some(
+          (name) => name.trim().toLowerCase() === normalizedName
+        )) {
+          throw new runtime.WorkspaceSkillNotToggleableError(
+            skillName,
+            "locked",
+            scope
+          );
+        }
+      }
+      const workspaceDisabled = disabledNames(
+        fresh.workspace.settings.skills?.disabled
+      );
+      const next = [];
+      let found = false;
+      let changed = false;
+      for (const name of workspaceDisabled) {
+        if (name.trim().toLowerCase() !== normalizedName) {
+          next.push(name);
+          continue;
+        }
+        if (enabled) {
+          changed = true;
+          continue;
+        }
+        if (!found) {
+          next.push(skillName);
+          found = true;
+          if (name !== skillName) changed = true;
+        } else {
+          changed = true;
+        }
+      }
+      if (!enabled && !found) {
+        next.push(skillName);
+        changed = true;
+      }
+      if (!changed) return { changed: false, disabled: workspaceDisabled };
+      fresh.setValue(
+        WORKSPACE_SETTING_SCOPE,
+        "skills.disabled",
+        next.length > 0 ? next : void 0
+      );
+      return { changed: true, disabled: next };
+    }), "persistDisabledSkillsFn");
     const persistSettingFn = /* @__PURE__ */ __name((workspace, scope, key, value) => withSettingsLock(workspace, async () => {
       const fresh = settingsRuntime.settings.loadSettings(workspace);
       fresh.setValue(scope, key, value);
@@ -2460,12 +2989,19 @@ async function runQwenServe(optsIn, deps = {}) {
         );
       }
     }), "persistSettingsFn");
+    const { createSubSessionLauncher } = await import("./create-sub-session-WJOWBFEP.js");
+    const subSessionLauncher = createSubSessionLauncher({
+      getBridge: /* @__PURE__ */ __name(() => bridgeRef, "getBridge"),
+      boundWorkspace
+    });
     const bridge = deps.bridge ?? runtime.createAcpSessionBridge({
       // Reverse tool channel: let `BridgeClient.extMethod` reach the WS
       // connection that hosts a named client MCP server (#5626).
       clientMcpSender: clientMcpSenderRegistry.lookup,
+      onCreateSubSession: subSessionLauncher.launch,
       maxSessions: opts.maxSessions,
       freshSessionAdmission: totalSessionAdmission.admit,
+      sessionLifecycle: sessionOwnerIndex.handleBridgeSessionLifecycle,
       ...opts.maxPendingPromptsPerSession !== void 0 ? { maxPendingPromptsPerSession: opts.maxPendingPromptsPerSession } : {},
       ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
       ...opts.compactedReplayMaxBytes !== void 0 ? { compactedReplayMaxBytes: opts.compactedReplayMaxBytes } : {},
@@ -2494,16 +3030,21 @@ async function runQwenServe(optsIn, deps = {}) {
       internalRuntimeBridgesForCleanup.push(bridge);
     }
     runtimeBridges.push(bridge);
+    let invalidatePrimaryServeFeaturesCache = /* @__PURE__ */ __name(() => {
+    }, "invalidatePrimaryServeFeaturesCache");
     const workspaceService = runtime.createDaemonWorkspaceService({
       boundWorkspace,
       contextFilename: contextFilenameForInit ?? "QWEN.md",
       statusProvider,
       workspaceProvidersStatusProvider,
       workspaceSkillsStatusProvider,
+      voiceEnv: runtimeEffectiveEnv,
       isChannelLive: /* @__PURE__ */ __name(() => bridge.isChannelLive(), "isChannelLive"),
       persistDisabledTools: persistDisabledToolsFn,
+      persistDisabledSkills: persistDisabledSkillsFn,
       persistSetting: persistSettingFn,
       persistSettings: persistSettingsFn,
+      preheatAcpChild: /* @__PURE__ */ __name(() => bridge.preheat(), "preheatAcpChild"),
       reloadDaemonEnv: /* @__PURE__ */ __name((workspace) => withSettingsLock(workspace, async () => {
         const fresh = settingsRuntime.settings.loadSettings(workspace, {
           skipLoadEnvironment: true
@@ -2566,7 +3107,12 @@ async function runQwenServe(optsIn, deps = {}) {
       queryWorkspaceStatus: /* @__PURE__ */ __name((method, idle) => bridge.queryWorkspaceStatus(method, idle), "queryWorkspaceStatus"),
       invokeWorkspaceCommand: /* @__PURE__ */ __name((method, params, invokeOpts) => bridge.invokeWorkspaceCommand(method, params, invokeOpts), "invokeWorkspaceCommand"),
       refreshExtensionsForAllSessions: /* @__PURE__ */ __name(() => bridge.refreshExtensionsForAllSessions(), "refreshExtensionsForAllSessions"),
-      publishWorkspaceEvent: /* @__PURE__ */ __name((event) => bridge.publishWorkspaceEvent(event), "publishWorkspaceEvent")
+      publishWorkspaceEvent: /* @__PURE__ */ __name((event) => {
+        if (event.type === "settings_changed" || event.type === "settings_reloaded") {
+          invalidatePrimaryServeFeaturesCache();
+        }
+        bridge.publishWorkspaceEvent(event);
+      }, "publishWorkspaceEvent")
     });
     const workspaceRuntimes = [
       {
@@ -2574,6 +3120,8 @@ async function runQwenServe(optsIn, deps = {}) {
         workspaceCwd: boundWorkspace,
         primary: true,
         trusted: trustedWorkspace,
+        removable: false,
+        registrationIds: workspaceInputs[0]?.registrationIds ?? [],
         env: primaryRuntimeEnv,
         bridge,
         workspaceService,
@@ -2614,6 +3162,13 @@ async function runQwenServe(optsIn, deps = {}) {
         }
       };
     }, "createRuntimeEnvMetadata");
+    const subSessionStoppers = [];
+    const subSessionStoppersByWorkspace = /* @__PURE__ */ new Map();
+    const runtimeCleanupPromises = /* @__PURE__ */ new WeakMap();
+    const removeArrayValue = /* @__PURE__ */ __name((values, value) => {
+      const index = values.indexOf(value);
+      if (index >= 0) values.splice(index, 1);
+    }, "removeArrayValue");
     for (const workspaceInput of workspaceInputs.slice(1)) {
       let secondarySettings;
       try {
@@ -2667,10 +3222,17 @@ async function runQwenServe(optsIn, deps = {}) {
         ...opts.experimentalLsp === true ? { extraArgs: ["--experimental-lsp"] } : {}
       });
       const secondaryClientMcpSenderRegistry = new ClientMcpSenderRegistry();
+      let secondaryBridgeRef;
+      const secondarySubSessionLauncher = createSubSessionLauncher({
+        getBridge: /* @__PURE__ */ __name(() => secondaryBridgeRef, "getBridge"),
+        boundWorkspace: workspaceInput.cwd
+      });
       const secondaryBridge = runtime.createAcpSessionBridge({
         clientMcpSender: secondaryClientMcpSenderRegistry.lookup,
+        onCreateSubSession: secondarySubSessionLauncher.launch,
         maxSessions: opts.maxSessions,
         freshSessionAdmission: totalSessionAdmission.admit,
+        sessionLifecycle: sessionOwnerIndex.handleBridgeSessionLifecycle,
         ...opts.maxPendingPromptsPerSession !== void 0 ? { maxPendingPromptsPerSession: opts.maxPendingPromptsPerSession } : {},
         ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
         ...opts.compactedReplayMaxBytes !== void 0 ? { compactedReplayMaxBytes: opts.compactedReplayMaxBytes } : {},
@@ -2696,8 +3258,14 @@ async function runQwenServe(optsIn, deps = {}) {
           fresh.setValue(WORKSPACE_SETTING_SCOPE, "tools.approvalMode", mode);
         }), "persistApprovalMode")
       });
+      secondaryBridgeRef = secondaryBridge;
       runtimeBridges.push(secondaryBridge);
       internalRuntimeBridgesForCleanup.push(secondaryBridge);
+      subSessionStoppers.push(secondarySubSessionLauncher.stop);
+      subSessionStoppersByWorkspace.set(
+        workspaceInput.cwd,
+        secondarySubSessionLauncher.stop
+      );
       const secondaryWorkspaceService = runtime.createDaemonWorkspaceService({
         boundWorkspace: workspaceInput.cwd,
         contextFilename: contextFilenameForInit ?? "QWEN.md",
@@ -2706,8 +3274,12 @@ async function runQwenServe(optsIn, deps = {}) {
           env: secondaryEnv.effectiveEnv
         }),
         workspaceSkillsStatusProvider: runtime.createWorkspaceSkillsStatusProvider(),
+        voiceEnv: secondaryEnv.effectiveEnv,
+        voiceSettingsScope: WORKSPACE_SETTING_SCOPE,
         isChannelLive: /* @__PURE__ */ __name(() => secondaryBridge.isChannelLive(), "isChannelLive"),
+        preheatAcpChild: /* @__PURE__ */ __name(() => secondaryBridge.preheat(), "preheatAcpChild"),
         persistDisabledTools: persistDisabledToolsFn,
+        persistDisabledSkills: persistDisabledSkillsFn,
         persistSetting: persistSettingFn,
         persistSettings: persistSettingsFn,
         reloadDaemonEnv: /* @__PURE__ */ __name((workspace) => withSettingsLock(workspace, async () => {
@@ -2765,6 +3337,8 @@ async function runQwenServe(optsIn, deps = {}) {
         workspaceCwd: workspaceInput.cwd,
         primary: false,
         trusted: secondaryTrusted,
+        removable: workspaceInput.removable,
+        registrationIds: workspaceInput.registrationIds,
         env: secondaryEnv.metadata,
         bridge: secondaryBridge,
         workspaceService: secondaryWorkspaceService,
@@ -2772,7 +3346,10 @@ async function runQwenServe(optsIn, deps = {}) {
         clientMcpSenderRegistry: secondaryClientMcpSenderRegistry
       });
     }
-    const workspaceRegistry = runtime.createWorkspaceRegistry(workspaceRuntimes);
+    const workspaceRegistry = runtime.createWorkspaceRegistry(workspaceRuntimes, {
+      sessionOwnerIndex
+    });
+    const workspaceVoiceCoordinator = new WorkspaceVoiceCoordinator();
     core.registerDaemonGaugeCallbacks({
       sessionCount: /* @__PURE__ */ __name(() => workspaceRegistry.list().reduce((sum, item) => sum + item.bridge.sessionCount, 0), "sessionCount"),
       sseCount: /* @__PURE__ */ __name(() => runtime.getActiveSseCount(), "sseCount"),
@@ -2801,7 +3378,7 @@ async function runQwenServe(optsIn, deps = {}) {
           prevCpu = cpu;
           prevCpuAt = nowMs;
         }
-        const acp = app2.locals?.["acpHandle"]?.registry.getSnapshot();
+        const acp = app2.locals?.["acpHandle"]?.getSnapshot();
         const hits = getRateLimiter(app2)?.getHitCounts();
         const rejectedTotal = hits ? hits.prompt + hits.mutation + hits.read : 0;
         const rateLimitRejected = prevRateRejected === void 0 ? 0 : Math.max(0, rejectedTotal - prevRateRejected);
@@ -2864,8 +3441,317 @@ async function runQwenServe(optsIn, deps = {}) {
         metricsLoopDelay.disable();
       }
     };
+    const createDynamicWorkspaceRuntime = /* @__PURE__ */ __name(async (cwd) => {
+      let wsSettings;
+      try {
+        wsSettings = settingsRuntime.settings.loadSettings(cwd);
+      } catch (err) {
+        writeStderrLine(
+          `qwen serve: could not read full settings for dynamic workspace ${cwd} (${err instanceof Error ? err.message : String(err)}); falling back to defaults.`
+        );
+      }
+      const trusted = wsSettings ? settingsRuntime.trustedFolders.getWorkspaceTrustStatus(
+        wsSettings.merged,
+        cwd
+      ).effective.state === "trusted" : false;
+      const wsEnv = createRuntimeEnvMetadata(cwd, wsSettings);
+      const wsHash = core.hashDaemonWorkspace(cwd);
+      const wsFsFactory = runtime.resolveBridgeFsFactory({
+        boundWorkspaces: [cwd],
+        trusted,
+        emit: deps.fsAuditEmit,
+        pathLocks: sharedPathLocks,
+        ...customIgnoreFiles !== void 0 ? { customIgnoreFiles } : {}
+      });
+      const wsChannelFactory = runtime.createSpawnChannelFactory({
+        sourceEnv: wsEnv.effectiveEnv,
+        onDiagnosticLine: diagnosticSink,
+        pipeHooks: {
+          onMessageSent: /* @__PURE__ */ __name((bytes) => recordPipeMessage("outbound", bytes), "onMessageSent"),
+          onMessageReceived: /* @__PURE__ */ __name((bytes) => recordPipeMessage("inbound", bytes), "onMessageReceived"),
+          onMessageObserved: /* @__PURE__ */ __name(({ direction, bytes, message }) => observeLargePipeFrame({
+            direction: daemonPipeDirection(direction),
+            bytes,
+            message
+          }), "onMessageObserved")
+        },
+        ...opts.experimentalLsp === true ? { extraArgs: ["--experimental-lsp"] } : {}
+      });
+      const wsClientMcpRegistry = new ClientMcpSenderRegistry();
+      let wsBridgeRef;
+      const wsSubSessionLauncher = createSubSessionLauncher({
+        getBridge: /* @__PURE__ */ __name(() => wsBridgeRef, "getBridge"),
+        boundWorkspace: cwd
+      });
+      let wsBridge;
+      try {
+        wsBridge = runtime.createAcpSessionBridge({
+          clientMcpSender: wsClientMcpRegistry.lookup,
+          onCreateSubSession: wsSubSessionLauncher.launch,
+          maxSessions: opts.maxSessions,
+          freshSessionAdmission: totalSessionAdmission.admit,
+          sessionLifecycle: sessionOwnerIndex.handleBridgeSessionLifecycle,
+          ...opts.maxPendingPromptsPerSession !== void 0 ? { maxPendingPromptsPerSession: opts.maxPendingPromptsPerSession } : {},
+          ...opts.eventRingSize !== void 0 ? { eventRingSize: opts.eventRingSize } : {},
+          ...opts.compactedReplayMaxBytes !== void 0 ? { compactedReplayMaxBytes: opts.compactedReplayMaxBytes } : {},
+          ...opts.channelIdleTimeoutMs !== void 0 ? { channelIdleTimeoutMs: opts.channelIdleTimeoutMs } : {},
+          ...opts.sessionReapIntervalMs !== void 0 ? { sessionReapIntervalMs: opts.sessionReapIntervalMs } : {},
+          ...opts.sessionIdleTimeoutMs !== void 0 ? { sessionIdleTimeoutMs: opts.sessionIdleTimeoutMs } : {},
+          ...opts.permissionResponseTimeoutMs !== void 0 ? { permissionResponseTimeoutMs: opts.permissionResponseTimeoutMs } : {},
+          boundWorkspace: cwd,
+          sessionShellCommandEnabled,
+          childEnvOverrides,
+          channelFactory: wsChannelFactory,
+          onDiagnosticLine: diagnosticSink,
+          telemetry: createRuntimeBridgeTelemetry(wsHash),
+          ...permissionPolicy !== void 0 ? { permissionPolicy } : {},
+          ...permissionConsensusQuorum !== void 0 ? { permissionConsensusQuorum } : {},
+          permissionAudit: permissionAuditPublisher,
+          statusProvider: runtime.createDaemonStatusProvider({
+            env: wsEnv.effectiveEnv
+          }),
+          fileSystem: createBridgeFileSystemAdapter(wsFsFactory),
+          persistApprovalMode: /* @__PURE__ */ __name((workspace, mode) => withSettingsLock(workspace, async () => {
+            const fresh = settingsRuntime.settings.loadSettings(workspace);
+            fresh.setValue(
+              WORKSPACE_SETTING_SCOPE,
+              "tools.approvalMode",
+              mode
+            );
+          }), "persistApprovalMode")
+        });
+      } catch (err) {
+        wsSubSessionLauncher.stop();
+        throw err;
+      }
+      wsBridgeRef = wsBridge;
+      let wsService;
+      try {
+        wsService = runtime.createDaemonWorkspaceService({
+          boundWorkspace: cwd,
+          contextFilename: contextFilenameForInit ?? "QWEN.md",
+          statusProvider: runtime.createDaemonStatusProvider({
+            env: wsEnv.effectiveEnv
+          }),
+          workspaceProvidersStatusProvider: runtime.createWorkspaceProvidersStatusProvider({
+            env: wsEnv.effectiveEnv
+          }),
+          workspaceSkillsStatusProvider: runtime.createWorkspaceSkillsStatusProvider(),
+          voiceEnv: wsEnv.effectiveEnv,
+          voiceSettingsScope: WORKSPACE_SETTING_SCOPE,
+          isChannelLive: /* @__PURE__ */ __name(() => wsBridge.isChannelLive(), "isChannelLive"),
+          preheatAcpChild: /* @__PURE__ */ __name(() => wsBridge.preheat(), "preheatAcpChild"),
+          persistDisabledTools: persistDisabledToolsFn,
+          persistDisabledSkills: persistDisabledSkillsFn,
+          persistSetting: persistSettingFn,
+          persistSettings: persistSettingsFn,
+          reloadDaemonEnv: /* @__PURE__ */ __name((workspace) => withSettingsLock(workspace, async () => {
+            const fresh = settingsRuntime.settings.loadSettings(workspace, {
+              skipLoadEnvironment: true
+            });
+            const result = settingsRuntime.settings.reloadEnvironment(
+              fresh.merged,
+              workspace
+            );
+            try {
+              const refreshedRuntimeEnv = settingsRuntime.environment.buildRuntimeEnvironment(
+                fresh.merged,
+                workspace,
+                daemonRuntimeBaseEnv
+              );
+              logRuntimeEnvFileReadFailures(workspace, refreshedRuntimeEnv);
+              wsEnv.replace(refreshedRuntimeEnv.effectiveEnv);
+              wsEnv.metadata.envFileReadFailed = refreshedRuntimeEnv.envFileReadFailed;
+              wsEnv.metadata.envFileReadFailures.splice(
+                0,
+                wsEnv.metadata.envFileReadFailures.length,
+                ...refreshedRuntimeEnv.envFileReadFailures
+              );
+              wsEnv.metadata.overlayKeys.splice(
+                0,
+                wsEnv.metadata.overlayKeys.length,
+                ...refreshedRuntimeEnv.overlayKeys
+              );
+              wsEnv.metadata.envFilePaths.splice(
+                0,
+                wsEnv.metadata.envFilePaths.length,
+                ...refreshedRuntimeEnv.envFilePaths
+              );
+              delete wsEnv.metadata.fallbackReason;
+            } catch (err) {
+              wsEnv.metadata.fallbackReason = err instanceof Error ? err.message : String(err);
+              daemonLog.warn(
+                "failed to rebuild dynamic runtime env snapshot after daemon env reload; preserving previous runtime env",
+                {
+                  workspace,
+                  error: wsEnv.metadata.fallbackReason
+                }
+              );
+            }
+            return result;
+          }), "reloadDaemonEnv"),
+          queryWorkspaceStatus: /* @__PURE__ */ __name((method, idle) => wsBridge.queryWorkspaceStatus(method, idle), "queryWorkspaceStatus"),
+          invokeWorkspaceCommand: /* @__PURE__ */ __name((method, params, invokeOpts) => wsBridge.invokeWorkspaceCommand(method, params, invokeOpts), "invokeWorkspaceCommand"),
+          refreshExtensionsForAllSessions: /* @__PURE__ */ __name(() => wsBridge.refreshExtensionsForAllSessions(), "refreshExtensionsForAllSessions"),
+          publishWorkspaceEvent: /* @__PURE__ */ __name((event) => wsBridge.publishWorkspaceEvent(event), "publishWorkspaceEvent")
+        });
+      } catch (err) {
+        wsSubSessionLauncher.stop();
+        await wsBridge.shutdown().catch(() => {
+          try {
+            wsBridge.killAllSync();
+          } catch {
+          }
+        });
+        throw err;
+      }
+      runtimeBridges.push(wsBridge);
+      internalRuntimeBridgesForCleanup.push(wsBridge);
+      subSessionStoppers.push(wsSubSessionLauncher.stop);
+      subSessionStoppersByWorkspace.set(cwd, wsSubSessionLauncher.stop);
+      return {
+        workspaceId: wsHash,
+        workspaceCwd: cwd,
+        primary: false,
+        trusted,
+        removable: true,
+        registrationIds: [],
+        env: wsEnv.metadata,
+        bridge: wsBridge,
+        workspaceService: wsService,
+        routeFileSystemFactory: wsFsFactory,
+        clientMcpSenderRegistry: wsClientMcpRegistry
+      };
+    }, "createDynamicWorkspaceRuntime");
+    const workspaceRuntimeRemoval = {
+      async runtimeAdded(runtimeAdded) {
+        const app3 = runtimeApp ?? runtimeAppForCleanup;
+        const startScheduledTaskKeepaliveForWorkspace = app3?.locals?.["startScheduledTaskKeepaliveForWorkspace"];
+        startScheduledTaskKeepaliveForWorkspace?.(runtimeAdded);
+        if (!channelWorkerManager) return;
+        try {
+          await channelWorkerManager.restoreWorkspace(
+            runtimeAdded.workspaceCwd
+          );
+          await channelWorkerManager.refreshWorkspaces();
+        } catch (err) {
+          daemonLog.error(
+            "workspace channel worker startup error",
+            err instanceof Error ? err : null
+          );
+        } finally {
+          writeChannelWorkerPidfile();
+        }
+      },
+      beginDrain(runtimeToDrain) {
+        totalSessionAdmission.beginWorkspaceDrain(runtimeToDrain.workspaceCwd);
+        channelWorkerManager?.beginWorkspaceDrain(runtimeToDrain.workspaceCwd);
+        workspaceVoiceCoordinator.beginWorkspaceDrain(runtimeToDrain);
+      },
+      cancelDrain(runtimeToDrain) {
+        channelWorkerManager?.cancelWorkspaceDrain(runtimeToDrain.workspaceCwd);
+        totalSessionAdmission.cancelWorkspaceDrain(runtimeToDrain.workspaceCwd);
+        workspaceVoiceCoordinator.cancelWorkspaceDrain(runtimeToDrain);
+      },
+      completeDrain(runtimeToDrain) {
+        totalSessionAdmission.completeWorkspaceDrain(
+          runtimeToDrain.workspaceCwd
+        );
+        workspaceVoiceCoordinator.completeWorkspaceDrain(runtimeToDrain);
+      },
+      getActivity(runtimeToDrain) {
+        return {
+          pendingSessionStarts: totalSessionAdmission.snapshotForWorkspace(
+            runtimeToDrain.workspaceCwd
+          ).inFlight,
+          channelWorkers: channelWorkerManager?.workspaceActivity(
+            runtimeToDrain.workspaceCwd
+          ) ?? 0,
+          voiceSessions: workspaceVoiceCoordinator.getWorkspaceActivity(runtimeToDrain)
+        };
+      },
+      disposeRuntime(runtimeToDrain, reason = "workspace_removed") {
+        const existing = runtimeCleanupPromises.get(runtimeToDrain);
+        if (existing) return existing;
+        const cleanup = (async () => {
+          await workspaceVoiceCoordinator.disposeRuntime(
+            runtimeToDrain,
+            reason
+          );
+          const stopSubSessions = subSessionStoppersByWorkspace.get(
+            runtimeToDrain.workspaceCwd
+          );
+          try {
+            stopSubSessions?.();
+          } catch {
+          }
+          if (reason === "workspace_removed" && channelWorkerManager) {
+            await channelWorkerManager.removeWorkspace(runtimeToDrain.workspaceCwd).catch((err) => {
+              daemonLog.error(
+                "workspace channel worker cleanup error",
+                err instanceof Error ? err : null
+              );
+            });
+            try {
+              await channelWorkerManager.refreshWorkspaces();
+            } catch (err) {
+              channelWorkspaceGroups = (channelWorkspaceGroups ?? []).filter(
+                (group) => group.workspaceCwd !== runtimeToDrain.workspaceCwd
+              );
+              channelWebhookConfigVersion += 1;
+              refreshChannelWebhookConfigs?.();
+              daemonLog.error(
+                "workspace channel worker topology refresh error",
+                err instanceof Error ? err : null
+              );
+            }
+            writeChannelWorkerPidfile();
+          }
+          if (reason === "workspace_removed") {
+            const app3 = runtimeApp ?? runtimeAppForCleanup;
+            const stopWorkspaceGitStateForWorkspace = app3?.locals?.["stopWorkspaceGitStateForWorkspace"];
+            const stopScheduledTaskKeepaliveForWorkspace = app3?.locals?.["stopScheduledTaskKeepaliveForWorkspace"];
+            stopWorkspaceGitStateForWorkspace?.(runtimeToDrain.workspaceCwd);
+            stopScheduledTaskKeepaliveForWorkspace?.(
+              runtimeToDrain.workspaceCwd
+            );
+          }
+          let bridgeStopped = false;
+          try {
+            if (!shutdownBridges.has(runtimeToDrain.bridge)) {
+              await runtimeToDrain.bridge.shutdown({ reason });
+            }
+            bridgeStopped = true;
+          } finally {
+            if (bridgeStopped || reason === "workspace_removed") {
+              subSessionStoppersByWorkspace.delete(runtimeToDrain.workspaceCwd);
+              if (stopSubSessions) {
+                removeArrayValue(subSessionStoppers, stopSubSessions);
+              }
+              removeArrayValue(runtimeBridges, runtimeToDrain.bridge);
+              removeArrayValue(
+                internalRuntimeBridgesForCleanup,
+                runtimeToDrain.bridge
+              );
+              shutdownBridges.add(runtimeToDrain.bridge);
+            }
+          }
+        })();
+        runtimeCleanupPromises.set(runtimeToDrain, cleanup);
+        void cleanup.catch(() => {
+          if (reason === "daemon_shutdown" && runtimeCleanupPromises.get(runtimeToDrain) === cleanup) {
+            runtimeCleanupPromises.delete(runtimeToDrain);
+          }
+        });
+        return cleanup;
+      }
+    };
     const app2 = runtime.createServeApp(opts, () => actualPort, {
       workspaceRegistry,
+      createWorkspaceRuntime: createDynamicWorkspaceRuntime,
+      workspaceRegistrationStore,
+      workspaceRuntimeRemoval,
+      voiceCoordinator: workspaceVoiceCoordinator,
       bridge,
       webShellDir,
       boundWorkspace,
@@ -2880,6 +3766,27 @@ async function runQwenServe(optsIn, deps = {}) {
       primaryRuntimeEnv,
       daemonLog,
       getChannelWorkerSnapshot,
+      getChannelWorkerSnapshots,
+      getChannelWorkerControl,
+      isChannelControlDraining: /* @__PURE__ */ __name(() => channelControlDraining, "isChannelControlDraining"),
+      isChannelControlInitializing: /* @__PURE__ */ __name(() => channelWorkerManagerStarting !== void 0, "isChannelControlInitializing"),
+      setChannelWorkerSelection,
+      stopChannelWorker,
+      getChannelWebhookConfigSources,
+      getChannelWebhookConfigVersion: /* @__PURE__ */ __name(() => channelWebhookConfigVersion, "getChannelWebhookConfigVersion"),
+      registerChannelWebhookConfigRefresh: /* @__PURE__ */ __name((refresh) => {
+        refreshChannelWebhookConfigs = refresh;
+      }, "registerChannelWebhookConfigRefresh"),
+      enqueueChannelWebhookTask: /* @__PURE__ */ __name(async (task) => {
+        if (!channelWorkerManager) {
+          throw new ChannelWebhookEnqueueError(
+            "channel_worker_unavailable",
+            "Channel worker is not running."
+          );
+        }
+        return channelWorkerManager.enqueueWebhookTask(task);
+      }, "enqueueChannelWebhookTask"),
+      reloadChannelWorker,
       getPerfSnapshot: /* @__PURE__ */ __name(() => ({
         eventLoop: currentDaemonEventLoopMonitor.snapshot(),
         promptQueueWait: {
@@ -2901,8 +3808,12 @@ async function runQwenServe(optsIn, deps = {}) {
       // so the WS provider and the child-answering bridge share one sender map.
       clientMcpSenderRegistry,
       persistDisabledTools: persistDisabledToolsFn,
+      persistDisabledSkills: persistDisabledSkillsFn,
       persistSetting: persistSettingFn,
       persistSettings: persistSettingsFn,
+      sessionArtifactsPersistenceAvailable: sessionArtifactsPersistenceAvailableFromSettings(
+        runtimeBootSettings?.merged
+      ),
       installAuthProvider: /* @__PURE__ */ __name((req) => withSettingsLock(
         boundWorkspace,
         async () => {
@@ -2941,14 +3852,18 @@ async function runQwenServe(optsIn, deps = {}) {
         }
       ), "installAuthProvider")
     });
+    invalidatePrimaryServeFeaturesCache = app2.locals.invalidateServeFeaturesCache ?? invalidatePrimaryServeFeaturesCache;
+    app2.locals.subSessionStoppers = subSessionStoppers;
+    subSessionStoppers.push(subSessionLauncher.stop);
+    subSessionStoppersByWorkspace.set(boundWorkspace, subSessionLauncher.stop);
     return { app: app2, bridge };
   }, "buildRuntime");
   if (deps.bridge) {
     const runtime = await buildRuntime();
     runtimeAppForCleanup = runtime.app;
-    runtimeApp = runtime.app;
     bridgeRef = runtime.bridge;
     if (!opts.channelSelection) {
+      runtimeApp = runtime.app;
       runtimeStartupSettled = true;
       markRuntimeReady();
     }
@@ -2962,17 +3877,25 @@ async function runQwenServe(optsIn, deps = {}) {
     daemonLog,
     qwenCodeVersion: cliVersion,
     sessionShellCommandEnabled,
+    sessionArtifactsPersistenceAvailable,
     permissionPolicy,
     multiWorkspaceCapabilitiesRequireRuntime: workspaceInputs.length > 1,
     getRuntimeError: /* @__PURE__ */ __name(() => runtimeStartupError, "getRuntimeError"),
     getChannelWorkerSnapshot,
+    getChannelWorkerSnapshots,
     onHealthServed: deferRuntimeUntilFirstHealth ? () => startRuntimeAfterHealth?.() : void 0
   });
+  const deferredChannelWebhookAuth = deferRuntimeUntilFirstHealth ? createDeferredChannelWebhookAuth(
+    resolveChannelWebhookConfigSource,
+    await loadChannelWebhookConfigRuntime(),
+    daemonLog
+  ) : void 0;
   const app = runtimeApp ?? createDelegatingServeApp(bootstrapApp, () => runtimeApp, {
     waitForDeferredRuntimeRoutes: deferRuntimeUntilFirstHealth,
     startRuntime: /* @__PURE__ */ __name(() => startRuntimeForRequest?.(), "startRuntime"),
     runtimeReady,
-    authenticateDeferredRuntimeRequest: bearerAuth(opts.token)
+    authenticateDeferredRuntimeRequest: bearerAuth(opts.token),
+    authenticateDeferredChannelWebhookRequest: deferredChannelWebhookAuth
   });
   let listenHostname = opts.hostname;
   if (opts.hostname.startsWith("[")) {
@@ -2989,7 +3912,70 @@ async function runQwenServe(optsIn, deps = {}) {
       `Invalid maxConnections: ${opts.maxConnections}. Must be >= 0 (0 / Infinity = unlimited).`
     );
   }
-  reserveChannelServicePidfile();
+  const channelValidationSettingsRuntime = opts.channelSelection ? await loadSettingsRuntimeModules() : void 0;
+  const resolveChannelWorkspaceGroupsAtListen = /* @__PURE__ */ __name(() => {
+    if (!opts.channelSelection || !channelValidationSettingsRuntime || !channelRuntime) {
+      return void 0;
+    }
+    const settingsByWorkspace = /* @__PURE__ */ new Map();
+    if (workspaceInputs.length === 1) {
+      const workspace = workspaceInputs[0];
+      const settings = channelValidationSettingsRuntime.settings.loadSettings(
+        workspace.cwd
+      );
+      channelWebhookEnvByWorkspace.set(
+        workspace.cwd,
+        channelValidationSettingsRuntime.environment.buildRuntimeEnvironment(
+          settings.merged,
+          workspace.cwd,
+          daemonRuntimeBaseEnv
+        ).effectiveEnv
+      );
+      return void 0;
+    }
+    const workspaces = workspaceInputs.map((workspace, index) => {
+      const settings = channelValidationSettingsRuntime.settings.loadSettings(
+        workspace.cwd
+      );
+      settingsByWorkspace.set(workspace.cwd, settings);
+      channelWebhookEnvByWorkspace.set(
+        workspace.cwd,
+        channelValidationSettingsRuntime.environment.buildRuntimeEnvironment(
+          settings.merged,
+          workspace.cwd,
+          daemonRuntimeBaseEnv
+        ).effectiveEnv
+      );
+      const trusted = index === 0 && deps.trustedWorkspace !== void 0 ? deps.trustedWorkspace : channelValidationSettingsRuntime.trustedFolders.getWorkspaceTrustStatus(
+        settings.merged,
+        workspace.cwd
+      ).effective.state === "trusted";
+      return {
+        workspaceCwd: workspace.cwd,
+        primary: index === 0,
+        trusted
+      };
+    });
+    const grouping = resolveChannelWorkspaceGroups({
+      workspaces,
+      selection: opts.channelSelection,
+      loadChannelsConfig: /* @__PURE__ */ __name((cwd) => {
+        const settings = settingsByWorkspace.get(cwd);
+        if (!settings) return {};
+        return channelRuntime.loadChannelsConfig(cwd, settings);
+      }, "loadChannelsConfig")
+    });
+    if (!grouping.ok) {
+      throw Object.assign(new Error(grouping.error.message), {
+        code: grouping.error.code,
+        ...grouping.error.channel ? { channel: grouping.error.channel } : {}
+      });
+    }
+    return grouping.groups;
+  }, "resolveChannelWorkspaceGroupsAtListen");
+  if (opts.channelSelection) {
+    reserveChannelServicePidfile(opts.channelSelection);
+  }
   return await new Promise((resolve, reject) => {
     const onListening = /* @__PURE__ */ __name(() => {
       startup.listenerReadyAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -3008,45 +3994,14 @@ async function runQwenServe(optsIn, deps = {}) {
       const scheme = tlsOptions ? "https" : "http";
       const url = `${scheme}://${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,
-            onReady: /* @__PURE__ */ __name((snapshot) => {
-              writeChannelWorkerPidfile(snapshot);
-            }, "onReady"),
-            onLog: /* @__PURE__ */ __name(({ stream, line }) => {
-              const message = `channel worker ${stream}: ${line}`;
-              if (stream === "stderr") {
-                daemonLog.warn(message);
-              } else {
-                daemonLog.info(message);
-              }
-            }, "onLog"),
-            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"}, restartCount=${snapshot.restartCount ?? 0}, nextRestartAt=${snapshot.nextRestartAt ?? "none"}, staleHeartbeatAt=${snapshot.staleHeartbeatAt ?? "none"})`
-              );
-              writeChannelWorkerPidfile(snapshot, { clearWorkerPid: true });
-            }, "onExit")
-          });
-        }
+        channelWorkspaceGroups = resolveChannelWorkspaceGroupsAtListen();
       } 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",
+              "server close after channel worker validation error failed",
               closeErr
             );
           }
@@ -3054,6 +4009,19 @@ async function runQwenServe(optsIn, deps = {}) {
         });
         return;
       }
+      if (channelWorkspaceGroups) {
+        for (const group of channelWorkspaceGroups) {
+          daemonLog.info("channel worker group assigned", {
+            workspace: group.workspaceCwd,
+            channels: group.selection.mode === "all" ? ["all"] : group.selection.names
+          });
+        }
+        if (opts.channelSelection?.mode === "all") {
+          writeStderrLine(
+            "qwen serve: --channel all is primary-workspace only; non-primary workspace channels are not hosted."
+          );
+        }
+      }
       writeStdoutLine(
         `qwen serve listening on ${url} (mode=${opts.mode}, workspace=${boundWorkspace})`
       );
@@ -3129,20 +4097,28 @@ async function runQwenServe(optsIn, deps = {}) {
         }
       }, "shutdownBridgeAfterFailedStartup");
       const stopChannelWorkerAfterFailedStartup = /* @__PURE__ */ __name(async () => {
-        await channelWorker.stop().catch((stopErr) => {
+        if (!channelWorkerManager) return true;
+        try {
+          await channelWorkerManager.shutdown();
+          return true;
+        } catch (stopErr) {
           daemonLog.error(
             "channel worker stop after runtime startup error failed",
             stopErr instanceof Error ? stopErr : null
           );
-        });
+          return false;
+        }
       }, "stopChannelWorkerAfterFailedStartup");
       const failRuntimeStartup = /* @__PURE__ */ __name(async (err, bridgeForCleanup) => {
         const error = err instanceof Error ? err : new Error(String(err));
         if (runtimeStartupSettled) {
+          disposeRuntimeAppResources(runtimeApp ?? runtimeAppForCleanup);
           await shutdownBridgeAfterFailedStartup(bridgeForCleanup);
           return;
         }
         runtimeStartupSettled = true;
+        disposeRuntimeAppResources(runtimeApp ?? runtimeAppForCleanup);
+        runtimeApp = void 0;
         clearRuntimeStartupTimer();
         const message = error.message;
         runtimeStartupError = message;
@@ -3152,14 +4128,28 @@ async function runQwenServe(optsIn, deps = {}) {
         }
         writeStderrLine(`qwen serve: runtime startup failed: ${message}`);
         daemonLog.error("runtime startup failed", error);
-        await stopChannelWorkerAfterFailedStartup();
+        markRuntimeFailed(error);
+        if (closeServerAfterChannelWorkerStartupFailure && server.listening) {
+          runtimeFailureListenerClose = new Promise((resolve2) => {
+            server.close((closeErr) => {
+              if (closeErr) {
+                daemonLog.error(
+                  "server close after runtime startup error failed",
+                  closeErr
+                );
+              }
+              resolve2();
+            });
+          });
+          server.closeAllConnections();
+        }
+        const channelWorkerStopped = await stopChannelWorkerAfterFailedStartup();
         disposeDaemonEventLoopMonitor();
-        removeCurrentServePidfile();
+        if (channelWorkerStopped) removeCurrentServePidfile();
         const bridgesForCleanup = bridgeForCleanup ? [bridgeForCleanup, ...getRuntimeBridgesForCleanup()] : getRuntimeBridgesForCleanup();
         for (const bridge of [...new Set(bridgesForCleanup)]) {
           await shutdownBridgeAfterFailedStartup(bridge);
         }
-        markRuntimeFailed(error);
       }, "failRuntimeStartup");
       const armRuntimeStartupTimer = /* @__PURE__ */ __name(() => {
         if (runtimeStartupTimeoutMs <= 0 || runtimeStartupTimer) return;
@@ -3172,10 +4162,152 @@ async function runQwenServe(optsIn, deps = {}) {
         }, runtimeStartupTimeoutMs);
         runtimeStartupTimer.unref();
       }, "armRuntimeStartupTimer");
-      const completeRuntimeStartup = /* @__PURE__ */ __name(async () => {
+      const resolveRuntimeChannelGroups = /* @__PURE__ */ __name(async (channelSelection, candidateApp, operation) => {
+        const registry = candidateApp.locals?.["workspaceRegistry"];
+        if (!registry) {
+          throw new Error(
+            "Workspace registry is not available for channel workers."
+          );
+        }
+        const runtimes = registry.list();
+        if (runtimes.length <= 1 && operation === "initial") {
+          return [
+            {
+              workspaceCwd: registry.primary.workspaceCwd,
+              selection: channelSelection
+            }
+          ];
+        }
+        const workerRuntime = await ensureChannelRuntime();
+        const settingsRuntime = await loadSettingsRuntimeModules();
+        const settingsByWorkspace = /* @__PURE__ */ new Map();
+        const grouping = resolveChannelWorkspaceGroups({
+          workspaces: runtimes.map((runtime) => {
+            const settings = settingsRuntime.settings.loadSettings(
+              runtime.workspaceCwd
+            );
+            settingsByWorkspace.set(runtime.workspaceCwd, settings);
+            return {
+              workspaceCwd: runtime.workspaceCwd,
+              primary: runtime.primary,
+              trusted: runtime.trusted
+            };
+          }),
+          selection: channelSelection,
+          loadChannelsConfig: /* @__PURE__ */ __name((cwd) => {
+            const settings = settingsByWorkspace.get(cwd);
+            return settings ? workerRuntime.loadChannelsConfig(cwd, settings) : {};
+          }, "loadChannelsConfig")
+        });
+        if (!grouping.ok) {
+          throw Object.assign(new Error(grouping.error.message), {
+            code: grouping.error.code,
+            ...grouping.error.channel ? { channel: grouping.error.channel } : {}
+          });
+        }
+        return grouping.groups;
+      }, "resolveRuntimeChannelGroups");
+      ensureChannelWorkerManager = /* @__PURE__ */ __name(() => {
+        if (channelWorkerManager) return Promise.resolve(channelWorkerManager);
+        if (channelWorkerManagerStarting) return channelWorkerManagerStarting;
+        const starting = (async () => {
+          const candidateApp = runtimeApp ?? runtimeAppForCleanup;
+          const registry = candidateApp?.locals?.["workspaceRegistry"];
+          if (!candidateApp || !registry) {
+            throw new Error(
+              "Workspace registry is not available for channels."
+            );
+          }
+          const workerRuntime = await ensureChannelRuntime();
+          const createSupervisor = deps.channelWorkerSupervisorFactory ?? workerRuntime.createChannelWorkerSupervisor;
+          const createGroup = /* @__PURE__ */ __name((groups) => workerRuntime.createChannelWorkerGroup({
+            groups,
+            registry,
+            createSupervisor,
+            shared: {
+              cliEntryPath: workerRuntime.findCliEntryPath(),
+              daemonUrl: formatChannelWorkerDaemonUrl(
+                opts.hostname,
+                actualPort
+              ),
+              ...token ? { daemonToken: token } : {}
+            },
+            onReady: /* @__PURE__ */ __name((snapshot) => {
+              if (runtimeStartupError !== void 0) return;
+              if (workspaceInputs.length > 1) {
+                daemonLog.info("channel worker ready", {
+                  workspace: snapshot.workspaceCwd,
+                  pid: snapshot.pid,
+                  channels: snapshot.channels
+                });
+              }
+              channelWorkerManager?.workerChanged();
+              if (!runtimeStartupSettled) writeChannelWorkerPidfile();
+            }, "onReady"),
+            onExit: /* @__PURE__ */ __name((snapshot) => {
+              const workspacePrefix = workspaceInputs.length > 1 ? `workspace=${snapshot.workspaceCwd}, ` : "";
+              daemonLog.warn(
+                `channel worker exited (${workspacePrefix}state=${snapshot.state}, pid=${snapshot.pid ?? "unknown"}, code=${snapshot.exitCode ?? "null"}, signal=${snapshot.signal ?? "null"}, error=${snapshot.error ?? "none"}, restartCount=${snapshot.restartCount ?? 0}, nextRestartAt=${snapshot.nextRestartAt ?? "none"}, staleHeartbeatAt=${snapshot.staleHeartbeatAt ?? "none"})`
+              );
+              channelWorkerManager?.workerChanged();
+              if (!runtimeStartupSettled) writeChannelWorkerPidfile();
+            }, "onExit"),
+            onStateChange: /* @__PURE__ */ __name(() => {
+              channelWorkerManager?.workerChanged();
+              if (!runtimeStartupSettled) writeChannelWorkerPidfile();
+            }, "onStateChange"),
+            onLog: /* @__PURE__ */ __name(({ stream, line, workspaceCwd }) => {
+              const message = workspaceInputs.length > 1 ? `channel worker [${workspaceCwd}] ${stream}: ${line}` : `channel worker ${stream}: ${line}`;
+              if (stream === "stderr") daemonLog.warn(message);
+              else daemonLog.info(message);
+            }, "onLog")
+          }), "createGroup");
+          channelWorkerManager = workerRuntime.createChannelWorkerManager({
+            resolveGroups: /* @__PURE__ */ __name((selection, operation) => resolveRuntimeChannelGroups(selection, candidateApp, operation), "resolveGroups"),
+            createGroup,
+            reserveLease: reserveChannelServicePidfile,
+            releaseLease: /* @__PURE__ */ __name(() => {
+              removeCurrentServePidfile();
+              if (channelPidfileReserved) {
+                throw new Error("Failed to release the channel service lease.");
+              }
+            }, "releaseLease"),
+            initialLeaseReserved: channelPidfileReserved,
+            onCommittedSelection: /* @__PURE__ */ __name((_selection, groups) => {
+              channelWorkspaceGroups = groups;
+              channelWebhookConfigVersion += 1;
+              refreshChannelWebhookConfigs?.();
+            }, "onCommittedSelection"),
+            onStateChange: /* @__PURE__ */ __name(() => {
+              if (runtimeStartupSettled) writeChannelWorkerPidfile();
+            }, "onStateChange")
+          });
+          return channelWorkerManager;
+        })();
+        channelWorkerManagerStarting = starting;
+        void starting.then(
+          () => {
+            if (channelWorkerManagerStarting === starting) {
+              channelWorkerManagerStarting = void 0;
+            }
+          },
+          () => {
+            if (channelWorkerManagerStarting === starting) {
+              channelWorkerManagerStarting = void 0;
+            }
+          }
+        );
+        return starting;
+      }, "ensureChannelWorkerManager");
+      const completeRuntimeStartup = /* @__PURE__ */ __name(async (candidateApp) => {
         if (runtimeStartupSettled) return;
+        runtimeApp = candidateApp;
+        const acpHandle = candidateApp.locals?.["acpHandle"];
+        acpHandle?.attachServer?.(server);
         if (opts.channelSelection) {
-          await channelWorker.start();
+          closeServerAfterChannelWorkerStartupFailure = true;
+          const manager = await ensureChannelWorkerManager();
+          await manager.startInitial(opts.channelSelection);
           if (runtimeStartupSettled) return;
         }
         if (runtimeStartupSettled) return;
@@ -3210,6 +4342,7 @@ async function runQwenServe(optsIn, deps = {}) {
         clearRuntimeStartFallbackTimer();
         runtimeStarting = buildRuntime().then(async (runtime) => {
           if (runtimeStartupSettled) {
+            disposeRuntimeAppResources(runtime.app);
             await shutdownBridgeAfterFailedStartup(runtime.bridge);
             return;
           }
@@ -3222,13 +4355,10 @@ async function runQwenServe(optsIn, deps = {}) {
             );
             return;
           }
-          runtimeApp = runtime.app;
-          const acpHandle = runtime.app.locals?.["acpHandle"];
-          acpHandle?.attachServer?.(server);
           if (shouldPreheat) {
             startBridgePreheat(runtime.bridge);
           }
-          await completeRuntimeStartup();
+          await completeRuntimeStartup(runtime.app);
         }).catch((err) => failRuntimeStartup(err));
       }, "startRuntime");
       startRuntimeForRequest = startRuntime;
@@ -3266,11 +4396,10 @@ async function runQwenServe(optsIn, deps = {}) {
         if (shuttingDown) {
           daemonLog.warn(`received ${signal} during drain \u2014 forcing exit`);
           try {
-            channelWorker.killAllSync();
+            channelWorkerManager?.killAllSync();
             for (const runtimeBridge of getRuntimeBridgesForCleanup()) {
               runtimeBridge.killAllSync();
             }
-            removeCurrentServePidfile();
           } catch (err) {
             daemonLog.error(
               "force-kill error",
@@ -3286,16 +4415,24 @@ async function runQwenServe(optsIn, deps = {}) {
         try {
           await handle.close();
           await daemonLog.flush();
-          process.exit(0);
+          process.exit(runtimeStartupError === void 0 ? 0 : 1);
         } catch (err) {
           daemonLog.error("shutdown error", err instanceof Error ? err : null);
           await daemonLog.flush().catch(() => {
           });
+          if (channelWorkerManager?.state().enabled) {
+            daemonLog.error(
+              "refusing to exit while a channel worker or service lease remains; signal again to retry after the child exits (another signal during that retry forces exit)"
+            );
+            await daemonLog.flush().catch(() => {
+            });
+            return;
+          }
           process.exit(1);
         }
       }, "onSignal");
       const onUncaughtExceptionMonitor = /* @__PURE__ */ __name(() => {
-        if (process.listenerCount("uncaughtException") === 0) {
+        if (process.listenerCount("uncaughtException") === 0 && !channelWorkerManager?.state().enabled) {
           removeCurrentServePidfile();
         }
       }, "onUncaughtExceptionMonitor");
@@ -3310,17 +4447,24 @@ async function runQwenServe(optsIn, deps = {}) {
           if (closePromise) return closePromise;
           closePromise = new Promise((res, rej) => {
             shuttingDown = true;
-            app.locals.stopScheduledTaskKeepalive?.();
+            channelControlDraining = true;
+            const initiallyMountedApp = runtimeApp ?? runtimeAppForCleanup;
+            const initiallyMountedManagement = initiallyMountedApp?.locals?.["workspaceManagementHandle"];
+            const initialManagementWait = initiallyMountedManagement?.sealAndWait?.();
             clearRuntimeStartAfterHealthTimer();
             clearRuntimeStartFallbackTimer();
             cancelDeferredRuntimeStartup();
             let settled = false;
             let bridgeShutdownError;
+            let channelWorkerShutdownError;
             const finish = /* @__PURE__ */ __name((err) => {
               if (settled) return;
               settled = true;
-              process.removeListener("SIGINT", onSignal);
-              process.removeListener("SIGTERM", onSignal);
+              const preserveSignalHandlers = channelWorkerShutdownError !== void 0 && channelWorkerManager?.state().enabled === true;
+              if (!preserveSignalHandlers) {
+                process.removeListener("SIGINT", onSignal);
+                process.removeListener("SIGTERM", onSignal);
+              }
               process.removeListener(
                 "uncaughtExceptionMonitor",
                 onUncaughtExceptionMonitor
@@ -3331,9 +4475,17 @@ async function runQwenServe(optsIn, deps = {}) {
                 );
               }).finally(() => daemonLog.flush().catch(() => {
               })).finally(() => {
-                const finalErr = err ?? bridgeShutdownError;
-                if (finalErr) rej(finalErr);
-                else res();
+                const finalErr = err ?? bridgeShutdownError ?? channelWorkerShutdownError;
+                if (finalErr) {
+                  if (channelWorkerShutdownError && channelWorkerManager?.state().enabled) {
+                    closePromise = void 0;
+                    shuttingDown = false;
+                    channelControlDraining = false;
+                  }
+                  rej(finalErr);
+                } else {
+                  res();
+                }
               });
             }, "finish");
             void (coreRuntimePromise ? coreRuntimePromise.then((core) => core.forceFlushMetrics()) : Promise.resolve()).catch((flushErr) => {
@@ -3347,43 +4499,54 @@ async function runQwenServe(optsIn, deps = {}) {
                 daemonLog
               );
               const appForCleanup = runtimeApp ?? runtimeAppForCleanup;
-              const deviceFlowRegistry = appForCleanup ? getDeviceFlowRegistry(appForCleanup) : void 0;
-              if (deviceFlowRegistry) {
-                try {
-                  deviceFlowRegistry.dispose();
-                } catch (err) {
-                  daemonLog.warn(
-                    `device-flow registry dispose error: ${err instanceof Error ? err.message : String(err)}`
-                  );
-                }
+              const workspaceManagementHandle = appForCleanup?.locals?.["workspaceManagementHandle"];
+              await initialManagementWait;
+              if (workspaceManagementHandle !== initiallyMountedManagement) {
+                await workspaceManagementHandle?.sealAndWait?.();
               }
-              const acpHandle = appForCleanup?.locals?.["acpHandle"];
-              if (acpHandle?.dispose) {
-                try {
-                  acpHandle.dispose();
-                } catch (err) {
-                  daemonLog.warn(
-                    `ACP handle dispose error: ${err instanceof Error ? err.message : String(err)}`
+              disposeRuntimeAppResources(appForCleanup);
+              disposeDaemonEventLoopMonitor();
+              if (channelWorkerManager) {
+                await channelWorkerManager.shutdown().catch((err) => {
+                  daemonLog.error(
+                    "channel worker stop error",
+                    err instanceof Error ? err : null
                   );
-                }
-              }
-              const rl = appForCleanup ? getRateLimiter(appForCleanup) : void 0;
-              if (rl) {
-                rl.setDraining(true);
-                rl.dispose();
+                  channelWorkerShutdownError = err instanceof Error ? err : new Error(String(err));
+                });
+              } else {
+                removeCurrentServePidfile();
               }
-              disposeDaemonEventLoopMonitor();
-              await channelWorker.stop().catch((err) => {
-                daemonLog.error(
-                  "channel worker stop error",
-                  err instanceof Error ? err : null
+              const runtimeRemoval = appForCleanup?.locals?.["workspaceRuntimeRemoval"];
+              const workspaceRegistry = appForCleanup?.locals?.["workspaceRegistry"];
+              const managedRuntimeBridges = /* @__PURE__ */ new Set();
+              if (runtimeRemoval && workspaceRegistry) {
+                const managedRuntimes = workspaceRegistry.listManaged();
+                for (const workspaceRuntime of managedRuntimes) {
+                  managedRuntimeBridges.add(workspaceRuntime.bridge);
+                }
+                await Promise.all(
+                  managedRuntimes.map(
+                    (workspaceRuntime) => runtimeRemoval.disposeRuntime(workspaceRuntime, "daemon_shutdown").catch((err) => {
+                      daemonLog.error(
+                        "workspace runtime shutdown error",
+                        err instanceof Error ? err : null
+                      );
+                      bridgeShutdownError = err instanceof Error ? err : new Error(String(err));
+                      try {
+                        workspaceRuntime.bridge.killAllSync();
+                      } catch {
+                      }
+                    })
+                  )
                 );
-              });
-              removeCurrentServePidfile();
+              }
               for (const bridgeForShutdown of getRuntimeBridgesForCleanup()) {
+                if (managedRuntimeBridges.has(bridgeForShutdown)) continue;
                 if (shutdownBridges.has(bridgeForShutdown)) continue;
                 shutdownBridges.add(bridgeForShutdown);
                 await bridgeForShutdown.shutdown().catch((err) => {
+                  shutdownBridges.delete(bridgeForShutdown);
                   daemonLog.error(
                     "bridge shutdown error",
                     err instanceof Error ? err : null
@@ -3392,6 +4555,12 @@ async function runQwenServe(optsIn, deps = {}) {
                 });
               }
             }).finally(() => {
+              if (!server.listening) {
+                void (runtimeFailureListenerClose ?? Promise.resolve()).then(
+                  () => finish()
+                );
+                return;
+              }
               const SECONDARY_DEADLINE_MS = 2e3;
               let secondaryTimer;
               const forceTimer = setTimeout(() => {
@@ -3425,17 +4594,19 @@ async function runQwenServe(optsIn, deps = {}) {
       server.on("error", (err) => {
         daemonLog.error("server error", err instanceof Error ? err : null);
       });
-      if (runtimeApp && bridgeRef) {
-        const acpHandle = runtimeApp.locals?.["acpHandle"];
-        acpHandle?.attachServer?.(server);
+      const preparedRuntimeApp = runtimeApp ?? runtimeAppForCleanup;
+      if (preparedRuntimeApp && bridgeRef && deps.bridge) {
         if (shouldPreheat) {
           startBridgePreheat(bridgeRef);
         }
         if (opts.channelSelection && !runtimeStartupSettled) {
           armRuntimeStartupTimer();
-          runtimeStarting = completeRuntimeStartup().catch(
+          runtimeStarting = completeRuntimeStartup(preparedRuntimeApp).catch(
             (err) => failRuntimeStartup(err, bridgeRef)
           );
+        } else {
+          const acpHandle = preparedRuntimeApp.locals?.["acpHandle"];
+          acpHandle?.attachServer?.(server);
         }
       } else if (deferRuntimeUntilFirstHealth) {
         scheduleRuntimeStartFallback();
@@ -3448,14 +4619,24 @@ async function runQwenServe(optsIn, deps = {}) {
         void runtimeReady.then(
           () => resolve(handle),
           (err) => {
-            void handle.close().catch((closeErr) => {
-              daemonLog.error(
-                "shutdown after runtime startup error failed",
-                closeErr instanceof Error ? closeErr : null
-              );
-            }).finally(() => {
-              reject(err instanceof Error ? err : new Error(String(err)));
-            });
+            void handle.close().then(
+              () => {
+                reject(err instanceof Error ? err : new Error(String(err)));
+              },
+              (closeErr) => {
+                daemonLog.error(
+                  "shutdown after runtime startup error failed",
+                  closeErr instanceof Error ? closeErr : null
+                );
+                if (channelWorkerManager?.state().enabled) {
+                  daemonLog.error(
+                    "runtime startup failed, but qwen serve remains alive to retain the channel service lease until worker exit is confirmed"
+                  );
+                  return;
+                }
+                reject(err instanceof Error ? err : new Error(String(err)));
+              }
+            );
           }
         );
       }
@@ -3512,6 +4693,7 @@ async function runQwenServe(optsIn, deps = {}) {
 __name(runQwenServe, "runQwenServe");
 export {
   InvalidPolicyConfigError,
+  createDisabledChannelWorkerSupervisor,
   createLazyBridgeProxy,
   extractContextFilename,
   formatChannelWorkerDaemonUrl,
@@ -3522,11 +4704,11 @@ export {
 };
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen Team
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */