@qwen-code/qwen-code 0.24.5-preview.0 → 0.24.5

package/chunks/{run-qwen-serve-GMLWJITM.js → run-qwen-serve-CUB2NZ6P.js}

@@ -49,9 +49,10 @@ import {
   parseDaemonStatusDetail,
   positiveFiniteOrNull,
   prepareManagedScratchRoot,
+  pushChannelRestoreIssues,
   resolveAcpHttpEnabled,
   toDaemonStatusMemoryLimits
-} from "./chunk-H2GVLBFU.js";
+} from "./chunk-I36GIR6K.js";
 import {
   ConversationDirectoryIdentityError,
   assertExactConversationRootIdentity,
@@ -63,7 +64,7 @@ import {
   isSameConversationDirectoryObject,
   materializeConversationDirectoryIdentity,
   revalidateConversationRootIdentity
-} from "./chunk-PB7JBAHF.js";
+} from "./chunk-PVBIEIVZ.js";
 import {
   formatHostForAuthority,
   isLoopbackAddress,
@@ -79,12 +80,13 @@ import {
   normalizeSessionIdForLookup
 } from "./chunk-ZEZKIS2K.js";
 import "./chunk-NYWWQ437.js";
-import {
-  require_express
-} from "./chunk-5NFAKADR.js";
+import "./chunk-EMGHODF7.js";
 import {
   resolveWebShellDir
 } from "./chunk-FBX2SDQ4.js";
+import {
+  require_express
+} from "./chunk-WZCVB2ER.js";
 import {
   ConversationRuntimeOwnershipError,
   LIVE_HOST_PROTOCOL_VERSION
@@ -112,16 +114,16 @@ import {
 import "./chunk-CKXUWR6I.js";
 import {
   resolveChannelCwd
-} from "./chunk-VGLXXHTF.js";
-import "./chunk-4VSTV4C2.js";
+} from "./chunk-5BLOZPTW.js";
+import "./chunk-IH22ZGZI.js";
 import {
   resolveMaxRegisteredWorkspaces,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-SXFZ5P7F.js";
+} from "./chunk-FE7D3WKV.js";
 import {
   assertChannelControlWorkspaceCapacity
-} from "./chunk-ZX6EZ7EH.js";
+} from "./chunk-RBE3WRSN.js";
 import {
   LOAD_REPLAY_META_KEY
 } from "./chunk-LDH7MN44.js";
@@ -133,19 +135,19 @@ import {
 import {
   ExtraCaInspectionError,
   loadableCertificates
-} from "./chunk-CIS4SY3R.js";
+} from "./chunk-PPBZHGEQ.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-Z7B6SRPM.js";
 import {
   ChannelWebhookEnqueueError
-} from "./chunk-STUJ7IMZ.js";
+} from "./chunk-SI7XKACY.js";
 import {
   QWEN_SERVER_TOKEN_ENV
 } from "./chunk-GYTKQYDB.js";
 import {
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-X2R47SFR.js";
+} from "./chunk-FLVPNMCS.js";
 import {
   channelSelectionNames,
   normalizeServeChannelSelection
@@ -171,13 +173,13 @@ import {
 import "./chunk-TZBFVXNX.js";
 import {
   sanitizeLogText
-} from "./chunk-YWZOEHBT.js";
+} from "./chunk-DE2WI7RU.js";
 import "./chunk-6HOTTZKB.js";
 import {
   consumeServeFastPathRejectedLoaderKeys,
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
-} from "./chunk-HS5OZTQF.js";
+} from "./chunk-J2FLXQJM.js";
 import "./chunk-BW4333PP.js";
 import {
   acquireInheritedLoaderEnvScrub,
@@ -188,13 +190,13 @@ import {
 } from "./chunk-CCGFXABG.js";
 import {
   getCliVersion
-} from "./chunk-STKUN7BR.js";
+} from "./chunk-2XNGG7R3.js";
 import "./chunk-2RJJSLCF.js";
 import {
   InvalidExecutionSandboxConfigError,
   assertExecutionSandboxSupported,
   readOperatorSandboxSettings
-} from "./chunk-KY4HZXLV.js";
+} from "./chunk-GLPNIOEV.js";
 import {
   getGlobalQwenDirLite,
   resolveConfigPathLite
@@ -3017,6 +3019,53 @@ var ChannelDeliveryAuthorizationStore = class {
   }
 };
 
+// packages/cli/src/serve/channel-restore-failures.ts
+init_esbuild_shims();
+function restoreFailureMessage(message) {
+  return sanitizeLogText(
+    redactLogCredentials(normalizeWorkerDiagnostic(message)),
+    512
+  );
+}
+__name(restoreFailureMessage, "restoreFailureMessage");
+function createChannelRestoreFailures(options = {}) {
+  const byWorkspace = /* @__PURE__ */ new Map();
+  const isStale = options.isStale ?? (() => false);
+  return {
+    record(failures) {
+      for (const failure of failures) {
+        let channels = byWorkspace.get(failure.workspaceCwd);
+        if (!channels) {
+          channels = /* @__PURE__ */ new Map();
+          byWorkspace.set(failure.workspaceCwd, channels);
+        }
+        channels.set(failure.channel, {
+          workspaceCwd: failure.workspaceCwd,
+          channel: failure.channel,
+          message: restoreFailureMessage(failure.message)
+        });
+      }
+    },
+    get(workspaceCwd, channel) {
+      const failure = byWorkspace.get(workspaceCwd)?.get(channel);
+      return failure && !isStale(failure) ? failure : void 0;
+    },
+    list() {
+      return [...byWorkspace.values()].flatMap((channels) => [...channels.values()]).filter((failure) => !isStale(failure));
+    },
+    clear(workspaceCwd, channel) {
+      const channels = byWorkspace.get(workspaceCwd);
+      if (!channels) return;
+      channels.delete(channel);
+      if (channels.size === 0) byWorkspace.delete(workspaceCwd);
+    },
+    clearAll() {
+      byWorkspace.clear();
+    }
+  };
+}
+__name(createChannelRestoreFailures, "createChannelRestoreFailures");
+
 // packages/cli/src/serve/channel-workspace-grouping.ts
 init_esbuild_shims();
 function resolveChannelOwnerCwd(rawCwd, workspaceCwd) {
@@ -3244,6 +3293,7 @@ function resolveStartupChannelSelection(input) {
       selection: { mode: "all" },
       ownerHints: /* @__PURE__ */ new Map(),
       tolerantNames: /* @__PURE__ */ new Set(),
+      claimants: /* @__PURE__ */ new Map(),
       diagnostics
     };
   }
@@ -3267,6 +3317,12 @@ function resolveStartupChannelSelection(input) {
     selection: names.length > 0 ? { mode: "names", names } : void 0,
     ownerHints,
     tolerantNames,
+    claimants: new Map(
+      [...claimsByName].map(([name, claims]) => [
+        name,
+        claims.map((claim) => claim.workspaceCwd)
+      ])
+    ),
     diagnostics
   };
 }
@@ -4117,12 +4173,12 @@ __name(hasRetryableChannelWorkerShutdownError, "hasRetryableChannelWorkerShutdow
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-PUMSN4J2.js"),
-    import("./pidfile-BBUANGZX.js"),
-    import("./runtime-SSGPOXRZ.js"),
+    import("./channel-worker-supervisor-ENJ2AE2N.js"),
+    import("./pidfile-QIBF53CW.js"),
+    import("./runtime-2DAVBADX.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-AKPVHRUO.js"),
-    import("./channel-worker-manager-TDAQSKWX.js")
+    import("./channel-worker-group-QNX4OIMZ.js"),
+    import("./channel-worker-manager-IJCPV4WY.js")
   ]).then(
     ([
       supervisor,
@@ -4229,7 +4285,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./core-runtime-4IB27E7J.js");
+  coreRuntimePromise ??= import("./core-runtime-5CAK5DSM.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -4265,10 +4321,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-KSQ2DGPY.js"),
-    import("./environment-LUM7XX27.js"),
-    import("./loadedSettingsAdapter-5OSU3J46.js"),
-    import("./trustedFolders-4ZEV6RXD.js")
+    import("./settings-FPMUAVWD.js"),
+    import("./environment-Q2BVTUQO.js"),
+    import("./loadedSettingsAdapter-EKXSRWMY.js"),
+    import("./trustedFolders-3WNZBUH7.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -4281,8 +4337,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-SSGPOXRZ.js"),
-    import("./config-utils-CVLI36KM.js")
+    import("./runtime-2DAVBADX.js"),
+    import("./config-utils-3IOTAFBG.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -4309,19 +4365,19 @@ async function loadServeRuntimeModules() {
     workspaceRuntimeCoordinatorModule,
     promptLedgerModule
   ] = await Promise.all([
-    import("./server-3MMYOOJW.js"),
-    import("./bridge-KGJYQUWD.js"),
-    import("./spawnChannel-NVO7CCBW.js"),
+    import("./server-MJETIFJS.js"),
+    import("./bridge-BUCSJHCE.js"),
+    import("./spawnChannel-DBSAAUUT.js"),
     import("./process-registry-MDKO6QY2.js"),
-    import("./workspace-service-CERZFJ3B.js"),
+    import("./workspace-service-M3ZKR6WL.js"),
     import("./types-HKLPXZB3.js"),
-    import("./daemon-status-provider-ETDIOWMS.js"),
-    import("./workspace-providers-status-TU73CNRF.js"),
-    import("./workspace-skills-status-5M3EIAUY.js"),
-    import("./total-session-admission-EZJQKTPF.js"),
-    import("./workspace-registry-S7QTXFWM.js"),
-    import("./workspace-runtime-coordinator-GWNDUIGO.js"),
-    import("./prompt-terminal-ledger-ZBFYXJ4L.js")
+    import("./daemon-status-provider-GG64ZJR3.js"),
+    import("./workspace-providers-status-I5MO7Z2T.js"),
+    import("./workspace-skills-status-OC3EYL7U.js"),
+    import("./total-session-admission-UWMJWTWP.js"),
+    import("./workspace-registry-2UKNZO5M.js"),
+    import("./workspace-runtime-coordinator-TKCI5WJW.js"),
+    import("./prompt-terminal-ledger-LXFVLR6C.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -4562,6 +4618,7 @@ function createBootstrapServeApp(input) {
     getRuntimeError,
     getChannelWorkerSnapshot,
     getChannelWorkerSnapshots,
+    getChannelRestoreFailures,
     onHealthServed
   } = input;
   const app = (0, import_express.default)();
@@ -4659,6 +4716,7 @@ function createBootstrapServeApp(input) {
     };
     const daemonLogStatus = daemonLog.getStatus();
     const issues = [issue];
+    pushChannelRestoreIssues(issues, getChannelRestoreFailures());
     if (daemonLogStatus.health === "degraded") {
       issues.push({
         code: "daemon_log_degraded",
@@ -5432,7 +5490,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-743FRSOU.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-CBHKV34L.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -5550,9 +5608,22 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   });
   loggerLifecycle.initialized(daemonLog);
   let channelSelectionFromSettings = false;
-  let bootChannelOwnerHints = /* @__PURE__ */ new Map();
+  const channelSelectionFromFlag = opts.channelSelection !== void 0;
+  const bootChannelOwnerHints = /* @__PURE__ */ new Map();
   let channelOwnerHints = /* @__PURE__ */ new Map();
   let channelStartupTolerantNames = /* @__PURE__ */ new Set();
+  const lateRestoredWorkspaces = /* @__PURE__ */ new Set();
+  let bootChannelClaimants = /* @__PURE__ */ new Map();
+  const channelRestoreFailures = createChannelRestoreFailures({
+    isStale: /* @__PURE__ */ __name((failure) => {
+      if (channelWorkerManager?.committedChannelNames().includes(failure.channel)) {
+        return true;
+      }
+      const registry = (runtimeApp ?? runtimeAppForCleanup)?.locals?.["workspaceRegistry"];
+      return registry ? !registry.getByWorkspaceCwd(failure.workspaceCwd) : false;
+    }, "isStale")
+  });
+  let channelHostingStoppedByOperator = false;
   const reportConfiguredChannelStartupFailure = /* @__PURE__ */ __name((error) => {
     const message = sanitizeLogText(
       redactLogCredentials(
@@ -5600,6 +5671,20 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     workspaceCwd: workspace.cwd,
     primary: index === 0
   }));
+  const loadStartupChannelsFor = /* @__PURE__ */ __name((workspaceCwd) => (workspaceCwd === boundWorkspace ? bootSettings : loadServeFastPathSettings(workspaceCwd))?.serve?.channels, "loadStartupChannelsFor");
+  const startupChannelsForWorkspace = /* @__PURE__ */ __name((workspaceCwd) => {
+    const restored = resolveStartupChannelSelection({
+      // Never the primary workspace, and read from disk rather than from the
+      // boot snapshot: this runs long after boot, and the file may have been
+      // edited since — through the management API among other things.
+      workspaces: [{ workspaceCwd, primary: false }],
+      loadStartupChannels: /* @__PURE__ */ __name((cwd) => loadServeFastPathSettings(cwd)?.serve?.channels, "loadStartupChannels")
+    });
+    for (const diagnostic of restored.diagnostics) {
+      reportStartupChannelDiagnostic(diagnostic);
+    }
+    return restored.selection?.mode === "names" ? restored.selection.names : [];
+  }, "startupChannelsForWorkspace");
   if (!opts.channelSelection && (bootSettings?.serve?.channels !== void 0 || startupChannelWorkspaces.length > 1)) {
     try {
       const restored = resolveStartupChannelSelection({
@@ -5608,9 +5693,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         // 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")
+        loadStartupChannels: loadStartupChannelsFor
       });
       for (const diagnostic of restored.diagnostics) {
         reportStartupChannelDiagnostic(diagnostic);
@@ -5618,14 +5701,21 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       opts.channelSelection = restored.selection;
       if (opts.channelSelection) {
         channelSelectionFromSettings = true;
-        bootChannelOwnerHints = restored.ownerHints;
-        channelOwnerHints = restored.ownerHints;
+        for (const [name, owner] of restored.ownerHints) {
+          bootChannelOwnerHints.set(name, owner);
+        }
+        channelOwnerHints = new Map(bootChannelOwnerHints);
         channelStartupTolerantNames = restored.tolerantNames;
+        bootChannelClaimants = restored.claimants;
         channelRuntime = await ensureChannelRuntime();
         daemonLog.info("restoring channels from workspace serve.channels", {
           channels: channelSelectionNames(opts.channelSelection),
           workspaceCwd: boundWorkspace,
-          ...restored.ownerHints.size > 0 ? { requestedByWorkspace: Object.fromEntries(restored.ownerHints) } : {}
+          ...restored.ownerHints.size > 0 ? {
+            // The daemon log renders each field with String(), so an
+            // object here would print as "[object Object]".
+            requestedByWorkspace: [...restored.ownerHints].map(([name, owner]) => `${name}@${owner}`).join(",")
+          } : {}
         });
       }
     } catch (error) {
@@ -5810,7 +5900,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       "qwen serve: required external tool guard handshake succeeded."
     );
   }
-  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-BTKVV3DZ.js");
+  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-S3SFT3H7.js");
   const daemonToolGuardHandler = createDaemonToolGuard(
     externalToolGuardHandler
   );
@@ -5979,8 +6069,39 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       await manager.shutdown().catch(() => void 0);
       throw daemonDrainingError();
     }
-    return manager.setSelection(selection);
+    const result = await manager.setSelection(selection);
+    channelHostingStoppedByOperator = false;
+    channelRestoreFailures.clearAll();
+    return result;
   }, "setChannelWorkerSelection");
+  const channelStartupMessages = /* @__PURE__ */ __name((err) => {
+    const startupFailures = err?.startupFailures;
+    return new Map(
+      (Array.isArray(startupFailures) ? startupFailures : []).map((failure) => [failure.channel, failure.message])
+    );
+  }, "channelStartupMessages");
+  const lateRestoreFailures = /* @__PURE__ */ __name((workspaceCwd, requested, err) => {
+    const committed = new Set(channelWorkerManager?.committedChannelNames());
+    const reported = channelStartupMessages(err);
+    const message = err instanceof Error ? err.message : String(err);
+    return requested.filter((channel) => !committed.has(channel)).map((channel) => ({
+      workspaceCwd,
+      channel,
+      message: reported.get(channel) ?? message
+    }));
+  }, "lateRestoreFailures");
+  const addChannelsToSelection = /* @__PURE__ */ __name(async (names) => {
+    if (channelControlDraining) throw daemonDrainingError();
+    const manager = await ensureChannelWorkerManager?.();
+    if (!manager) throw new Error("Channel worker manager is unavailable.");
+    if (channelControlDraining) {
+      await manager.shutdown().catch(() => void 0);
+      throw daemonDrainingError();
+    }
+    await manager.addChannels(names, {
+      precondition: /* @__PURE__ */ __name(() => !channelHostingStoppedByOperator, "precondition")
+    });
+  }, "addChannelsToSelection");
   const stopChannelWorker = /* @__PURE__ */ __name(async () => {
     if (channelControlDraining) throw daemonDrainingError();
     const manager = channelWorkerManager ?? await channelWorkerManagerStarting;
@@ -5991,7 +6112,12 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     if (!manager) {
       return { changed: false, state: getChannelWorkerControl() };
     }
-    return manager.stopSelection();
+    const result = await manager.stopSelection();
+    if (result.changed) {
+      channelHostingStoppedByOperator = true;
+      channelRestoreFailures.clearAll();
+    }
+    return result;
   }, "stopChannelWorker");
   const reloadChannelWorker = /* @__PURE__ */ __name(async () => {
     if (channelControlDraining) throw daemonDrainingError();
@@ -6161,7 +6287,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       loadCoreRuntime(),
       loadSettingsRuntimeModules(),
       cliVersionPromise,
-      import("./daemon-trust-policy-U5SPHJLP.js")
+      import("./daemon-trust-policy-XNWYLQ32.js")
     ]);
     getWorkspaceRuntimeCoordinatorIfSupported = runtime.getWorkspaceRuntimeCoordinatorIfSupported;
     cliVersion = resolvedCliVersion;
@@ -6614,7 +6740,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         skillSettingStrings,
         skillToggleBlockForName,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-PDESL7S3.js");
+      } = await import("./skill-settings-XW7X244B.js");
       const fresh = loadSettingsForPersistence(workspace);
       const workspaceDisabled = skillSettingStrings(
         fresh,
@@ -6678,7 +6804,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         skillSettingStrings,
         skillToggleBlockForName,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-PDESL7S3.js");
+      } = await import("./skill-settings-XW7X244B.js");
       const fresh = loadSettingsForPersistence(workspace);
       const initialDisabled = skillSettingStrings(
         fresh,
@@ -6791,10 +6917,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       }
     }), "persistSettingsFn");
     const [{ createSubSessionLauncher }, scheduledTaskRoutes] = await Promise.all([
-      import("./create-sub-session-A73TQDAN.js"),
-      import("./scheduled-tasks-QJTC5XQ7.js")
+      import("./create-sub-session-DG4CVOQC.js"),
+      import("./scheduled-tasks-TGWYXZWW.js")
     ]);
-    const { sessionAttachmentsRoots } = await import("./session-attachments-root-ESP5CNBV.js");
+    const { sessionAttachmentsRoots } = await import("./session-attachments-root-RONFQ3D3.js");
     const createCurrentSessionScheduledTaskHandler = /* @__PURE__ */ __name((workspaceCwd, runtimeBaseDir, getBridge, assertGenerationOpen) => async ({
       callerSessionId,
       cron,
@@ -7651,7 +7777,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     };
     sessionPrRefreshTimer?.dispose();
     const refreshGeneration = ++sessionPrRefreshGeneration;
-    void import("./session-pr-refresh-B3N7PKUP.js").then((mod) => {
+    void import("./session-pr-refresh-ZPT6TAD4.js").then((mod) => {
       if (refreshGeneration !== sessionPrRefreshGeneration) return;
       sessionPrRefreshTimer = mod.startSessionPrRefreshTimer({
         workspaceRegistry,
@@ -8084,22 +8210,67 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
         channelWebhookConfigVersion += 1;
         refreshChannelWebhookConfigs?.();
-        if (!channelWorkerManager) return;
-        try {
-          if (runtimeAdded.trusted) {
-            await channelWorkerManager.restoreWorkspace(
-              runtimeAdded.workspaceCwd
-            );
-          }
-          await channelWorkerManager.refreshWorkspaces();
-        } catch (err) {
+        if (channelWorkerManager) {
+          const manager = channelWorkerManager;
+          const activatedCwd = runtimeAdded.workspaceCwd;
+          const activatedTrusted = runtimeAdded.trusted;
+          void (async () => {
+            try {
+              if (activatedTrusted) {
+                await manager.restoreWorkspace(activatedCwd);
+              }
+              await manager.refreshWorkspaces();
+            } catch (err) {
+              daemonLog.error(
+                "workspace channel worker startup error",
+                err instanceof Error ? err : null
+              );
+            } finally {
+              writeChannelWorkerPidfile();
+            }
+          })();
+        }
+        const workspaceCwd = runtimeAdded.workspaceCwd;
+        if (!runtimeAdded.trusted || runtimeAdded.primary || channelSelectionFromFlag || lateRestoredWorkspaces.has(workspaceCwd) || // A remote workspace's `serve.channels` is not this daemon's to
+        // host, the same exclusion boot applies.
+        readSshWorkspace(workspaceCwd)) {
+          return;
+        }
+        if (channelHostingStoppedByOperator) {
+          daemonLog.info(
+            "skipping serve.channels for a workspace registered after boot: channel hosting was stopped",
+            { workspaceCwd }
+          );
+          return;
+        }
+        if (channelWorkerManager?.state().selection?.mode === "all") {
+          return;
+        }
+        const requested = startupChannelsForWorkspace(workspaceCwd);
+        if (requested.length === 0) return;
+        lateRestoredWorkspaces.add(workspaceCwd);
+        daemonLog.info(
+          "restoring serve.channels for a workspace registered after boot",
+          { workspaceCwd, channels: requested }
+        );
+        void addChannelsToSelection(requested).catch((err) => {
           daemonLog.error(
-            "workspace channel worker startup error",
-            err instanceof Error ? err : null
+            `serve.channels for a workspace registered after boot were not restored: ${sanitizeLogText(
+              redactLogCredentials(
+                err instanceof Error ? err.message : String(err)
+              ),
+              512
+            )}`,
+            null,
+            { workspaceCwd }
           );
-        } finally {
+          if (channelControlDraining) return;
+          channelRestoreFailures.record(
+            lateRestoreFailures(workspaceCwd, requested, err)
+          );
+        }).finally(() => {
           writeChannelWorkerPidfile();
-        }
+        });
       },
       beginDrain(runtimeToDrain) {
         if (runtimeToDrain.primary) {
@@ -8335,13 +8506,14 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           { createChannelManagementService },
           { WorkspaceChannelSettingsStore }
         ] = await Promise.all([
-          import("./channel-management-service-YN4A3BJ6.js"),
-          import("./channel-settings-store-773UOD6B.js")
+          import("./channel-management-service-Q2B7WUPL.js"),
+          import("./channel-settings-store-U25CVEL6.js")
         ]);
         return createChannelManagementService({
           workspaceCwd: targetRuntime.workspaceCwd,
           store: new WorkspaceChannelSettingsStore(targetRuntime.workspaceCwd),
-          manager: await ensureChannelWorkerManager()
+          manager: await ensureChannelWorkerManager(),
+          restoreFailures: channelRestoreFailures
         });
       })();
       channelManagementServices.set(targetRuntime, pending);
@@ -8427,6 +8599,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       daemonLog,
       getChannelWorkerSnapshot,
       getChannelWorkerSnapshots,
+      getChannelRestoreFailures: /* @__PURE__ */ __name(() => channelRestoreFailures.list(), "getChannelRestoreFailures"),
       getChannelWorkerControl,
       isChannelControlDraining: /* @__PURE__ */ __name(() => channelControlDraining, "isChannelControlDraining"),
       isChannelControlInitializing: /* @__PURE__ */ __name(() => channelWorkerManagerStarting !== void 0, "isChannelControlInitializing"),
@@ -8499,7 +8672,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       ),
       updateModelContextWindow: /* @__PURE__ */ __name((workspace, key, size, assertGenerationOpen) => withSettingsLock(workspace, async () => {
         assertGenerationOpen();
-        const { updateModelContextWindow } = await import("./model-configuration-A52XMQW7.js");
+        const { updateModelContextWindow } = await import("./model-configuration-Q3MNGG3B.js");
         return updateModelContextWindow(
           loadSettingsForPersistence(workspace),
           key,
@@ -8537,7 +8710,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           const adapter = settingsRuntime.loadedSettingsAdapter.createLoadedSettingsAdapter(
             fresh
           );
-          const { getAuthTypeFromEnv } = await import("./modelConfigUtils-7O4P3SLE.js");
+          const { getAuthTypeFromEnv } = await import("./modelConfigUtils-WC5XDR34.js");
           const hasConversationAuth = adapter.getValue("security.auth.selectedType") || getAuthTypeFromEnv(primaryRuntimeEnv.effectiveEnv);
           await core.applyProviderInstallPlan(plan, {
             settings: adapter,
@@ -8576,8 +8749,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         { createWorkspaceTrustReconciler },
         { createDaemonTrustPolicyMonitor }
       ] = await Promise.all([
-        import("./workspace-trust-reconciler-Q3LUKMQB.js"),
-        import("./daemon-trust-policy-monitor-QKRCO5WI.js")
+        import("./workspace-trust-reconciler-YQZSUOH4.js"),
+        import("./daemon-trust-policy-monitor-DR5CRWMM.js")
       ]);
       const materializationFor = /* @__PURE__ */ __name((entry, snapshot, decision) => {
         const boundWorkspaces2 = entry.primary && decision.targetTrusted ? runtime.resolveBoundWorkspacesFromIdeEnv(
@@ -8756,6 +8929,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     getRuntimeError: /* @__PURE__ */ __name(() => runtimeStartupError, "getRuntimeError"),
     getChannelWorkerSnapshot,
     getChannelWorkerSnapshots,
+    getChannelRestoreFailures: /* @__PURE__ */ __name(() => channelRestoreFailures.list(), "getChannelRestoreFailures"),
     onHealthServed: deferRuntimeUntilFirstHealth ? () => startRuntimeAfterHealth?.() : void 0
   });
   const deferredChannelWebhookAuth = deferRuntimeUntilFirstHealth ? createDeferredChannelWebhookAuth(
@@ -8774,7 +8948,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-GI6FVIMI.js").then(
+    isPreAuthRequest: webShellMounted ? (req) => import("./web-shell-static-E3O6NW7Y.js").then(
       (webShellStatic) => webShellStatic.isPreAuthWebShellRequest(req)
     ) : void 0
   });
@@ -8903,7 +9077,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
   if (opts.channelSelection) {
     try {
       channelValidationSettingsRuntime = await loadSettingsRuntimeModules();
-      channelValidationTrustPolicy = await import("./daemon-trust-policy-U5SPHJLP.js");
+      channelValidationTrustPolicy = await import("./daemon-trust-policy-XNWYLQ32.js");
       channelValidationTrustSnapshot = await channelValidationTrustPolicy.readDaemonTrustPolicySnapshot();
       if (opts.channelSelection.mode === "names" && workspaceInputs.length > MAX_CHANNEL_CONTROL_WORKSPACES) {
         const resolved = resolveChannelWorkspaceGroupsAtListen();
@@ -9539,6 +9713,22 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
               throw error2;
             }
             closeServerAfterChannelWorkerStartupFailure = false;
+            if (opts.channelSelection?.mode === "names") {
+              const reported = channelStartupMessages(error2);
+              const message = error2 instanceof Error ? error2.message : String(error2);
+              channelRestoreFailures.record(
+                opts.channelSelection.names.flatMap((channel) => {
+                  const owners = bootChannelClaimants.get(channel) ?? [
+                    boundWorkspace
+                  ];
+                  return owners.map((workspaceCwd) => ({
+                    workspaceCwd,
+                    channel,
+                    message: reported.get(channel) ?? message
+                  }));
+                })
+              );
+            }
             opts.channelSelection = void 0;
             reportConfiguredChannelStartupFailure(error2);
             try {
@@ -9973,6 +10163,15 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
               code: skip.code,
               channel: skip.channel
             });
+            channelRestoreFailures.record(
+              (bootChannelClaimants.get(skip.channel) ?? []).map(
+                (workspaceCwd) => ({
+                  workspaceCwd,
+                  channel: skip.channel,
+                  message: skip.message
+                })
+              )
+            );
           }
           if (resolved.skipped.length > 0) {
             const hosted = new Set(