@qwen-code/qwen-code 0.24.2 → 0.24.3

package/chunks/{run-qwen-serve-7JVXBD5X.js → run-qwen-serve-6GXQP7DD.js}

@@ -7,12 +7,12 @@ import {
   hostAssignsIpv6Loopback,
   isOwnInterfaceAddress
 } from "./chunk-24FVUD5P.js";
-import {
-  RUNTIME_STARTUP_CANCELLED_MESSAGE
-} from "./chunk-QUPXZXLV.js";
 import {
   resolveRemoteServeToken
 } from "./chunk-F23YN37B.js";
+import {
+  RUNTIME_STARTUP_CANCELLED_MESSAGE
+} from "./chunk-QUPXZXLV.js";
 import {
   ACCESS_LOG_CONTROLLER_LOCAL,
   CAPABILITIES_SCHEMA_VERSION,
@@ -51,7 +51,7 @@ import {
   prepareManagedScratchRoot,
   resolveAcpHttpEnabled,
   toDaemonStatusMemoryLimits
-} from "./chunk-3GH6T7SH.js";
+} from "./chunk-OOBJCVOC.js";
 import {
   ConversationDirectoryIdentityError,
   assertExactConversationRootIdentity,
@@ -64,24 +64,28 @@ import {
   materializeConversationDirectoryIdentity,
   revalidateConversationRootIdentity
 } from "./chunk-PB7JBAHF.js";
-import {
-  setDeferredRuntimeRequestTiming
-} from "./chunk-LAUEEBDL.js";
 import {
   formatHostForAuthority,
   isLoopbackAddress,
   isLoopbackBind
 } from "./chunk-DMEUXLSS.js";
+import {
+  setDeferredRuntimeRequestTiming
+} from "./chunk-LAUEEBDL.js";
 import {
   normalizeSessionIdForLookup
 } from "./chunk-ZEZKIS2K.js";
 import {
   require_express
-} from "./chunk-MOWCV77B.js";
+} from "./chunk-2FZL7GEG.js";
 import {
   resolveWebShellDir
 } from "./chunk-FBX2SDQ4.js";
 import "./chunk-NYWWQ437.js";
+import {
+  ConversationRuntimeOwnershipError,
+  LIVE_HOST_PROTOCOL_VERSION
+} from "./chunk-TBUYRX6R.js";
 import {
   resolveSessionRestoreTimeoutMs
 } from "./chunk-4JRM2BSM.js";
@@ -106,29 +110,25 @@ import {
   resolveChannelCwd
 } from "./chunk-VGLXXHTF.js";
 import {
-  ConversationRuntimeOwnershipError,
-  LIVE_HOST_PROTOCOL_VERSION
-} from "./chunk-TBUYRX6R.js";
+  assertChannelControlWorkspaceCapacity
+} from "./chunk-VT3MGD7H.js";
+import {
+  LOAD_REPLAY_META_KEY
+} from "./chunk-FL4QZ67W.js";
+import "./chunk-OY4DP3XV.js";
 import "./chunk-CKXUWR6I.js";
 import "./chunk-TZBFVXNX.js";
 import {
   consumeServeFastPathRejectedLoaderKeys,
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-BJEZBTUO.js";
-import "./chunk-BIQXRY5B.js";
+} from "./chunk-TUYJ6S3L.js";
+import "./chunk-W4T4DHDJ.js";
 import {
   resolveMaxRegisteredWorkspaces,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-FSEZM6ZQ.js";
-import {
-  assertChannelControlWorkspaceCapacity
-} from "./chunk-HYLPVFWL.js";
-import {
-  LOAD_REPLAY_META_KEY
-} from "./chunk-FL4QZ67W.js";
-import "./chunk-OY4DP3XV.js";
+} from "./chunk-DACSVV23.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
@@ -136,19 +136,19 @@ import {
 import {
   ExtraCaInspectionError,
   loadableCertificates
-} from "./chunk-I2GU2HMQ.js";
+} from "./chunk-M6SELBSG.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-Z7B6SRPM.js";
 import {
   ChannelWebhookEnqueueError
 } from "./chunk-STUJ7IMZ.js";
+import {
+  QWEN_SERVER_TOKEN_ENV
+} from "./chunk-GYTKQYDB.js";
 import {
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
 } from "./chunk-X2R47SFR.js";
-import {
-  QWEN_SERVER_TOKEN_ENV
-} from "./chunk-GYTKQYDB.js";
 import {
   channelSelectionNames,
   normalizeServeChannelSelection
@@ -158,9 +158,6 @@ import {
   isChannelDeliveryError
 } from "./chunk-RKFGE7JH.js";
 import "./chunk-UDG5EZJI.js";
-import {
-  redactLogCredentials
-} from "./chunk-M5GB774H.js";
 import {
   EXTERNAL_TOOL_GUARD_PROVIDER_ATTACHED_VALUE,
   EXTERNAL_TOOL_GUARD_REQUIRED_VALUE,
@@ -168,6 +165,9 @@ import {
   PRIVATE_EXTERNAL_TOOL_GUARD_ENV,
   PRIVATE_EXTERNAL_TOOL_GUARD_PROVIDER_ENV
 } from "./chunk-3VUENPWF.js";
+import {
+  redactLogCredentials
+} from "./chunk-M5GB774H.js";
 import {
   sanitizeLogText
 } from "./chunk-YWZOEHBT.js";
@@ -189,7 +189,7 @@ import {
 } from "./chunk-6V4XP46I.js";
 import {
   getCliVersion
-} from "./chunk-4XNECBYG.js";
+} from "./chunk-5GYRIOWK.js";
 import "./chunk-2RJJSLCF.js";
 import "./chunk-NPQ5ZKRP.js";
 import {
@@ -202,18 +202,20 @@ import {
 } from "./chunk-32CM56LO.js";
 import "./chunk-LJZSMWOH.js";
 import "./chunk-GOFAQQZA.js";
-import "./chunk-65I7S4Z3.js";
+import "./chunk-CHBZHMBA.js";
+import "./chunk-4M7RD5QQ.js";
 import "./chunk-HEOH7JZY.js";
-import "./chunk-TWPJO254.js";
 import "./chunk-XIOVKC72.js";
+import "./chunk-ELYIK7SN.js";
+import "./chunk-TWPJO254.js";
 import {
   require_proper_lockfile
 } from "./chunk-VNTJJ4WQ.js";
 import "./chunk-XWRJCPHC.js";
-import "./chunk-5ETULJLP.js";
 import {
   MEMORY_PROJECT_SCOPES
 } from "./chunk-HD7O6WLV.js";
+import "./chunk-5ETULJLP.js";
 import {
   TraceFlags,
   init_esm,
@@ -3036,6 +3038,15 @@ function resolveChannelWorkspaceGroups(input) {
     );
   }
   const namesByWorkspace = /* @__PURE__ */ new Map();
+  const skipped = [];
+  const { preferredOwners, tolerant } = input;
+  const reject = /* @__PURE__ */ __name((name, code, message) => {
+    if (!tolerant?.has(name)) {
+      return { ok: false, error: { code, channel: name, message } };
+    }
+    skipped.push({ code, channel: name, message });
+    return void 0;
+  }, "reject");
   for (const name of selection.names) {
     const owners = [];
     for (const workspace of workspaces) {
@@ -3055,37 +3066,39 @@ function resolveChannelWorkspaceGroups(input) {
       }
     }
     if (owners.length === 0) {
-      return {
-        ok: false,
-        error: {
-          code: "channel_workspace_mismatch",
-          channel: name,
-          message: `Channel "${name}" is not configured in any registered workspace, or its "cwd" points outside them.`
-        }
-      };
+      const rejected = reject(
+        name,
+        "channel_workspace_mismatch",
+        `Channel "${name}" is not configured in any registered workspace, or its "cwd" points outside them.`
+      );
+      if (rejected) return rejected;
+      continue;
     }
+    let owner = owners[0];
     if (owners.length > 1) {
-      return {
-        ok: false,
-        error: {
-          code: "ambiguous_channel_workspace",
-          channel: name,
-          message: `Channel "${name}" is configured in multiple registered workspaces (${owners.map((owner2) => owner2.workspaceCwd).join(
+      const preferred = preferredOwners?.get(name);
+      const hinted = preferred === void 0 ? void 0 : owners.find((candidate) => candidate.workspaceCwd === preferred);
+      if (!hinted) {
+        const rejected = reject(
+          name,
+          "ambiguous_channel_workspace",
+          `Channel "${name}" is configured in multiple registered workspaces (${owners.map((candidate) => candidate.workspaceCwd).join(
             ", "
           )}). Define it in one workspace's settings or set an explicit "cwd".`
-        }
-      };
+        );
+        if (rejected) return rejected;
+        continue;
+      }
+      owner = hinted;
     }
-    const owner = owners[0];
     if (!owner.trusted) {
-      return {
-        ok: false,
-        error: {
-          code: "untrusted_workspace",
-          channel: name,
-          message: `Channel "${name}" targets untrusted workspace "${owner.workspaceCwd}".`
-        }
-      };
+      const rejected = reject(
+        name,
+        "untrusted_workspace",
+        `Channel "${name}" targets untrusted workspace "${owner.workspaceCwd}".`
+      );
+      if (rejected) return rejected;
+      continue;
     }
     const names = namesByWorkspace.get(owner.workspaceCwd) ?? [];
     names.push(name);
@@ -3096,11 +3109,138 @@ function resolveChannelWorkspaceGroups(input) {
     groups: [...namesByWorkspace.entries()].map(([workspaceCwd, names]) => ({
       workspaceCwd,
       selection: { mode: "names", names }
-    }))
+    })),
+    // Omitted when nothing was skipped so a caller that never passes
+    // `tolerant` keeps seeing the exact result shape it saw before.
+    ...skipped.length > 0 ? { skipped } : {}
   };
 }
 __name(resolveChannelWorkspaceGroups, "resolveChannelWorkspaceGroups");
 
+// packages/cli/src/serve/channel-startup-restore.ts
+init_esbuild_shims();
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(errorMessage, "errorMessage");
+function isUsableEntry(name) {
+  return Boolean(name) && name === name.trim() && sanitizeLogText(name, name.length) === name;
+}
+__name(isUsableEntry, "isUsableEntry");
+function resolveStartupChannelSelection(input) {
+  const diagnostics = [];
+  const claimsByName = /* @__PURE__ */ new Map();
+  const names = [];
+  let primaryAllWorkspace;
+  for (const workspace of input.workspaces) {
+    const workspaceCwd = workspace.workspaceCwd;
+    let raw;
+    try {
+      raw = input.loadStartupChannels(workspaceCwd);
+    } catch (error) {
+      diagnostics.push({
+        code: "settings_unreadable",
+        workspaceCwd,
+        message: errorMessage(error)
+      });
+      continue;
+    }
+    if (raw === void 0) continue;
+    if (!Array.isArray(raw) || !raw.every((name) => typeof name === "string")) {
+      diagnostics.push({
+        code: "invalid_setting",
+        workspaceCwd,
+        message: "serve.channels must be a string array."
+      });
+      continue;
+    }
+    const entries = raw.filter((name, index) => {
+      if (isUsableEntry(name)) return true;
+      diagnostics.push({
+        code: "invalid_entry",
+        workspaceCwd,
+        // Keep the operator-facing wording the single-workspace restore has
+        // always logged; the workspace it came from is a log field.
+        message: `ignored invalid workspace serve.channels entry at index ${index}`
+      });
+      return false;
+    });
+    let selection;
+    try {
+      selection = normalizeServeChannelSelection(entries, "serve.channels");
+    } catch (error) {
+      diagnostics.push({
+        code: "invalid_setting",
+        workspaceCwd,
+        message: errorMessage(error)
+      });
+      continue;
+    }
+    if (!selection) continue;
+    if (selection.mode === "all") {
+      if (workspace.primary) {
+        primaryAllWorkspace = workspaceCwd;
+        continue;
+      }
+      diagnostics.push({
+        code: "all_is_primary_only",
+        workspaceCwd,
+        message: `serve.channels selection "all" is primary-workspace only; workspace "${workspaceCwd}" was not restored.`
+      });
+      continue;
+    }
+    for (const name of selection.names) {
+      const claims = claimsByName.get(name);
+      if (claims) {
+        claims.push({ workspaceCwd, primary: workspace.primary });
+        continue;
+      }
+      claimsByName.set(name, [{ workspaceCwd, primary: workspace.primary }]);
+      names.push(name);
+    }
+  }
+  if (primaryAllWorkspace !== void 0) {
+    if (names.length > 0) {
+      diagnostics.push({
+        code: "all_is_primary_only",
+        workspaceCwd: primaryAllWorkspace,
+        message: `serve.channels selection "all" is primary-workspace only; channels listed by other workspaces were not restored: ${names.join(
+          ", "
+        )}.`
+      });
+    }
+    return {
+      selection: { mode: "all" },
+      ownerHints: /* @__PURE__ */ new Map(),
+      tolerantNames: /* @__PURE__ */ new Set(),
+      diagnostics
+    };
+  }
+  const ownerHints = /* @__PURE__ */ new Map();
+  const tolerantNames = /* @__PURE__ */ new Set();
+  for (const [name, claims] of claimsByName) {
+    if (claims.length > 1) {
+      diagnostics.push({
+        code: "claimed_by_multiple_workspaces",
+        workspaceCwd: claims[0].workspaceCwd,
+        channel: name,
+        message: `Channel "${name}" is listed in the serve.channels of several workspaces (${claims.map((claim) => claim.workspaceCwd).join(", ")}); its owner is resolved from the channel config alone.`
+      });
+    }
+    if (claims.every((claim) => !claim.primary)) tolerantNames.add(name);
+    if (claims.length === 1 && !claims[0].primary) {
+      ownerHints.set(name, claims[0].workspaceCwd);
+    }
+  }
+  return {
+    selection: names.length > 0 ? { mode: "names", names } : void 0,
+    ownerHints,
+    tolerantNames,
+    diagnostics
+  };
+}
+__name(resolveStartupChannelSelection, "resolveStartupChannelSelection");
+
 // packages/cli/src/serve/run-qwen-serve.ts
 var QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV = "QWEN_SERVE_CLIENT_MCP_OVER_WS";
 var QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV = "QWEN_SERVE_CDP_TUNNEL_OVER_WS";
@@ -3946,12 +4086,12 @@ __name(hasRetryableChannelWorkerShutdownError, "hasRetryableChannelWorkerShutdow
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-KNSB6NQS.js"),
-    import("./pidfile-65TYNQZO.js"),
-    import("./runtime-SPDHMWL2.js"),
+    import("./channel-worker-supervisor-GGTS6MM5.js"),
+    import("./pidfile-3HRF6UJA.js"),
+    import("./runtime-PBC4QVLS.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-M4MSCXVZ.js"),
-    import("./channel-worker-manager-UEAF66Y2.js")
+    import("./channel-worker-group-EJEMLDPE.js"),
+    import("./channel-worker-manager-GI3GMPHV.js")
   ]).then(
     ([
       supervisor,
@@ -4058,7 +4198,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./core-runtime-7OWIKZP7.js");
+  coreRuntimePromise ??= import("./core-runtime-5KHWEMVQ.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -4094,10 +4234,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-WC7MAKFU.js"),
-    import("./environment-BHQMXGGR.js"),
-    import("./loadedSettingsAdapter-AVY5HFYC.js"),
-    import("./trustedFolders-4ANVY47B.js")
+    import("./settings-MI63DAKE.js"),
+    import("./environment-FXLJ7ENW.js"),
+    import("./loadedSettingsAdapter-BCWAHAEI.js"),
+    import("./trustedFolders-PGLKXLUG.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -4110,8 +4250,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-SPDHMWL2.js"),
-    import("./config-utils-A7FSZDCO.js")
+    import("./runtime-PBC4QVLS.js"),
+    import("./config-utils-3PL3OQOI.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -4138,19 +4278,19 @@ async function loadServeRuntimeModules() {
     workspaceRuntimeCoordinatorModule,
     promptLedgerModule
   ] = await Promise.all([
-    import("./server-LZDC5WLZ.js"),
-    import("./bridge-FPDMUBTB.js"),
-    import("./spawnChannel-DOUIQJXZ.js"),
+    import("./server-KQJAQD55.js"),
+    import("./bridge-GHWETITW.js"),
+    import("./spawnChannel-DMP56IUE.js"),
     import("./process-registry-MDKO6QY2.js"),
-    import("./workspace-service-LD63VWNX.js"),
+    import("./workspace-service-RJOV7URE.js"),
     import("./types-HKLPXZB3.js"),
-    import("./daemon-status-provider-MCQ3OGR5.js"),
-    import("./workspace-providers-status-ZNWPVLFH.js"),
-    import("./workspace-skills-status-OXAHXVR5.js"),
-    import("./total-session-admission-YBOZM7OG.js"),
-    import("./workspace-registry-YLT7CXIQ.js"),
-    import("./workspace-runtime-coordinator-VRJNYOYA.js"),
-    import("./prompt-terminal-ledger-SOHAMM2Z.js")
+    import("./daemon-status-provider-PCJP7L7Z.js"),
+    import("./workspace-providers-status-AA7TXXGS.js"),
+    import("./workspace-skills-status-TYYFTIPU.js"),
+    import("./total-session-admission-VXAFAHGR.js"),
+    import("./workspace-registry-7M2GJXVY.js"),
+    import("./workspace-runtime-coordinator-644IZPWD.js"),
+    import("./prompt-terminal-ledger-WOPLWLBQ.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -5253,7 +5393,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   let workspaceRegistrationStore = deps.workspaceRegistrationStore;
   const explicitWorkspaceCount = workspaceInputs.length;
   if (workspaceRegistrationStore === void 0 && process.env["QWEN_SERVE_NO_PERSISTENT_REGISTRATION"] !== "1") {
-    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-CSOD2L3Q.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-OLL5737M.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -5366,6 +5506,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   });
   loggerLifecycle.initialized(daemonLog);
   let channelSelectionFromSettings = false;
+  let bootChannelOwnerHints = /* @__PURE__ */ new Map();
+  let channelOwnerHints = /* @__PURE__ */ new Map();
+  let channelStartupTolerantNames = /* @__PURE__ */ new Set();
   const reportConfiguredChannelStartupFailure = /* @__PURE__ */ __name((error) => {
     const message = sanitizeLogText(
       redactLogCredentials(
@@ -5381,31 +5524,64 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       `workspace serve.channels was not restored: ${detail} Continuing without channels`
     );
   }, "reportConfiguredChannelStartupFailure");
-  if (!opts.channelSelection && bootSettings?.serve?.channels !== void 0) {
+  const reportStartupChannelDiagnostic = /* @__PURE__ */ __name((diagnostic) => {
+    const detail = sanitizeLogText(
+      redactLogCredentials(diagnostic.message),
+      512
+    );
+    if (diagnostic.code === "invalid_entry") {
+      daemonLog.warn(detail, { workspaceCwd: diagnostic.workspaceCwd });
+      return;
+    }
+    if (diagnostic.code === "claimed_by_multiple_workspaces") {
+      daemonLog.warn(detail, {
+        code: diagnostic.code,
+        workspaceCwd: diagnostic.workspaceCwd,
+        ...diagnostic.channel ? { channel: diagnostic.channel } : {}
+      });
+      return;
+    }
+    writeStderrLine(
+      `qwen serve: workspace ${JSON.stringify(
+        diagnostic.workspaceCwd
+      )} serve.channels: ${detail}`
+    );
+    daemonLog.warn(`workspace serve.channels not fully restored: ${detail}`, {
+      code: diagnostic.code,
+      workspaceCwd: diagnostic.workspaceCwd,
+      ...diagnostic.channel ? { channel: diagnostic.channel } : {}
+    });
+  }, "reportStartupChannelDiagnostic");
+  const startupChannelWorkspaces = workspaceInputs.map((workspace, index) => ({
+    workspaceCwd: workspace.cwd,
+    primary: index === 0
+  }));
+  if (!opts.channelSelection && (bootSettings?.serve?.channels !== void 0 || startupChannelWorkspaces.length > 1)) {
     try {
-      const rawChannels = bootSettings.serve.channels;
-      if (!Array.isArray(rawChannels) || !rawChannels.every((name) => typeof name === "string")) {
-        throw new Error("serve.channels must be a string array.");
-      }
-      const configuredChannels = rawChannels.filter((name, index) => {
-        if (!name || name !== name.trim() || sanitizeLogText(name, name.length) !== name) {
-          daemonLog.warn(
-            `ignored invalid workspace serve.channels entry at index ${index}`
-          );
-          return false;
-        }
-        return true;
+      const restored = resolveStartupChannelSelection({
+        workspaces: startupChannelWorkspaces,
+        // The fast path already read the primary workspace; every other
+        // registered workspace is read here, through the same loader, so a
+        // secondary workspace contributes exactly what it would contribute if
+        // it were the one the daemon bound to.
+        loadStartupChannels: /* @__PURE__ */ __name((workspaceCwd) => (workspaceCwd === boundWorkspace ? bootSettings : (deps.loadWorkspaceBootSettings ?? loadServeFastPathSettings)(
+          workspaceCwd
+        ))?.serve?.channels, "loadStartupChannels")
       });
-      opts.channelSelection = normalizeServeChannelSelection(
-        configuredChannels,
-        "serve.channels"
-      );
+      for (const diagnostic of restored.diagnostics) {
+        reportStartupChannelDiagnostic(diagnostic);
+      }
+      opts.channelSelection = restored.selection;
       if (opts.channelSelection) {
         channelSelectionFromSettings = true;
+        bootChannelOwnerHints = restored.ownerHints;
+        channelOwnerHints = restored.ownerHints;
+        channelStartupTolerantNames = restored.tolerantNames;
         channelRuntime = await ensureChannelRuntime();
         daemonLog.info("restoring channels from workspace serve.channels", {
           channels: channelSelectionNames(opts.channelSelection),
-          workspaceCwd: boundWorkspace
+          workspaceCwd: boundWorkspace,
+          ...restored.ownerHints.size > 0 ? { requestedByWorkspace: Object.fromEntries(restored.ownerHints) } : {}
         });
       }
     } catch (error) {
@@ -5590,7 +5766,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       "qwen serve: required external tool guard handshake succeeded."
     );
   }
-  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-SJ7YWRBD.js");
+  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-LQ3XGSBU.js");
   const daemonToolGuardHandler = createDaemonToolGuard(
     externalToolGuardHandler
   );
@@ -5941,7 +6117,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       loadCoreRuntime(),
       loadSettingsRuntimeModules(),
       cliVersionPromise,
-      import("./daemon-trust-policy-BUGBZHZX.js")
+      import("./daemon-trust-policy-KXZY6JQN.js")
     ]);
     getWorkspaceRuntimeCoordinatorIfSupported = runtime.getWorkspaceRuntimeCoordinatorIfSupported;
     cliVersion = resolvedCliVersion;
@@ -6389,7 +6565,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         skillSettingStrings,
         skillToggleBlockForName,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-5QJZJXOA.js");
+      } = await import("./skill-settings-MNLFQXDX.js");
       const fresh = loadSettingsForPersistence(workspace);
       const workspaceDisabled = skillSettingStrings(
         fresh,
@@ -6453,7 +6629,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         skillSettingStrings,
         skillToggleBlockForName,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-5QJZJXOA.js");
+      } = await import("./skill-settings-MNLFQXDX.js");
       const fresh = loadSettingsForPersistence(workspace);
       const initialDisabled = skillSettingStrings(
         fresh,
@@ -6566,10 +6742,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       }
     }), "persistSettingsFn");
     const [{ createSubSessionLauncher }, scheduledTaskRoutes] = await Promise.all([
-      import("./create-sub-session-YFYNWAU3.js"),
-      import("./scheduled-tasks-NESFIYHB.js")
+      import("./create-sub-session-FB5YJFI5.js"),
+      import("./scheduled-tasks-WEC66H2D.js")
     ]);
-    const { sessionAttachmentsRoots } = await import("./session-attachments-root-SDTVDDHX.js");
+    const { sessionAttachmentsRoots } = await import("./session-attachments-root-L75Y47VK.js");
     const createCurrentSessionScheduledTaskHandler = /* @__PURE__ */ __name((workspaceCwd, runtimeBaseDir, getBridge, assertGenerationOpen) => async ({
       callerSessionId,
       cron,
@@ -7417,7 +7593,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     };
     sessionPrRefreshTimer?.dispose();
     const refreshGeneration = ++sessionPrRefreshGeneration;
-    void import("./session-pr-refresh-QLHN7R76.js").then((mod) => {
+    void import("./session-pr-refresh-5MHLCSC2.js").then((mod) => {
       if (refreshGeneration !== sessionPrRefreshGeneration) return;
       sessionPrRefreshTimer = mod.startSessionPrRefreshTimer({
         workspaceRegistry,
@@ -8092,8 +8268,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           { createChannelManagementService },
           { WorkspaceChannelSettingsStore }
         ] = await Promise.all([
-          import("./channel-management-service-B5JCH6G4.js"),
-          import("./channel-settings-store-3QLN4ATE.js")
+          import("./channel-management-service-DISO7Z3P.js"),
+          import("./channel-settings-store-7BHSX2TC.js")
         ]);
         return createChannelManagementService({
           workspaceCwd: targetRuntime.workspaceCwd,
@@ -8256,7 +8432,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       ),
       updateModelContextWindow: /* @__PURE__ */ __name((workspace, key, size, assertGenerationOpen) => withSettingsLock(workspace, async () => {
         assertGenerationOpen();
-        const { updateModelContextWindow } = await import("./model-configuration-TIUNBSA7.js");
+        const { updateModelContextWindow } = await import("./model-configuration-LQV2CJZZ.js");
         return updateModelContextWindow(
           loadSettingsForPersistence(workspace),
           key,
@@ -8294,7 +8470,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           const adapter = settingsRuntime.loadedSettingsAdapter.createLoadedSettingsAdapter(
             fresh
           );
-          const { getAuthTypeFromEnv } = await import("./modelConfigUtils-5AOF7V2F.js");
+          const { getAuthTypeFromEnv } = await import("./modelConfigUtils-3MJ6OTIS.js");
           const hasConversationAuth = adapter.getValue("security.auth.selectedType") || getAuthTypeFromEnv(primaryRuntimeEnv.effectiveEnv);
           await core.applyProviderInstallPlan(plan, {
             settings: adapter,
@@ -8333,8 +8509,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         { createWorkspaceTrustReconciler },
         { createDaemonTrustPolicyMonitor }
       ] = await Promise.all([
-        import("./workspace-trust-reconciler-EMAYOLR6.js"),
-        import("./daemon-trust-policy-monitor-7Q7XOMIB.js")
+        import("./workspace-trust-reconciler-64FF3I3X.js"),
+        import("./daemon-trust-policy-monitor-QAZ4KXVK.js")
       ]);
       const materializationFor = /* @__PURE__ */ __name((entry, snapshot, decision) => {
         const boundWorkspaces2 = entry.primary && decision.targetTrusted ? runtime.resolveBoundWorkspacesFromIdeEnv(
@@ -8531,7 +8707,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     // through (and start the runtime) exactly like the warm app would.
     // Dynamic import keeps web-shell-static out of the serve fast-path
     // static closure (see the import-boundary guards in fast-path.test.ts).
-    isPreAuthRequest: webShellMounted ? (req) => import("./web-shell-static-G654DFN2.js").then(
+    isPreAuthRequest: webShellMounted ? (req) => import("./web-shell-static-4SY6HOTM.js").then(
       (webShellStatic) => webShellStatic.isPreAuthWebShellRequest(req)
     ) : void 0
   });
@@ -8642,7 +8818,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         const settings = settingsByWorkspace.get(cwd);
         if (!settings) return {};
         return channelRuntime.loadChannelsConfig(cwd, settings);
-      }, "loadChannelsConfig")
+      }, "loadChannelsConfig"),
+      preferredOwners: channelOwnerHints,
+      tolerant: channelStartupTolerantNames
     });
     if (!grouping.ok) {
       throw Object.assign(new Error(grouping.error.message), {
@@ -8650,17 +8828,17 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         ...grouping.error.channel ? { channel: grouping.error.channel } : {}
       });
     }
-    return grouping.groups;
+    return { groups: grouping.groups, skipped: grouping.skipped ?? [] };
   }, "resolveChannelWorkspaceGroupsAtListen");
   if (opts.channelSelection) {
     try {
       channelValidationSettingsRuntime = await loadSettingsRuntimeModules();
-      channelValidationTrustPolicy = await import("./daemon-trust-policy-BUGBZHZX.js");
+      channelValidationTrustPolicy = await import("./daemon-trust-policy-KXZY6JQN.js");
       channelValidationTrustSnapshot = await channelValidationTrustPolicy.readDaemonTrustPolicySnapshot();
       if (opts.channelSelection.mode === "names" && workspaceInputs.length > MAX_CHANNEL_CONTROL_WORKSPACES) {
-        const groups = resolveChannelWorkspaceGroupsAtListen();
+        const resolved = resolveChannelWorkspaceGroupsAtListen();
         assertChannelControlWorkspaceCapacity(
-          groups?.map((group) => group.workspaceCwd) ?? []
+          resolved?.groups.map((group) => group.workspaceCwd) ?? []
         );
       }
       reserveChannelServicePidfile(opts.channelSelection);
@@ -9093,7 +9271,12 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           loadChannelsConfig: /* @__PURE__ */ __name((cwd) => {
             const settings = settingsByWorkspace.get(cwd);
             return settings ? workerRuntime.loadChannelsConfig(cwd, settings) : {};
-          }, "loadChannelsConfig")
+          }, "loadChannelsConfig"),
+          // A runtime change must resolve ownership the way this daemon
+          // already resolved it; without the hint a name that only boot could
+          // disambiguate would start failing every PUT as ambiguous. Runtime
+          // changes stay fail-fast, so no name is tolerated here.
+          preferredOwners: channelOwnerHints
         });
         if (!grouping.ok) {
           throw Object.assign(new Error(grouping.error.message), {
@@ -9234,6 +9417,14 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             initialLeaseReserved: channelPidfileReserved,
             onCommittedSelection: /* @__PURE__ */ __name((_selection, groups) => {
               channelWorkspaceGroups = groups;
+              channelOwnerHints = new Map([
+                ...bootChannelOwnerHints,
+                ...groups.flatMap(
+                  (group) => group.selection.mode === "names" ? group.selection.names.map(
+                    (name) => [name, group.workspaceCwd]
+                  ) : []
+                )
+              ]);
               channelWebhookConfigVersion += 1;
               refreshChannelWebhookConfigs?.();
             }, "onCommittedSelection"),
@@ -9694,7 +9885,39 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       closeHost = handle.close;
       handle.close = () => serveAppLifecycle.close();
       try {
-        channelWorkspaceGroups = resolveChannelWorkspaceGroupsAtListen();
+        const resolved = resolveChannelWorkspaceGroupsAtListen();
+        channelWorkspaceGroups = resolved?.groups;
+        if (resolved) {
+          for (const skip of resolved.skipped) {
+            const detail = sanitizeLogText(
+              redactLogCredentials(skip.message),
+              512
+            );
+            writeStderrLine(
+              `qwen serve: channel "${skip.channel}" was not restored: ${detail}`
+            );
+            daemonLog.warn(`channel was not restored: ${detail}`, {
+              code: skip.code,
+              channel: skip.channel
+            });
+          }
+          if (resolved.skipped.length > 0) {
+            const hosted = new Set(
+              resolved.groups.flatMap(
+                (group) => group.selection.mode === "names" ? group.selection.names : []
+              )
+            );
+            const remaining = opts.channelSelection?.mode === "names" ? opts.channelSelection.names.filter((name) => hosted.has(name)) : [];
+            opts.channelSelection = remaining.length > 0 ? { mode: "names", names: remaining } : void 0;
+            if (!opts.channelSelection) {
+              channelWorkspaceGroups = void 0;
+              removeCurrentServePidfile();
+              reportConfiguredChannelStartupFailure(
+                new Error("No configured channel could be hosted.")
+              );
+            }
+          }
+        }
       } catch (err) {
         removeCurrentServePidfile();
         const error2 = err instanceof Error ? err : new Error(String(err));