@qwen-code/qwen-code 0.21.12 → 0.21.13

package/chunks/{run-qwen-serve-GZW7B4WK.js → run-qwen-serve-3QSGRXAN.js}

@@ -10,8 +10,10 @@ import {
   ACCESS_LOG_CONTROLLER_LOCAL,
   CAPABILITIES_SCHEMA_VERSION,
   ClientMcpSenderRegistry,
+  ConversationRuntimeOwnershipError,
   PathMutexRegistry,
   SERVE_CAPABILITY_REGISTRY,
+  ServeAppLifecycleController,
   WorkspaceVoiceCoordinator,
   allowOriginCors,
   allowOriginMode,
@@ -34,7 +36,7 @@ import {
   resolveAcpHttpEnabled,
   setDeferredRuntimeRequestTiming,
   toDaemonStatusMemoryLimits
-} from "./chunk-HG3UBTJ4.js";
+} from "./chunk-O565M6A4.js";
 import "./chunk-VGHZT6JR.js";
 import {
   isLoopbackBind
@@ -44,9 +46,19 @@ import {
   resolveDaemonMemoryBudget,
   serveJournalGrowthPoolMb
 } from "./chunk-UXEO7E3V.js";
+import "./chunk-NYWWQ437.js";
 import {
   resolveSessionRestoreTimeoutMs
 } from "./chunk-4JRM2BSM.js";
+import {
+  DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
+  DEFAULT_MAX_JOURNAL_BYTES,
+  DEFAULT_MAX_JOURNAL_EVENTS,
+  JOURNAL_GROWTH_HARD_CAP_BYTES,
+  normalizeCompactedReplayMaxBytes,
+  normalizeMaxJournalBytes,
+  normalizeMaxJournalEvents
+} from "./chunk-WCCLLK7X.js";
 import {
   require_express,
   resolveWebShellDir
@@ -57,15 +69,6 @@ import {
 import {
   LIVE_HOST_PROTOCOL_VERSION
 } from "./chunk-NKLP3DCK.js";
-import {
-  DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
-  DEFAULT_MAX_JOURNAL_BYTES,
-  DEFAULT_MAX_JOURNAL_EVENTS,
-  JOURNAL_GROWTH_HARD_CAP_BYTES,
-  normalizeCompactedReplayMaxBytes,
-  normalizeMaxJournalBytes,
-  normalizeMaxJournalEvents
-} from "./chunk-WCCLLK7X.js";
 import "./chunk-K6KS3LTN.js";
 import "./chunk-FC4KQFCS.js";
 import "./chunk-T3CHYWJZ.js";
@@ -78,17 +81,17 @@ import {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-WCEI6J56.js";
-import "./chunk-LUISTZXI.js";
+} from "./chunk-JNDY2MDR.js";
+import "./chunk-AA2BEKV3.js";
 import {
   LOAD_REPLAY_META_KEY
-} from "./chunk-FQDCO3CJ.js";
+} from "./chunk-S5DWMTHO.js";
 import "./chunk-624NHDGB.js";
 import {
   canonicalizeWorkspace,
   translateAndCheckAbsoluteWorkspacePath
 } from "./chunk-6PLDPT2C.js";
-import "./chunk-SYHXR6WM.js";
+import "./chunk-4W5U2TUT.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-Z7B6SRPM.js";
 import {
@@ -113,13 +116,13 @@ import {
   PRIVATE_EXTERNAL_TOOL_GUARD_ENV,
   PRIVATE_EXTERNAL_TOOL_GUARD_PROVIDER_ENV
 } from "./chunk-3VUENPWF.js";
-import {
-  MAX_DAEMON_WORKSPACES
-} from "./chunk-5HBA2Z7V.js";
 import {
   sanitizeLogText
 } from "./chunk-AW27A43Y.js";
 import "./chunk-IW6RQPQB.js";
+import {
+  MAX_DAEMON_WORKSPACES
+} from "./chunk-5HBA2Z7V.js";
 import "./chunk-GOXKNSDZ.js";
 import {
   getGlobalQwenDirLite,
@@ -133,7 +136,7 @@ import {
 } from "./chunk-MS7GNABG.js";
 import {
   getCliVersion
-} from "./chunk-OWXFBIB6.js";
+} from "./chunk-CU6GJD55.js";
 import "./chunk-WZMH7II3.js";
 import "./chunk-NPQ5ZKRP.js";
 import {
@@ -145,7 +148,7 @@ import "./chunk-TWPJO254.js";
 import "./chunk-CQ35AJ4Z.js";
 import {
   require_proper_lockfile
-} from "./chunk-KRXPRVGL.js";
+} from "./chunk-MLXTMF7H.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-XWRJCPHC.js";
 import {
@@ -178,6 +181,7 @@ init_esbuild_shims();
 var import_express = __toESM(require_express(), 1);
 import { X509Certificate, createHash as createHash3, timingSafeEqual } from "node:crypto";
 import * as fs from "node:fs";
+import { createServer } from "node:http";
 import * as https from "node:https";
 import * as path from "node:path";
 import * as os from "node:os";
@@ -3024,15 +3028,22 @@ function withSettingsLock(workspace, fn) {
 }
 __name(withSettingsLock, "withSettingsLock");
 var retryableChannelWorkerShutdownErrors = /* @__PURE__ */ new WeakSet();
+function hasRetryableChannelWorkerShutdownError(error) {
+  if (error instanceof AggregateError) {
+    return error.errors.some(hasRetryableChannelWorkerShutdownError);
+  }
+  return error instanceof Error && retryableChannelWorkerShutdownErrors.has(error);
+}
+__name(hasRetryableChannelWorkerShutdownError, "hasRetryableChannelWorkerShutdownError");
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-ZJIIWM4I.js"),
-    import("./pidfile-RQGZBNXT.js"),
-    import("./runtime-MYRXEO2E.js"),
+    import("./channel-worker-supervisor-OEVWBHGT.js"),
+    import("./pidfile-4XSFLYBZ.js"),
+    import("./runtime-5MLLZ7DC.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-IHBIHQ45.js"),
-    import("./channel-worker-manager-GEHYJ5AE.js")
+    import("./channel-worker-group-7LXCMZ77.js"),
+    import("./channel-worker-manager-RYEME4ZZ.js")
   ]).then(
     ([
       supervisor,
@@ -3137,13 +3148,13 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./core-runtime-H5CZDN3A.js");
+  coreRuntimePromise ??= import("./core-runtime-7VMIKUTG.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
 var liveDiscoveryRuntimePromise;
 function loadLiveDiscoveryRuntime() {
-  liveDiscoveryRuntimePromise ??= import("./discovery-XLHITE74.js");
+  liveDiscoveryRuntimePromise ??= import("./discovery-ORA5J7YP.js");
   return liveDiscoveryRuntimePromise;
 }
 __name(loadLiveDiscoveryRuntime, "loadLiveDiscoveryRuntime");
@@ -3173,10 +3184,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-CSYVIP2R.js"),
-    import("./environment-WOAJXJDJ.js"),
-    import("./loadedSettingsAdapter-5O2TDS3I.js"),
-    import("./trustedFolders-MQS46LIU.js")
+    import("./settings-D5644OM5.js"),
+    import("./environment-S7CTIHMX.js"),
+    import("./loadedSettingsAdapter-T6TV4YJ7.js"),
+    import("./trustedFolders-LK6T4XC7.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -3189,8 +3200,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-MYRXEO2E.js"),
-    import("./config-utils-Z3OW3IQG.js")
+    import("./runtime-5MLLZ7DC.js"),
+    import("./config-utils-IVHRSXWI.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -3215,17 +3226,17 @@ async function loadServeRuntimeModules() {
     totalSessionAdmissionModule,
     workspaceRegistryModule
   ] = await Promise.all([
-    import("./server-AWQHKXLG.js"),
-    import("./bridge-NPBV53UA.js"),
-    import("./spawnChannel-PQSZIOLY.js"),
+    import("./server-TC4A7AAZ.js"),
+    import("./bridge-YNQBAA4Z.js"),
+    import("./spawnChannel-IYGXRHSQ.js"),
     import("./process-registry-PMJOA5CO.js"),
-    import("./workspace-service-LOXYKYTR.js"),
+    import("./workspace-service-XCDQLE2Y.js"),
     import("./types-WYCFCEHR.js"),
-    import("./daemon-status-provider-QYM57Z44.js"),
-    import("./workspace-providers-status-PDDMI6ST.js"),
-    import("./workspace-skills-status-IJ5FOQI6.js"),
-    import("./total-session-admission-N4E5SFBO.js"),
-    import("./workspace-registry-L4NCJ34K.js")
+    import("./daemon-status-provider-ZDOYJCU6.js"),
+    import("./workspace-providers-status-2ZPZPUPZ.js"),
+    import("./workspace-skills-status-RS4O7AIJ.js"),
+    import("./total-session-admission-4KBHMQQ2.js"),
+    import("./workspace-registry-34GTUUHB.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -3617,6 +3628,11 @@ function createBootstrapServeApp(input) {
         channelIdleTimeoutMs: channelIdleTimeoutMs(opts.channelIdleTimeoutMs),
         sessionIdleTimeoutMs: sessionIdleTimeoutMs(opts.sessionIdleTimeoutMs),
         acpConnectionCap: null,
+        acpPreAttachMaxFramesPerStream: null,
+        acpPreAttachMaxFramesPerConnection: null,
+        acpPreAttachMaxFramesGlobal: null,
+        acpPreAttachMaxPayloadBytesPerConnection: null,
+        acpPreAttachMaxPayloadBytesGlobal: null,
         // No child-heap policy during bootstrap: it is built with the
         // runtime, so `enforced` is correctly false and `childHeap` null in
         // this window even when the flag says `enforce`.
@@ -3660,7 +3676,17 @@ function createBootstrapServeApp(input) {
             sessionStreams: 0,
             sseStreams: 0,
             wsStreams: 0,
-            pendingClientRequests: 0
+            pendingClientRequests: 0,
+            preAttach: {
+              bufferedConnectionFrames: 0,
+              bufferedSessionFrames: 0,
+              pendingDeliveryFrames: 0,
+              usedFrames: 0,
+              usedBytes: 0,
+              highWaterFrames: 0,
+              highWaterBytes: 0,
+              guardFailures: 0
+            }
           }
         },
         rateLimit: {
@@ -3683,6 +3709,7 @@ function createBootstrapServeApp(input) {
       ...detail.detail === "full" ? {
         full: {
           sessions: [],
+          acpMounts: [],
           acpConnections: [],
           workspace: {},
           auth: {
@@ -4147,6 +4174,27 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     );
   }
   const validateAndCanonicalizeWorkspace = validateAndCanonicalizeWorkspaceInput;
+  const liveConversationWorkspace = deps.liveConversationWorkspace ?? new ConversationWorkspace();
+  const isReservedConversationWorkspace = /* @__PURE__ */ __name((candidate) => {
+    const resolvedCandidate = path.resolve(candidate);
+    const resolvedRoot = path.resolve(liveConversationWorkspace.rootPath);
+    let canonicalRoot = resolvedRoot;
+    try {
+      canonicalRoot = fs.realpathSync.native(resolvedRoot);
+    } catch {
+    }
+    return resolvedCandidate === resolvedRoot || isWithinRoot(resolvedCandidate, resolvedRoot) || resolvedCandidate === canonicalRoot || isWithinRoot(resolvedCandidate, canonicalRoot);
+  }, "isReservedConversationWorkspace");
+  const reservedRawWorkspace = rawWorkspaces.find(
+    (workspace) => isReservedConversationWorkspace(workspace)
+  );
+  if (reservedRawWorkspace) {
+    throw new Error(
+      `Workspace ${JSON.stringify(
+        reservedRawWorkspace
+      )} is reserved for Conversations.`
+    );
+  }
   const workspaceInputs = rawWorkspaces.map((workspace) => ({
     raw: workspace,
     cwd: validateAndCanonicalizeWorkspace(workspace),
@@ -4215,9 +4263,19 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       journalGrowthSessionLimitProviders.delete(provider);
     };
   }, "registerJournalGrowthSessionLimits");
+  const reservedStartupWorkspace = workspaceInputs.find(
+    (workspace) => isReservedConversationWorkspace(workspace.cwd)
+  );
+  if (reservedStartupWorkspace) {
+    throw new Error(
+      `Workspace ${JSON.stringify(
+        reservedStartupWorkspace.raw
+      )} is reserved for Conversations.`
+    );
+  }
   let workspaceRegistrationStore = deps.workspaceRegistrationStore;
   if (workspaceRegistrationStore === void 0 && process.env["QWEN_SERVE_NO_PERSISTENT_REGISTRATION"] !== "1") {
-    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-BGRKKIYR.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-CYNY6IP6.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -4226,6 +4284,14 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       for (const storedWorkspace of stored.workspaces) {
         const registrationId = workspaceRegistrationId(storedWorkspace);
         const displayName = stored.displayNames?.[registrationId];
+        if (isReservedConversationWorkspace(storedWorkspace)) {
+          writeStderrLine(
+            `qwen serve: skipping persisted workspace registration ${JSON.stringify(
+              storedWorkspace
+            )}: path is reserved for Conversations`
+          );
+          continue;
+        }
         let cwd;
         try {
           cwd = validateAndCanonicalizeWorkspace(storedWorkspace);
@@ -4237,6 +4303,14 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           );
           continue;
         }
+        if (isReservedConversationWorkspace(cwd)) {
+          writeStderrLine(
+            `qwen serve: skipping persisted workspace registration ${JSON.stringify(
+              storedWorkspace
+            )}: path is reserved for Conversations`
+          );
+          continue;
+        }
         const existingInput = workspaceInputs.find(
           (workspace) => workspace.cwd === cwd
         );
@@ -4485,7 +4559,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       "qwen serve: required external tool guard handshake succeeded."
     );
   }
-  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-LZDCNJGV.js");
+  const { createDaemonToolGuard } = await import("./daemon-git-worktree-guard-DXYIMWFT.js");
   const daemonToolGuardHandler = createDaemonToolGuard(
     externalToolGuardHandler
   );
@@ -4521,6 +4595,28 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     }
   }
   const webShellMounted = !!webShellDir;
+  const serveAppLifecycle = new ServeAppLifecycleController();
+  const liveDiscoveryStableBaseDir = path.resolve(
+    deps.liveDiscoveryStableBaseDir ?? path.join(os.homedir(), ".qwen")
+  );
+  let resolveServeAppStartup;
+  let rejectServeAppStartup;
+  let serveAppStartupSettled = false;
+  const serveAppStartupReady = new Promise((resolve3, reject) => {
+    resolveServeAppStartup = resolve3;
+    rejectServeAppStartup = reject;
+  });
+  void serveAppStartupReady.catch(() => void 0);
+  const markServeAppStartupReady = /* @__PURE__ */ __name(() => {
+    if (serveAppStartupSettled) return;
+    serveAppStartupSettled = true;
+    resolveServeAppStartup();
+  }, "markServeAppStartupReady");
+  const markServeAppStartupFailed = /* @__PURE__ */ __name((error) => {
+    if (serveAppStartupSettled) return;
+    serveAppStartupSettled = true;
+    rejectServeAppStartup(error);
+  }, "markServeAppStartupFailed");
   let runtimeApp;
   let runtimeAppForCleanup;
   let bridgeRef = deps.bridge;
@@ -4595,7 +4691,6 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     };
   }, "resolveChannelWebhookConfigSource");
   let closeServerAfterChannelWorkerStartupFailure = false;
-  let runtimeFailureListenerClose;
   const getChannelWorkerSnapshot = /* @__PURE__ */ __name(() => channelWorkerManager?.primarySnapshot() ?? {
     enabled: false,
     state: "disabled",
@@ -4792,7 +4887,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       loadCoreRuntime(),
       loadSettingsRuntimeModules(),
       cliVersionPromise,
-      import("./daemon-trust-policy-TSRVEYZR.js")
+      import("./daemon-trust-policy-E67OYUK2.js")
     ]);
     cliVersion = resolvedCliVersion;
     settingsRuntime.environment.preResolveHomeEnvOverrides();
@@ -4815,7 +4910,6 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         `qwen serve: managed scratch workspaces are unavailable: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    const liveConversationWorkspace = deps.liveConversationWorkspace ?? new ConversationWorkspace();
     let runtimeBootSettings;
     try {
       runtimeBootSettings = settingsRuntime.settings.loadSettings(
@@ -5165,7 +5259,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         resolveSkillSettings,
         skillSettingStrings,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-YOE7LBHE.js");
+      } = await import("./skill-settings-J65JKKES.js");
       const fresh = loadSettingsForPersistence(workspace);
       const normalizedName = skillName.trim().toLowerCase();
       const resolved = resolveSkillSettings(fresh);
@@ -5230,7 +5324,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         resolveSkillSettings,
         skillSettingStrings,
         updateWorkspaceSkillSettingLists
-      } = await import("./skill-settings-YOE7LBHE.js");
+      } = await import("./skill-settings-J65JKKES.js");
       const fresh = loadSettingsForPersistence(workspace);
       const resolved = resolveSkillSettings(fresh);
       const initialDisabled = skillSettingStrings(
@@ -5335,7 +5429,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
       }
     }), "persistSettingsFn");
-    const { createSubSessionLauncher } = await import("./create-sub-session-PA7MFTHK.js");
+    const { createSubSessionLauncher } = await import("./create-sub-session-2L5MQRN4.js");
     const subSessionLauncher = createSubSessionLauncher({
       getBridge: /* @__PURE__ */ __name(() => bridgeRef, "getBridge"),
       boundWorkspace,
@@ -5845,7 +5939,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     workspaceRegistryForPersistence.current = workspaceRegistry;
     const workspaceVoiceCoordinator = new WorkspaceVoiceCoordinator();
     core.registerDaemonGaugeCallbacks({
-      sessionCount: /* @__PURE__ */ __name(() => workspaceRegistry.list().reduce((sum, item) => sum + item.bridge.sessionCount, 0), "sessionCount"),
+      sessionCount: /* @__PURE__ */ __name(() => workspaceRegistry.listAll().reduce((sum, item) => sum + item.bridge.sessionCount, 0), "sessionCount"),
       sseCount: /* @__PURE__ */ __name(() => runtime.getActiveSseCount(), "sseCount"),
       heapUsed: /* @__PURE__ */ __name(() => process.memoryUsage().heapUsed, "heapUsed")
     });
@@ -5894,12 +5988,12 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           cpuPercent,
           rssBytes: mem.rss,
           heapUsedBytes: mem.heapUsed,
-          activeSessions: workspaceRegistry.list().reduce((sum, item) => sum + item.bridge.sessionCount, 0),
-          activePrompts: workspaceRegistry.list().reduce(
+          activeSessions: workspaceRegistry.listAll().reduce((sum, item) => sum + item.bridge.sessionCount, 0),
+          activePrompts: workspaceRegistry.listAll().reduce(
             (sum, item) => sum + (item.bridge.activePromptCount ?? 0),
             0
           ),
-          queuedPrompts: workspaceRegistry.list().reduce(
+          queuedPrompts: workspaceRegistry.listAll().reduce(
             (sum, item) => sum + (item.bridge.pendingPromptTotal ?? 0),
             0
           ),
@@ -6510,8 +6604,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           { createChannelManagementService },
           { WorkspaceChannelSettingsStore }
         ] = await Promise.all([
-          import("./channel-management-service-OADNGQM3.js"),
-          import("./channel-settings-store-4ODLJ4X2.js")
+          import("./channel-management-service-GWY2GAIC.js"),
+          import("./channel-settings-store-WNWYFHG7.js")
         ]);
         return createChannelManagementService({
           workspaceCwd: targetRuntime.workspaceCwd,
@@ -6565,6 +6659,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       throw new Error("Workspace runtime publication validation failed.");
     }, "validateWorkspaceRuntimeForPublication");
     const app2 = runtime.createServeApp(opts, () => actualPort, {
+      serveAppLifecycle,
+      liveDiscoveryStableBaseDir,
       workspaceRegistry,
       getSessionBridges: /* @__PURE__ */ __name(() => runtimeBridges, "getSessionBridges"),
       createWorkspaceRuntime: createDynamicWorkspaceRuntime,
@@ -6712,8 +6808,8 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         { createWorkspaceTrustReconciler },
         { createDaemonTrustPolicyMonitor }
       ] = await Promise.all([
-        import("./workspace-trust-reconciler-H36TCR2S.js"),
-        import("./daemon-trust-policy-monitor-2K2YETMT.js")
+        import("./workspace-trust-reconciler-AYGXC7A3.js"),
+        import("./daemon-trust-policy-monitor-RYYGCQ3J.js")
       ]);
       const materializationFor = /* @__PURE__ */ __name((entry, snapshot, decision) => {
         const boundWorkspaces2 = entry.primary && decision.targetTrusted ? runtime.resolveBoundWorkspacesFromIdeEnv(
@@ -6928,7 +7024,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     );
   }
   const channelValidationSettingsRuntime = opts.channelSelection ? await loadSettingsRuntimeModules() : void 0;
-  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-TSRVEYZR.js") : void 0;
+  const channelValidationTrustPolicy = opts.channelSelection ? await import("./daemon-trust-policy-E67OYUK2.js") : void 0;
   const channelValidationTrustSnapshot = channelValidationTrustPolicy ? await channelValidationTrustPolicy.readDaemonTrustPolicySnapshot() : void 0;
   const resolveChannelWorkspaceGroupsAtListen = /* @__PURE__ */ __name(() => {
     if (!opts.channelSelection || !channelValidationSettingsRuntime || !channelRuntime) {
@@ -7035,6 +7131,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
     reserveChannelServicePidfile(opts.channelSelection);
   }
   return await new Promise((resolve3, reject) => {
+    let closeHost;
     const onListening = /* @__PURE__ */ __name((error) => {
       if (error) return;
       startup.listenerReadyAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -7054,26 +7151,40 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       const url = `${scheme}://${formatHostForUrl(opts.hostname)}:${actualPort}`;
       const liveRuntimeBaseDir = path.dirname(daemonLogBaseDir);
       const liveDiscoveryOwners = [];
+      const rememberLiveDiscoveryOwner = /* @__PURE__ */ __name((owner) => {
+        if (liveDiscoveryOwners.some(
+          (candidate) => candidate.runtimeBaseDir === owner.runtimeBaseDir && candidate.instanceNonce === owner.instanceNonce && candidate.pid === owner.pid
+        )) {
+          return;
+        }
+        liveDiscoveryOwners.push(owner);
+      }, "rememberLiveDiscoveryOwner");
       let liveDiscoveryPublish;
       let liveDiscoveryRetryTimer;
       let liveDiscoveryRetryTask;
+      let liveDiscoveryBootRetryApp;
       let liveDiscoveryEnabled = false;
       let liveDiscoveryShuttingDown = false;
       let liveDiscoveryToggle = Promise.resolve();
       let attemptPendingLiveDiscovery;
       const pendingLiveDiscoveryBaseDirs = /* @__PURE__ */ new Set();
       const warnedLiveDiscoveryOwners = /* @__PURE__ */ new Set();
+      let warnedLiveDiscoveryBootFailure = false;
       const liveDiscoveryRetryDelayMs = deps.liveDiscoveryRetryDelayMs !== void 0 && Number.isFinite(deps.liveDiscoveryRetryDelayMs) && deps.liveDiscoveryRetryDelayMs >= 10 ? Math.min(deps.liveDiscoveryRetryDelayMs, 6e4) : DEFAULT_LIVE_DISCOVERY_RETRY_MS;
       const scheduleLiveDiscoveryRetry = /* @__PURE__ */ __name(() => {
-        if (liveDiscoveryShuttingDown || !liveDiscoveryEnabled || liveDiscoveryRetryTimer || liveDiscoveryRetryTask || pendingLiveDiscoveryBaseDirs.size === 0 || !attemptPendingLiveDiscovery) {
+        if (liveDiscoveryShuttingDown || !liveDiscoveryEnabled || liveDiscoveryRetryTimer || liveDiscoveryRetryTask || !liveDiscoveryBootRetryApp && (pendingLiveDiscoveryBaseDirs.size === 0 || !attemptPendingLiveDiscovery)) {
           return;
         }
         liveDiscoveryRetryTimer = setTimeout(() => {
           liveDiscoveryRetryTimer = void 0;
-          if (liveDiscoveryShuttingDown || !liveDiscoveryEnabled || !attemptPendingLiveDiscovery) {
+          if (liveDiscoveryShuttingDown || !liveDiscoveryEnabled) {
             return;
           }
-          const retry = attemptPendingLiveDiscovery().finally(() => {
+          const retryApp = liveDiscoveryBootRetryApp;
+          liveDiscoveryBootRetryApp = void 0;
+          const retryOperation = retryApp ? publishLiveDiscovery(retryApp) : attemptPendingLiveDiscovery?.();
+          if (!retryOperation) return;
+          const retry = retryOperation.finally(() => {
             if (liveDiscoveryRetryTask === retry) {
               liveDiscoveryRetryTask = void 0;
             }
@@ -7098,16 +7209,20 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         const coordinator = candidateApp.locals?.["liveCoordinator"];
         const instanceNonce = coordinator?.daemonInstanceNonce;
         if (typeof instanceNonce !== "string") return Promise.resolve();
-        liveDiscoveryPublish = loadLiveDiscoveryRuntime().then(
+        let publicationFailed = false;
+        let publicationRetryable = false;
+        const publication = serveAppLifecycle.startBoot().then(() => loadLiveDiscoveryRuntime()).then(
           async ({
-            getStableLiveDiscoveryBaseDir,
+            handoffLiveDiscoveryOwner,
             LiveDiscoveryOwnerActiveError,
+            LiveDiscoveryPublicationError,
+            removeLiveDiscoveryFile,
             writeLiveDiscoveryFile
           }) => {
             if (liveDiscoveryShuttingDown || !liveDiscoveryEnabled) return;
-            const stableBaseDir = path.resolve(
-              deps.liveDiscoveryStableBaseDir ?? getStableLiveDiscoveryBaseDir()
-            );
+            liveDiscoveryBootRetryApp = void 0;
+            warnedLiveDiscoveryBootFailure = false;
+            const stableBaseDir = liveDiscoveryStableBaseDir;
             const runtimeBaseDir = path.resolve(liveRuntimeBaseDir);
             const targetBaseDirs = /* @__PURE__ */ new Set();
             if (runtimeBaseDir !== stableBaseDir) {
@@ -7125,21 +7240,51 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
               instanceNonce
             };
             attemptPendingLiveDiscovery = /* @__PURE__ */ __name(async () => {
-              for (const runtimeBaseDir2 of [
-                ...pendingLiveDiscoveryBaseDirs
-              ]) {
-                if (liveDiscoveryShuttingDown || !liveDiscoveryEnabled)
+              const targets = [...pendingLiveDiscoveryBaseDirs];
+              const published = [];
+              const rollbackPublished = /* @__PURE__ */ __name(async () => {
+                for (const owner of published.splice(0)) {
+                  try {
+                    await removeLiveDiscoveryFile(
+                      owner.runtimeBaseDir,
+                      owner
+                    );
+                  } catch (cleanupError) {
+                    rememberLiveDiscoveryOwner(owner);
+                    daemonLog.warn(
+                      `failed to roll back Live Host discovery at ${owner.runtimeBaseDir}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
+                    );
+                  }
+                }
+              }, "rollbackPublished");
+              for (const runtimeBaseDir2 of targets) {
+                if (liveDiscoveryShuttingDown || !liveDiscoveryEnabled) {
+                  await rollbackPublished();
                   return;
+                }
                 try {
+                  if (runtimeBaseDir2 !== stableBaseDir) {
+                    await handoffLiveDiscoveryOwner(
+                      runtimeBaseDir2,
+                      record,
+                      async () => void 0
+                    );
+                  }
                   await writeLiveDiscoveryFile(runtimeBaseDir2, record);
-                  pendingLiveDiscoveryBaseDirs.delete(runtimeBaseDir2);
-                  warnedLiveDiscoveryOwners.delete(runtimeBaseDir2);
-                  liveDiscoveryOwners.push({
+                  published.push({
                     runtimeBaseDir: runtimeBaseDir2,
                     instanceNonce,
                     pid: process.pid
                   });
                 } catch (err) {
+                  if (err instanceof LiveDiscoveryPublicationError && err.published) {
+                    published.push({
+                      runtimeBaseDir: runtimeBaseDir2,
+                      instanceNonce,
+                      pid: process.pid
+                    });
+                  }
+                  await rollbackPublished();
                   if (err instanceof LiveDiscoveryOwnerActiveError) {
                     if (!warnedLiveDiscoveryOwners.has(runtimeBaseDir2)) {
                       warnedLiveDiscoveryOwners.add(runtimeBaseDir2);
@@ -7147,49 +7292,77 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
                         `failed to publish Live Host discovery at ${runtimeBaseDir2}: ${err.message}`
                       );
                     }
-                    continue;
+                    return;
                   }
-                  pendingLiveDiscoveryBaseDirs.delete(runtimeBaseDir2);
                   daemonLog.warn(
                     `failed to publish Live Host discovery at ${runtimeBaseDir2}: ${err instanceof Error ? err.message : String(err)}`
                   );
+                  return;
                 }
               }
+              for (const owner of published) {
+                pendingLiveDiscoveryBaseDirs.delete(owner.runtimeBaseDir);
+                warnedLiveDiscoveryOwners.delete(owner.runtimeBaseDir);
+                rememberLiveDiscoveryOwner(owner);
+              }
             }, "attemptPendingLiveDiscovery");
             await attemptPendingLiveDiscovery();
             scheduleLiveDiscoveryRetry();
           }
         ).catch((err) => {
-          daemonLog.warn(
-            `failed to publish Live Host discovery: ${err instanceof Error ? err.message : String(err)}`
-          );
+          publicationFailed = true;
+          publicationRetryable = err instanceof ConversationRuntimeOwnershipError && err.retryable;
+          if (!publicationRetryable || !warnedLiveDiscoveryBootFailure) {
+            warnedLiveDiscoveryBootFailure = publicationRetryable;
+            daemonLog.warn(
+              `failed to publish Live Host discovery: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        });
+        const trackedPublication = publication.finally(() => {
+          if (publicationFailed && liveDiscoveryPublish === trackedPublication) {
+            liveDiscoveryPublish = void 0;
+            if (publicationRetryable && !liveDiscoveryShuttingDown && liveDiscoveryEnabled) {
+              liveDiscoveryBootRetryApp = candidateApp;
+              scheduleLiveDiscoveryRetry();
+            }
+          }
         });
+        liveDiscoveryPublish = trackedPublication;
         return liveDiscoveryPublish;
       }, "publishLiveDiscovery");
       const removeLiveDiscoveryOwners = /* @__PURE__ */ __name(async () => {
-        const owners = liveDiscoveryOwners.splice(0);
+        const owners = [...liveDiscoveryOwners];
         if (owners.length === 0) return;
         let removeLiveDiscoveryFile;
         try {
           ({ removeLiveDiscoveryFile } = await loadLiveDiscoveryRuntime());
         } catch (err) {
-          daemonLog.warn(
-            `failed to load Live discovery runtime for cleanup: ${err instanceof Error ? err.message : String(err)}`
-          );
-          return;
+          throw new Error("Failed to load Live discovery cleanup support.", {
+            cause: err
+          });
         }
+        const errors = [];
         for (const owner of owners) {
           try {
             await removeLiveDiscoveryFile(owner.runtimeBaseDir, owner);
+            const index = liveDiscoveryOwners.indexOf(owner);
+            if (index >= 0) liveDiscoveryOwners.splice(index, 1);
           } catch (err) {
-            daemonLog.warn(
-              `failed to remove Live Host discovery at ${owner.runtimeBaseDir}: ${err instanceof Error ? err.message : String(err)}`
-            );
+            errors.push(err);
           }
         }
+        if (errors.length > 0) {
+          throw new AggregateError(
+            errors,
+            "Live Host discovery cleanup is incomplete."
+          );
+        }
       }, "removeLiveDiscoveryOwners");
       const unpublishLiveDiscovery = /* @__PURE__ */ __name(async () => {
         liveDiscoveryEnabled = false;
+        liveDiscoveryBootRetryApp = void 0;
+        warnedLiveDiscoveryBootFailure = false;
         cancelLiveDiscoveryRetry();
         pendingLiveDiscoveryBaseDirs.clear();
         attemptPendingLiveDiscovery = void 0;
@@ -7207,6 +7380,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           liveDiscoveryToggle = operation.catch(() => void 0);
           return operation;
         };
+        candidateApp.locals.onConversationRuntimeReady = () => {
+          void publishLiveDiscovery(candidateApp);
+        };
       }, "attachLiveDiscoveryControl");
       const cleanupLiveDiscovery = /* @__PURE__ */ __name(async () => {
         liveDiscoveryShuttingDown = true;
@@ -7214,58 +7390,6 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         await liveDiscoveryToggle;
         await unpublishLiveDiscovery();
       }, "cleanupLiveDiscovery");
-      try {
-        channelWorkspaceGroups = resolveChannelWorkspaceGroupsAtListen();
-      } catch (err) {
-        removeCurrentServePidfile();
-        const error2 = err instanceof Error ? err : new Error(String(err));
-        server.close((closeErr) => {
-          if (closeErr) {
-            daemonLog.error(
-              "server close after channel worker validation error failed",
-              closeErr
-            );
-          }
-          reject(error2);
-        });
-        return;
-      }
-      if (channelWorkspaceGroups) {
-        for (const group of channelWorkspaceGroups) {
-          daemonLog.info("channel worker group assigned", {
-            workspace: group.workspaceCwd,
-            channels: group.selection.mode === "all" ? ["all"] : group.selection.names
-          });
-        }
-        if (opts.channelSelection?.mode === "all") {
-          writeStderrLine(
-            "qwen serve: --channel all is primary-workspace only; non-primary workspace channels are not hosted."
-          );
-        }
-      }
-      writeStdoutLine(
-        `qwen serve listening on ${url} (mode=${opts.mode}, workspace=${boundWorkspace})`
-      );
-      writeStderrLine(
-        `qwen serve: bound to workspace ${JSON.stringify(boundWorkspace)}`
-      );
-      writeStderrLine(
-        `qwen serve: startup timing: processToListenMs=${startup.processToListenMs} runQwenServeToListenMs=${startup.runQwenServeToListenMs}`
-      );
-      if (!token) {
-        writeStderrLine(
-          `qwen serve: bearer auth disabled (loopback default). Set ${QWEN_SERVER_TOKEN_ENV} to enable.`
-        );
-        if (opts.clientMcpOverWs === true) {
-          writeStderrLine(
-            `qwen serve: client-hosted MCP tools are accepted over the WebSocket without auth. Set ${QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV}=0 to disable.`
-          );
-        }
-      } else if (opts.requireAuth) {
-        writeStderrLine(
-          "qwen serve: --require-auth enabled (bearer token mandatory on every route, including loopback /health)."
-        );
-      }
       let shuttingDown = false;
       let closePromise;
       let runtimeStartupTimer;
@@ -7332,6 +7456,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       }, "stopChannelWorkerAfterFailedStartup");
       const failRuntimeStartup = /* @__PURE__ */ __name(async (err, bridgeForCleanup) => {
         const error2 = err instanceof Error ? err : new Error(String(err));
+        markServeAppStartupFailed(error2);
         if (runtimeStartupSettled) {
           disposeRuntimeAppResources(runtimeApp ?? runtimeAppForCleanup);
           await shutdownBridgeAfterFailedStartup(bridgeForCleanup);
@@ -7351,16 +7476,13 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         daemonLog.error("runtime startup failed", error2);
         markRuntimeFailed(error2);
         if (closeServerAfterChannelWorkerStartupFailure && server.listening) {
-          runtimeFailureListenerClose = new Promise((resolve4) => {
-            server.close((closeErr) => {
-              if (closeErr) {
-                daemonLog.error(
-                  "server close after runtime startup error failed",
-                  closeErr
-                );
-              }
-              resolve4();
-            });
+          server.close((closeErr) => {
+            if (closeErr) {
+              daemonLog.error(
+                "server close after runtime startup error failed",
+                closeErr
+              );
+            }
           });
           server.closeAllConnections();
         }
@@ -7548,6 +7670,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           if (runtimeStartupSettled) return;
         }
         if (runtimeStartupSettled) return;
+        markServeAppStartupReady();
         await publishLiveDiscovery(candidateApp);
         runtimeStartupSettled = true;
         clearRuntimeStartupTimer();
@@ -7663,7 +7786,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
           process.exit(runtimeStartupError === void 0 ? 0 : 1);
         } catch (err) {
           daemonLog.error("shutdown error", err instanceof Error ? err : null);
-          if (err instanceof Error && retryableChannelWorkerShutdownErrors.has(err)) {
+          if (hasRetryableChannelWorkerShutdownError(err)) {
             daemonLog.error(
               "refusing to exit while a channel worker or service lease remains; signal again to retry after the child exits (another signal during that retry forces exit)"
             );
@@ -7698,10 +7821,12 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
             const initiallyMountedApp = runtimeApp ?? runtimeAppForCleanup;
             const initiallyMountedManagement = initiallyMountedApp?.locals?.["workspaceManagementHandle"];
             const initiallyMountedSessionMaintenance = initiallyMountedApp?.locals?.["sessionArchiveCoordinator"];
+            const initiallyMountedConversationActivity = initiallyMountedApp?.locals?.["conversationRuntimeActivity"];
             const initialManagementWait = initiallyMountedManagement?.sealAndWait?.();
             const initiallyMountedLive = initiallyMountedApp?.locals;
             const initialLiveWait = initiallyMountedLive?.sealAndWaitLiveCoordinator?.();
             const initialSessionMaintenanceWait = initiallyMountedSessionMaintenance?.sealMaintenanceAndWait?.();
+            const initialConversationActivityWait = initiallyMountedConversationActivity?.sealAndWait?.();
             let processRegistryShutdown;
             const startProcessRegistryShutdown = /* @__PURE__ */ __name(() => {
               processRegistryShutdown ??= managedProcessRegistry?.shutdown().then(
@@ -7735,7 +7860,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
                   `qwen serve: telemetry shutdown error: ${telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr)}`
                 );
               }).finally(async () => {
-                const finalErr = err ?? bridgeShutdownError ?? channelWorkerShutdownError;
+                let finalErr = err ?? bridgeShutdownError ?? channelWorkerShutdownError;
                 const retryableChannelClose = channelWorkerShutdownError !== void 0 && channelWorkerManager?.state().enabled === true;
                 if (retryableChannelClose) {
                   const retryableError = channelWorkerShutdownError;
@@ -7750,7 +7875,20 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
                   rej(retryableError);
                   return;
                 }
-                await cleanupLiveDiscovery();
+                try {
+                  await cleanupLiveDiscovery();
+                } catch (cleanupError) {
+                  const normalizedCleanupError = cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
+                  if (finalErr) {
+                    writeDaemonLifecycleBestEffort(() => {
+                      daemonLog.error(
+                        "Live Host discovery cleanup failed during shutdown",
+                        normalizedCleanupError
+                      );
+                    });
+                  }
+                  finalErr ??= normalizedCleanupError;
+                }
                 if (loggerPublished || loggerSignalOwned) {
                   writeDaemonLifecycleBestEffort(() => {
                     if (finalErr) {
@@ -7782,6 +7920,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
               const appForCleanup = runtimeApp ?? runtimeAppForCleanup;
               const workspaceManagementHandle = appForCleanup?.locals?.["workspaceManagementHandle"];
               const sessionMaintenance = appForCleanup?.locals?.["sessionArchiveCoordinator"];
+              const conversationActivity = appForCleanup?.locals?.["conversationRuntimeActivity"];
               await initialManagementWait;
               if (workspaceManagementHandle !== initiallyMountedManagement) {
                 await workspaceManagementHandle?.sealAndWait?.();
@@ -7795,6 +7934,10 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
               if (sessionMaintenance !== initiallyMountedSessionMaintenance) {
                 await sessionMaintenance?.sealMaintenanceAndWait?.();
               }
+              await initialConversationActivityWait;
+              if (conversationActivity !== initiallyMountedConversationActivity) {
+                await conversationActivity?.sealAndWait?.();
+              }
               stopTrustPolicyMonitor(appForCleanup);
               const waitForTrustPolicyIdle = appForCleanup?.locals?.["waitForTrustPolicyIdle"];
               await waitForTrustPolicyIdle?.().catch((err) => {
@@ -7862,43 +8005,71 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
                 );
                 bridgeShutdownError ??= processRegistryError;
               }
-            }).finally(() => {
-              if (!server.listening) {
-                void (runtimeFailureListenerClose ?? Promise.resolve()).then(
-                  () => finish()
-                );
-                return;
-              }
-              const SECONDARY_DEADLINE_MS = 2e3;
-              let secondaryTimer;
-              const forceTimer = setTimeout(() => {
-                daemonLog.warn(
-                  `${SHUTDOWN_FORCE_CLOSE_MS}ms listener-drain timeout reached; force-closing remaining connections`
-                );
-                server.closeAllConnections();
-                secondaryTimer = setTimeout(() => {
-                  daemonLog.warn(
-                    `server.close did not fire ${SECONDARY_DEADLINE_MS}ms after force-close; resolving anyway`
-                  );
-                  finish();
-                }, SECONDARY_DEADLINE_MS);
-                secondaryTimer.unref();
-              }, SHUTDOWN_FORCE_CLOSE_MS);
-              forceTimer.unref();
-              server.close((err) => {
-                clearTimeout(forceTimer);
-                if (secondaryTimer) clearTimeout(secondaryTimer);
-                finish(err);
-              });
-            });
+            }).then(
+              () => finish(),
+              (error2) => finish(
+                error2 instanceof Error ? error2 : new Error(String(error2))
+              )
+            );
           });
           return closePromise;
         }, "close")
       };
+      closeHost = handle.close;
+      handle.close = () => serveAppLifecycle.close();
+      try {
+        channelWorkspaceGroups = resolveChannelWorkspaceGroupsAtListen();
+      } catch (err) {
+        removeCurrentServePidfile();
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        markServeAppStartupFailed(error2);
+        void serveAppLifecycle.close().then(
+          () => reject(error2),
+          (closeError) => reject(
+            closeError instanceof Error ? new AggregateError([error2, closeError], error2.message) : error2
+          )
+        );
+        return;
+      }
+      if (channelWorkspaceGroups) {
+        for (const group of channelWorkspaceGroups) {
+          daemonLog.info("channel worker group assigned", {
+            workspace: group.workspaceCwd,
+            channels: group.selection.mode === "all" ? ["all"] : group.selection.names
+          });
+        }
+        if (opts.channelSelection?.mode === "all") {
+          writeStderrLine(
+            "qwen serve: --channel all is primary-workspace only; non-primary workspace channels are not hosted."
+          );
+        }
+      }
+      writeStdoutLine(
+        `qwen serve listening on ${url} (mode=${opts.mode}, workspace=${boundWorkspace})`
+      );
+      writeStderrLine(
+        `qwen serve: bound to workspace ${JSON.stringify(boundWorkspace)}`
+      );
+      writeStderrLine(
+        `qwen serve: startup timing: processToListenMs=${startup.processToListenMs} runQwenServeToListenMs=${startup.runQwenServeToListenMs}`
+      );
+      if (!token) {
+        writeStderrLine(
+          `qwen serve: bearer auth disabled (loopback default). Set ${QWEN_SERVER_TOKEN_ENV} to enable.`
+        );
+        if (opts.clientMcpOverWs === true) {
+          writeStderrLine(
+            `qwen serve: client-hosted MCP tools are accepted over the WebSocket without auth. Set ${QWEN_SERVE_CLIENT_MCP_OVER_WS_ENV}=0 to disable.`
+          );
+        }
+      } else if (opts.requireAuth) {
+        writeStderrLine(
+          "qwen serve: --require-auth enabled (bearer token mandatory on every route, including loopback /health)."
+        );
+      }
       process.on("SIGINT", onSignal);
       process.on("SIGTERM", onSignal);
       process.on("uncaughtExceptionMonitor", onUncaughtExceptionMonitor);
-      server.removeAllListeners("error");
       server.on("error", (err) => {
         daemonLog.error("server error", err instanceof Error ? err : null);
       });
@@ -7916,6 +8087,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         } else {
           const acpHandle = preparedRuntimeApp.locals?.["acpHandle"];
           acpHandle?.attachServer?.(server);
+          markServeAppStartupReady();
           void publishLiveDiscovery(preparedRuntimeApp);
         }
       } else if (deferRuntimeUntilFirstHealth) {
@@ -7949,7 +8121,7 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
                     closeErr instanceof Error ? closeErr : null
                   )
                 );
-                if (closeErr instanceof Error && retryableChannelWorkerShutdownErrors.has(closeErr)) {
+                if (hasRetryableChannelWorkerShutdownError(closeErr)) {
                   writeDaemonLifecycleBestEffort(
                     () => daemonLog.error(
                       "runtime startup failed, but qwen serve remains alive to retain the channel service lease until worker exit is confirmed"
@@ -7965,10 +8137,9 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
       }
     }, "onListening");
     let server;
-    let httpsServer;
     if (tlsOptions) {
       try {
-        httpsServer = https.createServer(tlsOptions, app);
+        server = https.createServer(tlsOptions, app);
       } catch (err) {
         reject(
           new Error(
@@ -7977,38 +8148,69 @@ async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
         );
         return;
       }
-    }
+    } else {
+      server = deps.httpServerFactory?.(app) ?? createServer(app);
+    }
+    serveAppLifecycle.bindServer(server, {
+      startupReady: serveAppStartupReady,
+      drainHost: /* @__PURE__ */ __name(() => {
+        if (closeHost) return closeHost();
+        if (!server.listening) return Promise.resolve();
+        return new Promise((resolve4, rejectClose) => {
+          server.close((error) => {
+            if (error) rejectClose(error);
+            else resolve4();
+          });
+        });
+      }, "drainHost")
+    });
     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 handleListening = /* @__PURE__ */ __name(() => {
+        server.removeListener("error", handleError);
+        onListening();
+      }, "handleListening");
+      const handleError = /* @__PURE__ */ __name((err) => {
+        server.removeListener("listening", handleListening);
         const nextPort = attemptPort + 1;
         if (err.code === "EADDRINUSE" && opts.strictPort !== true && 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);
+          return;
         }
-      });
+        if (err.code === "EADDRINUSE" && attempt > 0) {
+          writeStderrLine(
+            `qwen serve: all ports ${opts.port}\u2013${attemptPort} are in use`
+          );
+        }
+        removeCurrentServePidfile();
+        markServeAppStartupFailed(err);
+        void serveAppLifecycle.close().then(
+          () => reject(err),
+          (closeError) => reject(
+            closeError instanceof Error ? new AggregateError([err, closeError], err.message) : err
+          )
+        );
+      }, "handleError");
+      try {
+        server.once("listening", handleListening);
+        server.once("error", handleError);
+        server.listen(attemptPort, listenHostname);
+      } catch (err) {
+        removeCurrentServePidfile();
+        server.removeListener("listening", handleListening);
+        server.removeListener("error", handleError);
+        const error = err instanceof Error ? err : new Error(String(err));
+        markServeAppStartupFailed(error);
+        void serveAppLifecycle.close().then(
+          () => reject(error),
+          (closeError) => reject(
+            closeError instanceof Error ? new AggregateError([error, closeError], error.message) : error
+          )
+        );
+        return;
+      }
     }, "tryListen");
     tryListen(opts.port, 0);
   });