@qwen-code/qwen-code 0.22.0-nightly.20260825.22bb5e8b9f → 0.22.1

package/chunks/{server-7LKYWHCE.js → server-TWXRRREO.js}

@@ -21,13 +21,13 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-W4JA6Z44.js";
+} from "./chunk-KWFP3WV6.js";
 import {
   deriveWebSocketBase,
   openQwenAsrRealtimeStream,
   openVoiceStream,
   openVoiceStreamWithRetry
-} from "./chunk-TEQKBONY.js";
+} from "./chunk-CPPYZHBN.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -39,15 +39,15 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-SNWAXNJ4.js";
+} from "./chunk-HJOWQUE2.js";
 import {
   OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
   ObservedChannelContactStore
-} from "./chunk-DF6DJZIX.js";
+} from "./chunk-4TPAG3O7.js";
 import {
   escapeAnsiCtrlCodes
 } from "./chunk-E7REAOTN.js";
-import "./chunk-QKSMM4HF.js";
+import "./chunk-L436XFLJ.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-TXASDT2M.js";
@@ -128,7 +128,7 @@ import {
   tagListener,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-3N7EFOOM.js";
+} from "./chunk-SQPOJ4ZI.js";
 import "./chunk-VGHZT6JR.js";
 import {
   isValidSessionId,
@@ -139,56 +139,11 @@ import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
 import "./chunk-UXEO7E3V.js";
-import {
-  createTotalSessionAdmissionController
-} from "./chunk-X2UOOG5V.js";
-import {
-  WorkspaceGenerationClosedError,
-  createSingleWorkspaceRegistry,
-  createWorkspaceSessionOwnerIndex
-} from "./chunk-K3LPAED5.js";
-import {
-  isInternalWorkspaceRuntime
-} from "./chunk-NYWWQ437.js";
-import "./chunk-OIBUG24X.js";
-import {
-  MAX_SESSION_RESTORE_TIMEOUT_MS,
-  resolveSessionRestoreTimeoutMs,
-  restoreRetryAfterSeconds
-} from "./chunk-4JRM2BSM.js";
-import {
-  assertValidChannelSecretUpdates
-} from "./chunk-RSOG6JND.js";
-import {
-  createWorkspaceProvidersStatusProvider
-} from "./chunk-GQQHY6TL.js";
-import "./chunk-4K7NQDCG.js";
-import {
-  getAuthTypeFromEnv,
-  resolveCliGenerationConfig
-} from "./chunk-MSCVPOZR.js";
-import {
-  createWorkspaceSkillsStatusProvider
-} from "./chunk-NDVTSFWZ.js";
-import "./chunk-BGXZBI5B.js";
-import {
-  isServeDebugMode,
-  mountWebShellAssets,
-  mountWebShellSpaFallback
-} from "./chunk-DIMEPKCW.js";
-import {
-  require_express
-} from "./chunk-AYHQZBJ4.js";
-import "./chunk-FBX2SDQ4.js";
-import {
-  evaluateDaemonWorkspaceTrust,
-  readDaemonTrustPolicySnapshot
-} from "./chunk-YPJVAQ7V.js";
 import {
   readRecentPromptTerminals,
   reconcileDanglingPromptTerminals,
   withPromptTerminals
-} from "./chunk-SXBRB7ZP.js";
+} from "./chunk-IRIX323G.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   MAX_WORKSPACE_SKILL_NAME_LENGTH,
@@ -202,14 +157,14 @@ import {
   validateWorkspaceSkillName,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-SJDR2S55.js";
+} from "./chunk-MYLXL7F6.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-3K5ORUVO.js";
+} from "./chunk-I32QCIK7.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -217,47 +172,45 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-IX3CWNG7.js";
+} from "./chunk-76WGY6LW.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-7KGJGYGA.js";
-import "./chunk-LNKZTLTH.js";
-import "./chunk-Z4X5MTRT.js";
+} from "./chunk-2MHGD7EE.js";
+import "./chunk-2SERYG4T.js";
 import {
-  WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError,
-  mapWorkspaceSkillToggleError
-} from "./chunk-Z7VOMGDC.js";
+  createTotalSessionAdmissionController
+} from "./chunk-X2UOOG5V.js";
 import {
-  daemonObservedContactsPath,
-  loadChannelsConfig
-} from "./chunk-P7DVAZKV.js";
-import "./chunk-GWUZOBCQ.js";
-import "./chunk-57OAHC2Y.js";
+  WorkspaceGenerationClosedError,
+  createSingleWorkspaceRegistry,
+  createWorkspaceSessionOwnerIndex
+} from "./chunk-K3LPAED5.js";
 import {
-  getStableLiveDiscoveryBaseDir
-} from "./chunk-5MK45KZ3.js";
+  isInternalWorkspaceRuntime
+} from "./chunk-NYWWQ437.js";
+import "./chunk-OIBUG24X.js";
 import {
-  LIVE_HOST_BUNDLE_ID,
-  LIVE_HOST_PROTOCOL_VERSION,
-  LIVE_INPUT_AUDIO_EPOCH_BYTES
-} from "./chunk-NKLP3DCK.js";
+  MAX_SESSION_RESTORE_TIMEOUT_MS,
+  resolveSessionRestoreTimeoutMs,
+  restoreRetryAfterSeconds
+} from "./chunk-4JRM2BSM.js";
+import {
+  assertValidChannelSecretUpdates
+} from "./chunk-6YAR6ZU3.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-OINGLDAX.js";
+} from "./chunk-ODXCSIH5.js";
 import "./chunk-JS73NNWF.js";
-import "./chunk-EEBIINBT.js";
-import {
-  snapshotProcessEnv
-} from "./chunk-HDH5IDJH.js";
+import "./chunk-4DCP3362.js";
+import "./chunk-DCSAVGDJ.js";
 import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge,
   parseSessionSource
-} from "./chunk-KUPVZ4EO.js";
+} from "./chunk-I6YW3T3W.js";
 import {
   EVENT_SCHEMA_VERSION,
   EventBus,
@@ -265,26 +218,74 @@ import {
 } from "./chunk-7U5G6JXI.js";
 import "./chunk-WCCLLK7X.js";
 import "./chunk-OCPBI7J5.js";
+import {
+  createWorkspaceProvidersStatusProvider
+} from "./chunk-NY3IJYAV.js";
+import "./chunk-4K7NQDCG.js";
+import {
+  getAuthTypeFromEnv,
+  resolveCliGenerationConfig
+} from "./chunk-GNRVKN76.js";
+import {
+  snapshotProcessEnv
+} from "./chunk-R2ZJH3FV.js";
+import {
+  createWorkspaceSkillsStatusProvider
+} from "./chunk-BX2BZPFJ.js";
+import "./chunk-BGXZBI5B.js";
+import "./chunk-Z4X5MTRT.js";
+import {
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError,
+  mapWorkspaceSkillToggleError
+} from "./chunk-Z7VOMGDC.js";
+import {
+  isServeDebugMode,
+  mountWebShellAssets,
+  mountWebShellSpaFallback
+} from "./chunk-DIMEPKCW.js";
+import {
+  require_express
+} from "./chunk-AYHQZBJ4.js";
+import "./chunk-FBX2SDQ4.js";
+import {
+  evaluateDaemonWorkspaceTrust,
+  readDaemonTrustPolicySnapshot
+} from "./chunk-5MK32KJV.js";
+import {
+  daemonObservedContactsPath,
+  loadChannelsConfig
+} from "./chunk-SM7ZVKTF.js";
+import "./chunk-A7X32SCT.js";
+import "./chunk-57OAHC2Y.js";
+import {
+  parseChannelWebhookConfigLenient
+} from "./chunk-EAV3TENS.js";
+import "./chunk-7JPW6IYH.js";
+import {
+  supportedChannelCatalog
+} from "./chunk-IKN3IUJP.js";
+import "./chunk-V6WHFGST.js";
+import {
+  getStableLiveDiscoveryBaseDir
+} from "./chunk-5MK45KZ3.js";
+import {
+  LIVE_HOST_BUNDLE_ID,
+  LIVE_HOST_PROTOCOL_VERSION,
+  LIVE_INPUT_AUDIO_EPOCH_BYTES
+} from "./chunk-NKLP3DCK.js";
 import {
   createSpawnChannelFactory
-} from "./chunk-NSPS67BG.js";
+} from "./chunk-GZJUCMH4.js";
 import {
   STATUS_SCHEMA_VERSION,
   SessionRestoreTimeoutError,
   createIdleWorkspaceMemoryStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-HYBEI2LH.js";
+} from "./chunk-CITGRGCM.js";
 import "./chunk-K6KS3LTN.js";
 import "./chunk-HMJ2P3SV.js";
 import "./chunk-7E7UCJHS.js";
-import {
-  parseChannelWebhookConfigLenient
-} from "./chunk-QWTNAHCM.js";
-import "./chunk-XQNWTA4Y.js";
-import {
-  supportedChannelCatalog
-} from "./chunk-SEMN7BNM.js";
-import "./chunk-V6WHFGST.js";
 import {
   MAX_REGISTERED_WORKSPACES,
   WorkspaceDisplayNameValidationError,
@@ -292,13 +293,13 @@ import {
   WorkspaceRegistrationStoreLimitError,
   normalizeWorkspaceDisplayName,
   workspaceRegistrationId
-} from "./chunk-ENZMDVCM.js";
+} from "./chunk-OQ6LTSX3.js";
 import {
   CHANNEL_PROMPT_META_KEY,
   DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
   REQUESTED_SESSION_ID_META_KEY,
   gradeActiveWorkCoverage
-} from "./chunk-LURJYO2T.js";
+} from "./chunk-OZ6KS6KW.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -354,7 +355,7 @@ import {
 } from "./chunk-7CWEZQ6T.js";
 import {
   normalizeWorkerDiagnostic
-} from "./chunk-IFWUT4GY.js";
+} from "./chunk-JVPFTDBK.js";
 import {
   QWEN_SERVER_TOKEN_ENV
 } from "./chunk-GYTKQYDB.js";
@@ -369,7 +370,7 @@ import "./chunk-3VUENPWF.js";
 import "./chunk-5HBA2Z7V.js";
 import {
   sanitizeLogText
-} from "./chunk-NFDTDV37.js";
+} from "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import {
   WORKSPACE_RESTRICTED_SETTING_KEYS,
@@ -381,24 +382,26 @@ import {
   getWritableScopes,
   loadSettings,
   validateSettingValue
-} from "./chunk-YS4H3OFV.js";
+} from "./chunk-MDZO5V2O.js";
 import "./chunk-RKUWKYED.js";
-import "./chunk-AIT6BMBI.js";
+import "./chunk-BDHLBR46.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
 import {
   detectSystemLanguage,
   resolveLanguageSetting
-} from "./chunk-E6BJFSLJ.js";
+} from "./chunk-W2WRNJKX.js";
 import {
   SUPPORTED_LANGUAGES,
   resolveSupportedLanguage
 } from "./chunk-5EJZE3FP.js";
-import "./chunk-FXNLH7E6.js";
+import "./chunk-2CRNTW2B.js";
 import "./chunk-5PA6UEYA.js";
+import "./chunk-6KS24S3X.js";
+import "./chunk-W3N5XAZ6.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-NDJ3436G.js";
+} from "./chunk-XNXWEGKB.js";
 import "./chunk-NPQ5ZKRP.js";
 import {
   isWithinRoot as isWithinRoot2
@@ -428,21 +431,20 @@ import {
   shouldShowStep,
   watchRepoBranch,
   writeWorkspaceContextFile
-} from "./chunk-DLYJ3RN7.js";
-import "./chunk-EJ5XRNOK.js";
-import "./chunk-MGEXTDBI.js";
-import "./chunk-YLFLHKDL.js";
-import "./chunk-HTIG2U5C.js";
+} from "./chunk-VMDURMFY.js";
+import "./chunk-J7MLXFC5.js";
+import "./chunk-LRKMQPMD.js";
 import "./chunk-LJZSMWOH.js";
-import "./chunk-2ZH5XAOO.js";
-import "./chunk-DZPWZPGJ.js";
+import "./chunk-47SIHHPL.js";
+import "./chunk-JLGFGPZJ.js";
+import "./chunk-SKNVVYIJ.js";
 import {
   readWorktreeSession,
   writeWorktreeSession
-} from "./chunk-LD76HNCC.js";
-import "./chunk-F37T2S4O.js";
-import "./chunk-IKPQM6I5.js";
-import "./chunk-V6R3IEHF.js";
+} from "./chunk-UCSV2IZW.js";
+import "./chunk-T2HMXHYA.js";
+import "./chunk-3FSBMAYD.js";
+import "./chunk-XJS54K4A.js";
 import "./chunk-ZPJWUGCS.js";
 import {
   QwenOAuth2Client,
@@ -452,8 +454,8 @@ import {
   isDeviceAuthorizationSuccess,
   isDeviceTokenPending,
   isDeviceTokenSuccess
-} from "./chunk-RLR7K4JJ.js";
-import "./chunk-FZUVUBYH.js";
+} from "./chunk-ZWKGZB2K.js";
+import "./chunk-OX44MOAN.js";
 import {
   BuiltinAgentRegistry,
   Client,
@@ -475,12 +477,16 @@ import {
   SessionOrganizationError,
   SessionOrganizationService,
   SessionService,
+  SessionStorageEntryError,
+  SessionTranscriptChangedError,
   SessionTranscriptCursorCodec,
+  SessionTranscriptIdentityUnavailableError,
   SessionTranscriptPageTooLargeError,
   SessionTranscriptReader,
   SessionTranscriptSnapshotUnavailableError,
   SessionTranscriptTooLargeError,
   SessionWriterError,
+  SessionWriterUnavailableError,
   StandardFileSystemService,
   StdioClientTransport,
   StreamableHTTPClientTransport,
@@ -504,7 +510,7 @@ import {
   sleepInhibitor,
   stripTerminalControlSequences,
   upsertSessionPr
-} from "./chunk-UFWRXRQ5.js";
+} from "./chunk-XYX474JQ.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
@@ -512,12 +518,12 @@ import "./chunk-CQ35AJ4Z.js";
 import {
   MAX_JOBS,
   nextDurableFireMs
-} from "./chunk-J54EA46E.js";
-import "./chunk-PQ4RTSTH.js";
-import "./chunk-3E53DKST.js";
-import "./chunk-DV3KOUUU.js";
+} from "./chunk-3UZCLCXR.js";
+import "./chunk-TOF4UZHH.js";
+import "./chunk-O3BUXIPM.js";
+import "./chunk-ZLTEQYNC.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-R7Q5V3A5.js";
+import "./chunk-AYVIGUUK.js";
 import {
   nextFireTime,
   parseCron
@@ -530,39 +536,39 @@ import {
   readCronTasks,
   taskHasLegacyCondition,
   updateCronTasks
-} from "./chunk-KDGY3ST4.js";
+} from "./chunk-JECO75XD.js";
 import "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
 import {
   GitWorktreeService,
   writeWorktreeSessionMarker
-} from "./chunk-FLTGTSLG.js";
+} from "./chunk-LJP2BBMK.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-NA6AZRDQ.js";
-import "./chunk-ZB7VDPZB.js";
-import "./chunk-CGWPQ6IM.js";
+import "./chunk-5Y2JCJAH.js";
+import "./chunk-T2CRBIDJ.js";
+import "./chunk-77TOMRBG.js";
 import {
   findGitRoot,
   glob
-} from "./chunk-RSWDOHXS.js";
-import "./chunk-5X33EPHJ.js";
-import "./chunk-CPZQJP6J.js";
-import "./chunk-UY2JOZK7.js";
+} from "./chunk-DEYPMJPD.js";
+import "./chunk-T6OODF2U.js";
+import "./chunk-27ONXAFY.js";
+import "./chunk-ZEADBZLO.js";
 import {
   parseGoalControlRequest
-} from "./chunk-WANR3VVK.js";
+} from "./chunk-FN5C6C7G.js";
 import {
   APPROVAL_MODES
-} from "./chunk-3KV5KXKU.js";
+} from "./chunk-BVE5EMIG.js";
 import "./chunk-MLXTMF7H.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-OY3ZSNQC.js";
-import "./chunk-AHQBSQYT.js";
+import "./chunk-FVDQ5E67.js";
+import "./chunk-V3GINY6K.js";
 import "./chunk-QHMLYMMS.js";
 import {
   recordDaemonBridgeError,
   recordDaemonHttpRequest
-} from "./chunk-JS55F2GJ.js";
+} from "./chunk-SDVF6A42.js";
 import "./chunk-P3QQPMQA.js";
 import {
   addDaemonRequestAttribute,
@@ -575,24 +581,24 @@ import {
   recordDaemonHttpResponse,
   runWithDaemonTelemetryContext,
   withDaemonRequestSpan
-} from "./chunk-O5ONGZGZ.js";
+} from "./chunk-ILPXSKGQ.js";
 import "./chunk-XWRJCPHC.js";
 import "./chunk-VNOVK4I7.js";
 import "./chunk-SAH4BD2J.js";
-import "./chunk-CZIF7I53.js";
-import "./chunk-OWE7TE3F.js";
+import "./chunk-ZKAZP2ZG.js";
+import "./chunk-DP7LABIB.js";
 import "./chunk-S6LOFUVP.js";
 import "./chunk-2LD5U7Q3.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-BOQRZ443.js";
+import "./chunk-I6VVOZDK.js";
 import "./chunk-K2OJUPOE.js";
 import "./chunk-CFKIH3D3.js";
-import "./chunk-27HAGBZG.js";
-import "./chunk-JGDTCEBH.js";
+import "./chunk-EB4VDXNI.js";
+import "./chunk-FJWICLG7.js";
 import {
   parseLineTolerant,
   read
-} from "./chunk-EUZE3GSL.js";
+} from "./chunk-UX3IFLJM.js";
 import "./chunk-YRLW2MSX.js";
 import "./chunk-VGC4I5JJ.js";
 import {
@@ -603,41 +609,41 @@ import {
   getAllGeminiMdFilenames,
   isUtf8CompatibleEncoding,
   isWithinRoot
-} from "./chunk-QKGJIP2H.js";
-import "./chunk-MTKBZIXU.js";
-import "./chunk-QQQSUCC4.js";
+} from "./chunk-WBT3STGU.js";
+import "./chunk-PVBT5QPD.js";
+import "./chunk-IPQA4SR5.js";
 import "./chunk-WZAD4ZNJ.js";
 import "./chunk-FPGTNKCP.js";
-import "./chunk-SIC4S3RX.js";
-import "./chunk-O6CS7VRT.js";
+import "./chunk-SLEWBQWM.js";
+import "./chunk-ICWGPK23.js";
 import "./chunk-XZA32HII.js";
-import "./chunk-UEY5WCRB.js";
-import "./chunk-FNZ42WN7.js";
+import "./chunk-7QGEJI7M.js";
+import "./chunk-GTUKW3I6.js";
 import "./chunk-HHJLM3WQ.js";
 import {
   isTelemetrySdkInitialized,
   redactUrlCredentials,
   stripAnsiAndControl
-} from "./chunk-ZJWFRMCY.js";
+} from "./chunk-6US7BF3G.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-DD5XZICM.js";
+import "./chunk-VL4YX3FH.js";
 import {
   SubagentError,
   SubagentErrorCode
-} from "./chunk-COT2IXPM.js";
-import "./chunk-K623ENWT.js";
+} from "./chunk-JUIJ3FXC.js";
+import "./chunk-E6FGMDFQ.js";
 import {
   escapeXml
 } from "./chunk-AQ37AY7B.js";
-import "./chunk-SJLW5XGQ.js";
-import "./chunk-3LUGIYS3.js";
+import "./chunk-RRKNX553.js";
+import "./chunk-KOJ6MHD5.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger,
   getErrorMessage,
   runWithoutDebugLogSession
-} from "./chunk-VLEGGCEA.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   writeStderrLine,
   writeStderrLineSafe,
@@ -3752,6 +3758,17 @@ function resolveWorkspaceRuntimeFromParam(registry, req, res, paramName = "works
   return runtime;
 }
 __name(resolveWorkspaceRuntimeFromParam, "resolveWorkspaceRuntimeFromParam");
+function resolveTrustedRuntime(registry, req, res, paramName = "workspace") {
+  const runtime = resolveWorkspaceRuntimeFromParam(
+    registry,
+    req,
+    res,
+    paramName
+  );
+  if (!runtime) return null;
+  return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
+}
+__name(resolveTrustedRuntime, "resolveTrustedRuntime");
 function resolveWorkspaceRuntimeWithLiveCompatibilityFromParam(registry, req, res, paramName = "workspace") {
   if (typeof registry.getManagedEntryByWorkspaceId !== "function" || typeof registry.getManagedEntryByWorkspaceCwd !== "function") {
     return resolveWorkspaceRuntimeFromParam(registry, req, res, paramName);
@@ -8287,56 +8304,68 @@ function isBoundTask(task) {
   return typeof task.sessionId === "string" && task.sessionId.length > 0;
 }
 __name(isBoundTask, "isBoundTask");
-async function disableTasksForSessions(projectRoot, sessionIds) {
+async function disableTasksForSessions(projectRoot, sessionIds, options = {}) {
   if (sessionIds.length === 0) return;
   const targets = new Set(sessionIds);
-  await updateCronTasks(projectRoot, (tasks) => {
-    let changed = false;
-    const next = tasks.map((task) => {
-      if (isBoundTask(task) && targets.has(task.sessionId) && task.enabled !== false) {
-        changed = true;
-        return { ...task, enabled: false, disabledByArchive: true };
-      }
-      return task;
-    });
-    return changed ? next : tasks;
-  });
+  await updateCronTasks(
+    projectRoot,
+    (tasks) => {
+      let changed = false;
+      const next = tasks.map((task) => {
+        if (isBoundTask(task) && targets.has(task.sessionId) && task.enabled !== false) {
+          changed = true;
+          return { ...task, enabled: false, disabledByArchive: true };
+        }
+        return task;
+      });
+      return changed ? next : tasks;
+    },
+    options
+  );
 }
 __name(disableTasksForSessions, "disableTasksForSessions");
-async function enableTasksForSessions(projectRoot, sessionIds, now = Date.now()) {
+async function enableTasksForSessions(projectRoot, sessionIds, now = Date.now(), options = {}) {
   if (sessionIds.length === 0) return;
   const targets = new Set(sessionIds);
-  await updateCronTasks(projectRoot, (tasks) => {
-    let changed = false;
-    const next = tasks.map((task) => {
-      if (isBoundTask(task) && targets.has(task.sessionId) && task.enabled === false && task.disabledByArchive === true) {
-        changed = true;
-        const resumed = { ...task, enabled: true };
-        delete resumed.disabledByArchive;
-        const minute = now - now % 6e4;
-        if (resumed.recurring) {
-          resumed.lastFiredAt = minute;
-        } else {
-          resumed.createdAt = now;
-          resumed.lastFiredAt = minute;
+  await updateCronTasks(
+    projectRoot,
+    (tasks) => {
+      let changed = false;
+      const next = tasks.map((task) => {
+        if (isBoundTask(task) && targets.has(task.sessionId) && task.enabled === false && task.disabledByArchive === true) {
+          changed = true;
+          const resumed = { ...task, enabled: true };
+          delete resumed.disabledByArchive;
+          const minute = now - now % 6e4;
+          if (resumed.recurring) {
+            resumed.lastFiredAt = minute;
+          } else {
+            resumed.createdAt = now;
+            resumed.lastFiredAt = minute;
+          }
+          return resumed;
         }
-        return resumed;
-      }
-      return task;
-    });
-    return changed ? next : tasks;
-  });
+        return task;
+      });
+      return changed ? next : tasks;
+    },
+    options
+  );
 }
 __name(enableTasksForSessions, "enableTasksForSessions");
-async function removeTasksForSessions(projectRoot, sessionIds) {
+async function removeTasksForSessions(projectRoot, sessionIds, options = {}) {
   if (sessionIds.length === 0) return;
   const targets = new Set(sessionIds);
-  await updateCronTasks(projectRoot, (tasks) => {
-    const next = tasks.filter(
-      (task) => !isBoundTask(task) || !targets.has(task.sessionId)
-    );
-    return next.length === tasks.length ? tasks : next;
-  });
+  await updateCronTasks(
+    projectRoot,
+    (tasks) => {
+      const next = tasks.filter(
+        (task) => !isBoundTask(task) || !targets.has(task.sessionId)
+      );
+      return next.length === tasks.length ? tasks : next;
+    },
+    options
+  );
 }
 __name(removeTasksForSessions, "removeTasksForSessions");
 
@@ -8458,10 +8487,22 @@ async function runWithDaemonWriterLease(params) {
   } = params;
   let lease;
   try {
-    lease = await service.acquireSessionWriterLease(sessionId, {
+    const leaseOptions = {
       processKind: "daemon",
-      reclaimPolicy: "never"
-    });
+      reclaimPolicy: "never",
+      takeoverPolicy: "certified"
+    };
+    try {
+      lease = await service.acquireSessionWriterLease(sessionId, leaseOptions);
+    } catch (error2) {
+      if (!(error2 instanceof SessionWriterUnavailableError) && !(error2 instanceof SessionTranscriptChangedError)) {
+        throw error2;
+      }
+      lease = await service.acquireSessionMaintenanceLease(
+        sessionId,
+        leaseOptions
+      );
+    }
   } catch (error2) {
     return { mutationApplied: false, error: error2 };
   }
@@ -8538,27 +8579,61 @@ function logMaintenanceLeaseReleaseFailure(params) {
 }
 __name(logMaintenanceLeaseReleaseFailure, "logMaintenanceLeaseReleaseFailure");
 async function classifySessionLocation(service, sessionId) {
-  return service.getSessionLocation(sessionId);
+  return service.getMaintainableSessionLocation(sessionId);
 }
 __name(classifySessionLocation, "classifySessionLocation");
 function sessionLocationError(sessionId) {
-  return new Error(`Session archive conflict: ${sessionId}`);
+  const error2 = new SessionConflictError(sessionId);
+  error2.message = `Session "${sessionId}" exists in both active and archived directories. Retry with resolveConflicts: true to keep one copy.`;
+  return error2;
 }
 __name(sessionLocationError, "sessionLocationError");
-function updateScheduledTaskForMaintenance(service, sessionId, action) {
+function updateScheduledTaskForMaintenance(service, sessionId, action, assertCanMutate) {
   if (action === "archive") {
-    return disableTasksForSessions(service.getProjectRoot(), [sessionId]);
+    return disableTasksForSessions(service.getProjectRoot(), [sessionId], {
+      assertCanCommit: assertCanMutate
+    });
   }
   if (action === "unarchive") {
-    return enableTasksForSessions(service.getProjectRoot(), [sessionId]);
+    return enableTasksForSessions(
+      service.getProjectRoot(),
+      [sessionId],
+      Date.now(),
+      { assertCanCommit: assertCanMutate }
+    );
   }
-  return removeTasksForSessions(service.getProjectRoot(), [sessionId]);
+  return removeTasksForSessions(service.getProjectRoot(), [sessionId], {
+    assertCanCommit: assertCanMutate
+  });
 }
 __name(updateScheduledTaskForMaintenance, "updateScheduledTaskForMaintenance");
-async function deletePersistedSessionWithLease(service, sessionId) {
+async function deletePersistedSessionWithLease(service, sessionId, assertCanMutate) {
   const initialLocation = await classifySessionLocation(service, sessionId);
   if (initialLocation === void 0) {
-    return { kind: "notFound", mutationApplied: false };
+    let maintenanceError;
+    try {
+      assertCanMutate?.();
+      await updateScheduledTaskForMaintenance(
+        service,
+        sessionId,
+        "delete",
+        assertCanMutate
+      );
+    } catch (error2) {
+      maintenanceError = error2;
+      logSessionArchiveWarning(
+        `scheduled task lifecycle update failed action=delete workspace=${safeLogValue(
+          service.getProjectRoot()
+        )} session=${safeLogValue(sessionId)} error=${safeLogValue(
+          errorMessage(error2)
+        )}`
+      );
+    }
+    return {
+      kind: "notFound",
+      mutationApplied: false,
+      maintenanceError
+    };
   }
   const mutation = await runWithDaemonWriterLease({
     action: "delete",
@@ -8572,26 +8647,38 @@ async function deletePersistedSessionWithLease(service, sessionId) {
           mutationApplied: false
         };
       }
-      await assertOwnedAndUnchanged();
-      const removed = await service.removeSession(sessionId);
+      const removed = await service.removeSession(sessionId, {
+        assertStorageUnchanged: assertOwnedAndUnchanged,
+        assertCanMutate
+      });
       return {
         value: removed ? "removed" : "notFound",
         mutationApplied: removed
       };
     }, "mutate"),
     mutationAppliedAfterError: /* @__PURE__ */ __name(async () => await classifySessionLocation(service, sessionId) === void 0, "mutationAppliedAfterError"),
-    afterMutationApplied: /* @__PURE__ */ __name(() => updateScheduledTaskForMaintenance(service, sessionId, "delete"), "afterMutationApplied")
+    afterMutationApplied: /* @__PURE__ */ __name(async () => {
+      assertCanMutate?.();
+      await updateScheduledTaskForMaintenance(
+        service,
+        sessionId,
+        "delete",
+        assertCanMutate
+      );
+    }, "afterMutationApplied")
   });
   if (mutation.error !== void 0) {
     return {
       kind: "error",
       error: mutation.error,
-      mutationApplied: mutation.mutationApplied
+      mutationApplied: mutation.mutationApplied,
+      maintenanceError: mutation.maintenanceError
     };
   }
   return {
     kind: mutation.value ?? "notFound",
-    mutationApplied: mutation.mutationApplied
+    mutationApplied: mutation.mutationApplied,
+    maintenanceError: mutation.maintenanceError
   };
 }
 __name(deletePersistedSessionWithLease, "deletePersistedSessionWithLease");
@@ -8602,6 +8689,7 @@ async function deleteDaemonSessions(params) {
     bridge,
     coordinator,
     coordinatorLockHeld = false,
+    assertCanMutate,
     onError
   } = params;
   const uniqueSessionIds = [
@@ -8616,10 +8704,12 @@ async function deleteDaemonSessions(params) {
     uniqueSessionIds.map(async (sessionId) => {
       try {
         const mutateSession = /* @__PURE__ */ __name(async () => {
+          assertCanMutate?.();
           const removePersistedSession = /* @__PURE__ */ __name(async () => {
             const result = await deletePersistedSessionWithLease(
               service,
-              sessionId
+              sessionId,
+              assertCanMutate
             );
             if (result.kind === "error") {
               onError?.({
@@ -8630,7 +8720,13 @@ async function deleteDaemonSessions(params) {
               return result;
             }
             try {
-              await bridge.deleteSessionAttachments(sessionId);
+              if (assertCanMutate) {
+                await bridge.deleteSessionAttachments(sessionId, {
+                  assertCanCommit: assertCanMutate
+                });
+              } else {
+                await bridge.deleteSessionAttachments(sessionId);
+              }
               return result;
             } catch (error2) {
               onError?.({
@@ -8641,7 +8737,8 @@ async function deleteDaemonSessions(params) {
               return {
                 kind: "error",
                 error: error2,
-                mutationApplied: result.mutationApplied
+                mutationApplied: result.mutationApplied,
+                maintenanceError: result.maintenanceError
               };
             }
           }, "removePersistedSession");
@@ -8695,6 +8792,12 @@ async function deleteDaemonSessions(params) {
     } else {
       errors.push({ sessionId, error: errorMessage(result.error) });
     }
+    if (result.maintenanceError !== void 0) {
+      errors.push({
+        sessionId,
+        error: "Scheduled task lifecycle update failed."
+      });
+    }
   }
   return { removed, notFound, errors };
 }
@@ -8840,7 +8943,9 @@ async function archiveDaemonSessions(params) {
     service,
     bridge,
     coordinator,
-    coordinatorLockHeld = false
+    coordinatorLockHeld = false,
+    resolveConflicts = false,
+    assertCanMutate
   } = params;
   const uniqueSessionIds = [
     ...new Set(sessionIds.map(normalizeSessionIdForLookup))
@@ -8854,6 +8959,7 @@ async function archiveDaemonSessions(params) {
     uniqueSessionIds.map(async (sessionId) => {
       try {
         const mutateSession = /* @__PURE__ */ __name(async () => {
+          assertCanMutate?.();
           try {
             await bridge.closeSession(sessionId, void 0, {
               requireAgentClose: true
@@ -8875,12 +8981,31 @@ async function archiveDaemonSessions(params) {
             return { kind: "notFound", mutationApplied: false };
           }
           if (initialLocation === "archived") {
+            let maintenanceError;
+            try {
+              await updateScheduledTaskForMaintenance(
+                service,
+                sessionId,
+                "archive",
+                assertCanMutate
+              );
+            } catch (error2) {
+              maintenanceError = error2;
+              logSessionArchiveWarning(
+                `scheduled task lifecycle update failed action=archive workspace=${safeLogValue(
+                  service.getProjectRoot()
+                )} session=${safeLogValue(sessionId)} error=${safeLogValue(
+                  errorMessage(error2)
+                )}`
+              );
+            }
             return {
               kind: "alreadyArchived",
-              mutationApplied: false
+              mutationApplied: false,
+              maintenanceError
             };
           }
-          if (initialLocation === "conflict") {
+          if (initialLocation === "conflict" && !resolveConflicts) {
             return {
               kind: "error",
               error: sessionLocationError(sessionId),
@@ -8908,17 +9033,18 @@ async function archiveDaemonSessions(params) {
                   mutationApplied: false
                 };
               }
-              if (lockedLocation === "conflict") {
+              if (lockedLocation === "conflict" && !resolveConflicts) {
                 throw sessionLocationError(sessionId);
               }
-              await assertOwnedAndUnchanged();
               const result = await service.archiveSessions([sessionId], {
-                knownLocation: "active"
+                resolveConflicts,
+                assertStorageUnchanged: assertOwnedAndUnchanged,
+                assertCanMutate
               });
               if (result.errors[0]) throw result.errors[0].error;
               if (result.archived.length > 0) {
                 return {
-                  value: "archived",
+                  value: result.resolvedConflicts.length ? "resolvedConflict" : "archived",
                   mutationApplied: true
                 };
               }
@@ -8928,18 +9054,28 @@ async function archiveDaemonSessions(params) {
               };
             }, "mutate"),
             mutationAppliedAfterError: /* @__PURE__ */ __name(async () => await classifySessionLocation(service, sessionId) === "archived", "mutationAppliedAfterError"),
-            afterMutationApplied: /* @__PURE__ */ __name(() => updateScheduledTaskForMaintenance(service, sessionId, "archive"), "afterMutationApplied")
+            afterMutationApplied: /* @__PURE__ */ __name(async () => {
+              assertCanMutate?.();
+              await updateScheduledTaskForMaintenance(
+                service,
+                sessionId,
+                "archive",
+                assertCanMutate
+              );
+            }, "afterMutationApplied")
           });
           if (mutation.error !== void 0) {
             return {
               kind: "error",
               error: mutation.error,
-              mutationApplied: mutation.mutationApplied
+              mutationApplied: mutation.mutationApplied,
+              maintenanceError: mutation.maintenanceError
             };
           }
           return {
             kind: mutation.value ?? "notFound",
-            mutationApplied: mutation.mutationApplied
+            mutationApplied: mutation.mutationApplied,
+            maintenanceError: mutation.maintenanceError
           };
         }, "mutateSession");
         return await (coordinatorLockHeld ? mutateSession() : coordinator.runExclusiveMany([sessionId], mutateSession));
@@ -8958,16 +9094,23 @@ async function archiveDaemonSessions(params) {
   );
   const archived = [];
   const alreadyArchived = [];
+  const resolvedConflicts = [];
   const notFound = [];
   const errors = [];
   for (let i = 0; i < results.length; i++) {
     const sessionId = uniqueSessionIds[i];
     const result = results[i];
     if (result.kind === "archived") archived.push(sessionId);
-    else if (result.kind === "alreadyArchived") {
+    else if (result.kind === "resolvedConflict") {
+      archived.push(sessionId);
+      resolvedConflicts.push(sessionId);
+    } else if (result.kind === "alreadyArchived") {
       alreadyArchived.push(sessionId);
     } else if (result.kind === "notFound") notFound.push(sessionId);
     else errors.push({ sessionId, error: result.error });
+    if ("maintenanceError" in result && result.maintenanceError !== void 0) {
+      errors.push({ sessionId, error: result.maintenanceError });
+    }
   }
   logSessionArchiveResult("archive", {
     requested: uniqueSessionIds,
@@ -8976,7 +9119,13 @@ async function archiveDaemonSessions(params) {
     notFound,
     errors
   });
-  return { archived, alreadyArchived, notFound, errors };
+  return {
+    archived,
+    alreadyArchived,
+    resolvedConflicts,
+    notFound,
+    errors
+  };
 }
 __name(archiveDaemonSessions, "archiveDaemonSessions");
 async function unarchiveDaemonSessions(params) {
@@ -8984,7 +9133,9 @@ async function unarchiveDaemonSessions(params) {
     sessionIds,
     service,
     coordinator,
-    coordinatorLockHeld = false
+    coordinatorLockHeld = false,
+    resolveConflicts = false,
+    assertCanMutate
   } = params;
   const uniqueSessionIds = [
     ...new Set(sessionIds.map(normalizeSessionIdForLookup))
@@ -8998,6 +9149,7 @@ async function unarchiveDaemonSessions(params) {
     uniqueSessionIds.map(async (sessionId) => {
       try {
         const mutateSession = /* @__PURE__ */ __name(async () => {
+          assertCanMutate?.();
           const initialLocation = await classifySessionLocation(
             service,
             sessionId
@@ -9011,7 +9163,8 @@ async function unarchiveDaemonSessions(params) {
               await updateScheduledTaskForMaintenance(
                 service,
                 sessionId,
-                "unarchive"
+                "unarchive",
+                assertCanMutate
               );
             } catch (error2) {
               maintenanceError = error2;
@@ -9029,7 +9182,7 @@ async function unarchiveDaemonSessions(params) {
               maintenanceError
             };
           }
-          if (initialLocation === "conflict") {
+          if (initialLocation === "conflict" && !resolveConflicts) {
             return {
               kind: "error",
               error: sessionLocationError(sessionId),
@@ -9057,17 +9210,18 @@ async function unarchiveDaemonSessions(params) {
                   mutationApplied: false
                 };
               }
-              if (lockedLocation === "conflict") {
+              if (lockedLocation === "conflict" && !resolveConflicts) {
                 throw sessionLocationError(sessionId);
               }
-              await assertOwnedAndUnchanged();
               const result = await service.unarchiveSessions([sessionId], {
-                knownLocation: "archived"
+                resolveConflicts,
+                assertStorageUnchanged: assertOwnedAndUnchanged,
+                assertCanMutate
               });
               if (result.errors[0]) throw result.errors[0].error;
               if (result.unarchived.length > 0) {
                 return {
-                  value: "unarchived",
+                  value: result.resolvedConflicts.length ? "resolvedConflict" : "unarchived",
                   mutationApplied: true
                 };
               }
@@ -9077,17 +9231,22 @@ async function unarchiveDaemonSessions(params) {
               };
             }, "mutate"),
             mutationAppliedAfterError: /* @__PURE__ */ __name(async () => await classifySessionLocation(service, sessionId) === "active", "mutationAppliedAfterError"),
-            afterMutationApplied: /* @__PURE__ */ __name(() => updateScheduledTaskForMaintenance(
-              service,
-              sessionId,
-              "unarchive"
-            ), "afterMutationApplied")
+            afterMutationApplied: /* @__PURE__ */ __name(async () => {
+              assertCanMutate?.();
+              await updateScheduledTaskForMaintenance(
+                service,
+                sessionId,
+                "unarchive",
+                assertCanMutate
+              );
+            }, "afterMutationApplied")
           });
           if (mutation.error !== void 0) {
             return {
               kind: "error",
               error: mutation.error,
-              mutationApplied: mutation.mutationApplied
+              mutationApplied: mutation.mutationApplied,
+              maintenanceError: mutation.maintenanceError
             };
           }
           return {
@@ -9112,13 +9271,17 @@ async function unarchiveDaemonSessions(params) {
   );
   const unarchived = [];
   const alreadyActive = [];
+  const resolvedConflicts = [];
   const notFound = [];
   const errors = [];
   for (let i = 0; i < results.length; i++) {
     const sessionId = uniqueSessionIds[i];
     const result = results[i];
     if (result.kind === "unarchived") unarchived.push(sessionId);
-    else if (result.kind === "alreadyActive") alreadyActive.push(sessionId);
+    else if (result.kind === "resolvedConflict") {
+      unarchived.push(sessionId);
+      resolvedConflicts.push(sessionId);
+    } else if (result.kind === "alreadyActive") alreadyActive.push(sessionId);
     else if (result.kind === "notFound") notFound.push(sessionId);
     else errors.push({ sessionId, error: result.error });
     if (result.maintenanceError !== void 0) {
@@ -9132,7 +9295,13 @@ async function unarchiveDaemonSessions(params) {
     notFound,
     errors
   });
-  return { unarchived, alreadyActive, notFound, errors };
+  return {
+    unarchived,
+    alreadyActive,
+    resolvedConflicts,
+    notFound,
+    errors
+  };
 }
 __name(unarchiveDaemonSessions, "unarchiveDaemonSessions");
 
@@ -9364,6 +9533,9 @@ var TRUSTED_WORKSPACE_METHODS = /* @__PURE__ */ new Set([
   `${QWEN_METHOD_NS}workspace/mcp/resources`,
   `${QWEN_METHOD_NS}workspace/mcp/servers/add`,
   `${QWEN_METHOD_NS}workspace/mcp/servers/remove`,
+  `${QWEN_METHOD_NS}sessions/delete`,
+  `${QWEN_METHOD_NS}sessions/archive`,
+  `${QWEN_METHOD_NS}sessions/unarchive`,
   `${QWEN_METHOD_NS}workspace/agents/list`,
   `${QWEN_METHOD_NS}workspace/agents/get`,
   `${QWEN_METHOD_NS}workspace/agents/create`,
@@ -9393,6 +9565,9 @@ var WORKSPACE_GENERATION_MUTATION_METHODS = /* @__PURE__ */ new Set([
   `${QWEN_METHOD_NS}file/edit`,
   `${QWEN_METHOD_NS}workspace/mcp/servers/add`,
   `${QWEN_METHOD_NS}workspace/mcp/servers/remove`,
+  `${QWEN_METHOD_NS}sessions/delete`,
+  `${QWEN_METHOD_NS}sessions/archive`,
+  `${QWEN_METHOD_NS}sessions/unarchive`,
   `${QWEN_METHOD_NS}workspace/agents/create`,
   `${QWEN_METHOD_NS}workspace/agents/update`,
   `${QWEN_METHOD_NS}workspace/agents/delete`,
@@ -10056,6 +10231,14 @@ var AcpDispatcher = class {
     }
     return [...new Set(sessionIds)];
   }
+  parseResolveConflicts(params) {
+    const value = params["resolveConflicts"];
+    if (value === void 0) return false;
+    if (typeof value !== "boolean") {
+      throw new AcpParamError("`resolveConflicts` must be a boolean");
+    }
+    return value;
+  }
   rejectActiveLiveSessionMutation(conn, id, sessionIds) {
     const activeSessionId = sessionIds.find(
       (sessionId) => this.liveSessionIsolation?.isSessionActive?.(sessionId)
@@ -12945,6 +13128,7 @@ var AcpDispatcher = class {
               service: svc,
               bridge: this.bridge,
               coordinator: this.archiveCoordinator,
+              assertCanMutate: assertGenerationOpen,
               onError: /* @__PURE__ */ __name(({ phase, sessionId, error: error2 }) => {
                 const safeSessionId = logSafe(sessionId.slice(0, 8));
                 const safeMessage = logSafe(error2);
@@ -12954,11 +13138,13 @@ var AcpDispatcher = class {
               }, "onError")
             })
           );
+          assertGenerationOpen?.();
           this.replyConn(conn, id, result);
           return;
         }
         case `${QWEN_METHOD_NS}sessions/archive`: {
           const ids = this.parseSessionIds(params);
+          const resolveConflicts = this.parseResolveConflicts(params);
           if (this.rejectActiveLiveSessionMutation(conn, id, ids)) return;
           const svc = new SessionService(this.boundWorkspace, {
             onWarning: logSessionArchiveWarning
@@ -12969,12 +13155,16 @@ var AcpDispatcher = class {
               sessionIds: ids,
               service: svc,
               bridge: this.bridge,
-              coordinator: this.archiveCoordinator
+              coordinator: this.archiveCoordinator,
+              resolveConflicts,
+              assertCanMutate: assertGenerationOpen
             })
           );
+          assertGenerationOpen?.();
           this.replyConn(conn, id, {
             archived: result.archived,
             alreadyArchived: result.alreadyArchived,
+            resolvedConflicts: result.resolvedConflicts,
             notFound: result.notFound,
             errors: this.serializeSessionErrors(result.errors)
           });
@@ -12982,6 +13172,7 @@ var AcpDispatcher = class {
         }
         case `${QWEN_METHOD_NS}sessions/unarchive`: {
           const ids = this.parseSessionIds(params);
+          const resolveConflicts = this.parseResolveConflicts(params);
           const svc = new SessionService(this.boundWorkspace, {
             onWarning: logSessionArchiveWarning
           });
@@ -12990,12 +13181,16 @@ var AcpDispatcher = class {
             () => unarchiveDaemonSessions({
               sessionIds: ids,
               service: svc,
-              coordinator: this.archiveCoordinator
+              coordinator: this.archiveCoordinator,
+              resolveConflicts,
+              assertCanMutate: assertGenerationOpen
             })
           );
+          assertGenerationOpen?.();
           this.replyConn(conn, id, {
             unarchived: result.unarchived,
             alreadyActive: result.alreadyActive,
+            resolvedConflicts: result.resolvedConflicts,
             notFound: result.notFound,
             errors: this.serializeSessionErrors(result.errors)
           });
@@ -26073,7 +26268,26 @@ function registerSessionRoutes(app, deps) {
     generation.guard.assertOpen();
     return true;
   }, "assertCurrentInternalGeneration");
-  const resolveQualifiedSessionRuntime = /* @__PURE__ */ __name(async (req, res, route, sessionIds, archiveState) => {
+  const hasLifecycleStorageEvidence = /* @__PURE__ */ __name(async (service, sessionId) => {
+    try {
+      return await service.getMaintainableSessionLocation(sessionId) !== void 0;
+    } catch (error2) {
+      if (error2 instanceof SessionStorageEntryError) {
+        return error2.reason !== "foreign_project";
+      }
+      if (error2 instanceof SessionTranscriptIdentityUnavailableError) {
+        return true;
+      }
+      if (error2 instanceof SessionTranscriptChangedError) {
+        return true;
+      }
+      if (error2 !== null && typeof error2 === "object" && typeof error2.code === "string") {
+        return true;
+      }
+      throw error2;
+    }
+  }, "hasLifecycleStorageEvidence");
+  const resolveQualifiedSessionRuntime = /* @__PURE__ */ __name(async (req, res, route, sessionIds, archiveState, options = {}) => {
     const target = resolveQualifiedSessionTarget(req, res);
     if (!target) return void 0;
     if (target.kind === "ordinary") return target.runtime;
@@ -26086,6 +26300,12 @@ function registerSessionRoutes(app, deps) {
     const runtime = generation.runtime;
     const service = createWorkspaceRuntimeSessionService(runtime);
     for (const sessionId of sessionIds) {
+      if (options.lifecycleMaintenance) {
+        if (!await hasLifecycleStorageEvidence(service, sessionId)) {
+          throw new SessionNotFoundError(sessionId);
+        }
+        continue;
+      }
       const location = await service.getSessionLocation(sessionId);
       if (location === "conflict") {
         if (archiveState !== "active") {
@@ -26678,20 +26898,42 @@ function registerSessionRoutes(app, deps) {
   }, "resolveSessionAnyStateRuntime");
   const resolveSessionBatchRuntime = /* @__PURE__ */ __name(async (req, res, route, sessionIds) => {
     if (req) {
-      return resolveQualifiedSessionRuntime(req, res, route, sessionIds, "any");
+      return resolveQualifiedSessionRuntime(
+        req,
+        res,
+        route,
+        sessionIds,
+        "any",
+        { lifecycleMaintenance: true }
+      );
     }
     let internalRuntime;
     let hasInternalSession = false;
-    const hasOrdinarySession = /* @__PURE__ */ __name(async (sessionId) => {
-      for (const runtime of workspaceRegistry.list()) {
-        if (await createWorkspaceRuntimeSessionService(
-          runtime
-        ).sessionExistsInAnyState(sessionId)) {
-          return true;
+    let hasOrdinaryLiveSession = false;
+    const findOrdinarySessions = /* @__PURE__ */ __name(async (sessionId) => {
+      const runtimes = /* @__PURE__ */ new Set();
+      for (const entry of workspaceRegistry.listAllEntries()) {
+        const generation2 = entry.current;
+        if (entry.internal || !generation2) continue;
+        if (entry.state !== "active" || entry.current !== generation2 || generation2.guard.closed) {
+          sendWorkspaceRuntimeUnavailable(res);
+          return void 0;
+        }
+        generation2.guard.assertOpen();
+        const exists = await hasLifecycleStorageEvidence(
+          createWorkspaceRuntimeSessionService(generation2.runtime),
+          sessionId
+        );
+        if (entry.state !== "active" || entry.current !== generation2 || generation2.guard.closed) {
+          sendWorkspaceRuntimeUnavailable(res);
+          return void 0;
         }
+        if (!exists) continue;
+        generation2.guard.assertOpen();
+        runtimes.add(generation2.runtime);
       }
-      return false;
-    }, "hasOrdinarySession");
+      return runtimes;
+    }, "findOrdinarySessions");
     const sendBatchWorkspaceConflict = /* @__PURE__ */ __name(() => {
       res.status(409).json({
         error: "All sessions in this operation must share one workspace.",
@@ -26700,17 +26942,28 @@ function registerSessionRoutes(app, deps) {
     }, "sendBatchWorkspaceConflict");
     for (const sessionId of sessionIds) {
       const candidates = /* @__PURE__ */ new Set();
+      const ordinaryLiveCandidates = /* @__PURE__ */ new Set();
       const owner = workspaceRegistry.resolveLiveSessionOwner(sessionId);
       if (owner.kind === "unavailable") {
         sendWorkspaceRuntimeUnavailable(res);
         return void 0;
       }
-      if (owner.kind === "found" && isInternalWorkspaceRuntime(owner.runtime)) {
-        candidates.add(owner.runtime);
+      if (owner.kind === "found") {
+        if (isInternalWorkspaceRuntime(owner.runtime)) {
+          candidates.add(owner.runtime);
+        } else {
+          ordinaryLiveCandidates.add(owner.runtime);
+          hasOrdinaryLiveSession = true;
+        }
       }
       if (owner.kind === "ambiguous") {
         for (const runtime of owner.runtimes) {
-          if (isInternalWorkspaceRuntime(runtime)) candidates.add(runtime);
+          if (isInternalWorkspaceRuntime(runtime)) {
+            candidates.add(runtime);
+          } else {
+            ordinaryLiveCandidates.add(runtime);
+            hasOrdinaryLiveSession = true;
+          }
         }
       }
       for (const entry of workspaceRegistry.listAllEntries()) {
@@ -26721,32 +26974,32 @@ function registerSessionRoutes(app, deps) {
         }
         const runtime = generation2.runtime;
         const service = createWorkspaceRuntimeSessionService(runtime);
-        const exists = await service.sessionExistsInAnyState(sessionId);
+        const exists = await hasLifecycleStorageEvidence(service, sessionId);
         if (!assertCurrentInternalGeneration(entry, generation2, res)) {
           return void 0;
         }
         if (!exists) continue;
-        const metadata = await readLoadableLiveConversationMetadata(
-          sessionId,
-          service
-        );
-        if (!assertCurrentInternalGeneration(entry, generation2, res)) {
-          return void 0;
-        }
-        if (!metadata) continue;
         candidates.add(runtime);
       }
-      if (candidates.size > 0) {
-        for (const runtime of workspaceRegistry.list()) {
-          const service = createWorkspaceRuntimeSessionService(runtime);
-          if (await service.sessionExistsInAnyState(sessionId)) {
-            candidates.add(runtime);
-          }
+      if (candidates.size > 0 || hasInternalSession) {
+        if (hasOrdinaryLiveSession && ordinaryLiveCandidates.size === 0) {
+          sendBatchWorkspaceConflict();
+          return void 0;
+        }
+        for (const runtime of ordinaryLiveCandidates) {
+          candidates.add(runtime);
+        }
+        const ordinarySessions = await findOrdinarySessions(sessionId);
+        if (!ordinarySessions) return void 0;
+        for (const runtime of ordinarySessions) {
+          candidates.add(runtime);
         }
       }
       if (candidates.size === 0) {
         if (hasInternalSession) {
-          if (await hasOrdinarySession(sessionId)) {
+          const ordinarySessions = await findOrdinarySessions(sessionId);
+          if (!ordinarySessions) return void 0;
+          if (ordinarySessions.size > 0) {
             sendBatchWorkspaceConflict();
             return void 0;
           }
@@ -26773,20 +27026,15 @@ function registerSessionRoutes(app, deps) {
     }
     for (const sessionId of sessionIds) {
       const service = createWorkspaceRuntimeSessionService(internalRuntime);
-      if (!await service.sessionExistsInAnyState(sessionId)) {
-        if (await hasOrdinarySession(sessionId)) {
+      if (!await hasLifecycleStorageEvidence(service, sessionId)) {
+        const ordinarySessions = await findOrdinarySessions(sessionId);
+        if (!ordinarySessions) return void 0;
+        if (ordinarySessions.size > 0) {
           sendBatchWorkspaceConflict();
           return void 0;
         }
         throw new SessionNotFoundError(sessionId);
       }
-      const metadata = await readLoadableLiveConversationMetadata(
-        sessionId,
-        service
-      );
-      if (!metadata) {
-        throw new SessionNotFoundError(sessionId);
-      }
     }
     const internalEntry = workspaceRegistry.getManagedEntryByWorkspaceCwd(
       internalRuntime.workspaceCwd
@@ -26819,6 +27067,16 @@ function registerSessionRoutes(app, deps) {
     }
     return [...new Set(sessionIds)];
   }, "parseSessionIdsBody");
+  const parseResolveConflicts = /* @__PURE__ */ __name((req, res) => {
+    const value = safeBody(req)["resolveConflicts"];
+    if (value === void 0) return false;
+    if (typeof value === "boolean") return value;
+    res.status(400).json({
+      error: "`resolveConflicts` must be a boolean",
+      code: "invalid_request"
+    });
+    return void 0;
+  }, "parseResolveConflicts");
   const hasControlCharacter = /* @__PURE__ */ __name((value) => Array.from(value).some((character) => {
     const code = character.charCodeAt(0);
     return code <= 31 || code === 127;
@@ -26843,7 +27101,7 @@ function registerSessionRoutes(app, deps) {
   }, "parseSessionPrBody");
   const serializeSessionErrors = /* @__PURE__ */ __name((errors, redactDetails = false) => errors.map((e) => ({
     sessionId: e.sessionId,
-    error: redactDetails ? "Session operation failed." : e.error instanceof Error ? e.error.message : String(e.error)
+    error: redactDetails && !(e.error instanceof SessionConflictError) ? "Session operation failed." : e.error instanceof Error ? e.error.message : String(e.error)
   })), "serializeSessionErrors");
   const runResolvedSessionBatch = /* @__PURE__ */ __name(async (params) => {
     const { req, res, route, sessionIds, run: run2 } = params;
@@ -26869,14 +27127,18 @@ function registerSessionRoutes(app, deps) {
         sendWorkspaceRuntimeUnavailable(res);
         return void 0;
       }
-      return { result: await run2(verifiedRuntime, true), internal: true };
+      return {
+        result: await run2(verifiedRuntime, true),
+        internal: isInternalWorkspaceRuntime(verifiedRuntime)
+      };
     });
   }, "runResolvedSessionBatch");
   const deleteSessions = /* @__PURE__ */ __name((req, res, route, sessionIds) => {
     const run2 = /* @__PURE__ */ __name(async (runtime, coordinatorLockHeld) => {
-      captureRuntimeGenerationAssertion(runtime)?.();
+      const assertCanMutate = captureRuntimeGenerationAssertion(runtime);
+      assertCanMutate?.();
       const service = createWorkspaceRuntimeSessionService(runtime);
-      return runWithSessionListInvalidation(
+      const result = await runWithSessionListInvalidation(
         runtime,
         ["active", "archived"],
         () => runWithWorkspaceRuntimeStorage(
@@ -26887,6 +27149,7 @@ function registerSessionRoutes(app, deps) {
             bridge: runtime.bridge,
             coordinator: archiveCoordinator,
             coordinatorLockHeld,
+            assertCanMutate,
             onError: /* @__PURE__ */ __name(({ phase, sessionId, error: error2 }) => {
               writeStderrLine(
                 `qwen serve: ${phase}Session failed for ${safeLogValue(sessionId)}: ${safeLogValue(error2)}`
@@ -26895,16 +27158,19 @@ function registerSessionRoutes(app, deps) {
           })
         )
       );
+      assertCanMutate?.();
+      return result;
     }, "run");
     return runResolvedSessionBatch({ req, res, route, sessionIds, run: run2 });
   }, "deleteSessions");
-  const archiveSessions = /* @__PURE__ */ __name((req, res, route, sessionIds) => {
+  const archiveSessions = /* @__PURE__ */ __name((req, res, route, sessionIds, resolveConflicts = false) => {
     const run2 = /* @__PURE__ */ __name(async (runtime, coordinatorLockHeld) => {
-      captureRuntimeGenerationAssertion(runtime)?.();
+      const assertCanMutate = captureRuntimeGenerationAssertion(runtime);
+      assertCanMutate?.();
       const service = createWorkspaceRuntimeSessionService(runtime, {
         onWarning: logSessionArchiveWarning
       });
-      return runWithSessionListInvalidation(
+      const result = await runWithSessionListInvalidation(
         runtime,
         ["active", "archived"],
         () => runWithWorkspaceRuntimeStorage(
@@ -26914,20 +27180,25 @@ function registerSessionRoutes(app, deps) {
             service,
             bridge: runtime.bridge,
             coordinator: archiveCoordinator,
-            coordinatorLockHeld
+            coordinatorLockHeld,
+            resolveConflicts,
+            assertCanMutate
           })
         )
       );
+      assertCanMutate?.();
+      return result;
     }, "run");
     return runResolvedSessionBatch({ req, res, route, sessionIds, run: run2 });
   }, "archiveSessions");
-  const unarchiveSessions = /* @__PURE__ */ __name((req, res, route, sessionIds) => {
+  const unarchiveSessions = /* @__PURE__ */ __name((req, res, route, sessionIds, resolveConflicts = false) => {
     const run2 = /* @__PURE__ */ __name(async (runtime, coordinatorLockHeld) => {
-      captureRuntimeGenerationAssertion(runtime)?.();
+      const assertCanMutate = captureRuntimeGenerationAssertion(runtime);
+      assertCanMutate?.();
       const service = createWorkspaceRuntimeSessionService(runtime, {
         onWarning: logSessionArchiveWarning
       });
-      return runWithSessionListInvalidation(
+      const result = await runWithSessionListInvalidation(
         runtime,
         ["active", "archived"],
         () => runWithWorkspaceRuntimeStorage(
@@ -26936,10 +27207,14 @@ function registerSessionRoutes(app, deps) {
             sessionIds,
             service,
             coordinator: archiveCoordinator,
-            coordinatorLockHeld
+            coordinatorLockHeld,
+            resolveConflicts,
+            assertCanMutate
           })
         )
       );
+      assertCanMutate?.();
+      return result;
     }, "run");
     return runResolvedSessionBatch({ req, res, route, sessionIds, run: run2 });
   }, "unarchiveSessions");
@@ -29217,19 +29492,23 @@ function registerSessionRoutes(app, deps) {
   app.post("/sessions/archive", mutate(), async (req, res) => {
     const uniqueIds = parseSessionIdsBody(req, res);
     if (uniqueIds === void 0) return;
+    const resolveConflicts = parseResolveConflicts(req, res);
+    if (resolveConflicts === void 0) return;
     if (rejectActiveLiveSessionMutation(res, uniqueIds)) return;
     try {
       const operation = await archiveSessions(
         void 0,
         res,
         "POST /sessions/archive",
-        uniqueIds
+        uniqueIds,
+        resolveConflicts
       );
       if (!operation) return;
       const { result } = operation;
       res.status(200).json({
         archived: result.archived,
         alreadyArchived: result.alreadyArchived,
+        resolvedConflicts: result.resolvedConflicts,
         notFound: result.notFound,
         errors: serializeSessionErrors(result.errors, operation.internal)
       });
@@ -29240,18 +29519,22 @@ function registerSessionRoutes(app, deps) {
   app.post("/sessions/unarchive", mutate(), async (req, res) => {
     const uniqueIds = parseSessionIdsBody(req, res);
     if (uniqueIds === void 0) return;
+    const resolveConflicts = parseResolveConflicts(req, res);
+    if (resolveConflicts === void 0) return;
     try {
       const operation = await unarchiveSessions(
         void 0,
         res,
         "POST /sessions/unarchive",
-        uniqueIds
+        uniqueIds,
+        resolveConflicts
       );
       if (!operation) return;
       const { result } = operation;
       res.status(200).json({
         unarchived: result.unarchived,
         alreadyActive: result.alreadyActive,
+        resolvedConflicts: result.resolvedConflicts,
         notFound: result.notFound,
         errors: serializeSessionErrors(result.errors, operation.internal)
       });
@@ -29292,14 +29575,23 @@ function registerSessionRoutes(app, deps) {
       const route = "POST /workspaces/:workspace/sessions/archive";
       const uniqueIds = parseSessionIdsBody(req, res);
       if (uniqueIds === void 0) return;
+      const resolveConflicts = parseResolveConflicts(req, res);
+      if (resolveConflicts === void 0) return;
       if (rejectActiveLiveSessionMutation(res, uniqueIds)) return;
       try {
-        const operation = await archiveSessions(req, res, route, uniqueIds);
+        const operation = await archiveSessions(
+          req,
+          res,
+          route,
+          uniqueIds,
+          resolveConflicts
+        );
         if (!operation) return;
         const { result } = operation;
         res.status(200).json({
           archived: result.archived,
           alreadyArchived: result.alreadyArchived,
+          resolvedConflicts: result.resolvedConflicts,
           notFound: result.notFound,
           errors: serializeSessionErrors(result.errors, operation.internal)
         });
@@ -29315,13 +29607,22 @@ function registerSessionRoutes(app, deps) {
       const route = "POST /workspaces/:workspace/sessions/unarchive";
       const uniqueIds = parseSessionIdsBody(req, res);
       if (uniqueIds === void 0) return;
+      const resolveConflicts = parseResolveConflicts(req, res);
+      if (resolveConflicts === void 0) return;
       try {
-        const operation = await unarchiveSessions(req, res, route, uniqueIds);
+        const operation = await unarchiveSessions(
+          req,
+          res,
+          route,
+          uniqueIds,
+          resolveConflicts
+        );
         if (!operation) return;
         const { result } = operation;
         res.status(200).json({
           unarchived: result.unarchived,
           alreadyActive: result.alreadyActive,
+          resolvedConflicts: result.resolvedConflicts,
           notFound: result.notFound,
           errors: serializeSessionErrors(result.errors, operation.internal)
         });
@@ -32464,12 +32765,6 @@ function registerWorkspaceStatusRoutes(app, deps) {
   });
 }
 __name(registerWorkspaceStatusRoutes, "registerWorkspaceStatusRoutes");
-function resolveTrustedRuntime(registry, req, res) {
-  const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
-  if (!runtime) return null;
-  return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
-}
-__name(resolveTrustedRuntime, "resolveTrustedRuntime");
 function registerWorkspaceQualifiedStatusRoutes(app, deps) {
   const { workspaceRegistry, sendBridgeError: sendBridgeError2 } = deps;
   app.get("/workspaces/:workspace/mcp", async (req, res) => {
@@ -37493,15 +37788,9 @@ function registerWorkspaceGitRoutes(app, deps) {
   });
 }
 __name(registerWorkspaceGitRoutes, "registerWorkspaceGitRoutes");
-function resolveTrustedRuntime2(registry, req, res) {
-  const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
-  if (!runtime) return null;
-  return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
-}
-__name(resolveTrustedRuntime2, "resolveTrustedRuntime");
 function registerWorkspaceQualifiedGitRoutes(app, deps) {
   app.get("/workspaces/:workspace/git", async (req, res) => {
-    const runtime = resolveTrustedRuntime2(deps.workspaceRegistry, req, res);
+    const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
     if (!runtime) return;
     const route = "GET /workspaces/:workspace/git";
     try {
@@ -37677,15 +37966,9 @@ function registerWorkspaceGitDiffRoutes(app, deps) {
   });
 }
 __name(registerWorkspaceGitDiffRoutes, "registerWorkspaceGitDiffRoutes");
-function resolveTrustedRuntime3(registry, req, res) {
-  const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
-  if (!runtime) return null;
-  return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
-}
-__name(resolveTrustedRuntime3, "resolveTrustedRuntime");
 function registerWorkspaceQualifiedGitDiffRoutes(app, deps) {
   app.get("/workspaces/:workspace/git/diff", (req, res) => {
-    const runtime = resolveTrustedRuntime3(deps.workspaceRegistry, req, res);
+    const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
     if (!runtime) return;
     void handleDiffList(
       res,
@@ -37696,7 +37979,7 @@ function registerWorkspaceQualifiedGitDiffRoutes(app, deps) {
     );
   });
   app.get("/workspaces/:workspace/git/diff/file", (req, res) => {
-    const runtime = resolveTrustedRuntime3(deps.workspaceRegistry, req, res);
+    const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
     if (!runtime) return;
     void handleDiffFile(
       req,
@@ -37837,15 +38120,9 @@ function registerWorkspaceGitLogRoutes(app, deps) {
   });
 }
 __name(registerWorkspaceGitLogRoutes, "registerWorkspaceGitLogRoutes");
-function resolveTrustedRuntime4(registry, req, res) {
-  const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
-  if (!runtime) return null;
-  return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
-}
-__name(resolveTrustedRuntime4, "resolveTrustedRuntime");
 function registerWorkspaceQualifiedGitLogRoutes(app, deps) {
   app.get("/workspaces/:workspace/git/log", (req, res) => {
-    const runtime = resolveTrustedRuntime4(deps.workspaceRegistry, req, res);
+    const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
     if (!runtime) return;
     void handleLogList(
       req,
@@ -37856,7 +38133,7 @@ function registerWorkspaceQualifiedGitLogRoutes(app, deps) {
     );
   });
   app.get("/workspaces/:workspace/git/log/commit", (req, res) => {
-    const runtime = resolveTrustedRuntime4(deps.workspaceRegistry, req, res);
+    const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
     if (!runtime) return;
     void handleCommitDetail(
       req,
@@ -37872,12 +38149,6 @@ __name(registerWorkspaceQualifiedGitLogRoutes, "registerWorkspaceQualifiedGitLog
 // packages/cli/src/serve/routes/workspace-git-branches.ts
 init_esbuild_shims();
 var GIT_ERROR_MESSAGE_MAX = 512;
-function resolveTrustedRuntime5(registry, req, res) {
-  const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
-  if (!runtime) return null;
-  return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
-}
-__name(resolveTrustedRuntime5, "resolveTrustedRuntime");
 function sendGitError(res, err, route, sendBridgeError2, cwd) {
   let detail;
   if (err && typeof err === "object" && ("stdout" in err || "stderr" in err)) {
@@ -38186,7 +38457,7 @@ function registerWorkspaceGitBranchRoutes(app, deps) {
 __name(registerWorkspaceGitBranchRoutes, "registerWorkspaceGitBranchRoutes");
 function registerWorkspaceQualifiedGitBranchRoutes(app, deps) {
   app.get("/workspaces/:workspace/git/branches", (req, res) => {
-    const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+    const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
     if (!runtime) return;
     void handleBranches(
       res,
@@ -38201,7 +38472,7 @@ function registerWorkspaceQualifiedGitBranchRoutes(app, deps) {
     "/workspaces/:workspace/git/checkout",
     deps.mutate({ strict: true }),
     (req, res) => {
-      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
       if (!runtime) return;
       try {
         runtime.generationGuard?.assertOpen();
@@ -38234,7 +38505,7 @@ function registerWorkspaceQualifiedGitBranchRoutes(app, deps) {
     "/workspaces/:workspace/git/branch",
     deps.mutate({ strict: true }),
     (req, res) => {
-      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
       if (!runtime) return;
       try {
         runtime.generationGuard?.assertOpen();
@@ -38267,7 +38538,7 @@ function registerWorkspaceQualifiedGitBranchRoutes(app, deps) {
     "/workspaces/:workspace/git/push",
     deps.mutate({ strict: true }),
     (req, res) => {
-      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
       if (!runtime) return;
       try {
         runtime.generationGuard?.assertOpen();
@@ -38300,7 +38571,7 @@ function registerWorkspaceQualifiedGitBranchRoutes(app, deps) {
     "/workspaces/:workspace/git/pull",
     deps.mutate({ strict: true }),
     (req, res) => {
-      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
       if (!runtime) return;
       try {
         runtime.generationGuard?.assertOpen();
@@ -38333,7 +38604,7 @@ function registerWorkspaceQualifiedGitBranchRoutes(app, deps) {
     "/workspaces/:workspace/git/commit",
     deps.mutate({ strict: true }),
     (req, res) => {
-      const runtime = resolveTrustedRuntime5(deps.workspaceRegistry, req, res);
+      const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
       if (!runtime) return;
       try {
         runtime.generationGuard?.assertOpen();