@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260710.205430235

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

@@ -7,9 +7,6 @@ import {
 import {
   findCliEntryPath
 } from "./chunk-AHNXYU4O.js";
-import {
-  RUNTIME_STARTUP_CANCELLED_MESSAGE
-} from "./chunk-GHOTR7HL.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
   ClientMcpSenderRegistry,
@@ -25,22 +22,41 @@ import {
   getRateLimiter,
   getServeProtocolVersions,
   hostAllowlist,
+  isBrowserAutomationMcpAvailable,
   listenerMaxConnections,
   parseAllowOriginPatterns,
   parseDaemonStatusDetail,
   positiveFiniteOrNull,
   require_express,
   resolveWebShellDir
-} from "./chunk-RFIL6REB.js";
+} from "./chunk-GRB4QSBD.js";
 import {
   isLoopbackBind
 } from "./chunk-RNBYOUGV.js";
 import "./chunk-3HX5LZ6R.js";
 import "./chunk-7RYW5LQV.js";
+import {
+  RUNTIME_STARTUP_CANCELLED_MESSAGE
+} from "./chunk-GHOTR7HL.js";
+import {
+  LOAD_REPLAY_META_KEY
+} from "./chunk-AGHU5VRK.js";
+import {
+  canonicalizeWorkspace
+} from "./chunk-ER3BKOLB.js";
+import {
+  DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
+  normalizeCompactedReplayMaxBytes
+} from "./chunk-GLE2YUPU.js";
 import {
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-DNV4FSN5.js";
+} from "./chunk-I5XN6KDI.js";
+import {
+  getGlobalQwenDirLite,
+  resolveConfigPathLite
+} from "./chunk-O2YT7VB4.js";
+import "./chunk-Z3I3QJK3.js";
 import {
   QWEN_SERVER_TOKEN_ENV
 } from "./chunk-S6RLAIUR.js";
@@ -48,26 +64,16 @@ import {
   channelSelectionNames
 } from "./chunk-MX2YXRER.js";
 import {
-  getGlobalQwenDirLite,
-  resolveConfigPathLite
-} from "./chunk-4RQIB5UZ.js";
-import {
-  LOAD_REPLAY_META_KEY
-} from "./chunk-AGHU5VRK.js";
-import {
-  canonicalizeWorkspace
-} from "./chunk-ER3BKOLB.js";
+  isWithinRoot
+} from "./chunk-QYUE6W3T.js";
 import {
   getCliVersion
-} from "./chunk-GD236YPV.js";
+} from "./chunk-4ONWIT5C.js";
 import "./chunk-43W4YSO6.js";
 import {
   writeStderrLine,
   writeStdoutLine
-} from "./chunk-Y6Z2O3WR.js";
-import {
-  isWithinRoot
-} from "./chunk-QYUE6W3T.js";
+} from "./chunk-JM7BYJO5.js";
 import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
 import "./chunk-UWCTAVOD.js";
@@ -105,7 +111,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 +122,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 +151,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 +159,7 @@ function rejectUnsupportedMultiWorkspaceInputs(workspaces) {
       (workspace) => canonicalizeWorkspace(workspace)
     );
   } catch {
-    throw new MultipleWorkspaceInputError();
+    return;
   }
   const seen = /* @__PURE__ */ new Set();
   for (const workspace of canonicalWorkspaces) {
@@ -185,15 +180,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 +933,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 +1075,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,8 +1090,8 @@ __name(withSettingsLock, "withSettingsLock");
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-CRCVYQIE.js"),
-    import("./pidfile-LIBUENIV.js")
+    import("./channel-worker-supervisor-OPXXT4JK.js"),
+    import("./pidfile-LJ3NLS2P.js")
   ]).then(([supervisor, pidfile]) => ({
     createChannelWorkerSupervisor: supervisor.createChannelWorkerSupervisor,
     channelServicePidfile: pidfile
@@ -1105,6 +1113,9 @@ function createDisabledChannelWorkerSupervisor() {
     },
     async stop() {
     },
+    async restart() {
+      return { ...snapshot, channels: [] };
+    },
     killAllSync() {
     },
     snapshot: /* @__PURE__ */ __name(() => ({ ...snapshot, channels: [] }), "snapshot")
@@ -1154,7 +1165,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-XKZMNHXS.js");
+  coreRuntimePromise ??= import("./src-NELBIIGI.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -1184,11 +1195,13 @@ __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-W3IX7NHK.js"),
+    import("./environment-2CJAFOFN.js"),
+    import("./loadedSettingsAdapter-EHTUJRFB.js"),
+    import("./trustedFolders-IT4JBNPG.js")
+  ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
+    environment,
     loadedSettingsAdapter,
     trustedFolders
   }));
@@ -1204,16 +1217,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("./server-6HK5FJMR.js"),
+    import("./bridge-HVPFYNM4.js"),
+    import("./spawnChannel-FTZJ3I5O.js"),
+    import("./workspace-service-SY3P3FUY.js"),
     import("./types-QX5C3CHJ.js"),
-    import("./daemon-status-provider-XSAFKVDS.js"),
-    import("./workspace-providers-status-MVYXMYDG.js"),
-    import("./workspace-skills-status-IMMQ7CAY.js")
+    import("./daemon-status-provider-3EPG6BXX.js"),
+    import("./workspace-providers-status-7DTOAWEL.js"),
+    import("./workspace-skills-status-GTT2A4WN.js"),
+    import("./total-session-admission-PRZK35X4.js"),
+    import("./workspace-registry-BBIPESIZ.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -1226,7 +1243,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 +1270,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) {
   return getAdvertisedServeFeatures(void 0, {
     requireAuth: opts.requireAuth === true,
     mcpPoolActive: opts.mcpPoolActive !== false,
@@ -1259,12 +1279,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,
     // 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,
+      process.env
+    )
   });
 }
 __name(currentServeFeaturesForRunQwenServe, "currentServeFeaturesForRunQwenServe");
@@ -1276,7 +1302,8 @@ function createBootstrapCapabilities(input) {
     mode: input.opts.mode,
     features: currentServeFeaturesForRunQwenServe(
       input.opts,
-      input.sessionShellCommandEnabled
+      input.sessionShellCommandEnabled,
+      input.sessionArtifactsPersistenceAvailable
     ),
     modelServices: [],
     workspaceCwd: input.boundWorkspace,
@@ -1421,7 +1448,9 @@ function createBootstrapServeApp(input) {
     daemonLog,
     qwenCodeVersion,
     sessionShellCommandEnabled,
+    sessionArtifactsPersistenceAvailable,
     permissionPolicy,
+    multiWorkspaceCapabilitiesRequireRuntime,
     getRuntimeError,
     getChannelWorkerSnapshot,
     onHealthServed
@@ -1458,12 +1487,24 @@ 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,
+        sessionArtifactsPersistenceAvailable,
         permissionPolicy
       })
     );
@@ -1518,11 +1559,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 +1576,8 @@ function createBootstrapServeApp(input) {
         protocolVersions: getServeProtocolVersions(),
         features: currentServeFeaturesForRunQwenServe(
           opts,
-          sessionShellCommandEnabled
+          sessionShellCommandEnabled,
+          sessionArtifactsPersistenceAvailable
         )
       },
       runtime: {
@@ -1663,6 +1707,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 +1731,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 +1878,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 "${workspace}": exists but is not a directory.`
+        );
+      }
+    } 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}": directory does not exist.`
+          `Nested --workspace values are not supported: ${JSON.stringify(second)} is inside ${JSON.stringify(first)}.`
         );
       }
-      if (code === "EACCES" || code === "EPERM") {
+      if (secondRel && !secondRel.startsWith("..") && !path.isAbsolute(secondRel)) {
         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(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 +2010,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 +2031,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 +2069,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 +2110,7 @@ async function runQwenServe(optsIn, deps = {}) {
   let runtimeApp;
   let runtimeAppForCleanup;
   let bridgeRef = deps.bridge;
+  const internalRuntimeBridgesForCleanup = [];
   let daemonEventLoopMonitor;
   let daemonMetricsSampler;
   let runtimeStartupError;
@@ -2029,6 +2135,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 +2154,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 +2191,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 +2300,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 +2398,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 +2421,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 +2483,22 @@ async function runQwenServe(optsIn, deps = {}) {
         );
       }
     }), "persistSettingsFn");
+    const { createSubSessionLauncher } = await import("./create-sub-session-EVYZYAE3.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 +2521,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 +2534,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 +2858,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,
@@ -2442,6 +2909,7 @@ async function runQwenServe(optsIn, deps = {}) {
       }
     };
     const app2 = runtime.createServeApp(opts, () => actualPort, {
+      workspaceRegistry,
       bridge,
       webShellDir,
       boundWorkspace,
@@ -2451,18 +2919,15 @@ 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,
+      // 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 +2942,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 +2951,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 +2992,8 @@ async function runQwenServe(optsIn, deps = {}) {
         }
       ), "installAuthProvider")
     });
+    app2.locals.subSessionStoppers = subSessionStoppers;
+    subSessionStoppers.push(subSessionLauncher.stop);
     return { app: app2, bridge };
   }, "buildRuntime");
   if (deps.bridge) {
@@ -2544,7 +3015,9 @@ 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
@@ -2694,6 +3167,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 +3209,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 +3321,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 +3365,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 +3438,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 +3519,8 @@ async function runQwenServe(optsIn, deps = {}) {
       }
     }, "onListening");
     let server;
+    let httpsServer;
     if (tlsOptions) {
-      let httpsServer;
       try {
         httpsServer = https.createServer(tlsOptions, app);
       } catch (err) {
@@ -3046,14 +3531,40 @@ 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");