@qwen-code/qwen-code 0.21.8 → 0.21.9

package/chunks/{server-OWMEMAKR.js → server-ADMLELR6.js}

@@ -1,5 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  deriveWebSocketBase,
+  openQwenAsrRealtimeStream,
+  openVoiceStream,
+  openVoiceStreamWithRetry
+} from "./chunk-Q3JQ7OSU.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   LIVE_SESSION_SOURCE_PREFIX,
@@ -11,7 +17,6 @@ import {
   isCompatibleLiveSessionSource,
   isReservedLiveSessionSource,
   isValidServerName,
-  loadSettingsCached,
   normalizeChannelDelivery,
   parseChannelDelivery,
   readLoadableLiveConversationMetadata,
@@ -21,13 +26,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-ZPLALRXZ.js";
-import {
-  deriveWebSocketBase,
-  openQwenAsrRealtimeStream,
-  openVoiceStream,
-  openVoiceStreamWithRetry
-} from "./chunk-Q3JQ7OSU.js";
+} from "./chunk-FBMCDU63.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -39,12 +38,12 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-2M4K4KYS.js";
+} from "./chunk-P3RBMQ4P.js";
 import {
   OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
   ObservedChannelContactStore
 } from "./chunk-OWMAZHIX.js";
-import "./chunk-4ALIARFY.js";
+import "./chunk-UYAUA63Q.js";
 import {
   escapeAnsiCtrlCodes
 } from "./chunk-4NFY2S7N.js";
@@ -108,46 +107,14 @@ import {
   setRateLimiter,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-KAQCJO6Y.js";
+} from "./chunk-KTKYGS2P.js";
+import "./chunk-VGHZT6JR.js";
 import {
-  isLoopbackBind
-} from "./chunk-RXFQM6FQ.js";
+  isLoopbackBind,
+  normalizeSessionIdForLookup,
+  parseCallerSuppliedSessionId
+} from "./chunk-TQOF5KBL.js";
 import "./chunk-HGCQ5SE7.js";
-import {
-  createTotalSessionAdmissionController
-} from "./chunk-AKA24BGO.js";
-import {
-  WorkspaceGenerationClosedError,
-  createSingleWorkspaceRegistry,
-  createWorkspaceSessionOwnerIndex
-} from "./chunk-2M5N3DHY.js";
-import "./chunk-GRC5HGPI.js";
-import {
-  assertValidChannelSecretUpdates
-} from "./chunk-4WU6NY7F.js";
-import {
-  createWorkspaceProvidersStatusProvider
-} from "./chunk-XZKQT2B2.js";
-import {
-  getAuthTypeFromEnv,
-  resolveCliGenerationConfig
-} from "./chunk-GBDINRIL.js";
-import {
-  createWorkspaceSkillsStatusProvider
-} from "./chunk-DX5W5AON.js";
-import "./chunk-BGXZBI5B.js";
-import {
-  isServeDebugMode,
-  mountWebShellAssets,
-  mountWebShellSpaFallback
-} from "./chunk-SOORFWKY.js";
-import {
-  require_express
-} from "./chunk-GDXET5XU.js";
-import {
-  evaluateDaemonWorkspaceTrust,
-  readDaemonTrustPolicySnapshot
-} from "./chunk-SNRT2TJJ.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   MAX_WORKSPACE_SKILL_NAME_LENGTH,
@@ -161,14 +128,14 @@ import {
   validateWorkspaceSkillName,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-IBYULW65.js";
+} from "./chunk-46YJDYCU.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-KKDVZLGL.js";
+} from "./chunk-BAMN6XSD.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -176,46 +143,92 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-DQSDACD2.js";
+} from "./chunk-RBHQXGDK.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-C5VWPTGT.js";
+} from "./chunk-GAKGOXTC.js";
 import "./chunk-AOHJKPKL.js";
+import {
+  createTotalSessionAdmissionController
+} from "./chunk-BT6GQIEJ.js";
+import {
+  WorkspaceGenerationClosedError,
+  createSingleWorkspaceRegistry,
+  createWorkspaceSessionOwnerIndex
+} from "./chunk-CMOBWHWW.js";
+import "./chunk-OIBUG24X.js";
+import {
+  MAX_SESSION_RESTORE_TIMEOUT_MS,
+  resolveSessionRestoreTimeoutMs,
+  restoreRetryAfterSeconds
+} from "./chunk-4JRM2BSM.js";
+import {
+  assertValidChannelSecretUpdates
+} from "./chunk-QSNSL4R4.js";
+import {
+  createDaemonStatusProvider
+} from "./chunk-ZTQSOV56.js";
+import "./chunk-NTTBXH7U.js";
+import "./chunk-7S4JBJLU.js";
+import "./chunk-3SH53ANB.js";
+import {
+  createWorkspaceProvidersStatusProvider
+} from "./chunk-3WDYBTTI.js";
+import {
+  getAuthTypeFromEnv,
+  resolveCliGenerationConfig
+} from "./chunk-KTQGGPGV.js";
+import {
+  snapshotProcessEnv
+} from "./chunk-23VQTELM.js";
+import {
+  createWorkspaceSkillsStatusProvider
+} from "./chunk-ZBXGWQ4S.js";
+import "./chunk-BGXZBI5B.js";
 import "./chunk-Z4X5MTRT.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError,
-  WorkspaceSkillNotFoundError,
-  WorkspaceSkillNotToggleableError
-} from "./chunk-OA4JVLSA.js";
+  mapWorkspaceSkillToggleError
+} from "./chunk-Z7VOMGDC.js";
+import {
+  isServeDebugMode,
+  mountWebShellAssets,
+  mountWebShellSpaFallback
+} from "./chunk-SOORFWKY.js";
+import {
+  require_express
+} from "./chunk-GDXET5XU.js";
+import {
+  evaluateDaemonWorkspaceTrust,
+  readDaemonTrustPolicySnapshot
+} from "./chunk-G2TX5ZXC.js";
 import {
   daemonObservedContactsPath,
   loadChannelsConfig
-} from "./chunk-E4ZBKMSF.js";
-import "./chunk-QQWD7LZV.js";
+} from "./chunk-ATMO54WE.js";
+import "./chunk-HADWBW5R.js";
 import "./chunk-57OAHC2Y.js";
+import {
+  parseChannelWebhookConfigLenient
+} from "./chunk-LHEC5V6G.js";
+import "./chunk-67EWJE77.js";
+import {
+  supportedChannelCatalog
+} from "./chunk-E2FPSSKP.js";
 import {
   LIVE_HOST_BUNDLE_ID,
   LIVE_HOST_PROTOCOL_VERSION,
   LIVE_INPUT_AUDIO_EPOCH_BYTES
 } from "./chunk-NKLP3DCK.js";
-import {
-  createDaemonStatusProvider
-} from "./chunk-VWMUDKLC.js";
-import "./chunk-VXZBKKQR.js";
-import "./chunk-3SE7J4DR.js";
-import "./chunk-3SH53ANB.js";
-import {
-  snapshotProcessEnv
-} from "./chunk-S3Y3GBFD.js";
 import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge,
   parseSessionSource
-} from "./chunk-FYAXKJK7.js";
+} from "./chunk-P4ZEZSJZ.js";
 import {
   EVENT_SCHEMA_VERSION,
   EventBus,
@@ -223,22 +236,16 @@ import {
 } from "./chunk-MZSJ43WV.js";
 import "./chunk-XCGIMOLN.js";
 import "./chunk-OCPBI7J5.js";
-import "./chunk-RPWVIXDB.js";
+import "./chunk-I5VM3SKY.js";
 import {
   STATUS_SCHEMA_VERSION,
+  SessionRestoreTimeoutError,
   createIdleWorkspaceMemoryStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-NLREQJFK.js";
+} from "./chunk-DA4HRSBW.js";
 import "./chunk-K6KS3LTN.js";
 import "./chunk-FC4KQFCS.js";
 import "./chunk-T3CHYWJZ.js";
-import {
-  parseChannelWebhookConfigLenient
-} from "./chunk-QXVSWG66.js";
-import "./chunk-KJZ26VBX.js";
-import {
-  supportedChannelCatalog
-} from "./chunk-NGYI5EF5.js";
 import "./chunk-V6WHFGST.js";
 import {
   MAX_REGISTERED_WORKSPACES,
@@ -247,12 +254,14 @@ import {
   WorkspaceRegistrationStoreLimitError,
   normalizeWorkspaceDisplayName,
   workspaceRegistrationId
-} from "./chunk-757GB46F.js";
+} from "./chunk-W3FSZSF2.js";
 import {
+  REQUESTED_SESSION_ID_META_KEY,
   gradeActiveWorkCoverage
 } from "./chunk-M2PNLYGY.js";
 import {
   BranchWhilePromptActiveError,
+  BridgeChannelQuarantinedError,
   CancelSentinelCollisionError,
   CdWhilePromptActiveError,
   InvalidClientIdError,
@@ -283,7 +292,7 @@ import {
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
-} from "./chunk-J26HHFI5.js";
+} from "./chunk-LP2QGNSP.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace,
@@ -302,19 +311,19 @@ import {
 } from "./chunk-YP5KH5Y7.js";
 import {
   normalizeWorkerDiagnostic
-} from "./chunk-UFALT4LK.js";
+} from "./chunk-PBRVUF5B.js";
 import {
   normalizeServeChannelSelection
 } from "./chunk-ALMR3E6Q.js";
 import "./chunk-HIBNSEJE.js";
-import "./chunk-BKHCW2BI.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
+import "./chunk-BKHCW2BI.js";
 import "./chunk-5HBA2Z7V.js";
 import {
   sanitizeLogText
-} from "./chunk-DIWZNWZT.js";
+} from "./chunk-DX3RGJMS.js";
 import "./chunk-UDXSXLER.js";
 import {
   getDialogSettingKeys,
@@ -325,23 +334,26 @@ import {
   getWritableScopes,
   loadSettings,
   validateSettingValue
-} from "./chunk-OHKJVAKG.js";
+} from "./chunk-JUWS2Z5K.js";
+import "./chunk-7GOYZQPR.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
 import {
-  SUPPORTED_LANGUAGES,
   detectSystemLanguage,
-  resolveLanguageSetting,
+  resolveLanguageSetting
+} from "./chunk-WP5VOXF7.js";
+import {
+  SUPPORTED_LANGUAGES,
   resolveSupportedLanguage
-} from "./chunk-PG62DFWD.js";
-import "./chunk-B52AWKBB.js";
-import "./chunk-UA5H3DS2.js";
-import "./chunk-FN6YXJOP.js";
+} from "./chunk-5EJZE3FP.js";
+import "./chunk-T6HEQR2Q.js";
+import "./chunk-VFMASYQA.js";
+import "./chunk-IOEZE2YT.js";
 import "./chunk-VJNBRRZG.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-HA3SAB64.js";
+} from "./chunk-ZOSTTOUJ.js";
 import "./chunk-NPQ5ZKRP.js";
 import {
   isWithinRoot as isWithinRoot2
@@ -421,7 +433,7 @@ import {
   writeWorkspaceContextFile,
   writeWorktreeSession,
   writeWorktreeSessionMarker
-} from "./chunk-GXSNGY5M.js";
+} from "./chunk-XX7QFP34.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
@@ -434,7 +446,7 @@ import "./chunk-MVUQRLOH.js";
 import "./chunk-XCWO3SMQ.js";
 import "./chunk-7MH4J33A.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-VXZ5HAOV.js";
+import "./chunk-K4ADGWHU.js";
 import {
   nextFireTime,
   parseCron
@@ -462,7 +474,7 @@ import "./chunk-67N6HB5H.js";
 import {
   APPROVAL_MODES
 } from "./chunk-WAUGQKUU.js";
-import "./chunk-PLFATELK.js";
+import "./chunk-DZUO626D.js";
 import {
   addDaemonRequestAttribute,
   captureDaemonTelemetryContext,
@@ -474,7 +486,7 @@ import {
   recordDaemonHttpResponse,
   runWithDaemonTelemetryContext,
   withDaemonRequestSpan
-} from "./chunk-L4N6TIP7.js";
+} from "./chunk-4TRQPFDP.js";
 import "./chunk-SAH4BD2J.js";
 import "./chunk-CPG6P4GG.js";
 import "./chunk-S6LOFUVP.js";
@@ -521,23 +533,23 @@ import {
   isWithinRoot,
   parseLineTolerant,
   read
-} from "./chunk-3PY4LPJF.js";
+} from "./chunk-YGT2AUJ7.js";
 import "./chunk-WOJZWRAZ.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-FVKHVJZQ.js";
 import "./chunk-COBO5EBO.js";
 import "./chunk-6ZRFAKXK.js";
 import "./chunk-PYQADEFD.js";
-import "./chunk-M3STHEMM.js";
+import "./chunk-PVOGHGSF.js";
 import "./chunk-F6WFNA7U.js";
 import "./chunk-46UV252V.js";
 import "./chunk-ZBVS26BY.js";
 import "./chunk-KKBPOU75.js";
 import "./chunk-EUNWC2VS.js";
 import "./chunk-FOGU3LJX.js";
-import "./chunk-6M26GBKX.js";
+import "./chunk-L2AFWWJE.js";
 import "./chunk-W4RQUHY3.js";
-import "./chunk-LKRMNRSN.js";
+import "./chunk-PDPFQ2FO.js";
 import {
   FatalConfigError,
   Storage,
@@ -1225,26 +1237,165 @@ function createWorkspaceFileSystemFactory(deps) {
   });
   const lowFs = new StandardFileSystemService();
   const pathLocks = deps.pathLocks ?? new PathMutexRegistry();
+  const forRequest = /* @__PURE__ */ __name((ctx) => new WorkspaceFileSystemImpl({
+    primaryWorkspace,
+    workspaces,
+    trusted: deps.trusted,
+    audit,
+    ctx,
+    lowFs,
+    pathLocks,
+    generationGuard: deps.generationGuard
+  }), "forRequest");
   return {
     assertCanWrite() {
       deps.generationGuard?.assertOpen();
       assertTrustedForIntent(deps.trusted, "write");
     },
-    forRequest(ctx) {
-      return new WorkspaceFileSystemImpl({
-        primaryWorkspace,
-        workspaces,
-        trusted: deps.trusted,
-        audit,
-        ctx,
-        lowFs,
-        pathLocks,
-        generationGuard: deps.generationGuard
-      });
+    forRequest,
+    async writeSameHostToolText(ctx, request2) {
+      try {
+        deps.generationGuard?.assertOpen();
+      } catch (err) {
+        throw recordSameHostToolWriteDenied(audit, ctx, request2.path, err);
+      }
+      let resolved;
+      try {
+        resolved = await resolveWithinWorkspace(
+          request2.path,
+          workspaces.map((workspace) => workspace.path),
+          "write"
+        );
+        deps.generationGuard?.assertOpen();
+      } catch (err) {
+        if (!(err instanceof FsError && err.kind === "path_outside_workspace")) {
+          throw recordSameHostToolWriteDenied(audit, ctx, request2.path, err);
+        }
+        try {
+          await writeSameHostToolTextOutsideWorkspace({
+            request: request2,
+            trusted: deps.trusted,
+            audit,
+            ctx,
+            pathLocks,
+            generationGuard: deps.generationGuard
+          });
+          return;
+        } catch (outsideErr) {
+          throw recordSameHostToolWriteDenied(
+            audit,
+            ctx,
+            request2.path,
+            outsideErr
+          );
+        }
+      }
+      try {
+        await forRequest(ctx).writeTextOverwrite(resolved, request2.content);
+      } catch (err) {
+        if (isWorkspaceGenerationClosedError(err)) {
+          recordSameHostToolWriteDenied(audit, ctx, request2.path, err);
+        }
+        throw err;
+      }
     }
   };
 }
 __name(createWorkspaceFileSystemFactory, "createWorkspaceFileSystemFactory");
+async function writeSameHostToolTextOutsideWorkspace(deps) {
+  const start = performance.now();
+  deps.generationGuard?.assertOpen();
+  assertTrustedForIntent(deps.trusted, "write");
+  enforceWriteSize(Buffer.byteLength(deps.request.content, "utf-8"));
+  const target = await resolveSameHostToolWriteTarget(deps.request.path);
+  await deps.pathLocks.runExclusive(target, async () => {
+    deps.generationGuard?.assertOpen();
+    const meta = mergeWriteMeta(void 0, deps.request.meta ?? {});
+    const content = meta.bom && deps.request.content.charCodeAt(0) === 65279 ? deps.request.content.slice(1) : deps.request.content;
+    const result = await atomicWriteTextResolvedFile({
+      target,
+      content,
+      mode: "overwrite",
+      meta,
+      assertGenerationOpen: /* @__PURE__ */ __name(() => deps.generationGuard?.assertOpen(), "assertGenerationOpen")
+    });
+    deps.audit.recordAccess(deps.ctx, {
+      intent: "write",
+      absolute: target,
+      durationMs: performance.now() - start,
+      sizeBytes: result.sizeBytes
+    });
+  });
+}
+__name(writeSameHostToolTextOutsideWorkspace, "writeSameHostToolTextOutsideWorkspace");
+async function resolveSameHostToolWriteTarget(input) {
+  if (!path4.isAbsolute(input)) {
+    throw new FsError(
+      "path_outside_workspace",
+      `same-host external tool write requires an absolute path: ${input}`
+    );
+  }
+  if (hasSuspiciousPathPattern(input)) {
+    throw new FsError(
+      "path_outside_workspace",
+      `path contains suspicious pattern: ${input}`
+    );
+  }
+  let leaf;
+  try {
+    leaf = await fsp2.lstat(input);
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      throw err;
+    }
+    const parent = await fsp2.realpath(path4.dirname(input));
+    const parentStat = await fsp2.lstat(parent);
+    if (!parentStat.isDirectory()) {
+      throw new FsError(
+        "parse_error",
+        `parent path is not a directory: ${parent}`
+      );
+    }
+    return path4.join(parent, path4.basename(input));
+  }
+  if (leaf.isSymbolicLink()) {
+    throw new FsError(
+      "symlink_escape",
+      `path is a symlink and cannot be overwritten: ${input}`,
+      { hint: "resolve the target explicitly before writing" }
+    );
+  }
+  if (!leaf.isFile()) {
+    throw new FsError("parse_error", `path is not a regular file: ${input}`);
+  }
+  const canonical = await fsp2.realpath(input);
+  const canonicalStat = await fsp2.lstat(canonical);
+  if (!canonicalStat.isFile()) {
+    throw new FsError(
+      "parse_error",
+      `canonical path is not a regular file: ${canonical}`
+    );
+  }
+  assertSameFile(leaf, canonicalStat, input, "write");
+  return canonical;
+}
+__name(resolveSameHostToolWriteTarget, "resolveSameHostToolWriteTarget");
+function isWorkspaceGenerationClosedError(error2) {
+  return error2 instanceof Error && "code" in error2 && error2.code === "workspace_generation_closed";
+}
+__name(isWorkspaceGenerationClosedError, "isWorkspaceGenerationClosedError");
+function recordSameHostToolWriteDenied(audit, ctx, input, error2) {
+  const fsError = wrapAsFsError(error2);
+  audit.recordDenied(ctx, {
+    intent: "write",
+    input,
+    errorKind: fsError.kind,
+    hint: fsError.hint,
+    message: fsError.message
+  });
+  return isWorkspaceGenerationClosedError(error2) && error2 instanceof Error ? error2 : fsError;
+}
+__name(recordSameHostToolWriteDenied, "recordSameHostToolWriteDenied");
 function assertNoNestedWorkspaces(workspaces) {
   for (let i = 0; i < workspaces.length; i++) {
     const a = workspaces[i];
@@ -5168,6 +5319,214 @@ function mountWorkspaceQualifiedMemoryRememberRoutes(app, deps) {
 }
 __name(mountWorkspaceQualifiedMemoryRememberRoutes, "mountWorkspaceQualifiedMemoryRememberRoutes");
 
+// packages/cli/src/serve/session-id-admission.ts
+init_esbuild_shims();
+import { access } from "node:fs/promises";
+var RequestedSessionIdAdmissionError = class extends Error {
+  constructor(code, sessionId, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.sessionId = sessionId;
+    this.details = details;
+  }
+  static {
+    __name(this, "RequestedSessionIdAdmissionError");
+  }
+  name = "RequestedSessionIdAdmissionError";
+};
+async function persistedSessionExists(sessionService, sessionId) {
+  if (await sessionService.getSessionLocation(sessionId) !== void 0) {
+    return true;
+  }
+  if (await sessionService.findSessionIdIgnoringCase?.(sessionId) !== void 0) {
+    return true;
+  }
+  for (const state of ["active", "archived"]) {
+    try {
+      await access(
+        sessionService.getWorktreeSessionPathForArchiveState(sessionId, state)
+      );
+      return true;
+    } catch (error2) {
+      if (error2.code !== "ENOENT") throw error2;
+    }
+  }
+  return false;
+}
+__name(persistedSessionExists, "persistedSessionExists");
+function createRequestedSessionIdAdmission({
+  archiveCoordinator,
+  getBridges,
+  getPersistenceTargets,
+  getBridgeWorkspaceId
+}) {
+  const pending = /* @__PURE__ */ new Map();
+  const liveOwners = /* @__PURE__ */ __name((sessionId) => {
+    const owners = [];
+    let bridges;
+    try {
+      bridges = getBridges();
+    } catch {
+      throw new RequestedSessionIdAdmissionError(
+        "session_id_admission_unavailable",
+        sessionId,
+        `Unable to enumerate live bridges for session "${sessionId}".`,
+        { retryable: true }
+      );
+    }
+    for (const bridge of new Set(bridges)) {
+      try {
+        const summary = bridge.getSessionSummary(sessionId);
+        owners.push({
+          bridge,
+          workspaceCwd: summary.workspaceCwd,
+          workspaceId: getBridgeWorkspaceId?.(bridge)
+        });
+      } catch (error2) {
+        if (error2 instanceof SessionNotFoundError) continue;
+        throw new RequestedSessionIdAdmissionError(
+          "session_id_admission_unavailable",
+          sessionId,
+          `Unable to verify whether session "${sessionId}" is already live.`,
+          { retryable: true }
+        );
+      }
+    }
+    return owners;
+  }, "liveOwners");
+  const conflict = /* @__PURE__ */ __name((sessionId, conflictKind, workspaceCwd) => new RequestedSessionIdAdmissionError(
+    "session_id_conflict",
+    sessionId,
+    `Session "${sessionId}" already exists or is being created.`,
+    {
+      conflict: conflictKind,
+      ...workspaceCwd ? { liveWorkspaceCwd: workspaceCwd } : {}
+    }
+  ), "conflict");
+  const workspaceConflict = /* @__PURE__ */ __name((sessionId, target, conflictKind, liveWorkspaceCwd, liveWorkspaceId) => new RequestedSessionIdAdmissionError(
+    "session_workspace_conflict",
+    sessionId,
+    `Session "${sessionId}" is already live or restoring in another workspace runtime.`,
+    {
+      conflict: conflictKind,
+      workspaceCwd: target.workspaceCwd,
+      ...target.workspaceId ? { workspaceId: target.workspaceId } : {},
+      ...liveWorkspaceCwd ? { liveWorkspaceCwd } : {},
+      ...liveWorkspaceId ? { liveWorkspaceId } : {}
+    }
+  ), "workspaceConflict");
+  const createReservation = /* @__PURE__ */ __name((sessionId, state) => {
+    let released = false;
+    return {
+      release() {
+        if (released) return;
+        released = true;
+        if (pending.get(sessionId) !== state) return;
+        if (state.kind === "restore" && state.count > 1) {
+          state.count--;
+          return;
+        }
+        pending.delete(sessionId);
+      }
+    };
+  }, "createReservation");
+  return {
+    async reserveCreate(rawSessionId, target) {
+      const sessionId = normalizeSessionIdForLookup(rawSessionId);
+      const live = liveOwners(sessionId)[0];
+      if (live) throw conflict(sessionId, "live", live.workspaceCwd);
+      if (pending.has(sessionId)) throw conflict(sessionId, "pending");
+      const state = { kind: "create", target };
+      pending.set(sessionId, state);
+      const reservation = createReservation(sessionId, state);
+      try {
+        let persisted;
+        try {
+          persisted = await archiveCoordinator.runSharedMany(
+            [sessionId],
+            async () => {
+              const targets = [
+                ...new Map(
+                  getPersistenceTargets().map((entry) => [
+                    `${entry.runtimeBaseDir}\0${entry.workspaceCwd}`,
+                    entry
+                  ])
+                ).values()
+              ];
+              const results = await Promise.all(
+                targets.map(async (entry) => {
+                  const sessionService = new SessionService(
+                    entry.workspaceCwd,
+                    { runtimeBaseDir: entry.runtimeBaseDir }
+                  );
+                  return {
+                    entry,
+                    exists: await persistedSessionExists(
+                      sessionService,
+                      sessionId
+                    )
+                  };
+                })
+              );
+              return results.find((result) => result.exists)?.entry;
+            }
+          );
+        } catch {
+          throw new RequestedSessionIdAdmissionError(
+            "session_id_admission_unavailable",
+            sessionId,
+            `Unable to verify persisted state for session "${sessionId}".`,
+            { retryable: true }
+          );
+        }
+        if (persisted) {
+          throw conflict(sessionId, "persisted", persisted.workspaceCwd);
+        }
+        return reservation;
+      } catch (error2) {
+        reservation.release();
+        throw error2;
+      }
+    },
+    reserveRestore(rawSessionId, target) {
+      const sessionId = normalizeSessionIdForLookup(rawSessionId);
+      const foreignLive = liveOwners(sessionId).find(
+        (owner) => owner.bridge !== target.bridge
+      );
+      if (foreignLive) {
+        throw workspaceConflict(
+          sessionId,
+          target,
+          "live",
+          foreignLive.workspaceCwd,
+          foreignLive.workspaceId
+        );
+      }
+      const existing = pending.get(sessionId);
+      if (existing?.kind === "create") {
+        throw conflict(sessionId, "pending");
+      }
+      if (existing?.kind === "restore") {
+        if (existing.target.bridge !== target.bridge) {
+          throw workspaceConflict(
+            sessionId,
+            target,
+            "pending",
+            existing.target.workspaceCwd,
+            existing.target.workspaceId
+          );
+        }
+        existing.count++;
+        return createReservation(sessionId, existing);
+      }
+      const state = { kind: "restore", target, count: 1 };
+      pending.set(sessionId, state);
+      return createReservation(sessionId, state);
+    }
+  };
+}
+__name(createRequestedSessionIdAdmission, "createRequestedSessionIdAdmission");
+
 // packages/cli/src/serve/workspace-memory.ts
 init_esbuild_shims();
 import { promises as fs2 } from "node:fs";
@@ -8215,6 +8574,9 @@ var TRUSTED_WORKSPACE_METHODS = /* @__PURE__ */ new Set([
   `${QWEN_METHOD_NS}workspace/session_groups/delete`
 ]);
 var WORKSPACE_GENERATION_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "session/new",
+  "session/load",
+  "session/resume",
   `${QWEN_METHOD_NS}workspace/init`,
   `${QWEN_METHOD_NS}workspace/trust/request`,
   `${QWEN_METHOD_NS}workspace/permissions/set`,
@@ -8263,6 +8625,23 @@ var AcpParamError = class extends Error {
     __name(this, "AcpParamError");
   }
 };
+var InvalidRequestedSessionIdError = class extends Error {
+  static {
+    __name(this, "InvalidRequestedSessionIdError");
+  }
+};
+var RequestedSessionIdNotHonoredError = class extends Error {
+  constructor(requestedSessionId, actualSessionId) {
+    super(
+      `The ACP agent returned session "${actualSessionId}" instead of requested session "${requestedSessionId}".`
+    );
+    this.requestedSessionId = requestedSessionId;
+    this.actualSessionId = actualSessionId;
+  }
+  static {
+    __name(this, "RequestedSessionIdNotHonoredError");
+  }
+};
 function parseOptionalPositiveInteger(value, fallback, max) {
   if (value === void 0) return fallback;
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > max) {
@@ -8373,6 +8752,38 @@ function pickSessionArtifactInput(params) {
 }
 __name(pickSessionArtifactInput, "pickSessionArtifactInput");
 function toRpcError(err) {
+  if (err instanceof InvalidRequestedSessionIdError) {
+    return {
+      code: RPC.INVALID_PARAMS,
+      message: err.message,
+      data: { httpStatus: 400, errorKind: "invalid_session_id" }
+    };
+  }
+  if (err instanceof RequestedSessionIdAdmissionError) {
+    const unavailable = err.code === "session_id_admission_unavailable";
+    return {
+      code: unavailable ? RPC.INTERNAL_ERROR : RPC.INVALID_PARAMS,
+      message: err.message,
+      data: {
+        httpStatus: unavailable ? 503 : 409,
+        errorKind: err.code,
+        sessionId: err.sessionId,
+        ...err.details
+      }
+    };
+  }
+  if (err instanceof RequestedSessionIdNotHonoredError) {
+    return {
+      code: RPC.INTERNAL_ERROR,
+      message: err.message,
+      data: {
+        httpStatus: 500,
+        errorKind: "session_id_not_honored",
+        requestedSessionId: err.requestedSessionId,
+        actualSessionId: err.actualSessionId
+      }
+    };
+  }
   if (err instanceof DaemonDrainingError) {
     return {
       code: RPC.INTERNAL_ERROR,
@@ -8495,6 +8906,56 @@ function toRpcError(err) {
   }
   const name = err instanceof Error ? err.name : "";
   switch (name) {
+    case "SessionRestoreTimeoutError": {
+      const restoreError = err;
+      return {
+        code: RPC.INTERNAL_ERROR,
+        message: restoreError.message,
+        data: {
+          code: "session_restore_timeout",
+          errorKind: "restore_timeout",
+          httpStatus: 504,
+          retryable: true,
+          retryAfterSeconds: restoreRetryAfterSeconds(restoreError.timeoutMs),
+          sessionId: restoreError.sessionId,
+          action: restoreError.action,
+          timeoutMs: restoreError.timeoutMs
+        }
+      };
+    }
+    case "RestoreInProgressError": {
+      const fenceError = err;
+      return {
+        code: RPC.INTERNAL_ERROR,
+        message: fenceError.message,
+        data: {
+          code: "restore_in_progress",
+          errorKind: "restore_in_progress",
+          httpStatus: 409,
+          retryable: true,
+          reason: fenceError.reason,
+          retryAfterSeconds: fenceError.retryAfterSeconds,
+          sessionId: fenceError.sessionId,
+          activeAction: fenceError.activeAction,
+          requestedAction: fenceError.requestedAction
+        }
+      };
+    }
+    case "BridgeChannelQuarantinedError": {
+      const unavailableError = err;
+      return {
+        code: RPC.INTERNAL_ERROR,
+        message: unavailableError.message,
+        data: {
+          code: "acp_channel_unavailable",
+          errorKind: "acp_channel_unavailable",
+          httpStatus: 503,
+          retryable: true,
+          reason: unavailableError.reason,
+          retryAfterSeconds: unavailableError.retryAfterSeconds
+        }
+      };
+    }
     case "SessionArchivedError":
       return {
         code: RPC.INTERNAL_ERROR,
@@ -8588,12 +9049,16 @@ function rpcErrorFrame(id, err) {
 __name(rpcErrorFrame, "rpcErrorFrame");
 var ACP_PROTOCOL_VERSION = 1;
 var AcpDispatcher = class {
-  constructor(bridge, boundWorkspace, getEnv, workspace, workspaceRememberLane, fsFactory, deviceFlowRegistry, sessionShellCommandEnabled = false, registry, archiveCoordinator = new SessionArchiveCoordinator(), isWorkspaceTrusted = () => true, captureGenerationAssertion = () => void 0, liveSessionIsolation, sessionRuntimeBaseDir = Storage.getRuntimeBaseDir()) {
+  constructor(bridge, boundWorkspace, getEnv, workspace, workspaceRememberLane, requestedSessionIdAdmission, fsFactory, deviceFlowRegistry, sessionShellCommandEnabled = false, registry, archiveCoordinator = new SessionArchiveCoordinator(), isWorkspaceTrusted = () => true, captureGenerationAssertion = () => void 0, liveSessionIsolation, sessionRuntimeBaseDir = Storage.getRuntimeBaseDir(), getSessionRuntimeContext = () => ({
+    bridge,
+    sessionRuntimeBaseDir
+  })) {
     this.bridge = bridge;
     this.boundWorkspace = boundWorkspace;
     this.getEnv = getEnv;
     this.workspace = workspace;
     this.workspaceRememberLane = workspaceRememberLane;
+    this.requestedSessionIdAdmission = requestedSessionIdAdmission;
     this.fsFactory = fsFactory;
     this.deviceFlowRegistry = deviceFlowRegistry;
     this.sessionShellCommandEnabled = sessionShellCommandEnabled;
@@ -8603,26 +9068,31 @@ var AcpDispatcher = class {
     this.captureGenerationAssertion = captureGenerationAssertion;
     this.liveSessionIsolation = liveSessionIsolation;
     this.sessionRuntimeBaseDir = sessionRuntimeBaseDir;
+    this.getSessionRuntimeContext = getSessionRuntimeContext;
     this.agentManager = createDaemonSubagentManager(boundWorkspace);
   }
   static {
     __name(this, "AcpDispatcher");
   }
   agentManager;
-  killOrphanSession(sessionId, removePersistedSession = false) {
+  removeOrphanSession(sessionId, removePersistedSession = false, runtime = this.getSessionRuntimeContext()) {
     const cleanup = removePersistedSession ? deleteDaemonSessionIfOrphan({
       sessionId,
       service: new SessionService(this.boundWorkspace, {
-        runtimeBaseDir: this.sessionRuntimeBaseDir
+        runtimeBaseDir: runtime.sessionRuntimeBaseDir
       }),
-      bridge: this.bridge,
+      bridge: runtime.bridge,
       coordinator: this.archiveCoordinator
-    }) : this.bridge.killSession(sessionId, { requireZeroAttaches: true });
-    void cleanup.catch(
-      (err) => writeStderrLine(
+    }) : runtime.bridge.killSession(sessionId, { requireZeroAttaches: true });
+    return cleanup.catch((err) => {
+      writeStderrLine(
         `qwen serve: /acp orphan killSession(${logSafe(sessionId)}) failed: ${logSafe(errMsg(err))}`
-      )
-    );
+      );
+      return void 0;
+    });
+  }
+  killOrphanSession(sessionId, removePersistedSession = false, runtime) {
+    void this.removeOrphanSession(sessionId, removePersistedSession, runtime);
   }
   /**
    * Build the `WorkspaceRequestContext` for workspace-scoped operations
@@ -8726,9 +9196,9 @@ var AcpDispatcher = class {
    * child's own session state. Returned in `session/new` and as the result
    * of `session/set_config_option`. Best-effort — `undefined` on error.
    */
-  async configOptionsFor(sessionId) {
+  async configOptionsFor(sessionId, bridge = this.bridge) {
     try {
-      const ctx = await this.bridge.getSessionContextStatus(sessionId);
+      const ctx = await bridge.getSessionContextStatus(sessionId);
       const co = ctx?.state?.configOptions;
       return Array.isArray(co) ? co : void 0;
     } catch (err) {
@@ -8922,7 +9392,13 @@ var AcpDispatcher = class {
     }
     if (!isRequest(msg) && !isNotification(msg)) return;
     const method = msg.method;
-    const params = isObject(msg.params) ? msg.params : {};
+    const params = {
+      ...isObject(msg.params) ? msg.params : {}
+    };
+    if (typeof params["sessionId"] === "string") {
+      params["sessionId"] = normalizeSessionIdForLookup(params["sessionId"]);
+    }
+    const normalizedSessionHeader = sessionHeader ? normalizeSessionIdForLookup(sessionHeader) : void 0;
     const id = isRequest(msg) ? msg.id : void 0;
     const generationScoped = TRUSTED_WORKSPACE_METHODS.has(method) || WORKSPACE_GENERATION_MUTATION_METHODS.has(method);
     const assertGenerationOpen = generationScoped ? this.captureGenerationAssertion() : void 0;
@@ -8945,7 +9421,7 @@ var AcpDispatcher = class {
       }
       return;
     }
-    if (sessionHeader && typeof params["sessionId"] === "string" && params["sessionId"] !== sessionHeader) {
+    if (normalizedSessionHeader && typeof params["sessionId"] === "string" && params["sessionId"] !== normalizedSessionHeader) {
       if (id !== void 0) {
         conn.sendConn(
           error(
@@ -8963,6 +9439,16 @@ var AcpDispatcher = class {
           this.replyConn(conn, id, {});
           return;
         case "session/new": {
+          const meta = isObject(params["_meta"]) ? params["_meta"] : void 0;
+          const parsedSessionId = parseCallerSuppliedSessionId(
+            meta?.[REQUESTED_SESSION_ID_META_KEY]
+          );
+          if (parsedSessionId.kind === "invalid") {
+            throw new InvalidRequestedSessionIdError(
+              `\`_meta["${REQUESTED_SESSION_ID_META_KEY}"]\` must be an RFC UUID v1-v5`
+            );
+          }
+          const requestedSessionId = parsedSessionId.kind === "valid" ? parsedSessionId.sessionId : void 0;
           const cwd = this.parseSessionWorkspaceCwd(params);
           if (this.liveSessionIsolation) {
             if (id !== void 0) {
@@ -8977,6 +9463,7 @@ var AcpDispatcher = class {
             }
             return;
           }
+          const sessionRuntime = this.getSessionRuntimeContext();
           const source = parseSessionSource(
             params["sourceType"],
             params["sourceId"]
@@ -8999,39 +9486,89 @@ var AcpDispatcher = class {
             }
             return;
           }
-          const session = await this.bridge.spawnOrAttach({
-            workspaceCwd: cwd,
-            clientId: conn.clientId,
-            sessionScope: "thread",
-            ...source
-          });
-          if (conn.destroyed) {
-            this.killOrphanSession(session.sessionId, true);
-            return;
-          }
-          conn.getOrCreateSession(session.sessionId).clientId = session.clientId;
-          conn.ownSession(session.sessionId);
-          const configOptions = await this.configOptionsFor(session.sessionId);
-          if (conn.destroyed) {
-            this.killOrphanSession(session.sessionId, true);
+          const reservation = requestedSessionId ? await this.requestedSessionIdAdmission.reserveCreate(
+            requestedSessionId,
+            {
+              bridge: sessionRuntime.bridge,
+              workspaceCwd: cwd,
+              ...sessionRuntime.workspaceId ? { workspaceId: sessionRuntime.workspaceId } : {}
+            }
+          ) : void 0;
+          try {
+            assertGenerationOpen?.();
+            const session = await sessionRuntime.bridge.spawnOrAttach({
+              workspaceCwd: cwd,
+              clientId: conn.clientId,
+              sessionScope: "thread",
+              ...source,
+              ...requestedSessionId ? { sessionId: requestedSessionId } : {}
+            });
+            const rollbackSession = /* @__PURE__ */ __name(async () => {
+              if (session.attached) {
+                await sessionRuntime.bridge.detachClient(session.sessionId, session.clientId).catch(() => {
+                });
+              } else {
+                await this.removeOrphanSession(
+                  session.sessionId,
+                  true,
+                  sessionRuntime
+                );
+              }
+            }, "rollbackSession");
+            try {
+              assertGenerationOpen?.();
+            } catch (error2) {
+              await rollbackSession();
+              throw error2;
+            }
+            if (requestedSessionId !== void 0 && session.sessionId !== requestedSessionId) {
+              await rollbackSession();
+              throw new RequestedSessionIdNotHonoredError(
+                requestedSessionId,
+                session.sessionId
+              );
+            }
+            if (conn.destroyed) {
+              this.killOrphanSession(session.sessionId, true, sessionRuntime);
+              return;
+            }
+            const configOptions = await this.configOptionsFor(
+              session.sessionId,
+              sessionRuntime.bridge
+            );
+            try {
+              assertGenerationOpen?.();
+            } catch (error2) {
+              await rollbackSession();
+              throw error2;
+            }
+            if (conn.destroyed) {
+              this.killOrphanSession(session.sessionId, true, sessionRuntime);
+              return;
+            }
+            conn.getOrCreateSession(session.sessionId).clientId = session.clientId;
+            conn.ownSession(session.sessionId);
+            const models = this.extractModelState(configOptions);
+            const modes = this.extractModeState(configOptions);
+            this.replyConn(conn, id, {
+              sessionId: session.sessionId,
+              ...session.sourceType ? { sourceType: session.sourceType } : {},
+              ...session.sourceId !== void 0 ? { sourceId: session.sourceId } : {},
+              ...session.sourcePersisted !== void 0 ? { sourcePersisted: session.sourcePersisted } : {},
+              ...configOptions ? { configOptions } : {},
+              ...models ? { models } : {},
+              ...modes ? { modes } : {}
+            });
             return;
+          } finally {
+            reservation?.release();
           }
-          const models = this.extractModelState(configOptions);
-          const modes = this.extractModeState(configOptions);
-          this.replyConn(conn, id, {
-            sessionId: session.sessionId,
-            ...session.sourceType ? { sourceType: session.sourceType } : {},
-            ...session.sourceId !== void 0 ? { sourceId: session.sourceId } : {},
-            ...session.sourcePersisted !== void 0 ? { sourcePersisted: session.sourcePersisted } : {},
-            ...configOptions ? { configOptions } : {},
-            ...models ? { models } : {},
-            ...modes ? { modes } : {}
-          });
-          return;
         }
         case "session/load":
         case "session/resume": {
-          const sessionId = String(params["sessionId"] ?? "");
+          const sessionId = normalizeSessionIdForLookup(
+            String(params["sessionId"] ?? "")
+          );
           if (!sessionId) {
             if (id !== void 0) {
               conn.sendConn(
@@ -9053,134 +9590,183 @@ var AcpDispatcher = class {
             return;
           }
           const cwd = this.parseSessionWorkspaceCwd(params);
-          const restored = await this.archiveCoordinator.runSharedMany(
-            [sessionId],
-            async () => {
-              await assertSessionLoadable(cwd, sessionId);
-              const sessionService = new SessionService(cwd);
-              const metadata = this.liveSessionIsolation ? await readLoadableLiveConversationMetadata(
-                sessionId,
-                (candidateId) => sessionService.readCreationMetadata(candidateId)
-              ) : await sessionService.readCreationMetadata(sessionId);
-              if (metadata === void 0) {
-                throw new SessionNotFoundError(sessionId);
-              }
-              const liveConversationCwd = this.liveSessionIsolation ? await this.liveSessionIsolation.materializeConversationDirectory(
-                sessionId
-              ) : void 0;
-              const session = method === "session/load" ? await this.bridge.loadSession({
-                sessionId,
-                workspaceCwd: cwd,
-                clientId: conn.clientId,
-                historyReplay: "response",
-                ...metadata
-              }) : await this.bridge.resumeSession({
-                sessionId,
-                workspaceCwd: cwd,
-                clientId: conn.clientId,
-                ...metadata
-              });
-              if (liveConversationCwd === void 0) {
-                return session;
-              }
-              if (session.hasActivePrompt) {
-                if (session.currentCwd === liveConversationCwd) return session;
-                try {
-                  if (session.clientId) {
-                    await this.bridge.detachClient(
-                      session.sessionId,
-                      session.clientId
-                    );
-                  }
-                } catch {
-                }
-                throw new Error(
-                  "Active Live session is outside its isolated conversation directory."
+          const sessionRuntime = this.getSessionRuntimeContext();
+          const reservation = this.requestedSessionIdAdmission.reserveRestore(
+            sessionId,
+            {
+              bridge: sessionRuntime.bridge,
+              workspaceCwd: cwd,
+              ...sessionRuntime.workspaceId ? { workspaceId: sessionRuntime.workspaceId } : {}
+            }
+          );
+          try {
+            const restored = await this.archiveCoordinator.runSharedMany(
+              [sessionId],
+              async () => {
+                assertGenerationOpen?.();
+                await assertSessionLoadable(
+                  cwd,
+                  sessionId,
+                  sessionRuntime.sessionRuntimeBaseDir
                 );
-              }
-              try {
-                const changed = await this.bridge.changeSessionCwd(sessionId, {
-                  path: liveConversationCwd,
-                  allowedRoots: [cwd],
-                  managedRelocation: "live-conversation"
+                const sessionService = new SessionService(cwd, {
+                  runtimeBaseDir: sessionRuntime.sessionRuntimeBaseDir
+                });
+                const metadata = this.liveSessionIsolation ? await readLoadableLiveConversationMetadata(
+                  sessionId,
+                  (candidateId) => sessionService.readCreationMetadata(candidateId)
+                ) : await sessionService.readCreationMetadata(sessionId);
+                if (metadata === void 0) {
+                  throw new SessionNotFoundError(sessionId);
+                }
+                const liveConversationCwd = this.liveSessionIsolation ? await this.liveSessionIsolation.materializeConversationDirectory(
+                  sessionId
+                ) : void 0;
+                assertGenerationOpen?.();
+                const session = method === "session/load" ? await sessionRuntime.bridge.loadSession({
+                  sessionId,
+                  workspaceCwd: cwd,
+                  clientId: conn.clientId,
+                  historyReplay: "response",
+                  ...metadata
+                }) : await sessionRuntime.bridge.resumeSession({
+                  sessionId,
+                  workspaceCwd: cwd,
+                  clientId: conn.clientId,
+                  ...metadata
                 });
-                if (changed.newCwd !== liveConversationCwd) {
+                if (liveConversationCwd === void 0) {
+                  return session;
+                }
+                if (session.hasActivePrompt) {
+                  if (session.currentCwd === liveConversationCwd)
+                    return session;
+                  try {
+                    if (session.clientId) {
+                      await sessionRuntime.bridge.detachClient(
+                        session.sessionId,
+                        session.clientId
+                      );
+                    }
+                  } catch {
+                  }
                   throw new Error(
-                    "Live conversation directory relocation was rejected."
+                    "Active Live session is outside its isolated conversation directory."
                   );
                 }
-                session.currentCwd = changed.newCwd;
-              } catch (error2) {
                 try {
-                  if (session.attached && session.clientId) {
-                    await this.bridge.detachClient(
-                      session.sessionId,
-                      session.clientId
+                  const changed = await sessionRuntime.bridge.changeSessionCwd(
+                    sessionId,
+                    {
+                      path: liveConversationCwd,
+                      allowedRoots: [cwd],
+                      managedRelocation: "live-conversation"
+                    }
+                  );
+                  if (changed.newCwd !== liveConversationCwd) {
+                    throw new Error(
+                      "Live conversation directory relocation was rejected."
                     );
-                  } else if (!session.attached) {
-                    await this.bridge.killSession(session.sessionId, {
-                      requireZeroAttaches: true
-                    });
                   }
-                } catch {
+                  session.currentCwd = changed.newCwd;
+                } catch (error2) {
+                  try {
+                    if (session.attached && session.clientId) {
+                      await sessionRuntime.bridge.detachClient(
+                        session.sessionId,
+                        session.clientId
+                      );
+                    } else if (!session.attached) {
+                      await sessionRuntime.bridge.killSession(
+                        session.sessionId,
+                        {
+                          requireZeroAttaches: true
+                        }
+                      );
+                    }
+                  } catch {
+                  }
+                  throw error2;
                 }
-                throw error2;
+                return session;
+              }
+            );
+            const rollbackRestore = /* @__PURE__ */ __name(async () => {
+              if (restored.attached) {
+                await sessionRuntime.bridge.detachClient(sessionId, restored.clientId).catch(() => {
+                });
+              } else {
+                await sessionRuntime.bridge.killSession(sessionId, { requireZeroAttaches: true }).catch(() => {
+                });
               }
-              return session;
+            }, "rollbackRestore");
+            try {
+              assertGenerationOpen?.();
+            } catch (error2) {
+              await rollbackRestore();
+              throw error2;
             }
-          );
-          const closeRaced = conn.closingSessions.has(sessionId);
-          if (conn.destroyed || closeRaced) {
-            const cleanup = restored.attached ? this.bridge.detachClient(sessionId, restored.clientId) : this.bridge.killSession(sessionId, {
-              requireZeroAttaches: true
-            });
-            void cleanup.catch(
-              (err) => writeStderrLine(
-                `qwen serve: /acp orphan ${restored.attached ? "detach" : "kill"}(${logSafe(sessionId)}) teardown-race: ${logSafe(errMsg(err))}`
-              )
+            const loadConfigOptions = await this.configOptionsFor(
+              sessionId,
+              sessionRuntime.bridge
             );
-            if (closeRaced && !conn.destroyed && id !== void 0) {
-              conn.sendConn(
-                error(
-                  id,
-                  RPC.INTERNAL_ERROR,
-                  `session ${sessionId} was closed during load; retry`
+            const loadModels = this.extractModelState(loadConfigOptions);
+            const loadModes = this.extractModeState(loadConfigOptions);
+            const loadState = restored.state ?? {};
+            const loadMeta = isObject(loadState._meta) ? loadState._meta : void 0;
+            const loadQwenMeta = isObject(loadMeta?.[QWEN_META_KEY]) ? loadMeta[QWEN_META_KEY] : void 0;
+            const replayStatus = method === "session/load" && restored.partial === true ? {
+              partial: true,
+              ...typeof restored.replayError === "string" ? { replayError: restored.replayError } : {}
+            } : void 0;
+            try {
+              assertGenerationOpen?.();
+            } catch (error2) {
+              await rollbackRestore();
+              throw error2;
+            }
+            const closeRaced = conn.closingSessions.has(sessionId);
+            if (conn.destroyed || closeRaced) {
+              void rollbackRestore().catch(
+                (err) => writeStderrLine(
+                  `qwen serve: /acp orphan ${restored.attached ? "detach" : "kill"}(${logSafe(sessionId)}) teardown-race: ${logSafe(errMsg(err))}`
                 )
               );
+              if (closeRaced && !conn.destroyed && id !== void 0) {
+                conn.sendConn(
+                  error(
+                    id,
+                    RPC.INTERNAL_ERROR,
+                    `session ${sessionId} was closed during load; retry`
+                  )
+                );
+              }
+              return;
             }
+            conn.getOrCreateSession(sessionId).clientId = restored.clientId;
+            if (method === "session/load") {
+              conn.markInitialReplayPending(sessionId);
+            }
+            conn.ownSession(sessionId);
+            this.replyConn(conn, id, {
+              ...loadState,
+              ...replayStatus ? {
+                _meta: {
+                  ...loadMeta ?? {},
+                  [QWEN_META_KEY]: {
+                    ...loadQwenMeta ?? {},
+                    sessionLoadReplay: replayStatus
+                  }
+                }
+              } : {},
+              ...loadConfigOptions ? { configOptions: loadConfigOptions } : {},
+              ...loadModels ? { models: loadModels } : {},
+              ...loadModes ? { modes: loadModes } : {}
+            });
             return;
+          } finally {
+            reservation.release();
           }
-          conn.getOrCreateSession(sessionId).clientId = restored.clientId;
-          if (method === "session/load") {
-            conn.markInitialReplayPending(sessionId);
-          }
-          conn.ownSession(sessionId);
-          const loadConfigOptions = await this.configOptionsFor(sessionId);
-          const loadModels = this.extractModelState(loadConfigOptions);
-          const loadModes = this.extractModeState(loadConfigOptions);
-          const loadState = restored.state ?? {};
-          const loadMeta = isObject(loadState._meta) ? loadState._meta : void 0;
-          const loadQwenMeta = isObject(loadMeta?.[QWEN_META_KEY]) ? loadMeta[QWEN_META_KEY] : void 0;
-          const replayStatus = method === "session/load" && restored.partial === true ? {
-            partial: true,
-            ...typeof restored.replayError === "string" ? { replayError: restored.replayError } : {}
-          } : void 0;
-          this.replyConn(conn, id, {
-            ...loadState,
-            ...replayStatus ? {
-              _meta: {
-                ...loadMeta ?? {},
-                [QWEN_META_KEY]: {
-                  ...loadQwenMeta ?? {},
-                  sessionLoadReplay: replayStatus
-                }
-              }
-            } : {},
-            ...loadConfigOptions ? { configOptions: loadConfigOptions } : {},
-            ...loadModels ? { models: loadModels } : {},
-            ...loadModes ? { modes: loadModes } : {}
-          });
-          return;
         }
         case "session/list": {
           const workspaceCwd = this.parseBoundWorkspaceParam(params);
@@ -13765,7 +14351,7 @@ function isActiveDrainCorrelation(registry, conn, message) {
     return false;
   }
   const params = message.params !== null && typeof message.params === "object" ? message.params : void 0;
-  return typeof params?.sessionId === "string" && conn.ownsSession(params.sessionId);
+  return typeof params?.sessionId === "string" && conn.ownsSession(normalizeSessionIdForLookup(params.sessionId));
 }
 __name(isActiveDrainCorrelation, "isActiveDrainCorrelation");
 var PLURAL_WS_PREFIX = "/workspaces/";
@@ -13942,6 +14528,9 @@ function mountAcpHttp(app, bridge, opts) {
   const enabled = opts.enabled ?? resolveAcpHttpEnabled();
   if (!enabled) return void 0;
   const daemonEnv = opts.daemonEnv ?? process.env;
+  const primarySessionRuntimeBaseDir = opts.workspaceRegistry?.primary.sessionRuntimeBaseDir ?? Storage.getRuntimeBaseDir();
+  const archiveCoordinator = opts.archiveCoordinator ?? new SessionArchiveCoordinator();
+  const requestedSessionIdAdmission = opts.requestedSessionIdAdmission;
   const getPrimaryEnv = /* @__PURE__ */ __name(() => opts.workspaceRegistry ? runtimeEffectiveEnv(opts.workspaceRegistry.primary, daemonEnv) : daemonEnv, "getPrimaryEnv");
   const path15 = opts.path ?? "/acp";
   const dispatcherRef = {};
@@ -14095,11 +14684,12 @@ function mountAcpHttp(app, bridge, opts) {
     getPrimaryEnv,
     opts.workspace,
     opts.workspaceRememberLane,
+    requestedSessionIdAdmission,
     opts.fsFactory,
     opts.deviceFlowRegistry,
     opts.sessionShellCommandEnabled === true,
     registry,
-    opts.archiveCoordinator ?? new SessionArchiveCoordinator(),
+    archiveCoordinator,
     opts.isPrimaryWorkspaceTrusted ?? (() => {
       const entry = opts.workspaceRegistry?.primaryEntry;
       return entry ? entry.state === "active" && entry.current?.runtime.trusted === true : true;
@@ -14109,7 +14699,18 @@ function mountAcpHttp(app, bridge, opts) {
       return guard ? () => guard.assertOpen() : void 0;
     },
     void 0,
-    opts.workspaceRegistry?.primary.sessionRuntimeBaseDir ?? Storage.getRuntimeBaseDir()
+    primarySessionRuntimeBaseDir,
+    () => {
+      const runtime = opts.workspaceRegistry?.primary;
+      return runtime ? {
+        bridge: runtime.bridge,
+        sessionRuntimeBaseDir: runtime.sessionRuntimeBaseDir,
+        workspaceId: runtime.workspaceId
+      } : {
+        bridge,
+        sessionRuntimeBaseDir: primarySessionRuntimeBaseDir
+      };
+    }
   );
   dispatcherRef.current = dispatcher;
   const primaryMount = {
@@ -14289,7 +14890,8 @@ function mountAcpHttp(app, bridge, opts) {
       res.status(404).json({ error: "Unknown Acp-Connection-Id" });
       return;
     }
-    const sessionId = headerOf(req, ACP_SESSION_HEADER);
+    const rawSessionId = headerOf(req, ACP_SESSION_HEADER);
+    const sessionId = rawSessionId ? normalizeSessionIdForLookup(rawSessionId) : void 0;
     if (!sessionId) {
       const connId = conn.connectionId;
       const stream2 = new SseStream(
@@ -14396,12 +14998,17 @@ function mountAcpHttp(app, bridge, opts) {
       rt.bridge,
       rt.workspaceCwd
     );
+    const registeredGeneration = opts.workspaceRegistry?.getEntryByWorkspaceId(
+      rt.workspaceId
+    )?.current;
+    const generationGuard = registeredGeneration?.runtime === rt ? registeredGeneration.guard : rt.generationGuard;
     const secondaryDispatcher = new AcpDispatcher(
       rt.bridge,
       rt.workspaceCwd,
       () => runtimeEffectiveEnv(rt, daemonEnv),
       rt.workspaceService,
       workspaceRememberLane,
+      requestedSessionIdAdmission,
       rt.routeFileSystemFactory,
       // Phase 4: secondary mounts share the daemon-global device-flow registry
       // (single instance per daemon; OAuth credentials are global state). The
@@ -14411,14 +15018,16 @@ function mountAcpHttp(app, bridge, opts) {
       opts.deviceFlowRegistry,
       opts.sessionShellCommandEnabled === true,
       secondaryRegistry,
-      opts.archiveCoordinator ?? new SessionArchiveCoordinator(),
+      archiveCoordinator,
       () => rt.trusted,
-      () => {
-        const guard = rt.generationGuard;
-        return guard ? () => guard.assertOpen() : void 0;
-      },
+      () => generationGuard ? () => generationGuard.assertOpen() : void 0,
       rt.provenance === "live-conversation" ? opts.liveSessionIsolation : void 0,
-      rt.sessionRuntimeBaseDir
+      rt.sessionRuntimeBaseDir,
+      () => ({
+        bridge: rt.bridge,
+        sessionRuntimeBaseDir: rt.sessionRuntimeBaseDir,
+        workspaceId: rt.workspaceId
+      })
     );
     secondaryDispatcherRef.current = secondaryDispatcher;
     return {
@@ -15056,7 +15665,8 @@ function mountAcpHttp(app, bridge, opts) {
             return;
           }
           if (isRequest(message) && message.params && typeof message.params === "object") {
-            const sid = message.params["sessionId"];
+            const rawSid = message.params["sessionId"];
+            const sid = typeof rawSid === "string" ? normalizeSessionIdForLookup(rawSid) : rawSid;
             if (typeof sid === "string" && conn.ownsSession(sid)) {
               const binding = conn.sessions.get(sid);
               if (binding && !binding.stream && conn.connStream && !conn.connStream.isClosed) {
@@ -15955,667 +16565,10 @@ function registerDaemonStatusRoutes(app, deps) {
 }
 __name(registerDaemonStatusRoutes, "registerDaemonStatusRoutes");
 
-// packages/cli/src/serve/routes/health-demo.ts
-init_esbuild_shims();
-
-// packages/cli/src/serve/demo.ts
+// packages/cli/src/serve/routes/health.ts
 init_esbuild_shims();
-function getDemoHtml(_port) {
-  return (
-    /* html */
-    `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8" />
-<meta name="viewport" content="width=device-width, initial-scale=1" />
-<title>Qwen Serve Demo</title>
-<style>
-  :root { --bg: #1a1a2e; --surface: #16213e; --border: #0f3460; --accent: #e94560; --text: #eee; --text2: #aab; --ok: #4ade80; --warn: #fbbf24; --err: #f87171; }
-  * { box-sizing: border-box; margin: 0; padding: 0; }
-  body { font-family: 'SF Mono', 'Menlo', 'Consolas', monospace; font-size: 13px; background: var(--bg); color: var(--text); min-height: 100vh; }
-  .header { background: var(--surface); border-bottom: 1px solid var(--border); padding: 12px 20px; display: flex; align-items: center; gap: 12px; }
-  .header h1 { font-size: 16px; font-weight: 600; }
-  .header .badge { font-size: 11px; background: var(--accent); color: #fff; padding: 2px 8px; border-radius: 10px; }
-  .header .status { margin-left: auto; display: flex; align-items: center; gap: 6px; font-size: 12px; color: var(--text2); }
-  .header .dot { width: 8px; height: 8px; border-radius: 50%; background: var(--err); }
-  .header .dot.ok { background: var(--ok); }
-  .container { display: grid; grid-template-columns: 340px 1fr; height: calc(100vh - 49px); }
-  .sidebar { background: var(--surface); border-right: 1px solid var(--border); overflow-y: auto; padding: 12px; display: flex; flex-direction: column; gap: 12px; }
-  .panel { background: var(--bg); border: 1px solid var(--border); border-radius: 6px; padding: 12px; }
-  .panel h3 { font-size: 12px; color: var(--accent); margin-bottom: 8px; text-transform: uppercase; letter-spacing: 0.5px; }
-  .panel label { display: block; font-size: 11px; color: var(--text2); margin-bottom: 3px; }
-  .panel input, .panel textarea { width: 100%; background: var(--surface); border: 1px solid var(--border); color: var(--text); padding: 6px 8px; border-radius: 4px; font-family: inherit; font-size: 12px; margin-bottom: 8px; }
-  .panel input:focus, .panel textarea:focus { outline: none; border-color: var(--accent); }
-  .panel textarea { resize: vertical; min-height: 60px; }
-  .btn { display: inline-flex; align-items: center; gap: 4px; padding: 6px 14px; border: 1px solid var(--border); border-radius: 4px; background: var(--surface); color: var(--text); font-family: inherit; font-size: 12px; cursor: pointer; transition: all 0.15s; }
-  .btn:hover { border-color: var(--accent); color: var(--accent); }
-  .btn.primary { background: var(--accent); border-color: var(--accent); color: #fff; }
-  .btn.primary:hover { opacity: 0.85; }
-  .btn:disabled { opacity: 0.4; cursor: not-allowed; }
-  .btn-row { display: flex; gap: 6px; flex-wrap: wrap; }
-  .main { display: flex; flex-direction: column; overflow: hidden; }
-  .tabs { display: flex; background: var(--surface); border-bottom: 1px solid var(--border); }
-  .tab { padding: 8px 16px; font-size: 12px; color: var(--text2); cursor: pointer; border-bottom: 2px solid transparent; }
-  .tab.active { color: var(--accent); border-bottom-color: var(--accent); }
-  .tab-content { flex: 1; overflow: hidden; display: none; flex-direction: column; }
-  .tab-content.active { display: flex; }
-  .log { flex: 1; overflow-y: auto; padding: 12px; font-size: 12px; line-height: 1.6; }
-  .log-entry { padding: 3px 0; border-bottom: 1px solid rgba(255,255,255,0.03); word-break: break-all; }
-  .log-entry .ts { color: var(--text2); margin-right: 8px; font-size: 11px; }
-  .log-entry .tag { display: inline-block; padding: 0 5px; border-radius: 3px; font-size: 10px; margin-right: 6px; }
-  .tag-info { background: #1e40af; color: #93c5fd; }
-  .tag-event { background: #065f46; color: #6ee7b7; }
-  .tag-error { background: #7f1d1d; color: #fca5a5; }
-  .tag-response { background: #713f12; color: #fde68a; }
-  .tag-thought { background: #4c1d95; color: #c4b5fd; }
-  .tag-message { background: #164e63; color: #67e8f9; }
-  .chat { flex: 1; overflow-y: auto; padding: 16px; }
-  .chat-msg { margin-bottom: 12px; max-width: 85%; }
-  .chat-msg.user { margin-left: auto; }
-  .chat-msg .bubble { padding: 8px 12px; border-radius: 8px; line-height: 1.5; white-space: pre-wrap; }
-  .chat-msg.user .bubble { background: var(--accent); color: #fff; border-bottom-right-radius: 2px; }
-  .chat-msg.assistant .bubble { background: var(--surface); border: 1px solid var(--border); border-bottom-left-radius: 2px; }
-  .chat-msg .meta { font-size: 10px; color: var(--text2); margin-top: 3px; }
-  .chat-input { display: flex; gap: 8px; padding: 12px; border-top: 1px solid var(--border); background: var(--surface); }
-  .chat-input input { flex: 1; }
-  .session-info { font-size: 11px; color: var(--text2); padding: 4px 0; }
-  .session-info span { color: var(--ok); }
-  .empty-hint { color: var(--text2); text-align: center; padding: 40px 20px; font-size: 12px; }
-  .permission-card { background: var(--surface); border: 1px solid var(--warn); border-radius: 6px; padding: 10px 12px; margin: 8px 0; }
-  .permission-card h4 { color: var(--warn); font-size: 12px; margin-bottom: 6px; }
-  .permission-card .opt-btn { margin-right: 4px; margin-top: 4px; }
-</style>
-</head>
-<body>
-
-<div class="header">
-  <h1>Qwen Serve</h1>
-  <span class="badge">Demo</span>
-  <div class="status">
-    <span class="dot" id="statusDot"></span>
-    <span id="statusText">Connecting...</span>
-  </div>
-</div>
-
-<div class="container">
-  <div class="sidebar">
-    <div class="panel">
-      <h3>Session</h3>
-      <label>Working Directory (cwd)</label>
-      <input type="text" id="cwdInput" placeholder="/path/to/project" />
-      <div class="btn-row">
-        <button class="btn primary" id="btnCreateSession">Create / Attach</button>
-        <button class="btn" id="btnListSessions">List</button>
-      </div>
-      <div class="session-info" id="sessionInfo" style="display:none">
-        Session: <span id="sessionIdDisplay"></span>
-      </div>
-    </div>
-
-    <div class="panel">
-      <h3>Prompt</h3>
-      <textarea id="promptInput" placeholder="Type your prompt here..."></textarea>
-      <div class="btn-row">
-        <button class="btn primary" id="btnSendPrompt" disabled>Send</button>
-        <button class="btn" id="btnCancel" disabled>Cancel</button>
-      </div>
-    </div>
-
-    <div class="panel">
-      <h3>Model</h3>
-      <input type="text" id="modelInput" placeholder="Model ID (e.g. qwen3-coder)" />
-      <button class="btn" id="btnSetModel" disabled>Switch Model</button>
-    </div>
-
-    <div class="panel">
-      <h3>Auth Token</h3>
-      <label>Bearer Token (if --token is set)</label>
-      <input type="password" id="tokenInput" placeholder="Optional bearer token" />
-    </div>
-
-    <div class="panel">
-      <h3>Quick Actions</h3>
-      <div class="btn-row">
-        <button class="btn" id="btnHealth">Health</button>
-        <button class="btn" id="btnHealthDeep">Health (deep)</button>
-        <button class="btn" id="btnCaps">Capabilities</button>
-      </div>
-    </div>
-
-    <div class="panel" id="permissionPanel" style="display:none">
-      <h3>Pending Permissions</h3>
-      <div id="permissionList"></div>
-    </div>
-  </div>
-
-  <div class="main">
-    <div class="tabs">
-      <div class="tab active" data-tab="chat">Chat</div>
-      <div class="tab" data-tab="events">Events</div>
-      <div class="tab" data-tab="requests">API Log</div>
-    </div>
-
-    <div class="tab-content active" id="tab-chat">
-      <div class="chat" id="chatArea">
-        <div class="empty-hint">Create a session to start chatting</div>
-      </div>
-      <div class="chat-input">
-        <input type="text" id="chatInput" placeholder="Send a message..." disabled />
-        <button class="btn primary" id="btnChatSend" disabled>Send</button>
-      </div>
-    </div>
-
-    <div class="tab-content" id="tab-events">
-      <div class="log" id="eventLog"></div>
-    </div>
-
-    <div class="tab-content" id="tab-requests">
-      <div class="log" id="requestLog"></div>
-    </div>
-  </div>
-</div>
-
-<script>
-(function() {
-  const BASE = '';
-  let sessionId = null;
-  let eventSource = null;
-  let currentAssistantBubble = null;
-  let currentThought = '';
-
-  // --- DOM refs ---
-  const $ = (s) => document.querySelector(s);
-  const statusDot = $('#statusDot');
-  const statusText = $('#statusText');
-  const cwdInput = $('#cwdInput');
-  const promptInput = $('#promptInput');
-  const modelInput = $('#modelInput');
-  const tokenInput = $('#tokenInput');
-  const chatArea = $('#chatArea');
-  const chatInput = $('#chatInput');
-  const eventLog = $('#eventLog');
-  const requestLog = $('#requestLog');
-  const sessionInfo = $('#sessionInfo');
-  const sessionIdDisplay = $('#sessionIdDisplay');
-  const permissionPanel = $('#permissionPanel');
-  const permissionList = $('#permissionList');
-
-  // --- Tabs ---
-  document.querySelectorAll('.tab').forEach(tab => {
-    tab.addEventListener('click', () => {
-      document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
-      document.querySelectorAll('.tab-content').forEach(t => t.classList.remove('active'));
-      tab.classList.add('active');
-      $('#tab-' + tab.dataset.tab).classList.add('active');
-    });
-  });
-
-  // --- Logging ---
-  function ts() {
-    return new Date().toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
-  }
-  const MAX_LOG_ENTRIES = 500;
-  function addLog(container, tag, tagClass, msg) {
-    const el = document.createElement('div');
-    el.className = 'log-entry';
-    const text = typeof msg === 'object' ? JSON.stringify(msg, null, 2) : msg;
-    const tsSpan = document.createElement('span');
-    tsSpan.className = 'ts';
-    tsSpan.textContent = ts();
-    const tagSpan = document.createElement('span');
-    tagSpan.className = 'tag ' + tagClass;
-    tagSpan.textContent = tag;
-    el.appendChild(tsSpan);
-    el.appendChild(tagSpan);
-    el.appendChild(document.createTextNode(text));
-    container.appendChild(el);
-    while (container.children.length > MAX_LOG_ENTRIES) {
-      container.removeChild(container.firstChild);
-    }
-    container.scrollTop = container.scrollHeight;
-  }
-  function logEvent(tag, msg) { addLog(eventLog, tag, 'tag-event', msg); }
-  function logRequest(tag, msg) { addLog(requestLog, tag, 'tag-info', msg); }
-  function logResponse(tag, msg) { addLog(requestLog, tag, 'tag-response', msg); }
-  function logError(tag, msg) { addLog(requestLog, tag, 'tag-error', msg); }
-
-  function escHtml(s) {
-    const d = document.createElement('div');
-    d.textContent = String(s);
-    return d.innerHTML;
-  }
-
-  // --- 401 token hint ---
-  let tokenHintTimer = null;
-  function highlightTokenInput(msg) {
-    tokenInput.style.borderColor = 'var(--warn)';
-    tokenInput.focus();
-    // Show hint text below the input
-    let hint = document.getElementById('tokenHint');
-    if (!hint) {
-      hint = document.createElement('div');
-      hint.id = 'tokenHint';
-      hint.style.cssText = 'font-size:11px;color:var(--warn);margin-top:-4px;margin-bottom:4px;';
-      tokenInput.parentNode.insertBefore(hint, tokenInput.nextSibling);
-    }
-    hint.textContent = msg;
-    if (tokenHintTimer) clearTimeout(tokenHintTimer);
-    tokenHintTimer = setTimeout(() => {
-      tokenInput.style.borderColor = '';
-      hint.textContent = '';
-    }, 6000);
-  }
-
-  // --- API helpers ---
-  function authHeaders() {
-    const token = tokenInput.value.trim();
-    return token ? { 'Authorization': 'Bearer ' + token } : {};
-  }
-
-  async function api(method, path, body) {
-    const opts = { method, headers: { ...authHeaders() } };
-    if (body !== undefined) {
-      opts.headers['Content-Type'] = 'application/json';
-      opts.body = JSON.stringify(body);
-    }
-    logRequest(method, path + (body ? ' ' + JSON.stringify(body) : ''));
-    try {
-      const res = await fetch(BASE + path, opts);
-      const text = await res.text();
-      let data;
-      try { data = JSON.parse(text); } catch { data = text; }
-      if (!res.ok) {
-        logError(res.status, JSON.stringify(data));
-        if (res.status === 401) {
-          highlightTokenInput('API returned 401 \u2014 enter your bearer token below');
-        }
-        return { ok: false, status: res.status, data };
-      }
-      logResponse(res.status, JSON.stringify(data));
-      return { ok: true, status: res.status, data };
-    } catch (err) {
-      logError('ERR', err.message);
-      return { ok: false, status: 0, data: { error: err.message } };
-    }
-  }
-
-  // --- Health check on load ---
-  async function checkHealth() {
-    const r = await api('GET', '/health');
-    if (r.ok) {
-      statusDot.classList.add('ok');
-      statusText.textContent = 'Connected';
-    } else {
-      statusDot.classList.remove('ok');
-      statusText.textContent = 'Disconnected';
-    }
-  }
-
-  // --- Session ---
-  async function createSession() {
-    const cwd = cwdInput.value.trim();
-    if (!cwd) { alert('Please enter a working directory'); return; }
-    const r = await api('POST', '/session', { cwd });
-    if (r.ok) {
-      sessionId = r.data.sessionId;
-      sessionInfo.style.display = 'block';
-      sessionIdDisplay.textContent = sessionId;
-      enablePrompt(true);
-      chatArea.innerHTML = '';
-      currentAssistantBubble = null;
-      pendingPerms.clear();
-      renderPermissions();
-      if (r.data.attached) {
-        addChatMeta('Attached to existing session');
-      } else {
-        addChatMeta('New session created');
-      }
-      connectSSE();
-    } else {
-      const msg = r.data.error || 'session creation failed (' + r.status + ')';
-      addChatMeta('Error: ' + msg);
-      if (r.status === 401) highlightTokenInput('Token required or invalid');
-    }
-  }
-
-  function enablePrompt(on) {
-    $('#btnSendPrompt').disabled = !on;
-    $('#btnCancel').disabled = !on;
-    $('#btnSetModel').disabled = !on;
-    chatInput.disabled = !on;
-    $('#btnChatSend').disabled = !on;
-  }
-
-  // --- SSE ---
-  function connectSSE() {
-    if (eventSource) { eventSource.close(); }
-    const url = BASE + '/session/' + sessionId + '/events';
-    logEvent('SSE', 'Connecting to ' + url);
-
-    // Use fetch-based SSE to avoid Origin header issues with EventSource
-    const abort = new AbortController();
-    eventSource = { close: () => abort.abort() };
-
-    (async function readSSE() {
-      try {
-        const hdrs = authHeaders();
-        const res = await fetch(url, { signal: abort.signal, headers: hdrs });
-        if (!res.ok) {
-          logEvent('SSE-ERR', 'HTTP ' + res.status);
-          statusDot.classList.remove('ok');
-          statusText.textContent = 'SSE failed (' + res.status + ')';
-          enablePrompt(false);
-          if (res.status === 401) {
-            highlightTokenInput('SSE returned 401 \u2014 enter your bearer token and recreate the session');
-          }
-          return;
-        }
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-        let currentEvent = {};
-
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-
-          const lines = buffer.split('\\n');
-          buffer = lines.pop();
-
-          for (const line of lines) {
-            if (line.startsWith('data: ')) {
-              currentEvent.data = line.slice(6);
-            } else if (line.startsWith('event: ')) {
-              currentEvent.event = line.slice(7);
-            } else if (line.startsWith('id: ')) {
-              currentEvent.id = line.slice(4);
-            } else if (line === '') {
-              if (currentEvent.data) {
-                handleSSEMessage(currentEvent);
-              }
-              currentEvent = {};
-            }
-          }
-        }
-        // Process any remaining buffered data
-        if (currentEvent.data) handleSSEMessage(currentEvent);
-        statusDot.classList.remove('ok');
-        statusText.textContent = 'SSE stream ended';
-        enablePrompt(false);
-        logEvent('SSE', 'Stream ended by server');
-      } catch (err) {
-        if (err.name !== 'AbortError') {
-          logEvent('SSE-ERR', err.message);
-          statusDot.classList.remove('ok');
-          statusText.textContent = 'SSE error';
-          enablePrompt(false);
-        }
-      }
-    })();
-  }
-
-  function handleSSEMessage(msg) {
-    let data;
-    try { data = JSON.parse(msg.data); } catch { data = msg.data; }
-    const type = data.type || msg.event || 'unknown';
-
-    if (type === 'session_update' && data.data) {
-      const update = data.data.update || data.data;
-      const kind = update.sessionUpdate;
-
-      if (kind === 'agent_message_chunk') {
-        const text = update.content?.text || '';
-        if (text) appendAssistantChunk(text);
-        if (update._meta?.usage) {
-          const u = update._meta.usage;
-          addChatMeta('tokens: in=' + u.inputTokens + ' out=' + u.outputTokens + ' | ' + (update._meta.durationMs || 0) + 'ms');
-          currentAssistantBubble = null;
-        }
-        logEvent('MSG', text || '(usage meta)');
-      } else if (kind === 'agent_thought_chunk') {
-        const text = update.content?.text || '';
-        currentThought += text;
-        logEvent('THINK', text);
-      } else {
-        logEvent(kind || type, JSON.stringify(update));
-      }
-    } else if (type === 'permission_request') {
-      handlePermissionRequest(data);
-      logEvent('PERM', JSON.stringify(data.data));
-    } else if (type === 'permission_resolved') {
-      logEvent('PERM-OK', JSON.stringify(data.data));
-      removePermission(data.data?.requestId);
-    } else if (type === 'session_died') {
-      addChatMeta('Session died: ' + JSON.stringify(data.data));
-      logEvent('DIED', JSON.stringify(data.data));
-      enablePrompt(false);
-    } else if (type === 'model_switched') {
-      addChatMeta('Model switched: ' + JSON.stringify(data.data));
-      logEvent('MODEL', JSON.stringify(data.data));
-    } else {
-      logEvent(type, JSON.stringify(data));
-    }
-  }
-
-  // --- Chat UI ---
-  function addUserMessage(text) {
-    currentAssistantBubble = null;
-    currentThought = '';
-    const el = document.createElement('div');
-    el.className = 'chat-msg user';
-    el.innerHTML = '<div class="bubble">' + escHtml(text) + '</div>';
-    chatArea.appendChild(el);
-    chatArea.scrollTop = chatArea.scrollHeight;
-  }
-
-  function appendAssistantChunk(text) {
-    if (!currentAssistantBubble) {
-      if (currentThought) {
-        const te = document.createElement('div');
-        te.className = 'chat-msg assistant';
-        te.innerHTML = '<div class="bubble" style="color:var(--text2);font-style:italic;border-color:var(--border)">Thinking: ' + escHtml(currentThought) + '</div>';
-        chatArea.appendChild(te);
-        currentThought = '';
-      }
-      const el = document.createElement('div');
-      el.className = 'chat-msg assistant';
-      el.innerHTML = '<div class="bubble"></div>';
-      chatArea.appendChild(el);
-      currentAssistantBubble = el.querySelector('.bubble');
-    }
-    currentAssistantBubble.textContent += text;
-    chatArea.scrollTop = chatArea.scrollHeight;
-  }
-
-  function addChatMeta(text) {
-    const el = document.createElement('div');
-    el.className = 'chat-msg assistant';
-    el.innerHTML = '<div class="meta">' + escHtml(text) + '</div>';
-    chatArea.appendChild(el);
-    chatArea.scrollTop = chatArea.scrollHeight;
-  }
-
-  // --- Prompt ---
-  let promptInFlight = false;
-  async function sendPrompt(text) {
-    if (!sessionId || !text.trim() || promptInFlight) return;
-    promptInFlight = true;
-    enablePrompt(false);
-    addUserMessage(text.trim());
-    promptInput.value = '';
-    chatInput.value = '';
-    try {
-      const r = await api('POST', '/session/' + sessionId + '/prompt', {
-        prompt: [{ type: 'text', text: text.trim() }]
-      });
-      if (r.ok) {
-        addChatMeta('stopReason: ' + (r.data.stopReason || 'unknown'));
-      } else {
-        addChatMeta('Error: ' + (r.data.error || 'prompt failed (' + r.status + ')'));
-      }
-    } finally {
-      promptInFlight = false;
-      if (sessionId) enablePrompt(true);
-    }
-  }
-
-  // --- Permission handling ---
-  const pendingPerms = new Map();
-
-  function handlePermissionRequest(data) {
-    const req = data.data;
-    const requestId = req?.requestId;
-    if (!requestId) return;
-    pendingPerms.set(requestId, req);
-    renderPermissions();
-
-    addChatMeta('Permission requested: ' + requestId);
-  }
-
-  function removePermission(requestId) {
-    pendingPerms.delete(requestId);
-    renderPermissions();
-  }
-
-  function renderPermissions() {
-    if (pendingPerms.size === 0) {
-      permissionPanel.style.display = 'none';
-      return;
-    }
-    permissionPanel.style.display = 'block';
-    permissionList.innerHTML = '';
-    for (const [id, req] of pendingPerms) {
-      const card = document.createElement('div');
-      card.className = 'permission-card';
-
-      const h4 = document.createElement('h4');
-      h4.textContent = req.tool?.name || 'Permission';
-      card.appendChild(h4);
-
-      const idDiv = document.createElement('div');
-      idDiv.style.cssText = 'font-size:11px;color:var(--text2);margin-bottom:6px';
-      idDiv.textContent = id;
-      card.appendChild(idDiv);
-
-      // Show toolCall context (command, input, path, etc.) when available
-      const tc = req.toolCall || req.tool;
-      if (tc) {
-        const detail = document.createElement('pre');
-        detail.style.cssText = 'font-size:11px;color:var(--text2);margin-bottom:6px;white-space:pre-wrap;word-break:break-all;max-height:120px;overflow-y:auto;background:var(--bg);padding:6px;border-radius:4px;border:1px solid var(--border)';
-        const parts = [];
-        if (tc.command) parts.push('command: ' + tc.command);
-        if (tc.input) parts.push('input: ' + (typeof tc.input === 'string' ? tc.input : JSON.stringify(tc.input, null, 2)));
-        if (tc.path) parts.push('path: ' + tc.path);
-        if (tc.diff) parts.push('diff: ' + tc.diff);
-        if (tc.serverUrl) parts.push('url: ' + tc.serverUrl);
-        if (parts.length === 0 && tc.name) parts.push('tool: ' + tc.name);
-        if (parts.length > 0) {
-          detail.textContent = parts.join('\\n');
-          card.appendChild(detail);
-        }
-      }
-
-      function makePermBtn(reqId, optId, label, isCancel) {
-        const btn = document.createElement('button');
-        btn.className = 'btn opt-btn';
-        btn.textContent = label;
-        btn.dataset.req = reqId;
-        if (isCancel) {
-          btn.dataset.cancel = '1';
-          btn.style.borderColor = 'var(--err)';
-          btn.style.color = 'var(--err)';
-        } else {
-          btn.dataset.opt = optId;
-        }
-        btn.addEventListener('click', async () => {
-          let outcome;
-          if (isCancel) {
-            outcome = { outcome: 'cancelled' };
-          } else {
-            outcome = { outcome: 'selected', optionId: optId };
-          }
-          const result = await api('POST', '/permission/' + reqId, { outcome });
-          if (result.ok) {
-            removePermission(reqId);
-          } else {
-            logError('PERM-ERR', 'Failed to resolve permission ' + reqId + ': ' + JSON.stringify(result.data));
-          }
-        });
-        return btn;
-      }
-
-      if (req.options && Array.isArray(req.options)) {
-        for (const opt of req.options) {
-          card.appendChild(makePermBtn(id, opt.optionId, opt.name || opt.optionId, false));
-        }
-      }
-      card.appendChild(makePermBtn(id, null, 'Cancel', true));
-      permissionList.appendChild(card);
-    }
-  }
-
-  // --- Button bindings ---
-  $('#btnCreateSession').addEventListener('click', createSession);
-  $('#btnListSessions').addEventListener('click', async () => {
-    const cwd = cwdInput.value.trim();
-    if (!cwd) { alert('Enter a cwd first'); return; }
-    await api('GET', '/workspace/' + encodeURIComponent(cwd) + '/sessions');
-  });
-  $('#btnSendPrompt').addEventListener('click', () => sendPrompt(promptInput.value));
-  $('#btnChatSend').addEventListener('click', () => sendPrompt(chatInput.value));
-  chatInput.addEventListener('keydown', (e) => {
-    if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); sendPrompt(chatInput.value); }
-  });
-  promptInput.addEventListener('keydown', (e) => {
-    if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); sendPrompt(promptInput.value); }
-  });
-  $('#btnCancel').addEventListener('click', async () => {
-    if (!sessionId) return;
-    await api('POST', '/session/' + sessionId + '/cancel', {});
-  });
-  $('#btnSetModel').addEventListener('click', async () => {
-    if (!sessionId) return;
-    const mid = modelInput.value.trim();
-    if (!mid) { alert('Enter a model ID'); return; }
-    await api('POST', '/session/' + sessionId + '/model', { modelId: mid });
-  });
-  $('#btnHealth').addEventListener('click', () => api('GET', '/health'));
-  $('#btnHealthDeep').addEventListener('click', () => api('GET', '/health?deep=1'));
-  $('#btnCaps').addEventListener('click', () => api('GET', '/capabilities'));
-
-  // --- Init ---
-  checkHealth();
-})();
-</script>
-</body>
-</html>`
-  );
-}
-__name(getDemoHtml, "getDemoHtml");
-
-// packages/cli/src/serve/routes/health-demo.ts
-function createHealthDemoRoutes(deps) {
-  const {
-    opts,
-    getPort,
-    workspaceRegistry,
-    getActiveSseCount: getActiveSseCount2,
-    getRateLimiter
-  } = deps;
-  const demoHandler = /* @__PURE__ */ __name((_req, res) => {
-    try {
-      res.type("html").set("X-Frame-Options", "DENY").set(
-        "Content-Security-Policy",
-        "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'; frame-ancestors 'none'"
-      ).send(getDemoHtml(getPort()));
-    } catch (err) {
-      writeStderrLine(
-        `qwen serve: /demo render failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-      res.status(500).json({ error: "Failed to render demo page" });
-    }
-  }, "demoHandler");
+function createHealthRoutes(deps) {
+  const { opts, workspaceRegistry, getActiveSseCount: getActiveSseCount2, getRateLimiter } = deps;
   const healthHandler = /* @__PURE__ */ __name((req, res) => {
     if (!isDeepHealthQuery(req.query["deep"])) {
       res.status(200).json({ status: "ok" });
@@ -16705,11 +16658,10 @@ function createHealthDemoRoutes(deps) {
     exposeHealthPreAuth,
     register(app) {
       app.get("/health", healthHandler);
-      app.get("/demo", demoHandler);
     }
   };
 }
-__name(createHealthDemoRoutes, "createHealthDemoRoutes");
+__name(createHealthRoutes, "createHealthRoutes");
 
 // packages/cli/src/serve/routes/workspace-auth.ts
 init_esbuild_shims();
@@ -22430,7 +22382,6 @@ __name(createWorkspaceRuntimeSessionService, "createWorkspaceRuntimeSessionServi
 var GIT_RESERVED_BRANCH = "HEAD";
 var MAX_BRANCH_NAME_BYTES = 1e3;
 var MAX_BRANCH_COMPONENT_BYTES = 200;
-var HTTP_SESSION_ID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var WORKSPACE_TRANSCRIPT_RESPONSE_MAX_BYTES = 2 * SESSION_TRANSCRIPT_MAX_EXPANDED_PAGE_BYTES;
 var WORKSPACE_TRANSCRIPT_CURSOR_MAX_BYTES = 64 * 1024;
 var TRANSCRIPT_CURSOR_TOO_LARGE_REPLAY_ERROR = "Transcript pagination state exceeds the safe limit";
@@ -22590,15 +22541,6 @@ function shouldPreserveTranscriptResolutionError(err) {
   return err instanceof SessionArchivedError || err instanceof SessionConflictError || err instanceof SessionNotFoundError;
 }
 __name(shouldPreserveTranscriptResolutionError, "shouldPreserveTranscriptResolutionError");
-function isSessionLive(bridge, sessionId) {
-  try {
-    bridge.getSessionSummary(sessionId);
-    return true;
-  } catch (err) {
-    return !(err instanceof SessionNotFoundError);
-  }
-}
-__name(isSessionLive, "isSessionLive");
 function parseOptionalApprovalMode(body, res) {
   const rawApprovalMode = body["approvalMode"];
   if (rawApprovalMode === void 0) {
@@ -22628,12 +22570,27 @@ function registerSessionRoutes(app, deps) {
     sessionShellCommandEnabled,
     virtualSubagentSessions
   } = deps;
+  const requestedSessionIdAdmission = deps.requestedSessionIdAdmission ?? createRequestedSessionIdAdmission({
+    archiveCoordinator,
+    getBridges: /* @__PURE__ */ __name(() => workspaceRegistry.listManaged().map((runtime) => runtime.bridge), "getBridges"),
+    getPersistenceTargets: /* @__PURE__ */ __name(() => workspaceRegistry.listManaged().map((runtime) => ({
+      workspaceCwd: runtime.workspaceCwd,
+      runtimeBaseDir: runtime.sessionRuntimeBaseDir
+    })), "getPersistenceTargets"),
+    getBridgeWorkspaceId: /* @__PURE__ */ __name((bridge2) => workspaceRegistry.listEntries().find((entry) => entry.current?.runtime.bridge === bridge2)?.workspaceId, "getBridgeWorkspaceId")
+  });
+  const captureRuntimeGenerationAssertion = /* @__PURE__ */ __name((runtime) => {
+    const registeredGeneration = workspaceRegistry.getEntryByWorkspaceId(
+      runtime.workspaceId
+    )?.current;
+    const guard = registeredGeneration?.runtime === runtime ? registeredGeneration.guard : runtime.generationGuard;
+    return guard ? () => guard.assertOpen() : void 0;
+  }, "captureRuntimeGenerationAssertion");
   const LANGUAGE_CODES = deps.languageCodes;
   const transcriptCursorMasterKey = crypto3.randomBytes(32);
   const transcriptCursorCodecs = /* @__PURE__ */ new Map();
   const activeBranchSessions = /* @__PURE__ */ new Map();
   const inFlightBranchWorkspaces = /* @__PURE__ */ new Set();
-  const inFlightSessionIds = /* @__PURE__ */ new Set();
   const clearBranchSessionEntry = /* @__PURE__ */ __name((sessionId) => {
     for (const [cwd, sid] of activeBranchSessions) {
       if (sid === sessionId) {
@@ -22695,6 +22652,20 @@ function registerSessionRoutes(app, deps) {
       ...details
     });
   }, "logSessionRoutingFailure");
+  const sendRequestedSessionIdAdmissionError = /* @__PURE__ */ __name((res, error2, route) => {
+    const resolutionKind = error2.code === "session_workspace_conflict" ? "workspace_conflict" : error2.code;
+    logSessionRoutingFailure(route, resolutionKind, {
+      sessionId: error2.sessionId,
+      ...error2.details
+    });
+    const status = error2.code === "session_id_admission_unavailable" ? 503 : 409;
+    res.status(status).json({
+      error: error2.message,
+      code: error2.code,
+      sessionId: error2.sessionId,
+      ...error2.details
+    });
+  }, "sendRequestedSessionIdAdmissionError");
   const sendWorkspaceMismatch2 = /* @__PURE__ */ __name((res, requestedWorkspace) => {
     const runtimes = workspaceRegistry.list();
     if (runtimes.length > 1) {
@@ -22959,7 +22930,6 @@ function registerSessionRoutes(app, deps) {
     sendUntrustedSessionOwner(res, route, sessionId, runtime);
     return false;
   }, "assertTrustedSessionOwner");
-  const inFlightRestoreOwners = /* @__PURE__ */ new Map();
   const sendSessionWorkspaceConflict = /* @__PURE__ */ __name((res, route, sessionId, runtime, liveRuntime) => {
     logSessionRoutingFailure(route, "workspace_conflict", {
       sessionId,
@@ -22978,33 +22948,6 @@ function registerSessionRoutes(app, deps) {
       liveWorkspaceId: liveRuntime.workspaceId
     });
   }, "sendSessionWorkspaceConflict");
-  const enterRestoreOwner = /* @__PURE__ */ __name((res, route, sessionId, runtime) => {
-    const existing = inFlightRestoreOwners.get(sessionId);
-    if (existing && existing.workspaceCwd !== runtime.workspaceCwd) {
-      sendSessionWorkspaceConflict(res, route, sessionId, runtime, existing);
-      return void 0;
-    }
-    if (existing) {
-      existing.count += 1;
-    } else {
-      inFlightRestoreOwners.set(sessionId, {
-        workspaceId: runtime.workspaceId,
-        workspaceCwd: runtime.workspaceCwd,
-        count: 1
-      });
-    }
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      const current = inFlightRestoreOwners.get(sessionId);
-      if (!current || current.workspaceCwd !== runtime.workspaceCwd) return;
-      current.count -= 1;
-      if (current.count <= 0) {
-        inFlightRestoreOwners.delete(sessionId);
-      }
-    };
-  }, "enterRestoreOwner");
   const resolveRuntimeForSessionRestore = /* @__PURE__ */ __name((body, res, route, sessionId) => {
     const cwd = parseOptionalWorkspaceCwd(body, boundWorkspace, res);
     if (cwd === void 0) return void 0;
@@ -23255,6 +23198,7 @@ function registerSessionRoutes(app, deps) {
       });
       return;
     }
+    const assertRuntimeGenerationOpen = captureRuntimeGenerationAssertion(runtime);
     const modelServiceId = typeof body["modelServiceId"] === "string" ? body["modelServiceId"] : void 0;
     const rawSessionScope = body["sessionScope"];
     let sessionScope;
@@ -23287,52 +23231,39 @@ function registerSessionRoutes(app, deps) {
     }
     const clientId = parseClientIdHeader(req, res);
     if (clientId === null) return;
-    const rawSessionId = body["sessionId"];
-    let requestedSessionId;
-    if (rawSessionId !== void 0 && rawSessionId !== null) {
-      if (typeof rawSessionId !== "string" || !HTTP_SESSION_ID_REGEX.test(rawSessionId)) {
-        res.status(400).json({
-          error: '`sessionId` must be a UUID (e.g. "550e8400-e29b-41d4-a716-446655440000")',
-          code: "invalid_session_id"
-        });
-        return;
-      }
-      requestedSessionId = rawSessionId.toLowerCase();
-      const sessionIdToCheck = requestedSessionId;
-      if (isSessionLive(runtime.bridge, sessionIdToCheck)) {
-        res.status(409).json({
-          error: `Session "${requestedSessionId}" already exists`,
-          code: "session_id_conflict"
-        });
-        return;
-      }
-      const runtimeOutputDir = loadSettingsCached(workspaceCwd).merged.advanced?.runtimeOutputDir;
-      if (await Storage.runWithRuntimeBaseDir(
-        runtimeOutputDir,
-        workspaceCwd,
-        () => new SessionService(workspaceCwd).sessionExistsInAnyState(
-          sessionIdToCheck
-        )
-      )) {
-        res.status(409).json({
-          error: `Session "${requestedSessionId}" already exists`,
-          code: "session_id_conflict"
-        });
-        return;
-      }
-      if (inFlightSessionIds.has(requestedSessionId)) {
-        res.status(409).json({
-          error: `Session "${requestedSessionId}" creation already in progress`,
-          code: "session_id_conflict"
-        });
-        return;
+    const parsedSessionId = parseCallerSuppliedSessionId(body["sessionId"]);
+    if (parsedSessionId.kind === "invalid") {
+      res.status(400).json({
+        error: '`sessionId` must be an RFC UUID v1-v5 (e.g. "550e8400-e29b-41d4-a716-446655440000")',
+        code: "invalid_session_id"
+      });
+      return;
+    }
+    const requestedSessionId = parsedSessionId.kind === "valid" ? parsedSessionId.sessionId : void 0;
+    let sessionIdReservation;
+    if (requestedSessionId !== void 0) {
+      try {
+        sessionIdReservation = await requestedSessionIdAdmission.reserveCreate(
+          requestedSessionId,
+          {
+            bridge: runtime.bridge,
+            workspaceCwd,
+            workspaceId: runtime.workspaceId
+          }
+        );
+      } catch (error2) {
+        if (error2 instanceof RequestedSessionIdAdmissionError) {
+          sendRequestedSessionIdAdmissionError(res, error2, "POST /session");
+          return;
+        }
+        throw error2;
       }
-      inFlightSessionIds.add(requestedSessionId);
     }
     let branchMeta;
     let branchBaseCommit;
     let worktreeMeta;
     try {
+      assertRuntimeGenerationOpen?.();
       const rawBranch = body["branch"];
       if (rawBranch !== void 0 && rawBranch !== null) {
         if (body["worktree"] !== void 0 && body["worktree"] !== null) {
@@ -23440,6 +23371,7 @@ function registerSessionRoutes(app, deps) {
           });
           return;
         }
+        assertRuntimeGenerationOpen?.();
         inFlightBranchWorkspaces.add(workspaceCwd);
         try {
           await createBranch(workspaceCwd, branchName);
@@ -23509,6 +23441,7 @@ function registerSessionRoutes(app, deps) {
           return;
         }
         const baseBranch = await wtService.getCurrentBranch().catch(() => void 0);
+        assertRuntimeGenerationOpen?.();
         const wtResult = await wtService.createUserWorktree(slug, baseBranch);
         if (!wtResult.success || !wtResult.worktree) {
           res.status(500).json({
@@ -23527,6 +23460,7 @@ function registerSessionRoutes(app, deps) {
       if (requestedSessionId !== void 0) {
         sessionScope = "thread";
       }
+      assertRuntimeGenerationOpen?.();
       const session = await runtime.bridge.spawnOrAttach({
         workspaceCwd,
         modelServiceId,
@@ -23556,6 +23490,9 @@ function registerSessionRoutes(app, deps) {
               coordinator: archiveCoordinator
             })
           ).catch(() => false);
+        } else {
+          await runtime.bridge.detachClient(session.sessionId, session.clientId).catch(() => {
+          });
         }
         if (worktreeMeta) {
           await new GitWorktreeService(workspaceCwd).removeUserWorktree(worktreeMeta.slug, { deleteBranch: true }).catch(() => {
@@ -23576,7 +23513,7 @@ function registerSessionRoutes(app, deps) {
         return;
       }
       try {
-        runtime.generationGuard?.assertOpen();
+        assertRuntimeGenerationOpen?.();
       } catch (error2) {
         if (!session.attached) {
           try {
@@ -23747,9 +23684,7 @@ function registerSessionRoutes(app, deps) {
       }
       sendBridgeError2(res, err, { route: "POST /session" });
     } finally {
-      if (requestedSessionId !== void 0) {
-        inFlightSessionIds.delete(requestedSessionId);
-      }
+      sessionIdReservation?.release();
     }
   });
   const restoreSessionHandler = /* @__PURE__ */ __name((action) => async (req, res) => {
@@ -23820,27 +23755,29 @@ function registerSessionRoutes(app, deps) {
     }
     if (resolvedRuntime === void 0) return;
     const { runtime, workspaceCwd } = resolvedRuntime;
-    const releaseRestoreOwner = enterRestoreOwner(
-      res,
-      route,
-      sessionId,
-      runtime
-    );
-    if (!releaseRestoreOwner) return;
+    const assertRuntimeGenerationOpen = captureRuntimeGenerationAssertion(runtime);
     const approvalMode = parseOptionalApprovalMode(body, res);
-    if (approvalMode === null) {
-      releaseRestoreOwner();
-      return;
-    }
+    if (approvalMode === null) return;
     const historyPageSize = action === "load" ? parseHistoryPageSize(body ?? {}, res) : void 0;
-    if (historyPageSize === null) {
-      releaseRestoreOwner();
-      return;
-    }
+    if (historyPageSize === null) return;
     const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) {
-      releaseRestoreOwner();
-      return;
+    if (clientId === null) return;
+    let sessionIdReservation;
+    try {
+      sessionIdReservation = requestedSessionIdAdmission.reserveRestore(
+        sessionId,
+        {
+          bridge: runtime.bridge,
+          workspaceCwd,
+          workspaceId: runtime.workspaceId
+        }
+      );
+    } catch (error2) {
+      if (error2 instanceof RequestedSessionIdAdmissionError) {
+        sendRequestedSessionIdAdmissionError(res, error2, route);
+        return;
+      }
+      throw error2;
     }
     try {
       const session = await archiveCoordinator.runSharedMany(
@@ -23867,7 +23804,7 @@ function registerSessionRoutes(app, deps) {
             }
             liveConversationCwd = await materialize(sessionId);
           }
-          runtime.generationGuard?.assertOpen();
+          assertRuntimeGenerationOpen?.();
           const restored = action === "load" ? await runtime.bridge.loadSession({
             sessionId,
             workspaceCwd,
@@ -23939,7 +23876,7 @@ function registerSessionRoutes(app, deps) {
         }
       );
       try {
-        runtime.generationGuard?.assertOpen();
+        assertRuntimeGenerationOpen?.();
       } catch (error2) {
         if (!session.attached) {
           await runtime.bridge.killSession(session.sessionId, { requireZeroAttaches: true }).catch(() => {
@@ -24041,7 +23978,7 @@ function registerSessionRoutes(app, deps) {
         sessionId
       });
     } finally {
-      releaseRestoreOwner();
+      sessionIdReservation.release();
     }
   }, "restoreSessionHandler");
   app.post("/session/:id/load", mutate(), restoreSessionHandler("load"));
@@ -27361,7 +27298,7 @@ function collectBoundSessionIds(tasks) {
   return ids;
 }
 __name(collectBoundSessionIds, "collectBoundSessionIds");
-var KEEPALIVE_REVIVE_TIMEOUT_MS = 3e4;
+var KEEPALIVE_REVIVE_TIMEOUT_MS = 7e4;
 var KEEPALIVE_SPAWN_TIMEOUT_MS = 3e4;
 var MAX_REVIVE_BACKOFF_MS = 30 * 6e4;
 async function bindAndNameSessions(bridge, boundWorkspace, tasks, renamed, spawnTimeoutMs, binding, cleanupSession) {
@@ -27607,7 +27544,7 @@ function startScheduledTaskKeepalive(opts) {
   };
 }
 __name(startScheduledTaskKeepalive, "startScheduledTaskKeepalive");
-var REHYDRATE_LOAD_TIMEOUT_MS = 3e4;
+var REHYDRATE_LOAD_TIMEOUT_MS = 7e4;
 var REHYDRATE_MAX_CONCURRENCY = 4;
 async function rehydrateScheduledTaskSessions(deps) {
   const { bridge, boundWorkspace } = deps;
@@ -27666,6 +27603,7 @@ async function rehydrateScheduledTaskSessions(deps) {
 }
 __name(rehydrateScheduledTaskSessions, "rehydrateScheduledTaskSessions");
 function withTimeout(p, ms, label) {
+  if (ms > MAX_SESSION_RESTORE_TIMEOUT_MS) return p;
   return new Promise((resolve5, reject) => {
     const timer = setTimeout(() => {
       reject(new Error(`${label} timed out after ${ms}ms`));
@@ -28232,6 +28170,7 @@ function registerCapabilitiesRoutes(app, deps) {
         maxPendingPromptsPerSession: advertisedMaxPendingPromptsPerSession(
           deps.maxPendingPromptsPerSession
         ),
+        sessionRestoreTimeoutMs: deps.sessionRestoreTimeoutMs,
         ...multiWorkspace ? {
           maxSessionsPerWorkspace: advertisedMaxSessions(
             deps.maxSessionsPerWorkspace
@@ -29056,6 +28995,25 @@ function bridgeErrorExtraContext(ctx) {
   return extra;
 }
 __name(bridgeErrorExtraContext, "bridgeErrorExtraContext");
+function recordExpectedBridgeError(err, ctx, daemonLog) {
+  recordDaemonBridgeError(err);
+  recordDaemonError(void 0, err, {
+    ...ctx?.route ? { "http.route": ctx.route } : {},
+    ...ctx?.sessionId ? { "session.id": ctx.sessionId } : {}
+  });
+  emitDaemonLog("Daemon bridge request failed.", {
+    ...ctx?.route ? { "http.route": ctx.route } : {},
+    ...ctx?.sessionId ? { "session.id": ctx.sessionId } : {},
+    "error.type": err.name,
+    "error.message": err.message.slice(0, 1024)
+  });
+  daemonLog?.warn(err.message, {
+    ...ctx?.route ? { route: ctx.route } : {},
+    ...ctx?.sessionId ? { sessionId: ctx.sessionId } : {},
+    errorType: err.name
+  });
+}
+__name(recordExpectedBridgeError, "recordExpectedBridgeError");
 function sendPermissionVoteError(res, err, ctx, daemonLog) {
   if (err instanceof InvalidPermissionOptionError) {
     res.status(400).json({
@@ -29097,6 +29055,33 @@ function sendPermissionVoteError(res, err, ctx, daemonLog) {
 }
 __name(sendPermissionVoteError, "sendPermissionVoteError");
 function sendBridgeError(res, err, ctx, daemonLog) {
+  if (err instanceof SessionRestoreTimeoutError) {
+    recordExpectedBridgeError(err, ctx, daemonLog);
+    res.set("Retry-After", String(restoreRetryAfterSeconds(err.timeoutMs)));
+    res.status(504).json({
+      error: err.message,
+      code: "session_restore_timeout",
+      errorKind: "restore_timeout",
+      retryable: true,
+      sessionId: err.sessionId,
+      action: err.action,
+      timeoutMs: err.timeoutMs
+    });
+    return;
+  }
+  if (err instanceof BridgeChannelQuarantinedError) {
+    recordExpectedBridgeError(err, ctx, daemonLog);
+    res.set("Retry-After", String(err.retryAfterSeconds));
+    res.status(503).json({
+      error: err.message,
+      code: "acp_channel_unavailable",
+      errorKind: "acp_channel_unavailable",
+      retryable: true,
+      reason: err.reason,
+      retryAfterSeconds: err.retryAfterSeconds
+    });
+    return;
+  }
   if (err instanceof DaemonDrainingError) {
     res.status(503).json({
       error: err.message,
@@ -29114,22 +29099,9 @@ function sendBridgeError(res, err, ctx, daemonLog) {
     });
     return;
   }
-  if (err instanceof WorkspaceSkillNotFoundError) {
-    res.status(404).json({
-      error: err.message,
-      code: "skill_not_found",
-      skillName: err.skillName
-    });
-    return;
-  }
-  if (err instanceof WorkspaceSkillNotToggleableError) {
-    res.status(409).json({
-      error: err.message,
-      code: err.reason === "inactive_extension" ? "skill_inactive_extension" : "skill_not_toggleable",
-      skillName: err.skillName,
-      reason: err.reason,
-      ...err.lockedScope ? { lockedScope: err.lockedScope } : {}
-    });
+  const skillError = mapWorkspaceSkillToggleError(err);
+  if (skillError) {
+    res.status(skillError.code === "skill_not_found" ? 404 : 409).json(skillError);
     return;
   }
   if (err instanceof InvalidSessionTranscriptCursorError) {
@@ -29395,10 +29367,12 @@ function sendBridgeError(res, err, ctx, daemonLog) {
     return;
   }
   if (err instanceof RestoreInProgressError) {
-    res.set("Retry-After", "5");
+    res.set("Retry-After", String(err.retryAfterSeconds));
     res.status(409).json({
       error: err.message,
       code: "restore_in_progress",
+      reason: err.reason,
+      retryable: true,
       sessionId: err.sessionId,
       activeAction: err.activeAction,
       requestedAction: err.requestedAction
@@ -35408,6 +35382,26 @@ __name(registerWorkspaceQualifiedToolsRoutes, "registerWorkspaceQualifiedToolsRo
 
 // packages/cli/src/serve/routes/workspace-skills.ts
 init_esbuild_shims();
+var MAX_WORKSPACE_SKILL_BATCH_SIZE = 100;
+function rejectSkillNameTooLong(skillName, res) {
+  if (skillName.length <= MAX_WORKSPACE_SKILL_NAME_LENGTH) return false;
+  res.status(400).json({
+    error: `Skill name exceeds ${MAX_WORKSPACE_SKILL_NAME_LENGTH}-character limit`,
+    code: "invalid_skill_name"
+  });
+  return true;
+}
+__name(rejectSkillNameTooLong, "rejectSkillNameTooLong");
+function parseEnabledFlag(body, res) {
+  const enabled = body["enabled"];
+  if (typeof enabled === "boolean") return { enabled };
+  res.status(400).json({
+    error: "`enabled` is required and must be a boolean",
+    code: "invalid_enabled_flag"
+  });
+  return void 0;
+}
+__name(parseEnabledFlag, "parseEnabledFlag");
 function parseSkillToggleRequest(req, res, safeBody2) {
   const rawSkillName = req.params["name"];
   if (!rawSkillName || typeof rawSkillName !== "string") {
@@ -35425,24 +35419,42 @@ function parseSkillToggleRequest(req, res, safeBody2) {
     });
     return void 0;
   }
-  if (skillName.length > MAX_WORKSPACE_SKILL_NAME_LENGTH) {
+  if (rejectSkillNameTooLong(skillName, res)) return void 0;
+  const flag = parseEnabledFlag(safeBody2(req), res);
+  return flag ? { skillName, enabled: flag.enabled } : void 0;
+}
+__name(parseSkillToggleRequest, "parseSkillToggleRequest");
+function parseSkillBatchToggleRequest(req, res, safeBody2) {
+  const body = safeBody2(req);
+  const rawSkillNames = body["skillNames"];
+  if (!Array.isArray(rawSkillNames) || rawSkillNames.length === 0 || rawSkillNames.length > MAX_WORKSPACE_SKILL_BATCH_SIZE || !rawSkillNames.every((name) => typeof name === "string")) {
     res.status(400).json({
-      error: `Skill name exceeds ${MAX_WORKSPACE_SKILL_NAME_LENGTH}-character limit`,
-      code: "invalid_skill_name"
+      error: `\`skillNames\` must be a non-empty string array (max ${MAX_WORKSPACE_SKILL_BATCH_SIZE})`,
+      code: "invalid_skill_names"
     });
     return void 0;
   }
-  const enabled = safeBody2(req)["enabled"];
-  if (typeof enabled !== "boolean") {
-    res.status(400).json({
-      error: "`enabled` is required and must be a boolean",
-      code: "invalid_enabled_flag"
-    });
-    return void 0;
+  const skillNames = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawSkillName of rawSkillNames) {
+    const skillName = rawSkillName.trim();
+    if (skillName.length === 0) {
+      res.status(400).json({
+        error: "Skill names must not be empty",
+        code: "invalid_skill_name"
+      });
+      return void 0;
+    }
+    if (rejectSkillNameTooLong(skillName, res)) return void 0;
+    const normalizedName = skillName.toLowerCase();
+    if (seen.has(normalizedName)) continue;
+    seen.add(normalizedName);
+    skillNames.push(skillName);
   }
-  return { skillName, enabled };
+  const flag = parseEnabledFlag(body, res);
+  return flag ? { skillNames, enabled: flag.enabled } : void 0;
 }
-__name(parseSkillToggleRequest, "parseSkillToggleRequest");
+__name(parseSkillBatchToggleRequest, "parseSkillBatchToggleRequest");
 function parseSkillScope(value, res) {
   if (value === "workspace" || value === "global") return value;
   res.status(400).json({
@@ -35462,13 +35474,7 @@ function parseSkillInstallRequest(req, res, safeBody2) {
     });
     return void 0;
   }
-  if (name.trim().length > MAX_WORKSPACE_SKILL_NAME_LENGTH) {
-    res.status(400).json({
-      error: `Skill name exceeds ${MAX_WORKSPACE_SKILL_NAME_LENGTH}-character limit`,
-      code: "invalid_skill_name"
-    });
-    return void 0;
-  }
+  if (rejectSkillNameTooLong(name.trim(), res)) return void 0;
   const scope = parseSkillScope(body["scope"], res);
   if (!scope) return void 0;
   const rawSource = body["source"];
@@ -35522,6 +35528,7 @@ function registerWorkspaceSkillsRoutes(app, deps) {
     deps.workspaceRuntime.workspaceCwd
   );
   const route = "POST /workspace/skills/:name/enable";
+  const batchRoute = "POST /workspace/skills/enable";
   app.post(
     "/workspace/skills/install",
     deps.mutate({ strict: true }),
@@ -35575,6 +35582,27 @@ function registerWorkspaceSkillsRoutes(app, deps) {
       }
     }
   );
+  app.post(
+    "/workspace/skills/enable",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      if (!requireTrustedWorkspaceRuntime(deps.workspaceRuntime, res)) return;
+      const input = parseSkillBatchToggleRequest(req, res, deps.safeBody);
+      if (!input) return;
+      const clientId = deps.parseAndValidateClientId(req, res);
+      if (clientId === null) return;
+      try {
+        const result = await deps.workspaceRuntime.workspaceService.setWorkspaceSkillsEnabled(
+          buildWorkspaceCtx(batchRoute, clientId),
+          input.skillNames,
+          input.enabled
+        );
+        res.status(200).json(result);
+      } catch (err) {
+        deps.sendBridgeError(res, err, { route: batchRoute });
+      }
+    }
+  );
   app.post(
     "/workspace/skills/:name/enable",
     deps.mutate({ strict: true }),
@@ -35600,6 +35628,7 @@ function registerWorkspaceSkillsRoutes(app, deps) {
 __name(registerWorkspaceSkillsRoutes, "registerWorkspaceSkillsRoutes");
 function registerWorkspaceQualifiedSkillsRoutes(app, deps) {
   const route = "POST /workspaces/:workspace/skills/:name/enable";
+  const batchRoute = "POST /workspaces/:workspace/skills/enable";
   app.post(
     "/workspaces/:workspace/skills/install",
     deps.mutate({ strict: true }),
@@ -35671,6 +35700,36 @@ function registerWorkspaceQualifiedSkillsRoutes(app, deps) {
       }
     }
   );
+  app.post(
+    "/workspaces/:workspace/skills/enable",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const runtime = resolveWorkspaceRuntimeFromParam(
+        deps.workspaceRegistry,
+        req,
+        res
+      );
+      if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+      const input = parseSkillBatchToggleRequest(req, res, deps.safeBody);
+      if (!input) return;
+      const clientId = parseAndValidateWorkspaceClientId(
+        req,
+        res,
+        runtime.bridge
+      );
+      if (clientId === null) return;
+      try {
+        const result = await runtime.workspaceService.setWorkspaceSkillsEnabled(
+          createBuildWorkspaceCtx(runtime.workspaceCwd)(batchRoute, clientId),
+          input.skillNames,
+          input.enabled
+        );
+        res.status(200).json(result);
+      } catch (err) {
+        deps.sendBridgeError(res, err, { route: batchRoute });
+      }
+    }
+  );
   app.post(
     "/workspaces/:workspace/skills/:name/enable",
     deps.mutate({ strict: true }),
@@ -39265,11 +39324,13 @@ var execFileAsync3 = promisify3(execFile3);
 var LIVE_HOST_BUNDLE_ID2 = "com.alibaba.qwen-code.live-host";
 var LIVE_HOST_TEAM_IDENTIFIER = "NF4574S59H";
 var LIVE_HOST_APP_PATH = "/Applications/Qwen Live Host.app";
+var LIVE_HOST_OSS_BASE_URL = "https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/live-host";
 var LIVE_HOST_RELEASE_BASE_URL = "https://github.com/QwenLM/qwen-code/releases/download/live-host-latest";
 var LIVE_HOST_MANIFEST_NAME = "Qwen-Live-Host-manifest.json";
+var LIVE_HOST_MANIFEST_FETCH_TIMEOUT_MS = 5 * 60 * 1e3;
+var LIVE_HOST_DOWNLOAD_TIMEOUT_MS = 60 * 60 * 1e3;
 var LIVE_HOST_APP_NAME = "Qwen Live Host.app";
 var MAX_DOWNLOAD_BYTES = 512 * 1024 * 1024;
-var FETCH_TIMEOUT_MS = 5 * 60 * 1e3;
 var COMMAND_TIMEOUT_MS = 2 * 60 * 1e3;
 var SHA256_PATTERN = /^[a-f0-9]{64}$/;
 var VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
@@ -39385,11 +39446,24 @@ async function inspectInstalledHost() {
   }
 }
 __name(inspectInstalledHost, "inspectInstalledHost");
-async function fetchManifest() {
-  const response = await fetch(
-    `${LIVE_HOST_RELEASE_BASE_URL}/${LIVE_HOST_MANIFEST_NAME}`,
-    { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) }
-  );
+function resolveLiveHostManifestUrls() {
+  return [
+    `${LIVE_HOST_OSS_BASE_URL}/latest/${LIVE_HOST_MANIFEST_NAME}`,
+    `${LIVE_HOST_RELEASE_BASE_URL}/${LIVE_HOST_MANIFEST_NAME}`
+  ];
+}
+__name(resolveLiveHostManifestUrls, "resolveLiveHostManifestUrls");
+function resolveLiveHostAssetUrls(version, assetName) {
+  return [
+    `${LIVE_HOST_OSS_BASE_URL}/v${version}/${assetName}`,
+    `${LIVE_HOST_RELEASE_BASE_URL}/${assetName}`
+  ];
+}
+__name(resolveLiveHostAssetUrls, "resolveLiveHostAssetUrls");
+async function fetchManifest(url, fetchImpl) {
+  const response = await fetchImpl(url, {
+    signal: AbortSignal.timeout(LIVE_HOST_MANIFEST_FETCH_TIMEOUT_MS)
+  });
   if (!response.ok) {
     await response.body?.cancel().catch(() => {
     });
@@ -39398,9 +39472,9 @@ async function fetchManifest() {
   return parseLiveHostReleaseManifest(await response.json());
 }
 __name(fetchManifest, "fetchManifest");
-async function downloadAsset(asset, destination, onProgress) {
-  const response = await fetch(`${LIVE_HOST_RELEASE_BASE_URL}/${asset.name}`, {
-    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+async function downloadAsset(asset, url, destination, onProgress, fetchImpl) {
+  const response = await fetchImpl(url, {
+    signal: AbortSignal.timeout(LIVE_HOST_DOWNLOAD_TIMEOUT_MS)
   });
   if (!response.ok || !response.body) {
     await response.body?.cancel().catch(() => {
@@ -39437,13 +39511,36 @@ async function downloadAsset(asset, destination, onProgress) {
   }
 }
 __name(downloadAsset, "downloadAsset");
+async function downloadLiveHostRelease(currentArchitecture, destination, onProgress, fetchImpl = fetch) {
+  const manifestUrls = resolveLiveHostManifestUrls();
+  const labels = ["OSS", "GitHub"];
+  const errors = [];
+  for (let index = 0; index < manifestUrls.length; index += 1) {
+    try {
+      await fsp5.rm(destination, { force: true });
+      const manifest = await fetchManifest(manifestUrls[index], fetchImpl);
+      const asset = manifest.assets[currentArchitecture];
+      const assetUrl = resolveLiveHostAssetUrls(manifest.version, asset.name)[index];
+      await downloadAsset(asset, assetUrl, destination, onProgress, fetchImpl);
+      return { manifest, asset };
+    } catch (error2) {
+      errors.push(
+        new Error(`${labels[index]}: ${errorMessage3(error2)}`, { cause: error2 })
+      );
+    }
+  }
+  await fsp5.rm(destination, { force: true });
+  throw new AggregateError(
+    errors,
+    `Qwen Live Host download failed. ${errors.map((error2) => error2.message).join(" ")}`
+  );
+}
+__name(downloadLiveHostRelease, "downloadLiveHostRelease");
 async function installLatestHost(currentArchitecture, onStatus) {
-  const manifest = await fetchManifest();
-  const asset = manifest.assets[currentArchitecture];
   const temporaryDirectory = await fsp5.mkdtemp(
     path14.join(os2.tmpdir(), "qwen-live-host-")
   );
-  const archivePath = path14.join(temporaryDirectory, asset.name);
+  const archivePath = path14.join(temporaryDirectory, "Qwen-Live-Host.zip");
   const extractedPath = path14.join(temporaryDirectory, "extracted");
   const candidatePath = path14.join(extractedPath, LIVE_HOST_APP_NAME);
   const stagingPath = `/Applications/.Qwen Live Host.install-${randomUUID11()}.app`;
@@ -39452,9 +39549,13 @@ async function installLatestHost(currentArchitecture, onStatus) {
   let installedCandidate = false;
   try {
     onStatus({ state: "downloading", progress: 0 });
-    await downloadAsset(asset, archivePath, (progress) => {
-      onStatus({ state: "downloading", progress });
-    });
+    const { manifest } = await downloadLiveHostRelease(
+      currentArchitecture,
+      archivePath,
+      (progress) => {
+        onStatus({ state: "downloading", progress });
+      }
+    );
     onStatus({ state: "verifying" });
     await fsp5.mkdir(extractedPath, { mode: 448 });
     await run("/usr/bin/ditto", ["-x", "-k", archivePath, extractedPath]);
@@ -42286,6 +42387,7 @@ function getRuntimeEffectiveEnv(metadata) {
 }
 __name(getRuntimeEffectiveEnv, "getRuntimeEffectiveEnv");
 var DEFAULT_SESSION_IDLE_TIMEOUT_MS = 30 * 6e4;
+var SCHEDULED_TASK_RESTORE_HEADROOM_MS = 1e4;
 var KEEPALIVE_MIN_INTERVAL_MS = 3e4;
 var KEEPALIVE_MAX_INTERVAL_MS = 10 * 6e4;
 function computeKeepaliveIntervalMs(idleTimeoutMs) {
@@ -42327,11 +42429,18 @@ function createLiveWorkspaceDelegate(getTarget) {
 }
 __name(createLiveWorkspaceDelegate, "createLiveWorkspaceDelegate");
 function createServeApp(opts, getPort = () => opts.port, deps = {}) {
+  const sessionRestoreTimeoutMs = resolveSessionRestoreTimeoutMs(opts);
+  const scheduledTaskRestoreTimeoutMs = sessionRestoreTimeoutMs + SCHEDULED_TASK_RESTORE_HEADROOM_MS > MAX_SESSION_RESTORE_TIMEOUT_MS ? MAX_SESSION_RESTORE_TIMEOUT_MS + 1 : sessionRestoreTimeoutMs + SCHEDULED_TASK_RESTORE_HEADROOM_MS;
   if (deps.workspaceRuntimeRemoval && !deps.voiceCoordinator) {
     throw new Error(
       "createServeApp: deps.workspaceRuntimeRemoval requires the matching deps.voiceCoordinator."
     );
   }
+  if ((deps.workspaceTrustHotReloadAvailable === true || deps.workspaceRuntimeRemoval !== void 0) && deps.getSessionBridges === void 0) {
+    throw new Error(
+      "createServeApp: runtime replacement/removal requires deps.getSessionBridges so session-id admission can inspect draining generations."
+    );
+  }
   const app = (0, import_express5.default)();
   const injectedWorkspaceRegistry = deps.workspaceRegistry;
   const boundWorkspace = injectedWorkspaceRegistry?.primary.workspaceCwd ?? deps.boundWorkspace ?? canonicalizeWorkspace(opts.workspace ?? process.cwd());
@@ -42503,6 +42612,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     maxJournalEvents: opts.maxJournalEvents,
     maxJournalBytes: opts.maxJournalBytes,
     initializeTimeoutMs: opts.initializeTimeoutMs,
+    sessionRestoreTimeoutMs,
     permissionResponseTimeoutMs: opts.permissionResponseTimeoutMs,
     boundWorkspace,
     sessionShellCommandEnabled,
@@ -42510,9 +42620,12 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     // that don't inject `deps.bridge` get daemon env + preflight cells.
     statusProvider,
     delegateReadTextFileToClient: false,
-    // Final ACP text writes remain delegated through WorkspaceFileSystem.
+    // Final ACP text writes remain delegated. Workspace writes use WFS;
+    // marked same-host tool writes may use the factory's host writer.
     // Unexpected delegated reads still fail closed at the WFS boundary.
-    fileSystem: createBridgeFileSystemAdapter(fsFactory),
+    fileSystem: createBridgeFileSystemAdapter(fsFactory, {
+      allowSameHostToolWritesOutsideWorkspace: deps.fsFactory === void 0
+    }),
     // Reverse tool channel: answer the child's `client_mcp/message`
     // ext-method by reaching the WS connection that hosts the named server.
     clientMcpSender: clientMcpSenderRegistry.lookup
@@ -42578,6 +42691,11 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
         "setWorkspaceSkillEnabled requires persistDisabledSkills in ServeAppDeps"
       );
     }),
+    persistDisabledSkillsBatch: deps.persistDisabledSkillsBatch ?? (async () => {
+      throw new Error(
+        "setWorkspaceSkillsEnabled requires persistDisabledSkillsBatch in ServeAppDeps"
+      );
+    }),
     queryWorkspaceStatus: /* @__PURE__ */ __name((method, idle) => bridge.queryWorkspaceStatus(method, idle), "queryWorkspaceStatus"),
     invokeWorkspaceCommand: /* @__PURE__ */ __name((method, params, invokeOpts) => bridge.invokeWorkspaceCommand(method, params, invokeOpts), "invokeWorkspaceCommand"),
     preheatAcpChild: /* @__PURE__ */ __name(() => bridge.preheat(), "preheatAcpChild"),
@@ -42613,6 +42731,15 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     } : {}
   );
   app.locals.workspaceRegistry = workspaceRegistry;
+  const requestedSessionIdAdmission = createRequestedSessionIdAdmission({
+    archiveCoordinator,
+    getBridges: deps.getSessionBridges ?? (() => workspaceRegistry.listManaged().map((runtime) => runtime.bridge)),
+    getPersistenceTargets: /* @__PURE__ */ __name(() => workspaceRegistry.listManaged().map((runtime) => ({
+      workspaceCwd: runtime.workspaceCwd,
+      runtimeBaseDir: runtime.sessionRuntimeBaseDir
+    })), "getPersistenceTargets"),
+    getBridgeWorkspaceId: /* @__PURE__ */ __name((bridge2) => workspaceRegistry.listEntries().find((entry) => entry.current?.runtime.bridge === bridge2)?.workspaceId, "getBridgeWorkspaceId")
+  });
   primaryTrustRegistry = workspaceRegistry;
   const primaryRuntime = createLiveWorkspaceDelegate(
     () => workspaceRegistry.primary
@@ -42935,15 +43062,14 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     mount: false,
     workspaceQualifiedAcpEnabled
   });
-  const healthDemoRoutes = createHealthDemoRoutes({
+  const healthRoutes = createHealthRoutes({
     opts,
-    getPort,
     workspaceRegistry,
     getActiveSseCount,
     getRateLimiter: /* @__PURE__ */ __name(() => rateLimiter, "getRateLimiter")
   });
-  if (healthDemoRoutes.exposeHealthPreAuth) {
-    healthDemoRoutes.register(app);
+  if (healthRoutes.exposeHealthPreAuth) {
+    healthRoutes.register(app);
   }
   installAccessLogMiddleware(app, daemonLog);
   const webShellDir = opts.serveWebShell !== false ? deps.webShellDir : void 0;
@@ -42990,8 +43116,8 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   if (rateLimiter) {
     app.use(rateLimiter.middleware);
   }
-  if (!healthDemoRoutes.exposeHealthPreAuth) {
-    healthDemoRoutes.register(app);
+  if (!healthRoutes.exposeHealthPreAuth) {
+    healthRoutes.register(app);
   }
   installJsonBodyParser(app);
   const mutate = createMutationGate({
@@ -43066,6 +43192,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     maxSessionsPerWorkspace: opts.maxSessions,
     maxTotalSessions: opts.maxTotalSessions,
     maxPendingPromptsPerSession: opts.maxPendingPromptsPerSession,
+    sessionRestoreTimeoutMs,
     languageCodes
   });
   if (liveVoiceSurfaceAvailable) {
@@ -43477,6 +43604,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     bridge: primaryBridge,
     workspaceRegistry,
     archiveCoordinator,
+    requestedSessionIdAdmission,
     mutate,
     sendBridgeError: sendBridgeError2,
     daemonLog,
@@ -43643,6 +43771,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
         () => rehydrateScheduledTaskSessions({
           bridge: runtime.bridge,
           boundWorkspace: runtime.workspaceCwd,
+          loadTimeoutMs: scheduledTaskRestoreTimeoutMs,
           onTasksRead: /* @__PURE__ */ __name((tasks) => registerScheduledTaskAuthorizations(runtime.workspaceCwd, tasks), "onTasksRead"),
           onError: /* @__PURE__ */ __name((sessionId, err) => {
             process.stderr.write(
@@ -43673,6 +43802,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
         bridge: runtime.bridge,
         boundWorkspace: runtime.workspaceCwd,
         intervalMs: keepaliveIntervalMs,
+        reviveTimeoutMs: scheduledTaskRestoreTimeoutMs,
         runtimeBaseDir: runtime.sessionRuntimeBaseDir,
         cleanupSession: /* @__PURE__ */ __name((sessionId) => cleanupSession(runtime, sessionId), "cleanupSession"),
         onTasksRead: /* @__PURE__ */ __name((tasks) => registerScheduledTaskAuthorizations(runtime.workspaceCwd, tasks), "onTasksRead")
@@ -43717,6 +43847,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     workspaceRegistry,
     isPrimaryWorkspaceTrusted,
     archiveCoordinator,
+    requestedSessionIdAdmission,
     workspace: primaryWorkspace,
     fsFactory: primaryRouteFileSystemFactory,
     deviceFlowRegistry,