@qwen-code/qwen-code 0.21.7 → 0.21.8-nightly.20260810.55e20db328

package/chunks/{server-XLJVLTYM.js → server-E7CH7WPK.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-TRLYP7OF.js";
-import {
-  deriveWebSocketBase,
-  openQwenAsrRealtimeStream,
-  openVoiceStream,
-  openVoiceStreamWithRetry
-} from "./chunk-Q3JQ7OSU.js";
+} from "./chunk-OSVH4SMN.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -39,12 +38,12 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-6XJMFJ4D.js";
+} from "./chunk-5WZL724W.js";
 import {
   OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
   ObservedChannelContactStore
 } from "./chunk-OWMAZHIX.js";
-import "./chunk-KXSDEOFU.js";
+import "./chunk-3KJQZEN3.js";
 import {
   escapeAnsiCtrlCodes
 } from "./chunk-4NFY2S7N.js";
@@ -108,46 +107,13 @@ import {
   setRateLimiter,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-RGSBTHSU.js";
+} from "./chunk-KMS57JDD.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-H2UQ2M5Z.js";
-import {
-  createWorkspaceProvidersStatusProvider
-} from "./chunk-W4B7UBUS.js";
-import {
-  getAuthTypeFromEnv,
-  resolveCliGenerationConfig
-} from "./chunk-CSZEXZBE.js";
-import {
-  createWorkspaceSkillsStatusProvider
-} from "./chunk-P3LEG54R.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-OMKQH5C5.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   MAX_WORKSPACE_SKILL_NAME_LENGTH,
@@ -161,14 +127,14 @@ import {
   validateWorkspaceSkillName,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-RERATVSK.js";
+} from "./chunk-7XX5IBXL.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-6GONZVLS.js";
+} from "./chunk-NZMXUSKS.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -176,46 +142,92 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-AE77C5ZU.js";
+} from "./chunk-RYQMJCUO.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-55LYDVPU.js";
+} from "./chunk-HDYQYYWB.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-EUVOKP6Y.js";
+import {
+  createDaemonStatusProvider
+} from "./chunk-UAB6J2IE.js";
+import "./chunk-NTTBXH7U.js";
+import "./chunk-2ASQDZSJ.js";
+import "./chunk-3SH53ANB.js";
+import {
+  createWorkspaceProvidersStatusProvider
+} from "./chunk-VHXPSL57.js";
+import {
+  getAuthTypeFromEnv,
+  resolveCliGenerationConfig
+} from "./chunk-HWXGX534.js";
+import {
+  snapshotProcessEnv
+} from "./chunk-OR6R3IUW.js";
+import {
+  createWorkspaceSkillsStatusProvider
+} from "./chunk-F6TUUA2U.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-FWWQIFDT.js";
 import {
   daemonObservedContactsPath,
   loadChannelsConfig
-} from "./chunk-EUQTXRKZ.js";
-import "./chunk-OHJLEW5J.js";
+} from "./chunk-EISUQQPS.js";
+import "./chunk-TWFFY5BP.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-YJQCUTT2.js";
-import "./chunk-VXZBKKQR.js";
-import "./chunk-SPMY6CX6.js";
-import "./chunk-3SH53ANB.js";
-import {
-  snapshotProcessEnv
-} from "./chunk-TYKC75AX.js";
 import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge,
   parseSessionSource
-} from "./chunk-LA7YLSR6.js";
+} from "./chunk-4EOURKA4.js";
 import {
   EVENT_SCHEMA_VERSION,
   EventBus,
@@ -223,22 +235,16 @@ import {
 } from "./chunk-MZSJ43WV.js";
 import "./chunk-XCGIMOLN.js";
 import "./chunk-OCPBI7J5.js";
-import "./chunk-E33LOKRA.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-ZXU5UHMI.js";
-import "./chunk-VWOVHOTT.js";
-import {
-  supportedChannelCatalog
-} from "./chunk-IUFV6FYU.js";
 import "./chunk-V6WHFGST.js";
 import {
   MAX_REGISTERED_WORKSPACES,
@@ -247,10 +253,14 @@ import {
   WorkspaceRegistrationStoreLimitError,
   normalizeWorkspaceDisplayName,
   workspaceRegistrationId
-} from "./chunk-P2AJ7FTI.js";
-import "./chunk-R574ATRM.js";
+} from "./chunk-H4JC7LZX.js";
+import {
+  REQUESTED_SESSION_ID_META_KEY,
+  gradeActiveWorkCoverage
+} from "./chunk-M2PNLYGY.js";
 import {
   BranchWhilePromptActiveError,
+  BridgeChannelQuarantinedError,
   CancelSentinelCollisionError,
   CdWhilePromptActiveError,
   InvalidClientIdError,
@@ -281,7 +291,7 @@ import {
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
-} from "./chunk-J26HHFI5.js";
+} from "./chunk-LP2QGNSP.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace,
@@ -300,19 +310,19 @@ import {
 } from "./chunk-YP5KH5Y7.js";
 import {
   normalizeWorkerDiagnostic
-} from "./chunk-24ER7UV4.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-DIEFUBV6.js";
+} from "./chunk-DX3RGJMS.js";
 import "./chunk-UDXSXLER.js";
 import {
   getDialogSettingKeys,
@@ -323,7 +333,7 @@ import {
   getWritableScopes,
   loadSettings,
   validateSettingValue
-} from "./chunk-PQBHU2IA.js";
+} from "./chunk-HKI3KHAO.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
@@ -332,15 +342,15 @@ import {
   detectSystemLanguage,
   resolveLanguageSetting,
   resolveSupportedLanguage
-} from "./chunk-DBOFL3LQ.js";
-import "./chunk-VOARQPTA.js";
-import "./chunk-6PEXNQTX.js";
-import "./chunk-FZBZSYKU.js";
+} from "./chunk-BL65MO72.js";
+import "./chunk-KP25NJNM.js";
+import "./chunk-R4ZA6GBK.js";
+import "./chunk-ZV7LTLFE.js";
 import "./chunk-VJNBRRZG.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-6XU3PH66.js";
-import "./chunk-ALGGS7UH.js";
+} from "./chunk-YR7ZQ4RD.js";
+import "./chunk-NPQ5ZKRP.js";
 import {
   isWithinRoot as isWithinRoot2
 } from "./chunk-MR3PXB6E.js";
@@ -360,6 +370,7 @@ import {
   MAX_LOG_LIMIT,
   ModelsConfig,
   RUNTIME_MCP_IF_ABSENT_CONFIG_FLAG,
+  SESSION_TRANSCRIPT_MAX_EXPANDED_PAGE_BYTES,
   SESSION_TRANSCRIPT_MAX_INDEX_BYTES,
   SESSION_TRANSCRIPT_MAX_LIMIT,
   SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
@@ -418,7 +429,7 @@ import {
   writeWorkspaceContextFile,
   writeWorktreeSession,
   writeWorktreeSessionMarker
-} from "./chunk-Y7E5LNLO.js";
+} from "./chunk-47ZUMGGY.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
@@ -426,12 +437,12 @@ import "./chunk-H6XPXXMH.js";
 import {
   MAX_JOBS,
   nextDurableFireMs
-} from "./chunk-CNIID3TV.js";
+} from "./chunk-2UUMVNYT.js";
 import "./chunk-MVUQRLOH.js";
 import "./chunk-XCWO3SMQ.js";
 import "./chunk-7MH4J33A.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-RMH5OWLD.js";
+import "./chunk-F3II4BTZ.js";
 import {
   nextFireTime,
   parseCron
@@ -445,7 +456,7 @@ import {
   taskHasLegacyCondition,
   updateCronTasks
 } from "./chunk-GNPNYXJB.js";
-import "./chunk-Y4NGLFGJ.js";
+import "./chunk-HUWENAHO.js";
 import "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
 import "./chunk-ZPJWUGCS.js";
@@ -454,22 +465,37 @@ import "./chunk-J6SZID63.js";
 import "./chunk-KRXPRVGL.js";
 import "./chunk-GM463R2B.js";
 import "./chunk-SEZ556DZ.js";
-import "./chunk-CJXIIILK.js";
-import "./chunk-3K7FH2KQ.js";
+import "./chunk-2FRY5CRX.js";
+import "./chunk-67N6HB5H.js";
 import {
   APPROVAL_MODES
-} from "./chunk-BVWVWGLE.js";
+} from "./chunk-WAUGQKUU.js";
+import "./chunk-DZUO626D.js";
+import {
+  addDaemonRequestAttribute,
+  captureDaemonTelemetryContext,
+  emitDaemonLog,
+  hashDaemonWorkspace,
+  recordDaemonBridgeError,
+  recordDaemonError,
+  recordDaemonHttpRequest,
+  recordDaemonHttpResponse,
+  runWithDaemonTelemetryContext,
+  withDaemonRequestSpan
+} from "./chunk-4TRQPFDP.js";
+import "./chunk-SAH4BD2J.js";
+import "./chunk-CPG6P4GG.js";
 import "./chunk-S6LOFUVP.js";
+import "./chunk-2J3OJGTL.js";
 import {
   SubagentError,
   SubagentErrorCode
-} from "./chunk-LZC3B5N2.js";
+} from "./chunk-IA7TGCN2.js";
 import "./chunk-K623ENWT.js";
 import {
   escapeXml
 } from "./chunk-AQ37AY7B.js";
 import "./chunk-EQL65XGA.js";
-import "./chunk-IIJEYBNH.js";
 import {
   QwenOAuth2Client,
   QwenOAuthPollError,
@@ -478,31 +504,18 @@ import {
   isDeviceAuthorizationSuccess,
   isDeviceTokenPending,
   isDeviceTokenSuccess
-} from "./chunk-22NBYCPD.js";
+} from "./chunk-3P2LV43B.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-3ULCB3NE.js";
-import "./chunk-BGG4MBYD.js";
+import "./chunk-HV76SFIA.js";
+import "./chunk-4PYCZH2V.js";
+import "./chunk-P3QQPMQA.js";
+import "./chunk-SR7RZ4MS.js";
+import "./chunk-M6HMMKVG.js";
 import "./chunk-DGEIYUC3.js";
 import "./chunk-MPHPFVKK.js";
 import "./chunk-AXMWHKXA.js";
-import "./chunk-DJ2GSRLV.js";
-import "./chunk-33ACCIIY.js";
-import {
-  addDaemonRequestAttribute,
-  captureDaemonTelemetryContext,
-  emitDaemonLog,
-  hashDaemonWorkspace,
-  recordDaemonBridgeError,
-  recordDaemonError,
-  recordDaemonHttpRequest,
-  recordDaemonHttpResponse,
-  runWithDaemonTelemetryContext,
-  withDaemonRequestSpan
-} from "./chunk-L4N6TIP7.js";
-import "./chunk-2J3OJGTL.js";
-import "./chunk-P3QQPMQA.js";
-import "./chunk-M6HMMKVG.js";
 import "./chunk-GLCZKT5V.js";
+import "./chunk-DJ2GSRLV.js";
 import "./chunk-EI3HZX6C.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-XWRJCPHC.js";
@@ -516,25 +529,28 @@ import {
   isWithinRoot,
   parseLineTolerant,
   read
-} from "./chunk-2U3WZGZG.js";
+} from "./chunk-YGT2AUJ7.js";
 import "./chunk-WOJZWRAZ.js";
 import "./chunk-VGC4I5JJ.js";
 import "./chunk-FVKHVJZQ.js";
-import "./chunk-NG2R4N5O.js";
-import "./chunk-IC4Z6LX6.js";
-import "./chunk-6EOI4HOK.js";
+import "./chunk-COBO5EBO.js";
+import "./chunk-6ZRFAKXK.js";
+import "./chunk-PYQADEFD.js";
+import "./chunk-E2T7FLDU.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,
   createDebugLogger,
+  getErrorMessage,
   runWithoutDebugLogSession
 } from "./chunk-OIVKILPI.js";
 import "./chunk-VOQXFAY5.js";
@@ -563,7 +579,7 @@ import {
 
 // packages/cli/src/serve/server.ts
 init_esbuild_shims();
-var import_express4 = __toESM(require_express(), 1);
+var import_express5 = __toESM(require_express(), 1);
 
 // packages/cli/src/serve/acp-http/index.ts
 init_esbuild_shims();
@@ -1180,11 +1196,11 @@ function decodeTextCursor(cursor) {
   return { off, size, dev, ino };
 }
 __name(decodeTextCursor, "decodeTextCursor");
-function assertCursorMatchesFile(cursor, stats, path14) {
+function assertCursorMatchesFile(cursor, stats, path15) {
   if (String(stats.dev) !== cursor.dev || String(stats.ino) !== cursor.ino || stats.size < cursor.size) {
     throw new FsError(
       "hash_mismatch",
-      `cursor no longer matches the file it was issued for: ${path14}`,
+      `cursor no longer matches the file it was issued for: ${path15}`,
       { hint: "re-read the file from the beginning to get a fresh cursor" }
     );
   }
@@ -1946,17 +1962,17 @@ var WorkspaceFileSystemImpl = class {
     if (err instanceof Error && "code" in err && err.code === "workspace_generation_closed") {
       return err;
     }
-    const fs7 = wrapAsFsError(err);
+    const fs8 = wrapAsFsError(err);
     this.deps.audit.recordDenied(this.deps.ctx, {
       intent,
       input,
-      errorKind: fs7.kind,
-      hint: fs7.hint,
+      errorKind: fs8.kind,
+      hint: fs8.hint,
       // Quote the underlying OS / FsError message so audit
       // consumers debugging a production incident can see the
       // actual cause (errno text, byte counts, glob pattern,
       // etc.) rather than just `errorKind` + `hint`.
-      message: fs7.message,
+      message: fs8.message,
       // For glob denials (parse_error pattern rejection,
       // catastrophic walk failures) the input IS the pattern
       // already; surfacing it on the dedicated `pattern` field
@@ -1965,7 +1981,7 @@ var WorkspaceFileSystemImpl = class {
       // branching on intent.
       pattern: intent === "glob" ? input : void 0
     });
-    return fs7;
+    return fs8;
   }
 };
 var CONTENT_HASH_RE = /^sha256:[0-9a-f]{64}$/;
@@ -3041,12 +3057,12 @@ function sendFsError(res, err, route) {
   applyReadHeaders(res);
   if (sendGenerationClosedError(res, err)) return;
   if (isFsError(err)) {
-    const fs7 = err;
-    res.status(fs7.status).json({
-      errorKind: fs7.kind,
-      error: fs7.message,
-      hint: fs7.hint,
-      status: fs7.status
+    const fs8 = err;
+    res.status(fs8.status).json({
+      errorKind: fs8.kind,
+      error: fs8.message,
+      hint: fs8.hint,
+      status: fs8.status
     });
     return;
   }
@@ -3159,13 +3175,13 @@ async function handleGetFile(req, res, deps) {
     return;
   }
   const cursor = rawCursor;
-  const fs7 = factory.forRequest({
+  const fs8 = factory.forRequest({
     originatorClientId: clientId ?? void 0,
     route: ROUTE2
   });
   try {
-    const resolved = await fs7.resolve(queryPath, "read");
-    const out = await fs7.readText(resolved, {
+    const resolved = await fs8.resolve(queryPath, "read");
+    const out = await fs8.readText(resolved, {
       maxBytes,
       line,
       limit,
@@ -3226,13 +3242,13 @@ async function handleGetFileBytes(req, res, deps) {
     });
     return;
   }
-  const fs7 = factory.forRequest({
+  const fs8 = factory.forRequest({
     originatorClientId: clientId ?? void 0,
     route: ROUTE2
   });
   try {
-    const resolved = await fs7.resolve(queryPath, "read");
-    const out = await fs7.readBytesWindow(resolved, {
+    const resolved = await fs8.resolve(queryPath, "read");
+    const out = await fs8.readBytesWindow(resolved, {
       offset: offset ?? 0,
       maxBytes: maxBytes ?? DEFAULT_FILE_BYTES_MAX_BYTES
     });
@@ -3260,13 +3276,13 @@ async function handleGetStat(req, res, deps) {
   if (clientId === null) return;
   const queryPath = requireStringQuery(res, req.query["path"], "path", ROUTE2);
   if (queryPath === null) return;
-  const fs7 = factory.forRequest({
+  const fs8 = factory.forRequest({
     originatorClientId: clientId ?? void 0,
     route: ROUTE2
   });
   try {
-    const resolved = await fs7.resolve(queryPath, "stat");
-    const st = await fs7.stat(resolved);
+    const resolved = await fs8.resolve(queryPath, "stat");
+    const st = await fs8.stat(resolved);
     applyReadHeaders(res);
     res.status(200).json({
       kind: "stat",
@@ -3289,13 +3305,13 @@ async function handleGetList(req, res, deps) {
   const queryPath = requireStringQuery(res, req.query["path"], "path", ROUTE2);
   if (queryPath === null) return;
   const includeIgnored = parseBoolFlag(req.query["includeIgnored"]);
-  const fs7 = factory.forRequest({
+  const fs8 = factory.forRequest({
     originatorClientId: clientId ?? void 0,
     route: ROUTE2
   });
   try {
-    const resolved = await fs7.resolve(queryPath, "list");
-    const entries = await fs7.list(resolved, {
+    const resolved = await fs8.resolve(queryPath, "list");
+    const entries = await fs8.list(resolved, {
       includeIgnored,
       maxEntries: MAX_LIST_ENTRIES + 1
     });
@@ -3348,15 +3364,15 @@ async function handleGetGlob(req, res, deps) {
   }
   const cwdRaw = req.query["cwd"];
   const cwdString = typeof cwdRaw === "string" && cwdRaw.length > 0 ? cwdRaw : void 0;
-  const fs7 = factory.forRequest({
+  const fs8 = factory.forRequest({
     originatorClientId: clientId ?? void 0,
     route: ROUTE2
   });
   const start = performance.now();
   try {
-    const cwdResolved = cwdString ? await fs7.resolve(cwdString, "list") : void 0;
+    const cwdResolved = cwdString ? await fs8.resolve(cwdString, "list") : void 0;
     const cap = maxResults ?? DEFAULT_GLOB_MAX_RESULTS;
-    const probe = await fs7.glob(pattern, {
+    const probe = await fs8.glob(pattern, {
       cwd: cwdResolved,
       includeIgnored,
       maxResults: cap + 1
@@ -3544,7 +3560,7 @@ function validateClientId(clientId, deps, res) {
 }
 __name(validateClientId, "validateClientId");
 function createSetupGithubFileOps(factory, route, originatorClientId, assertGenerationOpen) {
-  const fs7 = factory.forRequest({
+  const fs8 = factory.forRequest({
     route,
     ...originatorClientId ? { originatorClientId } : {}
   });
@@ -3572,14 +3588,14 @@ function createSetupGithubFileOps(factory, route, originatorClientId, assertGene
       );
     },
     async writeTextFile(_gitRepoRoot, relativePath, content) {
-      const resolved = await fs7.resolve(relativePath, "write");
-      const out = await fs7.writeTextOverwrite(resolved, content);
+      const resolved = await fs8.resolve(relativePath, "write");
+      const out = await fs8.writeTextOverwrite(resolved, content);
       return { sizeBytes: out.sizeBytes };
     },
     async readTextFile(_gitRepoRoot, relativePath) {
       try {
-        const resolved = await fs7.resolve(relativePath, "read");
-        const out = await fs7.readText(resolved);
+        const resolved = await fs8.resolve(relativePath, "read");
+        const out = await fs8.readText(resolved);
         return out.content;
       } catch (error2) {
         if (isFsError(error2) && error2.kind === "path_not_found") {
@@ -5160,6 +5176,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";
@@ -8207,6 +8431,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`,
@@ -8255,6 +8482,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) {
@@ -8365,6 +8609,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,
@@ -8487,6 +8763,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,
@@ -8580,12 +8906,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;
@@ -8595,26 +8925,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
@@ -8718,9 +9053,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) {
@@ -8914,7 +9249,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;
@@ -8937,7 +9278,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(
@@ -8955,6 +9296,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) {
@@ -8969,6 +9320,7 @@ var AcpDispatcher = class {
             }
             return;
           }
+          const sessionRuntime = this.getSessionRuntimeContext();
           const source = parseSessionSource(
             params["sourceType"],
             params["sourceId"]
@@ -8991,39 +9343,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(
@@ -9045,134 +9447,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);
@@ -10791,7 +11242,7 @@ var AcpDispatcher = class {
               );
             return;
           }
-          const fs7 = this.fsFactory.forRequest({
+          const fs8 = this.fsFactory.forRequest({
             originatorClientId: conn.clientId,
             route: `ACP ${method}`
           });
@@ -10856,8 +11307,8 @@ var AcpDispatcher = class {
             return;
           }
           const cursor = rawCursor;
-          const resolved = await fs7.resolve(p, "read");
-          const out = await fs7.readText(resolved, {
+          const resolved = await fs8.resolve(p, "read");
+          const out = await fs8.readText(resolved, {
             maxBytes,
             line,
             limit,
@@ -10884,7 +11335,7 @@ var AcpDispatcher = class {
               conn.sendConn(error(id, RPC.INVALID_PARAMS, "`path` required"));
             return;
           }
-          const fs7 = this.fsFactory.forRequest({
+          const fs8 = this.fsFactory.forRequest({
             originatorClientId: conn.clientId,
             route: `ACP ${method}`
           });
@@ -10920,8 +11371,8 @@ var AcpDispatcher = class {
               );
             return;
           }
-          const resolved = await fs7.resolve(p, "read");
-          const buf = await fs7.readBytesWindow(resolved, { offset, maxBytes });
+          const resolved = await fs8.resolve(p, "read");
+          const buf = await fs8.readBytesWindow(resolved, { offset, maxBytes });
           this.replyConn(conn, id, { path: p, ...buf });
           return;
         }
@@ -10939,12 +11390,12 @@ var AcpDispatcher = class {
               conn.sendConn(error(id, RPC.INVALID_PARAMS, "`path` required"));
             return;
           }
-          const fs7 = this.fsFactory.forRequest({
+          const fs8 = this.fsFactory.forRequest({
             originatorClientId: conn.clientId,
             route: `ACP ${method}`
           });
-          const resolved = await fs7.resolve(p, "read");
-          const result = await fs7.stat(resolved);
+          const resolved = await fs8.resolve(p, "read");
+          const result = await fs8.stat(resolved);
           this.replyConn(conn, id, { path: p, ...result });
           return;
         }
@@ -10962,13 +11413,13 @@ var AcpDispatcher = class {
               conn.sendConn(error(id, RPC.INVALID_PARAMS, "`path` required"));
             return;
           }
-          const fs7 = this.fsFactory.forRequest({
+          const fs8 = this.fsFactory.forRequest({
             originatorClientId: conn.clientId,
             route: `ACP ${method}`
           });
-          const resolved = await fs7.resolve(p, "read");
+          const resolved = await fs8.resolve(p, "read");
           const MAX_LIST = 2e3;
-          const entries = await fs7.list(resolved, { maxEntries: MAX_LIST + 1 });
+          const entries = await fs8.list(resolved, { maxEntries: MAX_LIST + 1 });
           const truncated = entries.length > MAX_LIST;
           this.replyConn(conn, id, {
             path: p,
@@ -10993,7 +11444,7 @@ var AcpDispatcher = class {
               );
             return;
           }
-          const fs7 = this.fsFactory.forRequest({
+          const fs8 = this.fsFactory.forRequest({
             originatorClientId: conn.clientId,
             route: `ACP ${method}`
           });
@@ -11013,7 +11464,7 @@ var AcpDispatcher = class {
               );
             return;
           }
-          const matches = await fs7.glob(pattern, {
+          const matches = await fs8.glob(pattern, {
             maxResults: maxResults + 1
           });
           const truncated = matches.length > maxResults;
@@ -11045,11 +11496,11 @@ var AcpDispatcher = class {
               );
             return;
           }
-          const fs7 = this.fsFactory.forRequest({
+          const fs8 = this.fsFactory.forRequest({
             originatorClientId: conn.clientId,
             route: `ACP ${method}`
           });
-          const resolved = await fs7.resolve(p, "write");
+          const resolved = await fs8.resolve(p, "write");
           if (Buffer.byteLength(params["content"], "utf8") > 10 * 1024 * 1024) {
             if (id !== void 0)
               conn.sendConn(
@@ -11057,7 +11508,7 @@ var AcpDispatcher = class {
               );
             return;
           }
-          await fs7.writeTextOverwrite(resolved, params["content"]);
+          await fs8.writeTextOverwrite(resolved, params["content"]);
           assertGenerationOpen?.();
           this.replyConn(conn, id, { ok: true, path: p });
           return;
@@ -11087,12 +11538,12 @@ var AcpDispatcher = class {
               );
             return;
           }
-          const fs7 = this.fsFactory.forRequest({
+          const fs8 = this.fsFactory.forRequest({
             originatorClientId: conn.clientId,
             route: `ACP ${method}`
           });
-          const resolved = await fs7.resolve(p, "write");
-          const result = await fs7.edit(
+          const resolved = await fs8.resolve(p, "write");
+          const result = await fs8.edit(
             resolved,
             params["oldText"],
             params["newText"]
@@ -13757,7 +14208,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/";
@@ -13934,8 +14385,11 @@ 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 path14 = opts.path ?? "/acp";
+  const path15 = opts.path ?? "/acp";
   const dispatcherRef = {};
   let disposed = false;
   const rejectIfDisposed = /* @__PURE__ */ __name((res) => {
@@ -14087,11 +14541,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;
@@ -14101,13 +14556,24 @@ 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 = {
     primary: true,
     workspaceCwd: opts.boundWorkspace,
-    routeLabel: logSafe(path14),
+    routeLabel: logSafe(path15),
     rateLimitScope: opts.workspaceRegistry?.primary.workspaceId ?? "primary",
     registry,
     dispatcher,
@@ -14261,7 +14727,7 @@ function mountAcpHttp(app, bridge, opts) {
     });
   }, "handleAcpPost");
   app.post(
-    path14,
+    path15,
     (req, res) => handleAcpPost(primaryMount, req, res)
   );
   const handleAcpGet = /* @__PURE__ */ __name((mount, req, res) => {
@@ -14281,7 +14747,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(
@@ -14359,10 +14826,10 @@ function mountAcpHttp(app, bridge, opts) {
       onPumpSettled();
     });
   }, "handleAcpGet");
-  app.get(path14, (req, res) => {
+  app.get(path15, (req, res) => {
     handleAcpGet(primaryMount, req, res);
   });
-  app.delete(path14, (req, res) => {
+  app.delete(path15, (req, res) => {
     handleAcpDelete(primaryMount, req, res);
   });
   const createSecondaryAcpMount = /* @__PURE__ */ __name((rt) => {
@@ -14388,12 +14855,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
@@ -14403,14 +14875,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 {
@@ -14564,7 +15038,7 @@ function mountAcpHttp(app, bridge, opts) {
       const isPluralAcpShape = pluralRawSelector !== null;
       const pluralVoiceRawSelector = opts.workspaceVoiceConnection ? pluralWorkspaceRawSelector(rawPath, PLURAL_VOICE_WS_SUFFIX) : null;
       const isPluralVoiceShape = pluralVoiceRawSelector !== null;
-      if (rawPath !== path14 && !isCdpPath && !extraRoute && !isPluralAcpShape && !isPluralVoiceShape) {
+      if (rawPath !== path15 && !isCdpPath && !extraRoute && !isPluralAcpShape && !isPluralVoiceShape) {
         logReject(`unknown-path ${logSafe(rawPath)}`);
         socket.destroy();
         return;
@@ -15048,7 +15522,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) {
@@ -15101,7 +15576,7 @@ function mountAcpHttp(app, bridge, opts) {
       });
     }, "upgradeListener");
     httpServer.on("upgrade", upgradeListener);
-    writeStderrLine(`qwen serve: /acp WebSocket transport enabled on ${path14}`);
+    writeStderrLine(`qwen serve: /acp WebSocket transport enabled on ${path15}`);
   }
   __name(setupWebSocket, "setupWebSocket");
   return {
@@ -15930,7 +16405,8 @@ function registerDaemonStatusRoutes(app, deps) {
           getChannelWorkerSnapshots: deps.getChannelWorkerSnapshots,
           getPerfSnapshot: deps.getPerfSnapshot,
           getMetricsSeries: deps.getMetricsSeries,
-          getTotalSessionAdmissionSnapshot: deps.getTotalSessionAdmissionSnapshot
+          getTotalSessionAdmissionSnapshot: deps.getTotalSessionAdmissionSnapshot,
+          getChildHeapPolicySnapshot: deps.getChildHeapPolicySnapshot
         })
       );
     } catch (err) {
@@ -16041,6 +16517,7 @@ function getDemoHtml(_port) {
       <div class="session-info" id="sessionInfo" style="display:none">
         Session: <span id="sessionIdDisplay"></span>
       </div>
+      <div class="session-info" id="contextUsage" style="display:none"></div>
     </div>
 
     <div class="panel">
@@ -16128,6 +16605,8 @@ function getDemoHtml(_port) {
   const requestLog = $('#requestLog');
   const sessionInfo = $('#sessionInfo');
   const sessionIdDisplay = $('#sessionIdDisplay');
+  const contextUsage = $('#contextUsage');
+  let lastLoggedContextPct = -1;
   const permissionPanel = $('#permissionPanel');
   const permissionList = $('#permissionList');
 
@@ -16251,6 +16730,8 @@ function getDemoHtml(_port) {
       sessionId = r.data.sessionId;
       sessionInfo.style.display = 'block';
       sessionIdDisplay.textContent = sessionId;
+      contextUsage.style.display = 'none';
+      lastLoggedContextPct = -1;
       enablePrompt(true);
       chatArea.innerHTML = '';
       currentAssistantBubble = null;
@@ -16368,6 +16849,24 @@ function getDemoHtml(_port) {
         const text = update.content?.text || '';
         currentThought += text;
         logEvent('THINK', text);
+      } else if (kind === 'usage_update') {
+        // One frame per model round: a long agentic turn (/review) emits
+        // hundreds, and the raw-JSON fallthrough below turned the Events tab
+        // into a scroll of identical lines. Render an in-place meter instead,
+        // and log only when the integer percentage moves \u2014 the transitions
+        // stay on record without the flood.
+        const used = update.used;
+        const size = update.size;
+        if (typeof used === 'number' && typeof size === 'number' && size > 0) {
+          const pct = Math.round((used / size) * 100);
+          const label = used + ' / ' + size + ' (' + pct + '%)';
+          contextUsage.style.display = 'block';
+          contextUsage.textContent = 'Context: ' + label;
+          if (pct !== lastLoggedContextPct) {
+            lastLoggedContextPct = pct;
+            logEvent('CTX', label);
+          }
+        }
       } else {
         logEvent(kind || type, JSON.stringify(update));
       }
@@ -16625,19 +17124,32 @@ function createHealthDemoRoutes(deps) {
       let sessions = 0;
       let pendingPermissions = 0;
       let activePrompts = 0;
+      let activeWork = false;
       let channelAlive = false;
       let lastActivity = null;
+      let coveredSessions = 0;
+      let sessionsOnNegotiatedChannel = 0;
+      let oldestReportAt = null;
       for (const runtime of runtimes) {
         failedWorkspaceId = runtime.workspaceId;
         const bridge = runtime.bridge;
         const runtimeSessions = bridge.sessionCount;
         const runtimePendingPermissions = bridge.pendingPermissionCount;
         const runtimeActivePrompts = bridge.activePromptCount;
+        const runtimeActiveWork = bridge.activeWork;
+        const runtimeCoverage = bridge.activeWorkCoverage;
+        const runtimeOldestReportAt = runtimeCoverage.oldestCoveredReportAt;
         const runtimeChannelAlive = bridge.isChannelLive();
         const runtimeLastActivity = bridge.lastActivityAt;
         sessions += runtimeSessions;
         pendingPermissions += runtimePendingPermissions;
         activePrompts += runtimeActivePrompts;
+        activeWork = activeWork || runtimeActiveWork;
+        coveredSessions += runtimeCoverage.covered;
+        sessionsOnNegotiatedChannel += runtimeCoverage.onNegotiatedChannel;
+        if (runtimeOldestReportAt !== null && (oldestReportAt === null || runtimeOldestReportAt < oldestReportAt)) {
+          oldestReportAt = runtimeOldestReportAt;
+        }
         channelAlive = channelAlive || runtimeChannelAlive;
         if (runtimeLastActivity !== null && (lastActivity === null || runtimeLastActivity > lastActivity)) {
           lastActivity = runtimeLastActivity;
@@ -16652,6 +17164,17 @@ function createHealthDemoRoutes(deps) {
         sessions,
         pendingPermissions,
         activePrompts,
+        activeWork,
+        activeWorkReporting: gradeActiveWorkCoverage({
+          total: sessions,
+          covered: coveredSessions,
+          onNegotiatedChannel: sessionsOnNegotiatedChannel
+        }),
+        // 0 rather than null when nothing is covered: an idle daemon with no
+        // sessions must not read as infinitely stale to a controller applying
+        // its own freshness floor. `oldestReportAt` is the oldest *covered*
+        // report, so this never disagrees with the grade above.
+        activeWorkStaleMs: oldestReportAt === null ? 0 : now - oldestReportAt,
         connectedClients: getActiveSseCount2(),
         channelAlive,
         lastActivityAt: lastActivity !== null ? new Date(lastActivity).toISOString() : null,
@@ -17177,6 +17700,10 @@ __name(registerWorkspaceAuthRoutes, "registerWorkspaceAuthRoutes");
 // packages/cli/src/serve/routes/workspace-extensions.ts
 init_esbuild_shims();
 import * as crypto2 from "node:crypto";
+import * as fs4 from "node:fs/promises";
+import * as os from "node:os";
+import * as path9 from "node:path";
+var import_express2 = __toESM(require_express(), 1);
 
 // packages/cli/src/serve/extension-operation-scheduler.ts
 init_esbuild_shims();
@@ -17258,6 +17785,7 @@ var MAX_UNFINISHED_EXTENSION_OPERATIONS = 10;
 var sanitizeDaemonMessage = /* @__PURE__ */ __name((message) => redactUrlCredentials(stripAnsiAndControl(message)), "sanitizeDaemonMessage");
 var redactExtensionDisplaySource = /* @__PURE__ */ __name((source) => {
   const redacted = redactUrlCredentials(source);
+  if (redacted.startsWith("upload:")) return redacted;
   if (/^[A-Za-z]:[\\/]/.test(redacted)) return redacted;
   try {
     const url = new URL(redacted);
@@ -17947,6 +18475,39 @@ var EXTENSION_PREPARE_DEADLINE_MS = 10 * 6e4;
 var EXTENSION_INTERACTION_DEADLINE_MS = 10 * 6e4;
 var EXTENSION_INTERACTIVE_PREPARE_DEADLINE_MS = EXTENSION_PREPARE_DEADLINE_MS + EXTENSION_INTERACTION_DEADLINE_MS;
 var EXTENSION_UPDATE_CHECK_DEADLINE_MS = 2 * 6e4;
+var EXTENSION_ARCHIVE_UPLOAD_LIMIT = "10mb";
+var extensionArchiveBodyParser = import_express2.default.raw({
+  type: "application/octet-stream",
+  limit: EXTENSION_ARCHIVE_UPLOAD_LIMIT
+});
+var parseExtensionArchiveFilename = /* @__PURE__ */ __name((value) => {
+  const invalidCharacter = typeof value === "string" && Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return character === "/" || character === "\\" || code < 32 || code === 127;
+  });
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > 255 || invalidCharacter) {
+    return null;
+  }
+  const lower = value.toLowerCase();
+  if (lower.endsWith(".tar.gz")) return { filename: value, suffix: ".tar.gz" };
+  if (lower.endsWith(".zip")) return { filename: value, suffix: ".zip" };
+  return null;
+}, "parseExtensionArchiveFilename");
+var extensionArchiveUploadMetadata = /* @__PURE__ */ __name((req, res, next) => {
+  if (req.query["consent"] !== "true") {
+    res.status(400).json({
+      error: "Extension installation requires explicit consent"
+    });
+    return;
+  }
+  if (!parseExtensionArchiveFilename(req.query["filename"])) {
+    res.status(400).json({
+      error: "`filename` must name a .zip or .tar.gz archive"
+    });
+    return;
+  }
+  next();
+}, "extensionArchiveUploadMetadata");
 var parseExtensionScope = /* @__PURE__ */ __name((body, res) => {
   const scope = body["scope"];
   if (scope !== "user" && scope !== "workspace") {
@@ -18388,6 +18949,127 @@ function registerWorkspaceExtensionRoutes(app, deps) {
         }
       }
     );
+    app.post(
+      `${base}/install-archive`,
+      mutate({ strict: true }),
+      extensionArchiveUploadMetadata,
+      extensionArchiveBodyParser,
+      async (req, res) => {
+        const ctrl = resolve5(req, res, true);
+        if (!ctrl) return;
+        try {
+          if (!ctrl.validateExtensionMutationClient(req, res, {
+            requireClientId: false
+          })) {
+            return;
+          }
+          const archiveName = parseExtensionArchiveFilename(
+            req.query["filename"]
+          );
+          if (!req.is("application/octet-stream")) {
+            res.status(415).json({
+              error: "Extension archive uploads require application/octet-stream"
+            });
+            return;
+          }
+          if (!Buffer.isBuffer(req.body) || req.body.length === 0) {
+            res.status(400).json({ error: "Extension archive is empty" });
+            return;
+          }
+          let archive = req.body;
+          const source = `upload:v1:${crypto2.randomUUID()}:${archiveName.filename}`;
+          ctrl.runQueuedExtensionMutation(
+            "install",
+            { source },
+            res,
+            async (extensionManager, _signal, context, operationId) => {
+              let uploadDir;
+              const sanitizeUploadError = /* @__PURE__ */ __name((error2) => {
+                const sanitized = new Error(
+                  uploadDir ? getErrorMessage(error2).replaceAll(
+                    uploadDir,
+                    "<extension-upload-dir>"
+                  ) : "Could not create the temporary extension upload directory"
+                );
+                const code = typeof error2 === "object" && error2 !== null && "code" in error2 && typeof error2.code === "string" ? error2.code : void 0;
+                if (code) Object.assign(sanitized, { code });
+                return sanitized;
+              }, "sanitizeUploadError");
+              let result;
+              let failure;
+              try {
+                uploadDir = await fs4.mkdtemp(
+                  path9.join(os.tmpdir(), "qwen-extension-upload-")
+                );
+                const archivePath = path9.join(
+                  uploadDir,
+                  `extension${archiveName.suffix}`
+                );
+                await fs4.writeFile(archivePath, archive);
+                archive = void 0;
+                const prepared = await context.prepare(async (signal) => {
+                  supersedeActiveInstallOperations(ctrl, operationId);
+                  return await extensionManager.prepareExtensionInstall({
+                    installMetadata: { type: "local", source },
+                    localSourcePath: archivePath,
+                    initialActivation: { scope: "user" },
+                    requestConsent: /* @__PURE__ */ __name(() => Promise.resolve(), "requestConsent"),
+                    signal
+                  });
+                });
+                try {
+                  const committed = await context.commit(
+                    async (onCommitted) => await extensionManager.commitPreparedExtension(
+                      prepared,
+                      onCommitted
+                    )
+                  );
+                  result = {
+                    status: "installed",
+                    source,
+                    name: committed.identity.name,
+                    version: committed.version
+                  };
+                } finally {
+                  await extensionManager.disposePreparedExtension(prepared);
+                }
+              } catch (error2) {
+                failure = sanitizeUploadError(error2);
+              }
+              if (uploadDir) {
+                try {
+                  await fs4.rm(uploadDir, { recursive: true, force: true });
+                } catch (error2) {
+                  failure ??= sanitizeUploadError(error2);
+                }
+              }
+              if (failure) throw failure;
+              return result;
+            },
+            {
+              createManager: /* @__PURE__ */ __name((operationId) => ctrl.createExtensionManager(
+                void 0,
+                void 0,
+                extensionInteractionHandlers(ctrl, operationId)
+              ), "createManager"),
+              onSettled: /* @__PURE__ */ __name((operationId) => {
+                supersededInstallOperations.delete(operationId);
+                cancelPendingExtensionInteraction(
+                  operationId,
+                  "Extension operation ended"
+                );
+              }, "onSettled"),
+              deadlineMs: EXTENSION_INTERACTIVE_PREPARE_DEADLINE_MS,
+              ...globalReconciliationOptions()
+            }
+          );
+        } catch (err) {
+          sendBridgeError2(res, err, {
+            route: `POST ${base}/install-archive`
+          });
+        }
+      }
+    );
     app.post(`${base}/install`, mutate({ strict: true }), async (req, res) => {
       const ctrl = resolve5(req, res, true);
       if (!ctrl) return;
@@ -19621,13 +20303,13 @@ async function handlePostFileWrite(req, res, deps) {
     req
   );
   if (originatorClientId === null) return;
-  const fs7 = factory.forRequest({
+  const fs8 = factory.forRequest({
     originatorClientId,
     route: ROUTE2
   });
   try {
-    const resolved = await fs7.resolve(queryPath, "write");
-    const out = await fs7.writeTextAtomic(resolved, content, {
+    const resolved = await fs8.resolve(queryPath, "write");
+    const out = await fs8.writeTextAtomic(resolved, content, {
       mode,
       ...expectedHash ? { expectedHash } : {},
       ...bom !== void 0 ? { bom } : {},
@@ -19680,13 +20362,13 @@ async function handlePostFileEdit(req, res, deps) {
     req
   );
   if (originatorClientId === null) return;
-  const fs7 = factory.forRequest({
+  const fs8 = factory.forRequest({
     originatorClientId,
     route: ROUTE2
   });
   try {
-    const resolved = await fs7.resolve(queryPath, "edit");
-    const out = await fs7.editAtomic(resolved, oldText, newText, {
+    const resolved = await fs8.resolve(queryPath, "edit");
+    const out = await fs8.editAtomic(resolved, oldText, newText, {
       expectedHash
     });
     applyReadHeaders(res);
@@ -20337,8 +21019,8 @@ function decodePathSegment(value) {
 }
 __name(decodePathSegment, "decodePathSegment");
 function matchLegacySessionTelemetryRoute(method, requestPath) {
-  const path14 = requestPath.length > 1 && requestPath.endsWith("/") ? requestPath.slice(0, -1) : requestPath;
-  const requestSegments = path14.split("/").slice(1);
+  const path15 = requestPath.length > 1 && requestPath.endsWith("/") ? requestPath.slice(0, -1) : requestPath;
+  const requestSegments = path15.split("/").slice(1);
   const prefix = requestSegments[0]?.toLowerCase();
   if (prefix !== "session" && prefix !== "sessions" && prefix !== "permission") {
     return void 0;
@@ -20390,23 +21072,23 @@ __name(setDaemonTelemetryWorkspace, "setDaemonTelemetryWorkspace");
 function resolveDaemonTelemetryRoute(req) {
   const legacyRoute = matchLegacySessionTelemetryRoute(req.method, req.path);
   if (legacyRoute) return legacyRoute;
-  const path14 = req.path.replace(/\/$/, "") || "/";
-  if (req.method === "GET" && path14 === "/daemon/status") {
+  const path15 = req.path.replace(/\/$/, "") || "/";
+  if (req.method === "GET" && path15 === "/daemon/status") {
     return { route: "GET /daemon/status" };
   }
-  if (req.method === "GET" && /^\/workspace\/[^/]+\/sessions$/.test(path14)) {
+  if (req.method === "GET" && /^\/workspace\/[^/]+\/sessions$/.test(path15)) {
     return { route: "GET /workspace/:id/sessions" };
   }
-  if (req.method === "GET" && /^\/workspaces\/[^/]+\/sessions$/.test(path14)) {
+  if (req.method === "GET" && /^\/workspaces\/[^/]+\/sessions$/.test(path15)) {
     return { route: "GET /workspace/:id/sessions" };
   }
-  if (req.method === "GET" && /^\/workspace\/[^/]+\/session-info$/.test(path14)) {
+  if (req.method === "GET" && /^\/workspace\/[^/]+\/session-info$/.test(path15)) {
     return { route: "GET /workspace/:id/session-info" };
   }
-  if (req.method === "GET" && /^\/workspaces\/[^/]+\/session-info$/.test(path14)) {
+  if (req.method === "GET" && /^\/workspaces\/[^/]+\/session-info$/.test(path15)) {
     return { route: "GET /workspace/:id/session-info" };
   }
-  const workspaceTranscript = path14.match(
+  const workspaceTranscript = path15.match(
     /^\/workspaces\/[^/]+\/session\/([^/]+)\/transcript$/
   );
   if (workspaceTranscript?.[1] && req.method === "GET") {
@@ -20415,7 +21097,7 @@ function resolveDaemonTelemetryRoute(req) {
       sessionId: decodePathSegment(workspaceTranscript[1])
     };
   }
-  const workspaceExport = path14.match(
+  const workspaceExport = path15.match(
     /^\/workspaces\/[^/]+\/session\/([^/]+)\/export$/
   );
   if (workspaceExport?.[1] && req.method === "GET") {
@@ -20424,7 +21106,7 @@ function resolveDaemonTelemetryRoute(req) {
       sessionId: decodePathSegment(workspaceExport[1])
     };
   }
-  const workspaceArchivedExport = path14.match(
+  const workspaceArchivedExport = path15.match(
     /^\/workspaces\/[^/]+\/session\/([^/]+)\/archive\/export$/
   );
   if (workspaceArchivedExport?.[1] && req.method === "GET") {
@@ -20434,8 +21116,8 @@ function resolveDaemonTelemetryRoute(req) {
     };
   }
   const pluralWorkspacePrefix = /^\/workspaces\/[^/]+/;
-  if (pluralWorkspacePrefix.test(path14)) {
-    const suffix = path14.replace(pluralWorkspacePrefix, "/workspace");
+  if (pluralWorkspacePrefix.test(path15)) {
+    const suffix = path15.replace(pluralWorkspacePrefix, "/workspace");
     if (req.method === "GET") {
       if (suffix === "/workspace/mcp" || suffix === "/workspace/skills" || suffix === "/workspace/tools" || suffix === "/workspace/providers" || suffix === "/workspace/env" || suffix === "/workspace/preflight" || suffix === "/workspace/hooks" || suffix === "/workspace/settings" || suffix === "/workspace/voice" || suffix === "/workspace/permissions" || suffix === "/workspace/trust" || suffix === "/workspace/memory" || suffix === "/workspace/agents") {
         return { route: `GET ${suffix}` };
@@ -20494,58 +21176,58 @@ function resolveDaemonTelemetryRoute(req) {
       return { route: "DELETE /workspace/session-groups/:groupId" };
     }
   }
-  if (req.method === "POST" && path14 === "/workspace/init") {
+  if (req.method === "POST" && path15 === "/workspace/init") {
     return { route: "POST /workspace/init" };
   }
-  if (req.method === "POST" && path14 === "/workspace/setup-github") {
+  if (req.method === "POST" && path15 === "/workspace/setup-github") {
     return { route: "POST /workspace/setup-github" };
   }
-  if (req.method === "POST" && path14 === "/workspace/reload") {
+  if (req.method === "POST" && path15 === "/workspace/reload") {
     return { route: "POST /workspace/reload" };
   }
-  const mcpRestart = path14.match(/^\/workspace\/mcp\/([^/]+)\/restart$/);
+  const mcpRestart = path15.match(/^\/workspace\/mcp\/([^/]+)\/restart$/);
   if (mcpRestart?.[1] && req.method === "POST") {
     return { route: "POST /workspace/mcp/:server/restart" };
   }
-  if (req.method === "POST" && path14 === "/workspace/mcp/servers") {
+  if (req.method === "POST" && path15 === "/workspace/mcp/servers") {
     return { route: "POST /workspace/mcp/servers" };
   }
-  const mcpDelete = path14.match(/^\/workspace\/mcp\/servers\/([^/]+)$/);
+  const mcpDelete = path15.match(/^\/workspace\/mcp\/servers\/([^/]+)$/);
   if (mcpDelete?.[1] && req.method === "DELETE") {
     return { route: "DELETE /workspace/mcp/servers/:name" };
   }
-  if (req.method === "POST" && path14 === "/workspace/auth/device-flow") {
+  if (req.method === "POST" && path15 === "/workspace/auth/device-flow") {
     return { route: "POST /workspace/auth/device-flow" };
   }
-  const deviceFlowDelete = path14.match(
+  const deviceFlowDelete = path15.match(
     /^\/workspace\/auth\/device-flow\/([^/]+)$/
   );
   if (deviceFlowDelete?.[1] && req.method === "DELETE") {
     return { route: "DELETE /workspace/auth/device-flow/:id" };
   }
-  const toolEnable = path14.match(/^\/workspace\/tools\/([^/]+)\/enable$/);
+  const toolEnable = path15.match(/^\/workspace\/tools\/([^/]+)\/enable$/);
   if (toolEnable?.[1] && req.method === "POST") {
     return { route: "POST /workspace/tools/:name/enable" };
   }
-  if (path14 === "/workspace/settings") {
+  if (path15 === "/workspace/settings") {
     if (req.method === "GET") return { route: "GET /workspace/settings" };
     if (req.method === "POST") return { route: "POST /workspace/settings" };
   }
-  if (path14 === "/workspace/permissions") {
+  if (path15 === "/workspace/permissions") {
     if (req.method === "GET") return { route: "GET /workspace/permissions" };
     if (req.method === "POST") return { route: "POST /workspace/permissions" };
   }
-  if (path14 === "/workspace/trust") {
+  if (path15 === "/workspace/trust") {
     if (req.method === "GET") return { route: "GET /workspace/trust" };
   }
-  if (req.method === "POST" && path14 === "/workspace/trust/request") {
+  if (req.method === "POST" && path15 === "/workspace/trust/request") {
     return { route: "POST /workspace/trust/request" };
   }
-  if (path14 === "/workspace/voice") {
+  if (path15 === "/workspace/voice") {
     if (req.method === "GET") return { route: "GET /workspace/voice" };
     if (req.method === "POST") return { route: "POST /workspace/voice" };
   }
-  if (req.method === "POST" && path14 === "/workspace/voice/transcribe") {
+  if (req.method === "POST" && path15 === "/workspace/voice/transcribe") {
     return { route: "POST /workspace/voice/transcribe" };
   }
   return void 0;
@@ -20813,8 +21495,8 @@ __name(registerPermissionRoutes, "registerPermissionRoutes");
 // packages/cli/src/serve/routes/session.ts
 init_esbuild_shims();
 import * as crypto3 from "node:crypto";
-import * as fs5 from "node:fs";
-import * as path9 from "node:path";
+import * as fs6 from "node:fs";
+import * as path10 from "node:path";
 
 // packages/cli/src/serve/server/prompt-deadline.ts
 init_esbuild_shims();
@@ -21505,7 +22187,7 @@ __name(deleteBranch, "deleteBranch");
 
 // packages/cli/src/serve/virtual-subagent-sessions.ts
 init_esbuild_shims();
-import * as fs4 from "node:fs/promises";
+import * as fs5 from "node:fs/promises";
 import { createReadStream } from "node:fs";
 import readline from "node:readline";
 var PREFIX = "subagent.";
@@ -21699,7 +22381,7 @@ var VirtualSubagentTarget = class _VirtualSubagentTarget {
   async readNewRecords(endOffset) {
     let handle;
     try {
-      handle = await fs4.open(this.task.outputFile, "r");
+      handle = await fs5.open(this.task.outputFile, "r");
       const stat3 = await handle.stat();
       const identity = `${stat3.dev}:${stat3.ino}`;
       if (this.transcriptIdentity !== void 0 && this.transcriptIdentity !== identity || stat3.size < this.offset) {
@@ -21743,7 +22425,7 @@ var VirtualSubagentTarget = class _VirtualSubagentTarget {
     const filePath = `${this.task.outputFile}.stream`;
     let handle;
     try {
-      handle = await fs4.open(filePath, "r");
+      handle = await fs5.open(filePath, "r");
       const stat3 = await handle.stat();
       const identity = `${stat3.dev}:${stat3.ino}`;
       if (this.streamIdentity !== void 0 && this.streamIdentity !== identity) {
@@ -21908,7 +22590,7 @@ var VirtualSubagentTarget = class _VirtualSubagentTarget {
   async captureReadBounds() {
     const size = /* @__PURE__ */ __name(async (filePath) => {
       try {
-        return (await fs4.stat(filePath)).size;
+        return (await fs5.stat(filePath)).size;
       } catch (error2) {
         if (error2.code === "ENOENT") return 0;
         throw error2;
@@ -22037,7 +22719,7 @@ var VirtualSubagentSessions = class {
     const sessionDir = getSubagentSessionDir(projectDir, parentSessionId);
     let names;
     try {
-      names = await fs4.readdir(sessionDir);
+      names = await fs5.readdir(sessionDir);
     } catch (error2) {
       if (error2.code === "ENOENT") return void 0;
       throw error2;
@@ -22093,7 +22775,7 @@ var VirtualSubagentSessions = class {
     const sessionDir = getSubagentSessionDir(projectDir, parentSessionId);
     let names;
     try {
-      names = await fs4.readdir(sessionDir);
+      names = await fs5.readdir(sessionDir);
     } catch (error2) {
       if (error2.code === "ENOENT") return void 0;
       throw error2;
@@ -22238,8 +22920,7 @@ __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 = 32 * 1024 * 1024;
+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";
 var CHANNEL_DELIVERY_AUTHORIZATION_GRACE_MS = 6e4;
@@ -22398,15 +23079,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) {
@@ -22436,12 +23108,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) {
@@ -22503,6 +23190,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) {
@@ -22582,7 +23283,7 @@ function registerSessionRoutes(app, deps) {
     const workspaceParam = req.params[paramName] ?? "";
     const byId = workspaceRegistry.getByWorkspaceId(workspaceParam);
     if (byId) return byId;
-    if (!path9.isAbsolute(workspaceParam)) {
+    if (!path10.isAbsolute(workspaceParam)) {
       res.status(400).json({
         error: `\`:${paramName}\` must decode to a workspace id or absolute path`
       });
@@ -22767,7 +23468,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,
@@ -22786,33 +23486,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;
@@ -23063,6 +23736,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;
@@ -23095,52 +23769,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) {
@@ -23248,6 +23909,7 @@ function registerSessionRoutes(app, deps) {
           });
           return;
         }
+        assertRuntimeGenerationOpen?.();
         inFlightBranchWorkspaces.add(workspaceCwd);
         try {
           await createBranch(workspaceCwd, branchName);
@@ -23317,6 +23979,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({
@@ -23335,6 +23998,7 @@ function registerSessionRoutes(app, deps) {
       if (requestedSessionId !== void 0) {
         sessionScope = "thread";
       }
+      assertRuntimeGenerationOpen?.();
       const session = await runtime.bridge.spawnOrAttach({
         workspaceCwd,
         modelServiceId,
@@ -23364,6 +24028,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(() => {
@@ -23384,7 +24051,7 @@ function registerSessionRoutes(app, deps) {
         return;
       }
       try {
-        runtime.generationGuard?.assertOpen();
+        assertRuntimeGenerationOpen?.();
       } catch (error2) {
         if (!session.attached) {
           try {
@@ -23473,7 +24140,7 @@ function registerSessionRoutes(app, deps) {
       if (worktreeMeta) {
         try {
           const createAllowedRoots = [
-            path9.join(workspaceCwd, ".qwen", "worktrees")
+            path10.join(workspaceCwd, ".qwen", "worktrees")
           ];
           let createRepoTop = null;
           try {
@@ -23484,7 +24151,7 @@ function registerSessionRoutes(app, deps) {
           }
           if (createRepoTop && createRepoTop !== workspaceCwd) {
             createAllowedRoots.push(
-              path9.join(createRepoTop, ".qwen", "worktrees")
+              path10.join(createRepoTop, ".qwen", "worktrees")
             );
           }
           await runtime.bridge.changeSessionCwd(session.sessionId, {
@@ -23555,9 +24222,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) => {
@@ -23628,27 +24293,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(
@@ -23675,7 +24342,7 @@ function registerSessionRoutes(app, deps) {
             }
             liveConversationCwd = await materialize(sessionId);
           }
-          runtime.generationGuard?.assertOpen();
+          assertRuntimeGenerationOpen?.();
           const restored = action === "load" ? await runtime.bridge.loadSession({
             sessionId,
             workspaceCwd,
@@ -23747,7 +24414,7 @@ function registerSessionRoutes(app, deps) {
         }
       );
       try {
-        runtime.generationGuard?.assertOpen();
+        assertRuntimeGenerationOpen?.();
       } catch (error2) {
         if (!session.attached) {
           await runtime.bridge.killSession(session.sessionId, { requireZeroAttaches: true }).catch(() => {
@@ -23783,10 +24450,10 @@ function registerSessionRoutes(app, deps) {
         if (sidecar) {
           let realTarget;
           const candidateRoots = [
-            path9.join(workspaceCwd, ".qwen", "worktrees")
+            path10.join(workspaceCwd, ".qwen", "worktrees")
           ];
           try {
-            realTarget = fs5.realpathSync(sidecar.worktreePath);
+            realTarget = fs6.realpathSync(sidecar.worktreePath);
             let repoTop = null;
             try {
               repoTop = await new GitWorktreeService(
@@ -23795,13 +24462,13 @@ function registerSessionRoutes(app, deps) {
             } catch {
             }
             if (repoTop && repoTop !== workspaceCwd) {
-              candidateRoots.push(path9.join(repoTop, ".qwen", "worktrees"));
+              candidateRoots.push(path10.join(repoTop, ".qwen", "worktrees"));
             }
             const contained = candidateRoots.some((root) => {
               try {
-                const realRoot = fs5.realpathSync(root);
-                const rel = path9.relative(realRoot, realTarget);
-                return !rel.startsWith("..") && !path9.isAbsolute(rel);
+                const realRoot = fs6.realpathSync(root);
+                const rel = path10.relative(realRoot, realTarget);
+                return !rel.startsWith("..") && !path10.isAbsolute(rel);
               } catch {
                 return false;
               }
@@ -23849,7 +24516,7 @@ function registerSessionRoutes(app, deps) {
         sessionId
       });
     } finally {
-      releaseRestoreOwner();
+      sessionIdReservation.release();
     }
   }, "restoreSessionHandler");
   app.post("/session/:id/load", mutate(), restoreSessionHandler("load"));
@@ -24117,7 +24784,7 @@ function registerSessionRoutes(app, deps) {
       async (req, res, sessionId, runtime) => {
         const body = safeBody(req);
         const targetPath = body["path"];
-        if (typeof targetPath !== "string" || targetPath.length === 0 || !path9.isAbsolute(targetPath)) {
+        if (typeof targetPath !== "string" || targetPath.length === 0 || !path10.isAbsolute(targetPath)) {
           res.status(400).json({
             error: "`path` is required and must be an absolute path",
             code: "invalid_path"
@@ -27151,7 +27818,7 @@ __name(registerUsageStatsRoutes, "registerUsageStatsRoutes");
 // packages/cli/src/serve/scheduled-task-keepalive.ts
 init_esbuild_shims();
 import * as fsSync from "node:fs";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 var log = createDebugLogger("SCHED_KEEPALIVE");
 function collectBoundSessionIds(tasks) {
   const seen = /* @__PURE__ */ new Set();
@@ -27169,7 +27836,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) {
@@ -27377,8 +28044,8 @@ function startScheduledTaskKeepalive(opts) {
     opts.runtimeBaseDir,
     () => getCronFilePath(boundWorkspace)
   );
-  const cronDir = path10.dirname(cronFilePath);
-  const cronFileName = path10.basename(cronFilePath);
+  const cronDir = path11.dirname(cronFilePath);
+  const cronFileName = path11.basename(cronFilePath);
   let fileWatcher;
   try {
     fsSync.mkdirSync(cronDir, { recursive: true });
@@ -27415,7 +28082,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;
@@ -27474,6 +28141,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`));
@@ -28040,6 +28708,7 @@ function registerCapabilitiesRoutes(app, deps) {
         maxPendingPromptsPerSession: advertisedMaxPendingPromptsPerSession(
           deps.maxPendingPromptsPerSession
         ),
+        sessionRestoreTimeoutMs: deps.sessionRestoreTimeoutMs,
         ...multiWorkspace ? {
           maxSessionsPerWorkspace: advertisedMaxSessions(
             deps.maxSessionsPerWorkspace
@@ -28864,6 +29533,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({
@@ -28905,6 +29593,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,
@@ -28922,22 +29637,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) {
@@ -29203,10 +29905,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
@@ -30323,7 +31027,7 @@ __name(registerWorkspaceModelsRoutes, "registerWorkspaceModelsRoutes");
 // packages/cli/src/serve/routes/a2ui-action.ts
 init_esbuild_shims();
 import * as fsp4 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 var A2UI_MIME = "application/a2ui+json";
 var ACTION_TOOL = "action";
 var CALL_TIMEOUT_MS = 15e3;
@@ -30346,7 +31050,7 @@ __name(usableServerConfig, "usableServerConfig");
 async function findFromSettingsFile(workspaceCwd) {
   try {
     const raw = await fsp4.readFile(
-      path11.join(workspaceCwd, ".qwen", "settings.json"),
+      path12.join(workspaceCwd, ".qwen", "settings.json"),
       "utf8"
     );
     const settings = JSON.parse(raw);
@@ -30507,7 +31211,7 @@ __name(registerA2uiActionRoutes, "registerA2uiActionRoutes");
 
 // packages/cli/src/serve/server/fs-factory.ts
 init_esbuild_shims();
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 var IDE_WORKSPACE_PATH_ENV_VAR = "QWEN_CODE_IDE_WORKSPACE_PATH";
 function createDefaultFsAuditEmit() {
   const WARN_EVERY = 100;
@@ -30582,14 +31286,14 @@ function parseIdeWorkspacePathEnv(value) {
       const parsed = JSON.parse(value);
       if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
         return parsed.filter(
-          (workspace) => workspace.length > 0 && path12.isAbsolute(workspace)
+          (workspace) => workspace.length > 0 && path13.isAbsolute(workspace)
         );
       }
       throw new Error("IDE workspace path JSON must be a string array");
     } catch {
     }
   }
-  return value.split(path12.delimiter).filter((workspace) => workspace.length > 0 && path12.isAbsolute(workspace));
+  return value.split(path13.delimiter).filter((workspace) => workspace.length > 0 && path13.isAbsolute(workspace));
 }
 __name(parseIdeWorkspacePathEnv, "parseIdeWorkspacePathEnv");
 function dropNestedWorkspacesPreservingPrimary(workspaces) {
@@ -30858,9 +31562,9 @@ __name(setupDeviceFlowRegistry, "setupDeviceFlowRegistry");
 
 // packages/cli/src/serve/server/error-handlers.ts
 init_esbuild_shims();
-var import_express2 = __toESM(require_express(), 1);
+var import_express3 = __toESM(require_express(), 1);
 function installJsonBodyParser(app) {
-  app.use(import_express2.default.json({ limit: "10mb" }));
+  app.use(import_express3.default.json({ limit: "10mb" }));
   app.use((err, _req, res, next) => {
     if (sendJsonBodyParserError(res, err)) return;
     next(err);
@@ -30914,10 +31618,10 @@ function installRateLimiter(app, opts, daemonLog, options = {}) {
         { tier, key: key.slice(0, 64) }
       );
     } : void 0,
-    onError: daemonLog ? (err, path14) => {
+    onError: daemonLog ? (err, path15) => {
       daemonLog.warn(
         `rate limiter error (fail-open): ${err instanceof Error ? err.message : String(err)}`,
-        { path: path14 }
+        { path: path15 }
       );
     } : void 0
   });
@@ -31113,7 +31817,7 @@ __name(registerWorkspaceQualifiedLifecycleRoutes, "registerWorkspaceQualifiedLif
 init_esbuild_shims();
 import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { realpathSync as realpathSync3 } from "node:fs";
-import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute7, join as join7, resolve as resolve4, sep as sep3 } from "node:path";
+import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute7, join as join8, resolve as resolve4, sep as sep3 } from "node:path";
 
 // packages/cli/src/serve/native-directory-picker.ts
 init_esbuild_shims();
@@ -31499,7 +32203,7 @@ function registerWorkspaceManagementRoutes(app, deps) {
         return;
       }
       const endsWithSep = prefix.endsWith("/") || process.platform === "win32" && prefix.endsWith("\\");
-      const dir = endsWithSep ? join7(prefix, ".") : dirname4(prefix);
+      const dir = endsWithSep ? join8(prefix, ".") : dirname4(prefix);
       const filter = endsWithSep ? "" : basename4(prefix);
       const filterLower = filter.toLowerCase();
       const suggestions = [];
@@ -31515,7 +32219,7 @@ function registerWorkspaceManagementRoutes(app, deps) {
           let isDir = entry.isDirectory();
           if (!isDir && entry.isSymbolicLink()) {
             try {
-              isDir = (await stat2(join7(dir, entry.name))).isDirectory();
+              isDir = (await stat2(join8(dir, entry.name))).isDirectory();
             } catch {
               continue;
             }
@@ -31525,7 +32229,7 @@ function registerWorkspaceManagementRoutes(app, deps) {
             truncated = true;
             break;
           }
-          suggestions.push({ name: entry.name, path: join7(dir, entry.name) });
+          suggestions.push({ name: entry.name, path: join8(dir, entry.name) });
         }
       } catch {
       }
@@ -31545,11 +32249,11 @@ function registerWorkspaceManagementRoutes(app, deps) {
       const controller = new AbortController();
       res.on("close", () => controller.abort());
       try {
-        const path14 = await pickWorkspaceDirectory(controller.signal);
+        const path15 = await pickWorkspaceDirectory(controller.signal);
         res.status(200).json({
           kind: "workspace-directory-picker",
-          selected: path14 !== void 0,
-          ...path14 === void 0 ? {} : { path: path14 }
+          selected: path15 !== void 0,
+          ...path15 === void 0 ? {} : { path: path15 }
         });
       } catch (error2) {
         const detail = error2 instanceof Error ? error2.message : String(error2);
@@ -32606,8 +33310,8 @@ function buildDiffList(workspaceCwd, result) {
       hiddenCount: 0
     };
   }
-  const files = [...result.perFileStats.entries()].map(([path14, s]) => ({
-    path: path14,
+  const files = [...result.perFileStats.entries()].map(([path15, s]) => ({
+    path: path15,
     oldPath: s.oldPath,
     added: s.added,
     removed: s.removed,
@@ -34696,18 +35400,43 @@ function parsePairingCode(body, res) {
   return code.trim().toUpperCase();
 }
 __name(parsePairingCode, "parsePairingCode");
-function parsePairingSenderId(body, res) {
+function parsePairingApprovalSubject(body, res) {
   const senderId = body["senderId"];
-  if (typeof senderId !== "string" || senderId.length === 0) {
+  const groupId = body["groupId"];
+  if (senderId !== void 0 && groupId !== void 0) {
+    res.status(400).json({
+      error: "Provide exactly one of `senderId` or `groupId`.",
+      code: "invalid_channel_pairing_subject"
+    });
+    return void 0;
+  }
+  if (senderId !== void 0) {
+    if (typeof senderId === "string" && senderId.length > 0) {
+      return { type: "user", id: senderId };
+    }
     res.status(400).json({
       error: "`senderId` must be a non-empty string.",
       code: "invalid_channel_pairing_sender_id"
     });
     return void 0;
   }
-  return senderId;
+  if (groupId !== void 0) {
+    if (typeof groupId === "string" && groupId.length > 0) {
+      return { type: "group", id: groupId };
+    }
+    res.status(400).json({
+      error: "`groupId` must be a non-empty string.",
+      code: "invalid_channel_pairing_group_id"
+    });
+    return void 0;
+  }
+  res.status(400).json({
+    error: "Provide exactly one of `senderId` or `groupId`.",
+    code: "invalid_channel_pairing_subject"
+  });
+  return void 0;
 }
-__name(parsePairingSenderId, "parsePairingSenderId");
+__name(parsePairingApprovalSubject, "parsePairingApprovalSubject");
 function errorCode2(error2) {
   if (!error2 || typeof error2 !== "object") return void 0;
   try {
@@ -34881,11 +35610,11 @@ function registerWorkspaceChannelManagementRoutes(app, deps) {
         if (!resolved || !validateClient(req, res, resolved.runtime)) return;
         const name = parseInstanceName(req, res);
         if (!name) return;
-        const senderId = parsePairingSenderId(deps.safeBody(req), res);
-        if (!senderId) return;
+        const subject = parsePairingApprovalSubject(deps.safeBody(req), res);
+        if (!subject) return;
         try {
           noStore(res);
-          res.status(200).json(await resolved.service.revokePairingApproval(name, senderId));
+          res.status(200).json(await resolved.service.revokePairingApproval(name, subject));
         } catch (error2) {
           sendManagementError(res, error2);
         }
@@ -35191,6 +35920,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") {
@@ -35208,24 +35957,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({
@@ -35245,13 +36012,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"];
@@ -35305,6 +36066,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 }),
@@ -35358,6 +36120,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 }),
@@ -35383,6 +36166,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 }),
@@ -35454,6 +36238,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 }),
@@ -35489,7 +36303,7 @@ __name(registerWorkspaceQualifiedSkillsRoutes, "registerWorkspaceQualifiedSkills
 
 // packages/cli/src/serve/routes/channel-webhooks.ts
 init_esbuild_shims();
-var import_express3 = __toESM(require_express(), 1);
+var import_express4 = __toESM(require_express(), 1);
 import { createHash as createHash4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
   "__proto__",
@@ -35538,7 +36352,7 @@ function registerChannelWebhookRoutes(app, deps) {
       locals.channelWebhook = { channelName, source, sourceConfig };
       next();
     },
-    import_express3.default.json({ limit: "1mb" }),
+    import_express4.default.json({ limit: "1mb" }),
     async (req, res) => {
       const locals = res.locals;
       const webhook = locals.channelWebhook;
@@ -39037,10 +39851,10 @@ __name(registerLiveSetupRoutes, "registerLiveSetupRoutes");
 init_esbuild_shims();
 import { execFile as execFile3 } from "node:child_process";
 import { createHash as createHash5, randomUUID as randomUUID11 } from "node:crypto";
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import * as fsp5 from "node:fs/promises";
-import * as os from "node:os";
-import * as path13 from "node:path";
+import * as os2 from "node:os";
+import * as path14 from "node:path";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { promisify as promisify3 } from "node:util";
@@ -39118,7 +39932,7 @@ async function readBundleValue(appPath, key) {
     "raw",
     "-o",
     "-",
-    path13.join(appPath, "Contents", "Info.plist")
+    path14.join(appPath, "Contents", "Info.plist")
   ]);
 }
 __name(readBundleValue, "readBundleValue");
@@ -39213,7 +40027,7 @@ async function downloadAsset(asset, destination, onProgress) {
   await pipeline(
     Readable.fromWeb(response.body),
     guard,
-    fs6.createWriteStream(destination, { flags: "wx", mode: 384 })
+    fs7.createWriteStream(destination, { flags: "wx", mode: 384 })
   );
   if (received !== asset.size || hash.digest("hex") !== asset.sha256) {
     throw new Error("Live Host checksum verification failed.");
@@ -39224,11 +40038,11 @@ async function installLatestHost(currentArchitecture, onStatus) {
   const manifest = await fetchManifest();
   const asset = manifest.assets[currentArchitecture];
   const temporaryDirectory = await fsp5.mkdtemp(
-    path13.join(os.tmpdir(), "qwen-live-host-")
+    path14.join(os2.tmpdir(), "qwen-live-host-")
   );
-  const archivePath = path13.join(temporaryDirectory, asset.name);
-  const extractedPath = path13.join(temporaryDirectory, "extracted");
-  const candidatePath = path13.join(extractedPath, LIVE_HOST_APP_NAME);
+  const archivePath = path14.join(temporaryDirectory, asset.name);
+  const extractedPath = path14.join(temporaryDirectory, "extracted");
+  const candidatePath = path14.join(extractedPath, LIVE_HOST_APP_NAME);
   const stagingPath = `/Applications/.Qwen Live Host.install-${randomUUID11()}.app`;
   const backupPath = `/Applications/.Qwen Live Host.backup-${randomUUID11()}.app`;
   let movedExisting = false;
@@ -39376,13 +40190,13 @@ var LiveHostInstaller = class {
 init_esbuild_shims();
 import { createHash as createHash6, randomUUID as randomUUID12 } from "node:crypto";
 import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // packages/cli/src/serve/live/realtime-startup-context.ts
 init_esbuild_shims();
 import { readdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename as basename5, join as join9 } from "node:path";
+import { basename as basename5, join as join10 } from "node:path";
 var STARTUP_CONTEXT_HEADER = "Startup context from Qwen Code.\nThis is background context about recent work and machine/workspace layout. It may be incomplete or stale. Use it to inform responses, and do not repeat it back unless relevant.";
 var CURRENT_THREAD_SECTION_TOKEN_BUDGET = 1200;
 var RECENT_WORK_SECTION_TOKEN_BUDGET = 2200;
@@ -39624,7 +40438,7 @@ function collectTreeLines(directory, depth, lines) {
     const indent = "  ".repeat(depth);
     lines.push(`${indent}- ${entry.name}${entry.isDirectory() ? "/" : ""}`);
     if (entry.isDirectory()) {
-      collectTreeLines(join9(directory, entry.name), depth + 1, lines);
+      collectTreeLines(join10(directory, entry.name), depth + 1, lines);
     }
   }
   if (entries.length > DIR_ENTRY_LIMIT) {
@@ -39743,13 +40557,13 @@ function openLiveAudioCapture(source, identifier) {
   try {
     mkdirSync2(directory, { recursive: true, mode: 448 });
     const safeIdentifier = identifier.replace(/[^A-Za-z0-9_-]/g, "_");
-    const path14 = join10(
+    const path15 = join11(
       directory,
       `${source}-${Date.now()}-${safeIdentifier}.pcm`
     );
-    const stream = createWriteStream2(path14, { flags: "wx", mode: 384 });
+    const stream = createWriteStream2(path15, { flags: "wx", mode: 384 });
     stream.on("error", () => void 0);
-    return { source, path: path14, stream, hash: createHash6("sha256"), bytes: 0 };
+    return { source, path: path15, stream, hash: createHash6("sha256"), bytes: 0 };
   } catch {
     return void 0;
   }
@@ -42069,6 +42883,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) {
@@ -42110,12 +42925,19 @@ 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."
     );
   }
-  const app = (0, import_express4.default)();
+  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());
   if (injectedWorkspaceRegistry) {
@@ -42286,14 +43108,16 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     maxJournalEvents: opts.maxJournalEvents,
     maxJournalBytes: opts.maxJournalBytes,
     initializeTimeoutMs: opts.initializeTimeoutMs,
+    sessionRestoreTimeoutMs,
     permissionResponseTimeoutMs: opts.permissionResponseTimeoutMs,
     boundWorkspace,
     sessionShellCommandEnabled,
     // Wire the production status provider so direct embeds / tests
     // that don't inject `deps.bridge` get daemon env + preflight cells.
     statusProvider,
-    // Wire the WorkspaceFileSystem adapter so ACP writeTextFile /
-    // readTextFile pick up trust / TOCTOU / audit.
+    delegateReadTextFileToClient: false,
+    // Final ACP text writes remain delegated through WorkspaceFileSystem.
+    // Unexpected delegated reads still fail closed at the WFS boundary.
     fileSystem: createBridgeFileSystemAdapter(fsFactory),
     // Reverse tool channel: answer the child's `client_mcp/message`
     // ext-method by reaching the WS connection that hosts the named server.
@@ -42360,6 +43184,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"),
@@ -42395,6 +43224,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
@@ -42830,7 +43668,8 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     getChannelWorkerSnapshots: deps.getChannelWorkerSnapshots,
     getPerfSnapshot: deps.getPerfSnapshot,
     getMetricsSeries: deps.getMetricsSeries,
-    getTotalSessionAdmissionSnapshot: deps.getTotalSessionAdmissionSnapshot ?? totalSessionAdmission?.snapshot
+    getTotalSessionAdmissionSnapshot: deps.getTotalSessionAdmissionSnapshot ?? totalSessionAdmission?.snapshot,
+    getChildHeapPolicySnapshot: deps.getChildHeapPolicySnapshot
   });
   if (liveVoiceEnabled) {
     app.use("/capabilities", (_req, _res, next) => {
@@ -42847,6 +43686,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     maxSessionsPerWorkspace: opts.maxSessions,
     maxTotalSessions: opts.maxTotalSessions,
     maxPendingPromptsPerSession: opts.maxPendingPromptsPerSession,
+    sessionRestoreTimeoutMs,
     languageCodes
   });
   if (liveVoiceSurfaceAvailable) {
@@ -43258,6 +44098,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     bridge: primaryBridge,
     workspaceRegistry,
     archiveCoordinator,
+    requestedSessionIdAdmission,
     mutate,
     sendBridgeError: sendBridgeError2,
     daemonLog,
@@ -43424,6 +44265,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(
@@ -43454,6 +44296,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")
@@ -43498,6 +44341,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     workspaceRegistry,
     isPrimaryWorkspaceTrusted,
     archiveCoordinator,
+    requestedSessionIdAdmission,
     workspace: primaryWorkspace,
     fsFactory: primaryRouteFileSystemFactory,
     deviceFlowRegistry,