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

package/chunks/{run-qwen-serve-5OKADVLE.js → run-qwen-serve-O6CMPURG.js}

@@ -3,13 +3,10 @@
 import {
   DaemonMetricsRing,
   computeCpuPercent
-} from "./chunk-II73RK2S.js";
-import {
-  findCliEntryPath
-} from "./chunk-AHNXYU4O.js";
+} from "./chunk-YVEDCAUE.js";
 import {
   RUNTIME_STARTUP_CANCELLED_MESSAGE
-} from "./chunk-GHOTR7HL.js";
+} from "./chunk-QUPXZXLV.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
   ClientMcpSenderRegistry,
@@ -25,63 +22,75 @@ import {
   getRateLimiter,
   getServeProtocolVersions,
   hostAllowlist,
+  isBrowserAutomationMcpAvailable,
   listenerMaxConnections,
   parseAllowOriginPatterns,
   parseDaemonStatusDetail,
   positiveFiniteOrNull,
   require_express,
   resolveWebShellDir
-} from "./chunk-RFIL6REB.js";
+} from "./chunk-KHUQZZJ6.js";
 import {
   isLoopbackBind
-} from "./chunk-RNBYOUGV.js";
-import "./chunk-3HX5LZ6R.js";
-import "./chunk-7RYW5LQV.js";
+} from "./chunk-RXFQM6FQ.js";
+import {
+  LOAD_REPLAY_META_KEY
+} from "./chunk-PZL23GTM.js";
+import {
+  canonicalizeWorkspace
+} from "./chunk-W7FJ3N32.js";
+import {
+  DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
+  normalizeCompactedReplayMaxBytes
+} from "./chunk-COH43MRJ.js";
+import "./chunk-WBL3FJEU.js";
+import "./chunk-T2NCM2ET.js";
 import {
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-DNV4FSN5.js";
+} from "./chunk-3SJSQXNS.js";
+import {
+  getGlobalQwenDirLite,
+  resolveConfigPathLite
+} from "./chunk-3BTRNWWD.js";
+import "./chunk-QRUIS3DN.js";
 import {
+  ChannelWebhookEnqueueError,
   QWEN_SERVER_TOKEN_ENV
-} from "./chunk-S6RLAIUR.js";
+} from "./chunk-X4NKFGFJ.js";
 import {
   channelSelectionNames
-} from "./chunk-MX2YXRER.js";
-import {
-  getGlobalQwenDirLite,
-  resolveConfigPathLite
-} from "./chunk-4RQIB5UZ.js";
+} from "./chunk-TJTKSVIV.js";
 import {
-  LOAD_REPLAY_META_KEY
-} from "./chunk-AGHU5VRK.js";
+  sanitizeLogText
+} from "./chunk-43JB7OF4.js";
+import "./chunk-UDXSXLER.js";
 import {
-  canonicalizeWorkspace
-} from "./chunk-ER3BKOLB.js";
+  isWithinRoot
+} from "./chunk-RDJSGHZE.js";
 import {
   getCliVersion
-} from "./chunk-GD236YPV.js";
-import "./chunk-43W4YSO6.js";
+} from "./chunk-CNOF2IZT.js";
+import "./chunk-VJNBRRZG.js";
 import {
   writeStderrLine,
   writeStdoutLine
-} from "./chunk-Y6Z2O3WR.js";
-import {
-  isWithinRoot
-} from "./chunk-QYUE6W3T.js";
-import "./chunk-5P5XGNYH.js";
-import "./chunk-SKAZWEV5.js";
-import "./chunk-UWCTAVOD.js";
-import "./chunk-SYCJMSIJ.js";
+} from "./chunk-YUZI3WAC.js";
+import "./chunk-CU3L64TP.js";
+import "./chunk-ZJE7NSL3.js";
+import "./chunk-H6XPXXMH.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
@@ -90,7 +99,7 @@ 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";
@@ -105,7 +114,7 @@ var DuplicateWorkspaceInputError = class extends Error {
   }
   constructor(workspace) {
     super(
-      `Duplicate --workspace value resolves to ${JSON.stringify(workspace)}. Multi-workspace serve is not enabled; pass one --workspace.`
+      `Duplicate --workspace value resolves to ${JSON.stringify(workspace)}. Pass distinct --workspace values.`
     );
     this.name = "DuplicateWorkspaceInputError";
   }
@@ -116,22 +125,11 @@ var NestedWorkspaceInputError = class extends Error {
   }
   constructor(parent, child) {
     super(
-      `Nested --workspace values are not supported yet: ${JSON.stringify(child)} is inside ${JSON.stringify(parent)}. Multi-workspace serve is not enabled; pass one --workspace.`
+      `Nested --workspace values are not supported yet: ${JSON.stringify(child)} is inside ${JSON.stringify(parent)}. Pass non-nested --workspace values.`
     );
     this.name = "NestedWorkspaceInputError";
   }
 };
-var MultipleWorkspaceInputError = class extends Error {
-  static {
-    __name(this, "MultipleWorkspaceInputError");
-  }
-  constructor() {
-    super(
-      "Multiple --workspace values are not supported yet. Multi-workspace serve is not enabled; pass one --workspace."
-    );
-    this.name = "MultipleWorkspaceInputError";
-  }
-};
 var MissingWorkspaceInputError = class extends Error {
   static {
     __name(this, "MissingWorkspaceInputError");
@@ -156,7 +154,7 @@ function isNestedWorkspace(parent, child) {
   return parent !== child && isWithinRoot(child, parent);
 }
 __name(isNestedWorkspace, "isNestedWorkspace");
-function rejectUnsupportedMultiWorkspaceInputs(workspaces) {
+function rejectDuplicateOrNestedWorkspaceInputs(workspaces) {
   if (workspaces.length <= 1) return;
   let canonicalWorkspaces;
   try {
@@ -164,7 +162,7 @@ function rejectUnsupportedMultiWorkspaceInputs(workspaces) {
       (workspace) => canonicalizeWorkspace(workspace)
     );
   } catch {
-    throw new MultipleWorkspaceInputError();
+    return;
   }
   const seen = /* @__PURE__ */ new Set();
   for (const workspace of canonicalWorkspaces) {
@@ -185,15 +183,14 @@ function rejectUnsupportedMultiWorkspaceInputs(workspaces) {
       }
     }
   }
-  throw new MultipleWorkspaceInputError();
 }
-__name(rejectUnsupportedMultiWorkspaceInputs, "rejectUnsupportedMultiWorkspaceInputs");
-function resolveSingleWorkspaceInput(workspace) {
+__name(rejectDuplicateOrNestedWorkspaceInputs, "rejectDuplicateOrNestedWorkspaceInputs");
+function resolveWorkspaceInputs(workspace) {
   const workspaces = normalizeWorkspaceInputs(workspace);
-  rejectUnsupportedMultiWorkspaceInputs(workspaces);
-  return workspaces[0];
+  rejectDuplicateOrNestedWorkspaceInputs(workspaces);
+  return workspaces;
 }
-__name(resolveSingleWorkspaceInput, "resolveSingleWorkspaceInput");
+__name(resolveWorkspaceInputs, "resolveWorkspaceInputs");
 
 // packages/cli/src/serve/permission-audit.ts
 init_esbuild_shims();
@@ -939,11 +936,21 @@ function isNonNegativeIntegerOrInfinity(value) {
   return value === Number.POSITIVE_INFINITY || Number.isFinite(value) && Number.isInteger(value) && value >= 0;
 }
 __name(isNonNegativeIntegerOrInfinity, "isNonNegativeIntegerOrInfinity");
+function deriveDefaultMaxTotalSessions(maxSessionsPerWorkspace, workspaceCount) {
+  if (workspaceCount <= 1) return void 0;
+  const perWorkspace = maxSessionsPerWorkspace ?? DEFAULT_MAX_SESSIONS;
+  if (perWorkspace === 0 || perWorkspace === Number.POSITIVE_INFINITY) {
+    return void 0;
+  }
+  return perWorkspace * workspaceCount;
+}
+__name(deriveDefaultMaxTotalSessions, "deriveDefaultMaxTotalSessions");
 function isNonNegativeIntegerMs(value) {
   return Number.isFinite(value) && Number.isInteger(value) && value >= 0;
 }
 __name(isNonNegativeIntegerMs, "isNonNegativeIntegerMs");
 var MAX_TIMEOUT_MS = 2147483647;
+var MAX_PORT_ATTEMPTS = 10;
 function assertTimerDelayInRange(name, value) {
   if (value > MAX_TIMEOUT_MS) {
     throw new TypeError(
@@ -1071,6 +1078,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();
@@ -1082,11 +1093,13 @@ __name(withSettingsLock, "withSettingsLock");
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-CRCVYQIE.js"),
-    import("./pidfile-LIBUENIV.js")
-  ]).then(([supervisor, pidfile]) => ({
+    import("./channel-worker-supervisor-LF66HCVT.js"),
+    import("./pidfile-O3OO2TCP.js"),
+    import("./cli-entry-path-4VJ3Y6T2.js")
+  ]).then(([supervisor, pidfile, cliEntryPath]) => ({
     createChannelWorkerSupervisor: supervisor.createChannelWorkerSupervisor,
-    channelServicePidfile: pidfile
+    channelServicePidfile: pidfile,
+    findCliEntryPath: cliEntryPath.findCliEntryPath
   })).catch((err) => {
     channelWorkerRuntimePromise = void 0;
     throw err;
@@ -1105,9 +1118,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");
@@ -1154,7 +1176,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-XKZMNHXS.js");
+  coreRuntimePromise ??= import("./src-2656Q6SN.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -1184,17 +1206,34 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-WFLNS3WT.js"),
-    import("./loadedSettingsAdapter-QVHHQPGM.js"),
-    import("./trustedFolders-Z475EIHL.js")
-  ]).then(([settings, loadedSettingsAdapter, trustedFolders]) => ({
+    import("./settings-PYEU5HVD.js"),
+    import("./environment-XCVLHOXG.js"),
+    import("./loadedSettingsAdapter-EOD3RVZS.js"),
+    import("./trustedFolders-BEX5334Z.js")
+  ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
+    environment,
     loadedSettingsAdapter,
     trustedFolders
   }));
   return settingsRuntimePromise;
 }
 __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
+var channelWebhookConfigRuntimePromise;
+function loadChannelWebhookConfigRuntime() {
+  channelWebhookConfigRuntimePromise ??= Promise.all([
+    import("./runtime-THE2YO27.js"),
+    import("./config-utils-ZITWCFBY.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,
@@ -1204,16 +1243,20 @@ async function loadServeRuntimeModules() {
     workspaceTypesModule,
     daemonStatusProviderModule,
     workspaceProvidersStatusModule,
-    workspaceSkillsStatusModule
+    workspaceSkillsStatusModule,
+    totalSessionAdmissionModule,
+    workspaceRegistryModule
   ] = await Promise.all([
-    import("./server-M372UENX.js"),
-    import("./bridge-BCU73DZO.js"),
-    import("./spawnChannel-RQHUWTCL.js"),
-    import("./workspace-service-OMBR6ZLG.js"),
-    import("./types-QX5C3CHJ.js"),
-    import("./daemon-status-provider-XSAFKVDS.js"),
-    import("./workspace-providers-status-MVYXMYDG.js"),
-    import("./workspace-skills-status-IMMQ7CAY.js")
+    import("./server-SAEKMY52.js"),
+    import("./bridge-OJL6LD42.js"),
+    import("./spawnChannel-62QKQBQN.js"),
+    import("./workspace-service-4QUMVGBX.js"),
+    import("./types-JNKGKUJT.js"),
+    import("./daemon-status-provider-7XJZ3HPS.js"),
+    import("./workspace-providers-status-NE7QWEYS.js"),
+    import("./workspace-skills-status-L34BYRSY.js"),
+    import("./total-session-admission-EQIHUOL6.js"),
+    import("./workspace-registry-RCWAP57G.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -1226,7 +1269,10 @@ async function loadServeRuntimeModules() {
     WorkspaceSettingsPartialPersistError: workspaceTypesModule.WorkspaceSettingsPartialPersistError,
     createDaemonStatusProvider: daemonStatusProviderModule.createDaemonStatusProvider,
     createWorkspaceProvidersStatusProvider: workspaceProvidersStatusModule.createWorkspaceProvidersStatusProvider,
-    createWorkspaceSkillsStatusProvider: workspaceSkillsStatusModule.createWorkspaceSkillsStatusProvider
+    createWorkspaceSkillsStatusProvider: workspaceSkillsStatusModule.createWorkspaceSkillsStatusProvider,
+    createTotalSessionAdmissionController: totalSessionAdmissionModule.createTotalSessionAdmissionController,
+    createWorkspaceRegistry: workspaceRegistryModule.createWorkspaceRegistry,
+    createWorkspaceSessionOwnerIndex: workspaceRegistryModule.createWorkspaceSessionOwnerIndex
   };
 }
 __name(loadServeRuntimeModules, "loadServeRuntimeModules");
@@ -1250,7 +1296,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,
@@ -1259,12 +1305,15 @@ 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,
     // 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");
@@ -1276,7 +1325,9 @@ function createBootstrapCapabilities(input) {
     mode: input.opts.mode,
     features: currentServeFeaturesForRunQwenServe(
       input.opts,
-      input.sessionShellCommandEnabled
+      input.sessionShellCommandEnabled,
+      input.sessionArtifactsPersistenceAvailable,
+      input.env
     ),
     modelServices: [],
     workspaceCwd: input.boundWorkspace,
@@ -1421,7 +1472,9 @@ function createBootstrapServeApp(input) {
     daemonLog,
     qwenCodeVersion,
     sessionShellCommandEnabled,
+    sessionArtifactsPersistenceAvailable,
     permissionPolicy,
+    multiWorkspaceCapabilitiesRequireRuntime,
     getRuntimeError,
     getChannelWorkerSnapshot,
     onHealthServed
@@ -1458,13 +1511,26 @@ function createBootstrapServeApp(input) {
     app.get(BOOTSTRAP_HEALTH_PATH, healthHandler);
   }
   app.get(BOOTSTRAP_CAPABILITIES_PATH, (_req, res) => {
+    if (multiWorkspaceCapabilitiesRequireRuntime) {
+      const runtimeError = getRuntimeError();
+      if (runtimeError === void 0) {
+        res.setHeader("Retry-After", "1");
+      }
+      res.status(503).json({
+        error: runtimeError ? "Daemon runtime failed to start" : "Daemon runtime is still starting",
+        code: runtimeError ? "daemon_runtime_failed" : "daemon_runtime_starting"
+      });
+      return;
+    }
     res.status(200).json(
       createBootstrapCapabilities({
         opts,
         boundWorkspace,
         qwenCodeVersion,
         sessionShellCommandEnabled,
-        permissionPolicy
+        sessionArtifactsPersistenceAvailable,
+        permissionPolicy,
+        env: process.env
       })
     );
   });
@@ -1518,11 +1584,13 @@ function createBootstrapServeApp(input) {
       },
       limits: {
         maxSessions: advertisedMaxSessions(opts.maxSessions),
+        maxTotalSessions: positiveFiniteOrNull(opts.maxTotalSessions),
         maxPendingPromptsPerSession: advertisedMaxPendingPromptsPerSession(
           opts.maxPendingPromptsPerSession
         ),
         listenerMaxConnections: listenerMaxConnections(opts.maxConnections),
         eventRingSize: opts.eventRingSize ?? DEFAULT_EVENT_RING_SIZE,
+        compactedReplayMaxBytes: opts.compactedReplayMaxBytes ?? DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
         promptDeadlineMs: positiveFiniteOrNull(opts.promptDeadlineMs),
         writerIdleTimeoutMs: positiveFiniteOrNull(opts.writerIdleTimeoutMs),
         channelIdleTimeoutMs: channelIdleTimeoutMs(opts.channelIdleTimeoutMs),
@@ -1533,7 +1601,9 @@ function createBootstrapServeApp(input) {
         protocolVersions: getServeProtocolVersions(),
         features: currentServeFeaturesForRunQwenServe(
           opts,
-          sessionShellCommandEnabled
+          sessionShellCommandEnabled,
+          sessionArtifactsPersistenceAvailable,
+          process.env
         )
       },
       runtime: {
@@ -1605,13 +1675,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 {
@@ -1633,6 +1702,80 @@ 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(workspace, 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 secret = readDeferredWebhookSecret(
+      runtime,
+      workspace,
+      channelName,
+      source
+    );
+    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) {
+  try {
+    const rawConfig = runtime.loadChannelsConfig(workspace)[channelName];
+    if (typeof rawConfig !== "object" || rawConfig === null) {
+      return void 0;
+    }
+    return runtime.parseChannelWebhookConfig(
+      channelName,
+      rawConfig
+    )?.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"]
@@ -1663,6 +1806,9 @@ async function runQwenServe(optsIn, deps = {}) {
     }
   };
   preResolveServeFastPathHomeEnvOverrides();
+  const daemonRuntimeBaseEnv = Object.freeze({
+    ...process.env
+  });
   const rawToken = optsIn.token ?? process.env[QWEN_SERVER_TOKEN_ENV];
   const token = typeof rawToken === "string" && rawToken.trim().length > 0 ? rawToken.trim() : void 0;
   const sessionShellCommandEnabled = optsIn.enableSessionShell === true && token !== void 0;
@@ -1684,7 +1830,8 @@ async function runQwenServe(optsIn, deps = {}) {
   const chromeExtensionOriginAllowed = hasChromeExtensionOrigin(
     optsIn.allowOrigins
   );
-  const rawWorkspace = resolveSingleWorkspaceInput(optsIn.workspace);
+  const rawWorkspaces = resolveWorkspaceInputs(optsIn.workspace);
+  const rawWorkspace = rawWorkspaces[0];
   const opts = {
     ...optsIn,
     token,
@@ -1830,41 +1977,84 @@ async function runQwenServe(optsIn, deps = {}) {
       "qwen serve: --allow-private-auth-base-url enabled; /workspace/auth/provider may install localhost/private-network model endpoints. Use only for local development with trusted clients."
     );
   }
-  if (!path.isAbsolute(rawWorkspace)) {
-    throw new Error(
-      `Invalid --workspace "${rawWorkspace}": must be an absolute path.`
-    );
-  }
-  try {
-    const stats = fs.statSync(rawWorkspace);
-    if (!stats.isDirectory()) {
+  const validateAndCanonicalizeWorkspace = /* @__PURE__ */ __name((workspace) => {
+    if (!path.isAbsolute(workspace)) {
       throw new Error(
-        `Invalid --workspace "${rawWorkspace}": exists but is not a directory.`
+        `Invalid --workspace "${workspace}": must be an absolute path.`
       );
     }
-  } catch (err) {
-    if (err && typeof err === "object" && "code" in err) {
-      const code = err.code;
-      if (code === "ENOENT") {
+    try {
+      const stats = fs.statSync(workspace);
+      if (!stats.isDirectory()) {
         throw new Error(
-          `Invalid --workspace "${rawWorkspace}": directory does not exist.`
+          `Invalid --workspace "${workspace}": exists but is not a directory.`
         );
       }
-      if (code === "EACCES" || code === "EPERM") {
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+          throw new Error(
+            `Invalid --workspace "${workspace}": directory does not exist.`
+          );
+        }
+        if (code === "EACCES" || code === "EPERM") {
+          throw new Error(
+            `Invalid --workspace "${workspace}": permission denied (${String(code)}). The path exists but cannot be stat'd by the current user.`
+          );
+        }
+      }
+      throw err;
+    }
+    return canonicalizeWorkspace(workspace);
+  }, "validateAndCanonicalizeWorkspace");
+  const workspaceInputs = rawWorkspaces.map((workspace) => ({
+    raw: workspace,
+    cwd: validateAndCanonicalizeWorkspace(workspace)
+  }));
+  const boundWorkspace = workspaceInputs[0].cwd;
+  const seenCanonicalWorkspaces = /* @__PURE__ */ new Set();
+  for (const workspace of workspaceInputs) {
+    if (seenCanonicalWorkspaces.has(workspace.cwd)) {
+      throw new Error(
+        `Duplicate --workspace value resolves to ${JSON.stringify(
+          workspace.cwd
+        )}.`
+      );
+    }
+    seenCanonicalWorkspaces.add(workspace.cwd);
+  }
+  for (let i = 0; i < workspaceInputs.length; i++) {
+    for (let j = i + 1; j < workspaceInputs.length; j++) {
+      const first = workspaceInputs[i].cwd;
+      const second = workspaceInputs[j].cwd;
+      const firstRel = path.relative(first, second);
+      const secondRel = path.relative(second, first);
+      if (firstRel && !firstRel.startsWith("..") && !path.isAbsolute(firstRel)) {
         throw new Error(
-          `Invalid --workspace "${rawWorkspace}": permission denied (${String(code)}). The path exists but cannot be stat'd by the current user.`
+          `Nested --workspace values are not supported: ${JSON.stringify(second)} is inside ${JSON.stringify(first)}.`
+        );
+      }
+      if (secondRel && !secondRel.startsWith("..") && !path.isAbsolute(secondRel)) {
+        throw new Error(
+          `Nested --workspace values are not supported: ${JSON.stringify(first)} is inside ${JSON.stringify(second)}.`
         );
       }
     }
-    throw err;
   }
-  const boundWorkspace = canonicalizeWorkspace(rawWorkspace);
+  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."
+    );
+  }
   let contextFilenameForInit;
   let permissionPolicy;
   let permissionConsensusQuorum;
   let bootSettings;
+  let sessionArtifactsPersistenceAvailable = true;
   try {
     bootSettings = deps.bootSettings ?? loadServeFastPathSettings(boundWorkspace);
+    sessionArtifactsPersistenceAvailable = sessionArtifactsPersistenceAvailableFromSettings(bootSettings);
     contextFilenameForInit = extractContextFilename(
       bootSettings.context?.fileName
     );
@@ -1919,6 +2109,13 @@ async function runQwenServe(optsIn, deps = {}) {
       );
     }
   }
+  if (opts.maxTotalSessions !== void 0) {
+    if (!isNonNegativeIntegerOrInfinity(opts.maxTotalSessions)) {
+      throw new TypeError(
+        `Invalid maxTotalSessions: ${opts.maxTotalSessions}. Must be a non-negative integer (0 / Infinity = unlimited).`
+      );
+    }
+  }
   if (opts.maxPendingPromptsPerSession !== void 0) {
     if (!isNonNegativeIntegerOrInfinity(opts.maxPendingPromptsPerSession)) {
       throw new TypeError(
@@ -1933,6 +2130,9 @@ async function runQwenServe(optsIn, deps = {}) {
       );
     }
   }
+  if (opts.compactedReplayMaxBytes !== void 0) {
+    normalizeCompactedReplayMaxBytes(opts.compactedReplayMaxBytes);
+  }
   if (opts.writerIdleTimeoutMs !== void 0) {
     if (!isPositiveIntegerMs(opts.writerIdleTimeoutMs)) {
       throw new TypeError(
@@ -1968,6 +2168,10 @@ async function runQwenServe(optsIn, deps = {}) {
       );
     }
   }
+  opts.maxTotalSessions ??= deriveDefaultMaxTotalSessions(
+    opts.maxSessions,
+    workspaceInputs.length
+  );
   const inheritedNoPool = process.env["QWEN_SERVE_NO_MCP_POOL"] === "1";
   if (opts.mcpPoolActive === void 0 && inheritedNoPool) {
     opts.mcpPoolActive = false;
@@ -2005,6 +2209,7 @@ async function runQwenServe(optsIn, deps = {}) {
   let runtimeApp;
   let runtimeAppForCleanup;
   let bridgeRef = deps.bridge;
+  const internalRuntimeBridgesForCleanup = [];
   let daemonEventLoopMonitor;
   let daemonMetricsSampler;
   let runtimeStartupError;
@@ -2029,6 +2234,7 @@ async function runQwenServe(optsIn, deps = {}) {
   }, "disposeDaemonEventLoopMonitor");
   let channelWorker = createDisabledChannelWorkerSupervisor();
   const getChannelWorkerSnapshot = /* @__PURE__ */ __name(() => channelWorker.snapshot(), "getChannelWorkerSnapshot");
+  const reloadChannelWorker = /* @__PURE__ */ __name(() => channelWorker.restart(), "reloadChannelWorker");
   const writeChannelWorkerPidfile = /* @__PURE__ */ __name((snapshot = channelWorker.snapshot(), options = {}) => {
     if (!opts.channelSelection || !channelServicePidfile) return;
     try {
@@ -2047,6 +2253,17 @@ async function runQwenServe(optsIn, deps = {}) {
     () => bridgeRef,
     () => runtimeStartupError
   );
+  const shutdownBridges = /* @__PURE__ */ new WeakSet();
+  const getRuntimeBridgesForCleanup = /* @__PURE__ */ __name(() => {
+    const appForCleanup = runtimeApp ?? runtimeAppForCleanup;
+    const registry = appForCleanup?.locals?.["workspaceRegistry"];
+    const bridges = [
+      ...registry ? registry.list().map((runtime) => runtime.bridge) : [],
+      ...bridgeRef ? [bridgeRef] : [],
+      ...internalRuntimeBridgesForCleanup
+    ];
+    return [...new Set(bridges)];
+  }, "getRuntimeBridgesForCleanup");
   const buildRuntime = /* @__PURE__ */ __name(async () => {
     const [runtime, core, settingsRuntime, resolvedCliVersion] = await Promise.all([
       loadServeRuntimeModules(),
@@ -2073,6 +2290,43 @@ async function runQwenServe(optsIn, deps = {}) {
         { workspace: boundWorkspace }
       );
     }
+    const runtimeEnvSnapshot = runtimeBootSettings ? settingsRuntime.environment.buildRuntimeEnvironment(
+      runtimeBootSettings.merged,
+      boundWorkspace,
+      daemonRuntimeBaseEnv
+    ) : {
+      effectiveEnv: { ...daemonRuntimeBaseEnv },
+      overlayKeys: Object.freeze([]),
+      envFilePaths: Object.freeze([]),
+      envFileReadFailed: false,
+      envFileReadFailures: Object.freeze([])
+    };
+    const logRuntimeEnvFileReadFailures = /* @__PURE__ */ __name((workspace, snapshot) => {
+      if (!snapshot.envFileReadFailed) return;
+      const failedFiles = snapshot.envFileReadFailures ?? [];
+      daemonLog.warn("one or more runtime env files could not be read", {
+        workspace,
+        ...failedFiles.length > 0 ? { failedFiles } : {}
+      });
+    }, "logRuntimeEnvFileReadFailures");
+    logRuntimeEnvFileReadFailures(boundWorkspace, runtimeEnvSnapshot);
+    const runtimeEffectiveEnv = {
+      ...runtimeEnvSnapshot.effectiveEnv
+    };
+    const replaceRuntimeEffectiveEnv = /* @__PURE__ */ __name((nextEnv) => {
+      for (const key of Object.keys(runtimeEffectiveEnv)) {
+        delete runtimeEffectiveEnv[key];
+      }
+      Object.assign(runtimeEffectiveEnv, nextEnv);
+    }, "replaceRuntimeEffectiveEnv");
+    const primaryRuntimeEnv = {
+      mode: "runtime-overlay",
+      overlayKeys: [...runtimeEnvSnapshot.overlayKeys],
+      effectiveEnv: runtimeEffectiveEnv,
+      envFilePaths: [...runtimeEnvSnapshot.envFilePaths],
+      envFileReadFailed: runtimeEnvSnapshot.envFileReadFailed,
+      envFileReadFailures: [...runtimeEnvSnapshot.envFileReadFailures]
+    };
     const daemonWorkspaceHash = core.hashDaemonWorkspace(boundWorkspace);
     let daemonTelemetrySettings;
     try {
@@ -2145,54 +2399,58 @@ async function runQwenServe(optsIn, deps = {}) {
       promptQueueWaitStats.lastMs = durationMs;
       core.recordDaemonPromptQueueWait(durationMs);
     }, "recordPromptQueueWait");
-    const daemonTelemetry = core.createDaemonBridgeTelemetry();
-    daemonTelemetry.metrics = {
-      sessionLifecycle(action) {
-        core.recordDaemonSessionLifecycle(action);
-        core.emitDaemonLog(
-          `Session ${action}.`,
-          {
-            "qwen-code.workspace.hash": daemonWorkspaceHash
-          },
-          {
-            eventName: `qwen-code.daemon.session.${action}`
-          }
-        );
-      },
-      channelLifecycle(action, expected) {
-        core.recordDaemonChannelLifecycle(action, expected);
-        core.emitDaemonLog(
-          action === "spawn" ? "ACP channel spawned." : `ACP channel exited (expected=${expected ?? true}).`,
-          {
-            ...action === "exit" ? { "qwen-code.daemon.channel.expected": expected ?? true } : {}
-          },
-          {
-            eventName: `qwen-code.daemon.channel.${action}`,
-            ...expected === false && action === "exit" ? { severityNumber: 13 } : {}
+    const createRuntimeBridgeTelemetry = /* @__PURE__ */ __name((workspaceHash) => {
+      const telemetry = core.createDaemonBridgeTelemetry();
+      telemetry.metrics = {
+        sessionLifecycle(action) {
+          core.recordDaemonSessionLifecycle(action);
+          core.emitDaemonLog(
+            `Session ${action}.`,
+            {
+              "qwen-code.workspace.hash": workspaceHash
+            },
+            {
+              eventName: `qwen-code.daemon.session.${action}`
+            }
+          );
+        },
+        channelLifecycle(action, expected) {
+          core.recordDaemonChannelLifecycle(action, expected);
+          core.emitDaemonLog(
+            action === "spawn" ? "ACP channel spawned." : `ACP channel exited (expected=${expected ?? true}).`,
+            {
+              ...action === "exit" ? { "qwen-code.daemon.channel.expected": expected ?? true } : {}
+            },
+            {
+              eventName: `qwen-code.daemon.channel.${action}`,
+              ...expected === false && action === "exit" ? { severityNumber: 13 } : {}
+            }
+          );
+        },
+        promptQueueWait(durationMs) {
+          recordPromptQueueWait(durationMs);
+          metricsRing.recordPromptQueueWait(durationMs);
+        },
+        promptDuration(durationMs) {
+          core.recordDaemonPromptDuration(durationMs);
+          metricsRing.recordPromptDuration(durationMs);
+        },
+        cancelled: core.recordDaemonCancel,
+        // Per-round model token usage + LLM round-trip time sniffed off
+        // `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) {
+          metricsRing.recordTokens(inputTokens, outputTokens);
+          if (typeof durationMs === "number") {
+            metricsRing.recordLlmDuration(durationMs);
           }
-        );
-      },
-      promptQueueWait(durationMs) {
-        recordPromptQueueWait(durationMs);
-        metricsRing.recordPromptQueueWait(durationMs);
-      },
-      promptDuration(durationMs) {
-        core.recordDaemonPromptDuration(durationMs);
-        metricsRing.recordPromptDuration(durationMs);
-      },
-      cancelled: core.recordDaemonCancel,
-      // Per-round model token usage + LLM round-trip time sniffed off
-      // `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) {
-        metricsRing.recordTokens(inputTokens, outputTokens);
-        if (typeof durationMs === "number") {
-          metricsRing.recordLlmDuration(durationMs);
         }
-      }
-    };
+      };
+      return telemetry;
+    }, "createRuntimeBridgeTelemetry");
+    const daemonTelemetry = createRuntimeBridgeTelemetry(daemonWorkspaceHash);
     const permissionAuditRing = new PermissionAuditRing();
     const permissionAuditPublisher = createPermissionAuditPublisher({
       ring: permissionAuditRing
@@ -2239,7 +2497,17 @@ async function runQwenServe(optsIn, deps = {}) {
       pathLocks: sharedPathLocks,
       ...customIgnoreFiles !== void 0 ? { customIgnoreFiles } : {}
     });
+    const routeFsFactory = runtime.resolveBridgeFsFactory({
+      // REST routes still return primary-relative paths, so keep their
+      // filesystem boundary primary-only until responses carry root IDs.
+      boundWorkspaces: [boundWorkspace],
+      trusted: trustedWorkspace,
+      emit: deps.fsAuditEmit,
+      pathLocks: sharedPathLocks,
+      ...customIgnoreFiles !== void 0 ? { customIgnoreFiles } : {}
+    });
     const channelFactory = runtime.createSpawnChannelFactory({
+      sourceEnv: runtimeEffectiveEnv,
       onDiagnosticLine: diagnosticSink,
       pipeHooks: {
         onMessageSent: /* @__PURE__ */ __name((bytes) => recordPipeMessage("outbound", bytes), "onMessageSent"),
@@ -2252,10 +2520,22 @@ async function runQwenServe(optsIn, deps = {}) {
       },
       ...opts.experimentalLsp === true ? { extraArgs: ["--experimental-lsp"] } : {}
     });
-    const statusProvider = runtime.createDaemonStatusProvider();
-    const workspaceProvidersStatusProvider = runtime.createWorkspaceProvidersStatusProvider();
+    const statusProvider = runtime.createDaemonStatusProvider({
+      env: runtimeEffectiveEnv
+    });
+    const workspaceProvidersStatusProvider = runtime.createWorkspaceProvidersStatusProvider({
+      env: runtimeEffectiveEnv
+    });
     const workspaceSkillsStatusProvider = runtime.createWorkspaceSkillsStatusProvider();
     const clientMcpSenderRegistry = new ClientMcpSenderRegistry();
+    const runtimeBridges = [];
+    const totalSessionAdmission = runtime.createTotalSessionAdmissionController(
+      {
+        maxTotalSessions: opts.maxTotalSessions,
+        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;
@@ -2302,13 +2582,22 @@ async function runQwenServe(optsIn, deps = {}) {
         );
       }
     }), "persistSettingsFn");
+    const { createSubSessionLauncher } = await import("./create-sub-session-VZIOFS6N.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 } : {},
       ...opts.channelIdleTimeoutMs !== void 0 ? { channelIdleTimeoutMs: opts.channelIdleTimeoutMs } : {},
       ...opts.sessionReapIntervalMs !== void 0 ? { sessionReapIntervalMs: opts.sessionReapIntervalMs } : {},
       ...opts.sessionIdleTimeoutMs !== void 0 ? { sessionIdleTimeoutMs: opts.sessionIdleTimeoutMs } : {},
@@ -2331,7 +2620,9 @@ async function runQwenServe(optsIn, deps = {}) {
     });
     if (!deps.bridge) {
       bridgeRef = bridge;
+      internalRuntimeBridgesForCleanup.push(bridge);
     }
+    runtimeBridges.push(bridge);
     const workspaceService = runtime.createDaemonWorkspaceService({
       boundWorkspace,
       contextFilename: contextFilenameForInit ?? "QWEN.md",
@@ -2342,22 +2633,291 @@ async function runQwenServe(optsIn, deps = {}) {
       persistDisabledTools: persistDisabledToolsFn,
       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
         });
-        return settingsRuntime.settings.reloadEnvironment(
+        const result = settingsRuntime.settings.reloadEnvironment(
           fresh.merged,
           workspace
         );
+        let refreshedRuntimeEnv;
+        let fallbackReason;
+        try {
+          refreshedRuntimeEnv = settingsRuntime.environment.buildRuntimeEnvironment(
+            fresh.merged,
+            workspace,
+            daemonRuntimeBaseEnv
+          );
+        } catch (err) {
+          fallbackReason = err instanceof Error ? err.message : String(err);
+          daemonLog.warn(
+            "failed to rebuild runtime env snapshot after daemon env reload; preserving previous runtime env",
+            {
+              error: fallbackReason
+            }
+          );
+          refreshedRuntimeEnv = {
+            effectiveEnv: { ...runtimeEffectiveEnv },
+            overlayKeys: [...primaryRuntimeEnv.overlayKeys],
+            envFilePaths: [...primaryRuntimeEnv.envFilePaths],
+            envFileReadFailed: primaryRuntimeEnv.envFileReadFailed ?? false,
+            envFileReadFailures: [
+              ...primaryRuntimeEnv.envFileReadFailures ?? []
+            ]
+          };
+        }
+        logRuntimeEnvFileReadFailures(workspace, refreshedRuntimeEnv);
+        replaceRuntimeEffectiveEnv(refreshedRuntimeEnv.effectiveEnv);
+        if (fallbackReason) {
+          primaryRuntimeEnv.fallbackReason = fallbackReason;
+        } else {
+          delete primaryRuntimeEnv.fallbackReason;
+        }
+        primaryRuntimeEnv.envFileReadFailed = refreshedRuntimeEnv.envFileReadFailed;
+        primaryRuntimeEnv.envFileReadFailures.splice(
+          0,
+          primaryRuntimeEnv.envFileReadFailures.length,
+          ...refreshedRuntimeEnv.envFileReadFailures
+        );
+        primaryRuntimeEnv.overlayKeys.splice(
+          0,
+          primaryRuntimeEnv.overlayKeys.length,
+          ...refreshedRuntimeEnv.overlayKeys
+        );
+        primaryRuntimeEnv.envFilePaths.splice(
+          0,
+          primaryRuntimeEnv.envFilePaths.length,
+          ...refreshedRuntimeEnv.envFilePaths
+        );
+        return result;
       }), "reloadDaemonEnv"),
       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")
     });
+    const workspaceRuntimes = [
+      {
+        workspaceId: daemonWorkspaceHash,
+        workspaceCwd: boundWorkspace,
+        primary: true,
+        trusted: trustedWorkspace,
+        env: primaryRuntimeEnv,
+        bridge,
+        workspaceService,
+        routeFileSystemFactory: routeFsFactory,
+        clientMcpSenderRegistry
+      }
+    ];
+    const createRuntimeEnvMetadata = /* @__PURE__ */ __name((workspace, settings) => {
+      const snapshot = settings ? settingsRuntime.environment.buildRuntimeEnvironment(
+        settings.merged,
+        workspace,
+        daemonRuntimeBaseEnv
+      ) : {
+        effectiveEnv: { ...daemonRuntimeBaseEnv },
+        overlayKeys: Object.freeze([]),
+        envFilePaths: Object.freeze([]),
+        envFileReadFailed: false,
+        envFileReadFailures: Object.freeze([])
+      };
+      logRuntimeEnvFileReadFailures(workspace, snapshot);
+      const effectiveEnv = { ...snapshot.effectiveEnv };
+      const metadata = {
+        mode: "runtime-overlay",
+        overlayKeys: [...snapshot.overlayKeys],
+        effectiveEnv,
+        envFilePaths: [...snapshot.envFilePaths],
+        envFileReadFailed: snapshot.envFileReadFailed,
+        envFileReadFailures: [...snapshot.envFileReadFailures]
+      };
+      return {
+        metadata,
+        effectiveEnv,
+        replace(nextEnv) {
+          for (const key of Object.keys(effectiveEnv)) {
+            delete effectiveEnv[key];
+          }
+          Object.assign(effectiveEnv, nextEnv);
+        }
+      };
+    }, "createRuntimeEnvMetadata");
+    const subSessionStoppers = [];
+    for (const workspaceInput of workspaceInputs.slice(1)) {
+      let secondarySettings;
+      try {
+        secondarySettings = settingsRuntime.settings.loadSettings(
+          workspaceInput.cwd
+        );
+      } catch (err) {
+        writeStderrLine(
+          `qwen serve: could not read full settings for secondary workspace ${workspaceInput.cwd} (${err instanceof Error ? err.message : String(err)}); falling back to defaults.`
+        );
+      }
+      const secondaryTrusted = secondarySettings ? settingsRuntime.trustedFolders.getWorkspaceTrustStatus(
+        secondarySettings.merged,
+        workspaceInput.cwd
+      ).effective.state === "trusted" : false;
+      if (!secondaryTrusted) {
+        daemonLog.warn("secondary workspace is not trusted", {
+          workspace: workspaceInput.cwd,
+          trustSettingsAvailable: secondarySettings !== void 0
+        });
+      }
+      const secondaryEnv = createRuntimeEnvMetadata(
+        workspaceInput.cwd,
+        secondarySettings
+      );
+      const secondaryWorkspaceHash = core.hashDaemonWorkspace(
+        workspaceInput.cwd
+      );
+      const secondaryStatusProvider = runtime.createDaemonStatusProvider({
+        env: secondaryEnv.effectiveEnv
+      });
+      const secondaryBridgeFsFactory = runtime.resolveBridgeFsFactory({
+        boundWorkspaces: [workspaceInput.cwd],
+        trusted: secondaryTrusted,
+        emit: deps.fsAuditEmit,
+        pathLocks: sharedPathLocks,
+        ...customIgnoreFiles !== void 0 ? { customIgnoreFiles } : {}
+      });
+      const secondaryChannelFactory = runtime.createSpawnChannelFactory({
+        sourceEnv: secondaryEnv.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 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 } : {},
+        ...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: workspaceInput.cwd,
+        sessionShellCommandEnabled,
+        childEnvOverrides,
+        channelFactory: secondaryChannelFactory,
+        onDiagnosticLine: diagnosticSink,
+        telemetry: createRuntimeBridgeTelemetry(secondaryWorkspaceHash),
+        ...permissionPolicy !== void 0 ? { permissionPolicy } : {},
+        ...permissionConsensusQuorum !== void 0 ? {
+          permissionConsensusQuorum
+        } : {},
+        permissionAudit: permissionAuditPublisher,
+        statusProvider: secondaryStatusProvider,
+        fileSystem: createBridgeFileSystemAdapter(secondaryBridgeFsFactory),
+        persistApprovalMode: /* @__PURE__ */ __name((workspace, mode) => withSettingsLock(workspace, async () => {
+          const fresh = settingsRuntime.settings.loadSettings(workspace);
+          fresh.setValue(WORKSPACE_SETTING_SCOPE, "tools.approvalMode", mode);
+        }), "persistApprovalMode")
+      });
+      secondaryBridgeRef = secondaryBridge;
+      runtimeBridges.push(secondaryBridge);
+      internalRuntimeBridgesForCleanup.push(secondaryBridge);
+      subSessionStoppers.push(secondarySubSessionLauncher.stop);
+      const secondaryWorkspaceService = runtime.createDaemonWorkspaceService({
+        boundWorkspace: workspaceInput.cwd,
+        contextFilename: contextFilenameForInit ?? "QWEN.md",
+        statusProvider: secondaryStatusProvider,
+        workspaceProvidersStatusProvider: runtime.createWorkspaceProvidersStatusProvider({
+          env: secondaryEnv.effectiveEnv
+        }),
+        workspaceSkillsStatusProvider: runtime.createWorkspaceSkillsStatusProvider(),
+        isChannelLive: /* @__PURE__ */ __name(() => secondaryBridge.isChannelLive(), "isChannelLive"),
+        preheatAcpChild: /* @__PURE__ */ __name(() => secondaryBridge.preheat(), "preheatAcpChild"),
+        persistDisabledTools: persistDisabledToolsFn,
+        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);
+            secondaryEnv.replace(refreshedRuntimeEnv.effectiveEnv);
+            secondaryEnv.metadata.envFileReadFailed = refreshedRuntimeEnv.envFileReadFailed;
+            secondaryEnv.metadata.envFileReadFailures.splice(
+              0,
+              secondaryEnv.metadata.envFileReadFailures.length,
+              ...refreshedRuntimeEnv.envFileReadFailures
+            );
+            secondaryEnv.metadata.overlayKeys.splice(
+              0,
+              secondaryEnv.metadata.overlayKeys.length,
+              ...refreshedRuntimeEnv.overlayKeys
+            );
+            secondaryEnv.metadata.envFilePaths.splice(
+              0,
+              secondaryEnv.metadata.envFilePaths.length,
+              ...refreshedRuntimeEnv.envFilePaths
+            );
+            delete secondaryEnv.metadata.fallbackReason;
+          } catch (err) {
+            secondaryEnv.metadata.fallbackReason = err instanceof Error ? err.message : String(err);
+            daemonLog.warn(
+              "failed to rebuild secondary runtime env snapshot after daemon env reload; preserving previous runtime env",
+              {
+                workspace,
+                error: secondaryEnv.metadata.fallbackReason
+              }
+            );
+          }
+          return result;
+        }), "reloadDaemonEnv"),
+        queryWorkspaceStatus: /* @__PURE__ */ __name((method, idle) => secondaryBridge.queryWorkspaceStatus(method, idle), "queryWorkspaceStatus"),
+        invokeWorkspaceCommand: /* @__PURE__ */ __name((method, params, invokeOpts) => secondaryBridge.invokeWorkspaceCommand(method, params, invokeOpts), "invokeWorkspaceCommand"),
+        refreshExtensionsForAllSessions: /* @__PURE__ */ __name(() => secondaryBridge.refreshExtensionsForAllSessions(), "refreshExtensionsForAllSessions"),
+        publishWorkspaceEvent: /* @__PURE__ */ __name((event) => secondaryBridge.publishWorkspaceEvent(event), "publishWorkspaceEvent")
+      });
+      workspaceRuntimes.push({
+        workspaceId: secondaryWorkspaceHash,
+        workspaceCwd: workspaceInput.cwd,
+        primary: false,
+        trusted: secondaryTrusted,
+        env: secondaryEnv.metadata,
+        bridge: secondaryBridge,
+        workspaceService: secondaryWorkspaceService,
+        routeFileSystemFactory: secondaryBridgeFsFactory,
+        clientMcpSenderRegistry: secondaryClientMcpSenderRegistry
+      });
+    }
+    const workspaceRegistry = runtime.createWorkspaceRegistry(workspaceRuntimes, {
+      sessionOwnerIndex
+    });
     core.registerDaemonGaugeCallbacks({
-      sessionCount: /* @__PURE__ */ __name(() => bridge.sessionCount, "sessionCount"),
+      sessionCount: /* @__PURE__ */ __name(() => workspaceRegistry.list().reduce((sum, item) => sum + item.bridge.sessionCount, 0), "sessionCount"),
       sseCount: /* @__PURE__ */ __name(() => runtime.getActiveSseCount(), "sseCount"),
       heapUsed: /* @__PURE__ */ __name(() => process.memoryUsage().heapUsed, "heapUsed")
     });
@@ -2397,9 +2957,15 @@ async function runQwenServe(optsIn, deps = {}) {
           cpuPercent,
           rssBytes: mem.rss,
           heapUsedBytes: mem.heapUsed,
-          activeSessions: bridge.sessionCount,
-          activePrompts: bridge.activePromptCount,
-          queuedPrompts: bridge.pendingPromptTotal ?? 0,
+          activeSessions: workspaceRegistry.list().reduce((sum, item) => sum + item.bridge.sessionCount, 0),
+          activePrompts: workspaceRegistry.list().reduce(
+            (sum, item) => sum + (item.bridge.activePromptCount ?? 0),
+            0
+          ),
+          queuedPrompts: workspaceRegistry.list().reduce(
+            (sum, item) => sum + (item.bridge.pendingPromptTotal ?? 0),
+            0
+          ),
           eventLoopLagP99Ms,
           sseConnections: runtime.getActiveSseCount(),
           wsConnections: acp?.wsStreams ?? 0,
@@ -2441,7 +3007,163 @@ 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
+      });
+      const 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")
+      });
+      wsBridgeRef = wsBridge;
+      const wsService = runtime.createDaemonWorkspaceService({
+        boundWorkspace: cwd,
+        contextFilename: contextFilenameForInit ?? "QWEN.md",
+        statusProvider: runtime.createDaemonStatusProvider({
+          env: wsEnv.effectiveEnv
+        }),
+        workspaceProvidersStatusProvider: runtime.createWorkspaceProvidersStatusProvider({
+          env: wsEnv.effectiveEnv
+        }),
+        workspaceSkillsStatusProvider: runtime.createWorkspaceSkillsStatusProvider(),
+        isChannelLive: /* @__PURE__ */ __name(() => wsBridge.isChannelLive(), "isChannelLive"),
+        preheatAcpChild: /* @__PURE__ */ __name(() => wsBridge.preheat(), "preheatAcpChild"),
+        persistDisabledTools: persistDisabledToolsFn,
+        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")
+      });
+      runtimeBridges.push(wsBridge);
+      internalRuntimeBridgesForCleanup.push(wsBridge);
+      subSessionStoppers.push(wsSubSessionLauncher.stop);
+      return {
+        workspaceId: wsHash,
+        workspaceCwd: cwd,
+        primary: false,
+        trusted,
+        env: wsEnv.metadata,
+        bridge: wsBridge,
+        workspaceService: wsService,
+        routeFileSystemFactory: wsFsFactory,
+        clientMcpSenderRegistry: wsClientMcpRegistry
+      };
+    }, "createDynamicWorkspaceRuntime");
     const app2 = runtime.createServeApp(opts, () => actualPort, {
+      workspaceRegistry,
+      createWorkspaceRuntime: createDynamicWorkspaceRuntime,
       bridge,
       webShellDir,
       boundWorkspace,
@@ -2451,18 +3173,16 @@ async function runQwenServe(optsIn, deps = {}) {
       // (keepalive) and reloads them on boot (rehydration). Off by default so
       // direct createServeApp embeds/tests don't spawn sessions.
       manageScheduledTaskSessions: true,
-      fsFactory: runtime.resolveBridgeFsFactory({
-        // REST routes still return primary-relative paths, so keep their
-        // filesystem boundary primary-only until responses carry root IDs.
-        boundWorkspaces: [boundWorkspace],
-        trusted: trustedWorkspace,
-        emit: deps.fsAuditEmit,
-        pathLocks: sharedPathLocks,
-        ...customIgnoreFiles !== void 0 ? { customIgnoreFiles } : {}
-      }),
+      fsFactory: routeFsFactory,
       primaryWorkspaceTrusted: trustedWorkspace,
+      primaryRuntimeEnv,
       daemonLog,
       getChannelWorkerSnapshot,
+      enqueueChannelWebhookTask: /* @__PURE__ */ __name((task) => channelWorker.enqueueWebhookTask(task), "enqueueChannelWebhookTask"),
+      // Gate both the `channel_reload` capability and the reload route on the
+      // presence of this dep, so it is advertised only when a channel worker
+      // exists to reload.
+      ...opts.channelSelection ? { reloadChannelWorker } : {},
       getPerfSnapshot: /* @__PURE__ */ __name(() => ({
         eventLoop: currentDaemonEventLoopMonitor.snapshot(),
         promptQueueWait: {
@@ -2477,6 +3197,7 @@ async function runQwenServe(optsIn, deps = {}) {
         }
       }), "getPerfSnapshot"),
       getMetricsSeries: /* @__PURE__ */ __name(() => metricsRing.snapshot(), "getMetricsSeries"),
+      getTotalSessionAdmissionSnapshot: totalSessionAdmission.snapshot,
       recordDaemonRequest: /* @__PURE__ */ __name((durationMs, statusCode) => metricsRing.recordRequest(durationMs, statusCode), "recordDaemonRequest"),
       workspace: workspaceService,
       // Reverse tool channel (#5626): the SAME registry wired into `bridge` above,
@@ -2485,6 +3206,9 @@ async function runQwenServe(optsIn, deps = {}) {
       persistDisabledTools: persistDisabledToolsFn,
       persistSetting: persistSettingFn,
       persistSettings: persistSettingsFn,
+      sessionArtifactsPersistenceAvailable: sessionArtifactsPersistenceAvailableFromSettings(
+        runtimeBootSettings?.merged
+      ),
       installAuthProvider: /* @__PURE__ */ __name((req) => withSettingsLock(
         boundWorkspace,
         async () => {
@@ -2523,6 +3247,8 @@ async function runQwenServe(optsIn, deps = {}) {
         }
       ), "installAuthProvider")
     });
+    app2.locals.subSessionStoppers = subSessionStoppers;
+    subSessionStoppers.push(subSessionLauncher.stop);
     return { app: app2, bridge };
   }, "buildRuntime");
   if (deps.bridge) {
@@ -2544,16 +3270,24 @@ async function runQwenServe(optsIn, deps = {}) {
     daemonLog,
     qwenCodeVersion: cliVersion,
     sessionShellCommandEnabled,
+    sessionArtifactsPersistenceAvailable,
     permissionPolicy,
+    multiWorkspaceCapabilitiesRequireRuntime: workspaceInputs.length > 1,
     getRuntimeError: /* @__PURE__ */ __name(() => runtimeStartupError, "getRuntimeError"),
     getChannelWorkerSnapshot,
     onHealthServed: deferRuntimeUntilFirstHealth ? () => startRuntimeAfterHealth?.() : void 0
   });
+  const deferredChannelWebhookAuth = deferRuntimeUntilFirstHealth ? createDeferredChannelWebhookAuth(
+    boundWorkspace,
+    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("[")) {
@@ -2591,7 +3325,8 @@ async function runQwenServe(optsIn, deps = {}) {
       try {
         if (opts.channelSelection) {
           const createSupervisor = deps.channelWorkerSupervisorFactory ?? channelRuntime?.createChannelWorkerSupervisor;
-          if (!createSupervisor) {
+          const findCliEntryPath = channelRuntime?.findCliEntryPath;
+          if (!createSupervisor || !findCliEntryPath) {
             throw new Error(
               "Channel worker supervisor runtime is not available."
             );
@@ -2694,6 +3429,8 @@ async function runQwenServe(optsIn, deps = {}) {
       }, "cancelDeferredRuntimeStartup");
       const shutdownBridgeAfterFailedStartup = /* @__PURE__ */ __name(async (bridge) => {
         if (!bridge || deps.bridge) return;
+        if (shutdownBridges.has(bridge)) return;
+        shutdownBridges.add(bridge);
         try {
           await bridge.shutdown();
         } catch (shutdownErr) {
@@ -2734,7 +3471,10 @@ async function runQwenServe(optsIn, deps = {}) {
         await stopChannelWorkerAfterFailedStartup();
         disposeDaemonEventLoopMonitor();
         removeCurrentServePidfile();
-        await shutdownBridgeAfterFailedStartup(bridgeForCleanup ?? bridgeRef);
+        const bridgesForCleanup = bridgeForCleanup ? [bridgeForCleanup, ...getRuntimeBridgesForCleanup()] : getRuntimeBridgesForCleanup();
+        for (const bridge of [...new Set(bridgesForCleanup)]) {
+          await shutdownBridgeAfterFailedStartup(bridge);
+        }
         markRuntimeFailed(error);
       }, "failRuntimeStartup");
       const armRuntimeStartupTimer = /* @__PURE__ */ __name(() => {
@@ -2843,7 +3583,9 @@ async function runQwenServe(optsIn, deps = {}) {
           daemonLog.warn(`received ${signal} during drain \u2014 forcing exit`);
           try {
             channelWorker.killAllSync();
-            bridgeRef?.killAllSync();
+            for (const runtimeBridge of getRuntimeBridgesForCleanup()) {
+              runtimeBridge.killAllSync();
+            }
             removeCurrentServePidfile();
           } catch (err) {
             daemonLog.error(
@@ -2885,6 +3627,10 @@ async function runQwenServe(optsIn, deps = {}) {
           closePromise = new Promise((res, rej) => {
             shuttingDown = true;
             app.locals.stopScheduledTaskKeepalive?.();
+            const stoppers = app.locals.subSessionStoppers;
+            if (stoppers) {
+              for (const stop of stoppers) stop();
+            }
             clearRuntimeStartAfterHealthTimer();
             clearRuntimeStartFallbackTimer();
             cancelDeferredRuntimeStartup();
@@ -2954,8 +3700,9 @@ async function runQwenServe(optsIn, deps = {}) {
                 );
               });
               removeCurrentServePidfile();
-              const bridgeForShutdown = bridgeRef;
-              if (bridgeForShutdown) {
+              for (const bridgeForShutdown of getRuntimeBridgesForCleanup()) {
+                if (shutdownBridges.has(bridgeForShutdown)) continue;
+                shutdownBridges.add(bridgeForShutdown);
                 await bridgeForShutdown.shutdown().catch((err) => {
                   daemonLog.error(
                     "bridge shutdown error",
@@ -3034,8 +3781,8 @@ async function runQwenServe(optsIn, deps = {}) {
       }
     }, "onListening");
     let server;
+    let httpsServer;
     if (tlsOptions) {
-      let httpsServer;
       try {
         httpsServer = https.createServer(tlsOptions, app);
       } catch (err) {
@@ -3046,19 +3793,46 @@ async function runQwenServe(optsIn, deps = {}) {
         );
         return;
       }
-      server = httpsServer.listen(opts.port, listenHostname, onListening);
-    } else {
-      server = app.listen(opts.port, listenHostname, onListening);
     }
-    server.once("error", (err) => {
-      removeCurrentServePidfile();
-      reject(err);
-    });
+    const tryListen = /* @__PURE__ */ __name((attemptPort, attempt) => {
+      try {
+        if (httpsServer) {
+          httpsServer.removeAllListeners("listening");
+          server = httpsServer.listen(attemptPort, listenHostname, onListening);
+        } else {
+          server = app.listen(attemptPort, listenHostname, onListening);
+        }
+      } catch (err) {
+        removeCurrentServePidfile();
+        reject(err instanceof Error ? err : new Error(String(err)));
+        return;
+      }
+      server.once("error", (err) => {
+        server.close();
+        const nextPort = attemptPort + 1;
+        if (err.code === "EADDRINUSE" && opts.port !== 0 && nextPort <= 65535 && attempt < MAX_PORT_ATTEMPTS - 1) {
+          writeStderrLine(
+            `qwen serve: port ${attemptPort} is in use, trying ${nextPort}...`
+          );
+          tryListen(nextPort, attempt + 1);
+        } else {
+          if (err.code === "EADDRINUSE" && attempt > 0) {
+            writeStderrLine(
+              `qwen serve: all ports ${opts.port}\u2013${attemptPort} are in use`
+            );
+          }
+          removeCurrentServePidfile();
+          reject(err);
+        }
+      });
+    }, "tryListen");
+    tryListen(opts.port, 0);
   });
 }
 __name(runQwenServe, "runQwenServe");
 export {
   InvalidPolicyConfigError,
+  createDisabledChannelWorkerSupervisor,
   createLazyBridgeProxy,
   extractContextFilename,
   formatChannelWorkerDaemonUrl,