@qwen-code/qwen-code 0.19.3-nightly.20260701.a974594d7 → 0.19.4

package/chunks/{server-P4YIH35I.js → server-4AGEK2HC.js}

@@ -1,34 +1,93 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
+  MAX_REMEMBER_CONTENT_BYTES,
+  extractRememberErrorCode,
   isValidServerName
-} from "./chunk-UAKXW3DN.js";
+} from "./chunk-RM3PGSGL.js";
 import {
   openQwenAsrRealtimeStream,
   openVoiceStream,
   openVoiceStreamWithRetry
-} from "./chunk-V5YJAUHW.js";
+} from "./chunk-CUGEBAKG.js";
 import {
   SetupGithubError,
   setupGithub
-} from "./chunk-Q3JOGB4U.js";
-import "./chunk-M2U5NM24.js";
-import "./chunk-GDIG7TMG.js";
+} from "./chunk-L7QPM2YD.js";
+import "./chunk-54YZOP7P.js";
+import "./chunk-HRZB5CSC.js";
+import {
+  CAPABILITIES_SCHEMA_VERSION,
+  CLIENT_ID_HEADER,
+  CLIENT_ID_RE,
+  ClientMcpSenderRegistry,
+  DeviceFlowRegistry,
+  MAX_CLIENT_ID_LENGTH,
+  MAX_SERVER_NAME_LENGTH,
+  MAX_TOOL_NAME_LENGTH,
+  TooManyActiveDeviceFlowsError,
+  UnsupportedDeviceFlowProviderError,
+  UpstreamDeviceFlowError,
+  allowOriginCors,
+  bearerAuth,
+  brandSecret,
+  buildDaemonStatusResponse,
+  createBridgeFileSystemAdapter,
+  createBuildWorkspaceCtx,
+  createClientMcpServerProvider,
+  createMutationGate,
+  createRateLimiter,
+  denyBrowserOriginCors,
+  detectFromLoopback,
+  getAdvertisedServeFeatures,
+  getServeProtocolVersions,
+  hostAllowlist,
+  parseAllowOriginPatterns,
+  parseAndValidateWorkspaceClientId,
+  parseClientIdHeader,
+  parseDaemonStatusDetail,
+  parseLastEventId,
+  parseMaxQueuedQuery,
+  parseOptionalWorkspaceCwd,
+  parsePermissionVoteBody,
+  requireSessionId,
+  require_express,
+  safeBody,
+  safeLogValue,
+  sanitizeForStderr,
+  sendJsonBodyParserError,
+  setDeviceFlowRegistry,
+  setRateLimiter,
+  unsafeRevealSecret,
+  validateMcpRuntimeServerName
+} from "./chunk-B7KGXIPZ.js";
+import {
+  isLoopbackBind
+} from "./chunk-RNBYOUGV.js";
+import "./chunk-3HX5LZ6R.js";
+import "./chunk-7RYW5LQV.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-FR3II765.js";
-import "./chunk-G525INVW.js";
+} from "./chunk-6CIIP6OE.js";
+import "./chunk-W2ZOAX7F.js";
 import "./chunk-KHDZHZMH.js";
+import "./chunk-W6X4FGWX.js";
 import {
   createAcpSessionBridge
-} from "./chunk-FV4SQ54H.js";
+} from "./chunk-KVPFPC4J.js";
+import "./chunk-EWALXUAD.js";
+import {
+  EVENT_SCHEMA_VERSION,
+  SubscriberLimitExceededError
+} from "./chunk-ALX6BUYW.js";
+import "./chunk-YBDZ63KI.js";
 import {
   createWorkspaceProvidersStatusProvider
-} from "./chunk-4722VFFU.js";
+} from "./chunk-L7VH7HQA.js";
 import {
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-OEY3YAL2.js";
+} from "./chunk-BQNJBEUA.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   WorkspaceVoiceError,
@@ -39,14 +98,14 @@ import {
   transcribeWorkspaceVoiceAudio,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-JERW36RG.js";
+} from "./chunk-UT5JU5DJ.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-DBR7PF4B.js";
+} from "./chunk-QAFQLTXG.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -54,12 +113,12 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-T44AF4I6.js";
+} from "./chunk-BNJLLAQ7.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-LXEW6BHF.js";
+} from "./chunk-Q7VHIRDD.js";
 import "./chunk-NIOPRZNN.js";
 import "./chunk-P7M4GA57.js";
 import {
@@ -77,7 +136,10 @@ import {
   PermissionPolicyNotImplementedError,
   PromptQueueFullError,
   RestoreInProgressError,
+  SessionArchivedError,
+  SessionArchivingError,
   SessionBusyError,
+  SessionConflictError,
   SessionLimitExceededError,
   SessionNotFoundError,
   SessionShellClientRequiredError,
@@ -87,91 +149,36 @@ import {
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
-} from "./chunk-DHXWNSJA.js";
-import {
-  WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError
-} from "./chunk-BMFMJINR.js";
-import {
-  CAPABILITIES_SCHEMA_VERSION,
-  CLIENT_ID_HEADER,
-  CLIENT_ID_RE,
-  ClientMcpSenderRegistry,
-  DeviceFlowRegistry,
-  MAX_CLIENT_ID_LENGTH,
-  MAX_SERVER_NAME_LENGTH,
-  MAX_TOOL_NAME_LENGTH,
-  TooManyActiveDeviceFlowsError,
-  UnsupportedDeviceFlowProviderError,
-  UpstreamDeviceFlowError,
-  allowOriginCors,
-  bearerAuth,
-  brandSecret,
-  buildDaemonStatusResponse,
-  createBridgeFileSystemAdapter,
-  createBuildWorkspaceCtx,
-  createClientMcpServerProvider,
-  createMutationGate,
-  createRateLimiter,
-  denyBrowserOriginCors,
-  detectFromLoopback,
-  getAdvertisedServeFeatures,
-  getServeProtocolVersions,
-  hostAllowlist,
-  isLoopbackBind,
-  parseAllowOriginPatterns,
-  parseAndValidateWorkspaceClientId,
-  parseClientIdHeader,
-  parseDaemonStatusDetail,
-  parseLastEventId,
-  parseMaxQueuedQuery,
-  parseOptionalWorkspaceCwd,
-  parsePermissionVoteBody,
-  requireSessionId,
-  require_express,
-  safeBody,
-  safeLogValue,
-  sanitizeForStderr,
-  sendJsonBodyParserError,
-  setDeviceFlowRegistry,
-  setRateLimiter,
-  unsafeRevealSecret,
-  validateMcpRuntimeServerName
-} from "./chunk-MTJVHQDP.js";
-import "./chunk-3HX5LZ6R.js";
-import "./chunk-7RYW5LQV.js";
-import "./chunk-HIYUAXBG.js";
-import "./chunk-EWALXUAD.js";
+} from "./chunk-T22H4V4R.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace
 } from "./chunk-SEZC2725.js";
 import {
-  EVENT_SCHEMA_VERSION,
-  SubscriberLimitExceededError
-} from "./chunk-ALX6BUYW.js";
+  STATUS_SCHEMA_VERSION,
+  createIdleWorkspaceMemoryStatus,
+  mapDomainErrorToErrorKind
+} from "./chunk-GICCHL2Q.js";
+import {
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError
+} from "./chunk-BMFMJINR.js";
 import {
   getDialogSettingKeys,
   getNestedProperty,
   getSettingDefinition,
   loadSettings,
   validateSettingValue
-} from "./chunk-6FIWYVN4.js";
+} from "./chunk-MKHC4BYZ.js";
 import {
   SUPPORTED_LANGUAGES
-} from "./chunk-3O2BJMFW.js";
+} from "./chunk-UQYOMM6J.js";
 import "./chunk-TLRYABYP.js";
-import "./chunk-KXVVXAAC.js";
 import "./chunk-UFC57OYT.js";
-import {
-  STATUS_SCHEMA_VERSION,
-  createIdleWorkspaceMemoryStatus,
-  mapDomainErrorToErrorKind
-} from "./chunk-VHRREANT.js";
 import "./chunk-PPFWEV7G.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-Z34RYLRO.js";
+} from "./chunk-ZJP5T7IA.js";
 import {
   writeStderrLine
 } from "./chunk-Y6Z2O3WR.js";
@@ -185,6 +192,7 @@ import {
   ClientMcpRegistrar,
   ExtensionManager,
   ModelsConfig,
+  RUNTIME_MCP_IF_ABSENT_CONFIG_FLAG,
   SessionService,
   StandardFileSystemService,
   StdioClientTransport,
@@ -204,21 +212,23 @@ import {
   redactUrlCredentials,
   shouldShowStep,
   writeWorkspaceContextFile
-} from "./chunk-35FH347N.js";
-import "./chunk-K5PGHDBN.js";
+} from "./chunk-BFG6OZN7.js";
 import "./chunk-5P5XGNYH.js";
+import "./chunk-K5PGHDBN.js";
 import "./chunk-SKAZWEV5.js";
-import "./chunk-ESVSWG6Z.js";
-import "./chunk-CA4ML3VH.js";
-import "./chunk-HWG4XLD7.js";
-import "./chunk-YCRTJYSQ.js";
-import "./chunk-FZY7NH37.js";
+import "./chunk-QOMAHFYI.js";
+import "./chunk-G7OQ3RFJ.js";
+import "./chunk-LKWAVAB5.js";
+import "./chunk-MEQWZGK5.js";
+import "./chunk-UANCYOOQ.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
 import "./chunk-SJBIFVD2.js";
 import "./chunk-MLZQVCF3.js";
+import "./chunk-S5EQPDTM.js";
 import "./chunk-LQ7TMOCE.js";
-import "./chunk-LD2XBG6Z.js";
+import "./chunk-E5A7LHNN.js";
+import "./chunk-GO6LNQXT.js";
 import "./chunk-B236XPGF.js";
 import "./chunk-YXK4GPYO.js";
 import "./chunk-TOAUDIS7.js";
@@ -236,15 +246,15 @@ import {
   recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   withDaemonRequestSpan
-} from "./chunk-B5MPZI4K.js";
-import "./chunk-3PJXIDKI.js";
+} from "./chunk-HJDF3ZVU.js";
+import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
 import "./chunk-MOUXUCXQ.js";
 import "./chunk-BZHLWC6T.js";
-import "./chunk-E5I6YSNO.js";
-import "./chunk-JV7A66DR.js";
+import "./chunk-UQFP2FEF.js";
+import "./chunk-4VZH35PN.js";
 import {
   QwenOAuth2Client,
   QwenOAuthPollError,
@@ -253,8 +263,8 @@ import {
   isDeviceAuthorizationSuccess,
   isDeviceTokenPending,
   isDeviceTokenSuccess
-} from "./chunk-LXGWLOCM.js";
-import "./chunk-QHHNFG22.js";
+} from "./chunk-TENOUWY2.js";
+import "./chunk-GLPV75ES.js";
 import "./chunk-22IFUCVR.js";
 import "./chunk-T42ACHFI.js";
 import "./chunk-YTFBURQD.js";
@@ -267,7 +277,7 @@ import {
 } from "./chunk-H6BD2ELD.js";
 import "./chunk-5IFG2VC4.js";
 import "./chunk-64WXLC72.js";
-import "./chunk-FQDMX5IL.js";
+import "./chunk-D5KISTLW.js";
 import {
   FatalConfigError,
   Storage,
@@ -292,6 +302,8 @@ var import_express4 = __toESM(require_express(), 1);
 // packages/cli/src/serve/acp-http/index.ts
 init_esbuild_shims();
 import { createHash as createHash3, timingSafeEqual } from "node:crypto";
+import { createRequire } from "node:module";
+import * as path9 from "node:path";
 
 // packages/cli/src/serve/acp-http/dispatch.ts
 init_esbuild_shims();
@@ -1500,8 +1512,8 @@ var PathMutexRegistry = class {
   async runExclusive(key, fn) {
     const previous = this.tails.get(key) ?? Promise.resolve();
     let release;
-    const current = new Promise((resolve4) => {
-      release = resolve4;
+    const current = new Promise((resolve5) => {
+      release = resolve5;
     });
     const tail = previous.catch(() => void 0).then(() => current);
     this.tails.set(key, tail);
@@ -1988,7 +2000,7 @@ async function renameWithRetryLocal(src, dest, retries, delayMs) {
       const retryable = code === "EPERM" || code === "EACCES";
       if (!retryable || attempt === retries) throw err;
       await new Promise(
-        (resolve4) => setTimeout(resolve4, delayMs * 2 ** attempt)
+        (resolve5) => setTimeout(resolve5, delayMs * 2 ** attempt)
       );
     }
   }
@@ -4157,6 +4169,316 @@ function createDaemonSubagentManager(boundWorkspace, safeMode = false) {
 }
 __name(createDaemonSubagentManager, "createDaemonSubagentManager");
 
+// packages/cli/src/serve/server/session-archive.ts
+init_esbuild_shims();
+var SessionArchiveCoordinator = class {
+  static {
+    __name(this, "SessionArchiveCoordinator");
+  }
+  exclusive = /* @__PURE__ */ new Set();
+  shared = /* @__PURE__ */ new Map();
+  assertNotTransitioning(sessionId) {
+    if (this.exclusive.has(sessionId)) {
+      throw new SessionArchivingError(sessionId);
+    }
+  }
+  async runExclusiveMany(sessionIds, fn) {
+    const uniqueSessionIds = [...new Set(sessionIds)];
+    for (const sessionId of uniqueSessionIds) {
+      this.assertNotTransitioning(sessionId);
+      if ((this.shared.get(sessionId) ?? 0) > 0) {
+        throw new SessionArchivingError(sessionId, "shared");
+      }
+    }
+    for (const sessionId of uniqueSessionIds) {
+      this.exclusive.add(sessionId);
+    }
+    try {
+      return await fn();
+    } finally {
+      for (const sessionId of uniqueSessionIds) {
+        this.exclusive.delete(sessionId);
+      }
+    }
+  }
+  async runSharedMany(sessionIds, fn) {
+    const uniqueSessionIds = [...new Set(sessionIds)];
+    for (const sessionId of uniqueSessionIds) {
+      this.assertNotTransitioning(sessionId);
+    }
+    for (const sessionId of uniqueSessionIds) {
+      this.shared.set(sessionId, (this.shared.get(sessionId) ?? 0) + 1);
+    }
+    try {
+      return await fn();
+    } finally {
+      for (const sessionId of uniqueSessionIds) {
+        const count = (this.shared.get(sessionId) ?? 1) - 1;
+        if (count <= 0) {
+          this.shared.delete(sessionId);
+        } else {
+          this.shared.set(sessionId, count);
+        }
+      }
+    }
+  }
+};
+async function deleteDaemonSessions(params) {
+  const { sessionIds, service, bridge, coordinator, onError } = params;
+  const uniqueSessionIds = [...new Set(sessionIds)];
+  const closeErrors = [];
+  const removed = [];
+  const notFound = [];
+  const removeErrors = [];
+  for (const sessionId of uniqueSessionIds) {
+    coordinator.assertNotTransitioning(sessionId);
+  }
+  await Promise.all(
+    uniqueSessionIds.map(async (sessionId) => {
+      try {
+        await coordinator.runExclusiveMany([sessionId], async () => {
+          let shouldRemove = false;
+          try {
+            await bridge.closeSession(sessionId);
+            shouldRemove = true;
+          } catch (closeErr) {
+            if (closeErr instanceof SessionNotFoundError || closeErr instanceof Error && closeErr.name === "SessionNotFoundError") {
+              shouldRemove = true;
+            } else {
+              const message = closeErr instanceof Error ? closeErr.message : String(closeErr);
+              onError?.({ phase: "close", sessionId, error: message });
+              closeErrors.push({ sessionId, error: message });
+            }
+          }
+          if (!shouldRemove) return;
+          try {
+            if (await service.removeSession(sessionId)) {
+              removed.push(sessionId);
+            } else {
+              notFound.push(sessionId);
+            }
+          } catch (removeErr) {
+            const message = removeErr instanceof Error ? removeErr.message : String(removeErr);
+            onError?.({ phase: "remove", sessionId, error: message });
+            removeErrors.push({ sessionId, error: message });
+          }
+        });
+      } catch (err) {
+        if (err instanceof SessionArchivingError && err.lockKind === "exclusive") {
+          throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        onError?.({ phase: "delete", sessionId, error: message });
+        closeErrors.push({ sessionId, error: message });
+      }
+    })
+  );
+  return { removed, notFound, errors: [...closeErrors, ...removeErrors] };
+}
+__name(deleteDaemonSessions, "deleteDaemonSessions");
+async function assertSessionLoadable(workspaceCwd, sessionId) {
+  const location = await new SessionService(workspaceCwd).getSessionLocation(
+    sessionId
+  );
+  if (location === "archived") {
+    throw new SessionArchivedError(sessionId);
+  }
+  if (location === "conflict") {
+    throw new SessionConflictError(sessionId);
+  }
+}
+__name(assertSessionLoadable, "assertSessionLoadable");
+function isSessionNotFoundError(err) {
+  return err instanceof SessionNotFoundError || err instanceof Error && err.name === "SessionNotFoundError";
+}
+__name(isSessionNotFoundError, "isSessionNotFoundError");
+async function classifySessionLocations(service, sessionIds) {
+  const result = {
+    active: [],
+    archived: [],
+    notFound: [],
+    errors: []
+  };
+  const locationResults = await Promise.allSettled(
+    sessionIds.map(async (sessionId) => ({
+      sessionId,
+      location: await service.getSessionLocation(sessionId)
+    }))
+  );
+  for (let i = 0; i < locationResults.length; i++) {
+    const sessionId = sessionIds[i];
+    const locationResult = locationResults[i];
+    if (locationResult.status === "rejected") {
+      result.errors.push({ sessionId, error: locationResult.reason });
+      continue;
+    }
+    const location = locationResult.value.location;
+    if (location === void 0) {
+      result.notFound.push(sessionId);
+    } else if (location === "archived") {
+      result.archived.push(sessionId);
+    } else if (location === "conflict") {
+      result.errors.push({
+        sessionId,
+        error: new Error(`Session archive conflict: ${sessionId}`)
+      });
+    } else {
+      result.active.push(sessionId);
+    }
+  }
+  return result;
+}
+__name(classifySessionLocations, "classifySessionLocations");
+function logSessionArchiveResult(action, result) {
+  const changedLabel = action === "archive" ? "archived" : "unarchived";
+  const alreadyLabel = action === "archive" ? "alreadyArchived" : "alreadyActive";
+  const details = [
+    `requested=${result.requested.length} requestedIds=${formatSessionIds(result.requested)}`,
+    `${changedLabel}=${result.changed.length} ${changedLabel}Ids=${formatSessionIds(result.changed)}`,
+    `${alreadyLabel}=${result.already.length} ${alreadyLabel}Ids=${formatSessionIds(result.already)}`,
+    `notFound=${result.notFound.length} notFoundIds=${formatSessionIds(result.notFound)}`,
+    `errors=${result.errors.length} errorIds=${formatSessionErrors(result.errors)}`
+  ].join(" ");
+  writeStderrLine(`qwen serve: sessions ${action} result ${details}`);
+}
+__name(logSessionArchiveResult, "logSessionArchiveResult");
+function formatSessionIds(sessionIds) {
+  return `[${sessionIds.map((sessionId) => safeLogValue(sessionId)).join(",")}]`;
+}
+__name(formatSessionIds, "formatSessionIds");
+function formatSessionErrors(errors) {
+  return `[${errors.map(
+    ({ sessionId, error: error2 }) => `${safeLogValue(sessionId)}:${safeLogValue(errorMessage(error2))}`
+  ).join(",")}]`;
+}
+__name(formatSessionErrors, "formatSessionErrors");
+function errorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+__name(errorMessage, "errorMessage");
+function logSessionArchiveWarning(message) {
+  writeStderrLine(`qwen serve: ${sanitizeLogLine(message)}`);
+}
+__name(logSessionArchiveWarning, "logSessionArchiveWarning");
+var LOG_LINE_UNSAFE_RE = /[\x00-\x1f\x7f-\x9f\u200b-\u200f\u2028-\u202e\u2066-\u2069\ufeff]/g;
+function sanitizeLogLine(message) {
+  return message.replace(LOG_LINE_UNSAFE_RE, " ").slice(0, 4096);
+}
+__name(sanitizeLogLine, "sanitizeLogLine");
+async function archiveDaemonSessions(params) {
+  const { sessionIds, service, bridge, coordinator } = params;
+  const uniqueSessionIds = [...new Set(sessionIds)];
+  const archived = [];
+  const alreadyArchived = [];
+  const notFound = [];
+  const errors = [];
+  const initial = await classifySessionLocations(service, uniqueSessionIds);
+  const activeIds = initial.active;
+  alreadyArchived.push(...initial.archived);
+  notFound.push(...initial.notFound);
+  errors.push(...initial.errors);
+  if (activeIds.length > 0) {
+    await coordinator.runExclusiveMany(activeIds, async () => {
+      const locked = await classifySessionLocations(service, activeIds);
+      const closableIds = locked.active;
+      alreadyArchived.push(...locked.archived);
+      notFound.push(...locked.notFound);
+      errors.push(...locked.errors);
+      const closeResults = await Promise.allSettled(
+        closableIds.map(async (sessionId) => {
+          try {
+            await bridge.closeSession(sessionId, void 0, {
+              requireAgentClose: true
+            });
+          } catch (err) {
+            if (!isSessionNotFoundError(err)) {
+              throw err;
+            }
+          }
+        })
+      );
+      const archiveIds = [];
+      for (let i = 0; i < closeResults.length; i++) {
+        const sessionId = closableIds[i];
+        const result = closeResults[i];
+        if (result.status === "fulfilled") {
+          archiveIds.push(sessionId);
+        } else {
+          errors.push({ sessionId, error: result.reason });
+        }
+      }
+      try {
+        const archiveResult = await service.archiveSessions(archiveIds, {
+          knownLocation: "active"
+        });
+        archived.push(...archiveResult.archived);
+        alreadyArchived.push(...archiveResult.alreadyArchived);
+        notFound.push(...archiveResult.notFound);
+        errors.push(...archiveResult.errors);
+      } catch (err) {
+        for (const sessionId of archiveIds) {
+          errors.push({ sessionId, error: err });
+        }
+      }
+    });
+  }
+  logSessionArchiveResult("archive", {
+    requested: uniqueSessionIds,
+    changed: archived,
+    already: alreadyArchived,
+    notFound,
+    errors
+  });
+  return { archived, alreadyArchived, notFound, errors };
+}
+__name(archiveDaemonSessions, "archiveDaemonSessions");
+async function unarchiveDaemonSessions(params) {
+  const { sessionIds, service, coordinator } = params;
+  const uniqueSessionIds = [...new Set(sessionIds)];
+  const unarchived = [];
+  const alreadyActive = [];
+  const notFound = [];
+  const errors = [];
+  const initial = await classifySessionLocations(service, uniqueSessionIds);
+  const archivedIds = initial.archived;
+  alreadyActive.push(...initial.active);
+  notFound.push(...initial.notFound);
+  errors.push(...initial.errors);
+  if (archivedIds.length > 0) {
+    await coordinator.runExclusiveMany(archivedIds, async () => {
+      const locked = await classifySessionLocations(service, archivedIds);
+      const unarchiveIds = locked.archived;
+      alreadyActive.push(...locked.active);
+      notFound.push(...locked.notFound);
+      errors.push(...locked.errors);
+      if (unarchiveIds.length > 0) {
+        try {
+          const result = await service.unarchiveSessions(unarchiveIds, {
+            knownLocation: "archived"
+          });
+          unarchived.push(...result.unarchived);
+          alreadyActive.push(...result.alreadyActive);
+          notFound.push(...result.notFound);
+          errors.push(...result.errors);
+        } catch (err) {
+          for (const sessionId of unarchiveIds) {
+            errors.push({ sessionId, error: err });
+          }
+        }
+      }
+    });
+  }
+  logSessionArchiveResult("unarchive", {
+    requested: uniqueSessionIds,
+    changed: unarchived,
+    already: alreadyActive,
+    notFound,
+    errors
+  });
+  return { unarchived, alreadyActive, notFound, errors };
+}
+__name(unarchiveDaemonSessions, "unarchiveDaemonSessions");
+
 // packages/cli/src/serve/acp-http/json-rpc.ts
 init_esbuild_shims();
 var QWEN_METHOD_NS = "_qwen/";
@@ -4275,6 +4597,8 @@ var ALL_QWEN_VENDOR_METHODS = [
   // Wave 1: memory
   `${QWEN_METHOD_NS}workspace/memory`,
   `${QWEN_METHOD_NS}workspace/memory/write`,
+  `${QWEN_METHOD_NS}workspace/memory/remember`,
+  `${QWEN_METHOD_NS}workspace/memory/remember/get`,
   // Wave 1: files
   `${QWEN_METHOD_NS}file/read`,
   `${QWEN_METHOD_NS}file/read_bytes`,
@@ -4295,6 +4619,8 @@ var ALL_QWEN_VENDOR_METHODS = [
   `${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`,
   // Wave 2: agents
   `${QWEN_METHOD_NS}workspace/agents/list`,
   `${QWEN_METHOD_NS}workspace/agents/get`,
@@ -4487,6 +4813,33 @@ function toRpcError(err) {
   }
   const name = err instanceof Error ? err.name : "";
   switch (name) {
+    case "SessionArchivedError":
+      return {
+        code: RPC.INTERNAL_ERROR,
+        message: errMsg(err),
+        data: {
+          errorKind: "session_archived",
+          sessionId: err.sessionId
+        }
+      };
+    case "SessionConflictError":
+      return {
+        code: RPC.INTERNAL_ERROR,
+        message: errMsg(err),
+        data: {
+          errorKind: "session_conflict",
+          sessionId: err.sessionId
+        }
+      };
+    case "SessionArchivingError":
+      return {
+        code: RPC.INTERNAL_ERROR,
+        message: errMsg(err),
+        data: {
+          errorKind: "session_archiving",
+          sessionId: err.sessionId
+        }
+      };
     case "SessionNotFoundError":
     case "InvalidSessionScopeError":
     case "WorkspaceMismatchError":
@@ -4523,14 +4876,16 @@ function rpcErrorFrame(id, err) {
 __name(rpcErrorFrame, "rpcErrorFrame");
 var ACP_PROTOCOL_VERSION = 1;
 var AcpDispatcher = class {
-  constructor(bridge, boundWorkspace, workspace, fsFactory, deviceFlowRegistry, sessionShellCommandEnabled = false, registry) {
+  constructor(bridge, boundWorkspace, workspace, workspaceRememberLane, fsFactory, deviceFlowRegistry, sessionShellCommandEnabled = false, registry, archiveCoordinator = new SessionArchiveCoordinator()) {
     this.bridge = bridge;
     this.boundWorkspace = boundWorkspace;
     this.workspace = workspace;
+    this.workspaceRememberLane = workspaceRememberLane;
     this.fsFactory = fsFactory;
     this.deviceFlowRegistry = deviceFlowRegistry;
     this.sessionShellCommandEnabled = sessionShellCommandEnabled;
     this.registry = registry;
+    this.archiveCoordinator = archiveCoordinator;
     this.agentManager = createDaemonSubagentManager(boundWorkspace);
   }
   static {
@@ -4556,6 +4911,21 @@ var AcpDispatcher = class {
       workspaceCwd: this.boundWorkspace
     };
   }
+  parseSessionIds(params) {
+    const sessionIds = params["sessionIds"];
+    if (!Array.isArray(sessionIds) || sessionIds.length === 0 || sessionIds.length > 100 || !sessionIds.every((s) => typeof s === "string")) {
+      throw new AcpParamError(
+        "`sessionIds` must be non-empty string array (max 100)"
+      );
+    }
+    return [...new Set(sessionIds)];
+  }
+  serializeSessionErrors(errors) {
+    return errors.map((e) => ({
+      sessionId: e.sessionId,
+      error: errMsg(e.error)
+    }));
+  }
   /**
    * Build the bridge context for a per-session call. Echoes the clientId the
    * bridge STAMPED at create/attach (the connection's own id is unregistered
@@ -4723,6 +5093,12 @@ var AcpDispatcher = class {
     );
     return false;
   }
+  async withMutableOwned(conn, sessionId, id, fn) {
+    if (!this.requireOwned(conn, sessionId, id)) return;
+    await this.archiveCoordinator.runSharedMany([sessionId], async () => {
+      await fn();
+    });
+  }
   findPendingClientRequest(conn, id) {
     const req = conn.pending.get(id);
     if (req) return { conn, id, req };
@@ -4837,17 +5213,23 @@ var AcpDispatcher = class {
             return;
           }
           const cwd = parseOptionalWorkspaceCwd2(params, this.boundWorkspace);
-          const restored = method === "session/load" ? await this.bridge.loadSession({
-            sessionId,
-            workspaceCwd: cwd,
-            clientId: conn.clientId
-          }) : await this.bridge.resumeSession({
-            sessionId,
-            workspaceCwd: cwd,
-            clientId: conn.clientId
-          });
-          const closeRaced = conn.closingSessions.has(sessionId);
-          if (conn.destroyed || closeRaced) {
+          const restored = await this.archiveCoordinator.runSharedMany(
+            [sessionId],
+            async () => {
+              await assertSessionLoadable(cwd, sessionId);
+              return method === "session/load" ? await this.bridge.loadSession({
+                sessionId,
+                workspaceCwd: cwd,
+                clientId: conn.clientId
+              }) : await this.bridge.resumeSession({
+                sessionId,
+                workspaceCwd: cwd,
+                clientId: conn.clientId
+              });
+            }
+          );
+          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
             });
@@ -4881,20 +5263,51 @@ var AcpDispatcher = class {
           return;
         }
         case "session/list": {
+          const rawWorkspace = typeof params["workspaceCwd"] === "string" ? params["workspaceCwd"] : void 0;
+          let workspaceCwd = rawWorkspace === void 0 ? this.boundWorkspace : parseOptionalWorkspaceCwd2(
+            { cwd: rawWorkspace },
+            this.boundWorkspace
+          );
+          if (rawWorkspace !== void 0) {
+            const requestedWorkspace = canonicalizeWorkspace(workspaceCwd);
+            if (requestedWorkspace !== this.boundWorkspace) {
+              throw new WorkspaceMismatchError(
+                this.boundWorkspace,
+                requestedWorkspace
+              );
+            }
+            workspaceCwd = requestedWorkspace;
+          }
           const cursor = typeof params["cursor"] === "string" ? params["cursor"] : void 0;
           const meta = isObject(params["_meta"]) ? params["_meta"] : void 0;
           const metaSize = typeof meta?.["size"] === "number" ? meta["size"] : void 0;
+          const rawArchiveState = typeof params["archiveState"] === "string" ? params["archiveState"] : typeof meta?.["archiveState"] === "string" ? meta["archiveState"] : void 0;
+          let archiveState;
+          if (rawArchiveState !== void 0) {
+            if (rawArchiveState !== "active" && rawArchiveState !== "archived") {
+              throw new AcpParamError(
+                '`archiveState` must be "active" or "archived"'
+              );
+            }
+            archiveState = rawArchiveState;
+          }
           const result = await listWorkspaceSessionsForResponse(
             this.bridge,
-            this.boundWorkspace,
-            { cursor, size: metaSize }
+            workspaceCwd,
+            { cursor, size: metaSize, archiveState }
           );
           this.replyConn(conn, id, {
             sessions: result.sessions.map((s) => ({
               sessionId: s.sessionId,
+              workspaceCwd: s.workspaceCwd,
               cwd: s.workspaceCwd,
+              createdAt: s.createdAt,
+              updatedAt: s.updatedAt,
+              displayName: s.displayName,
               title: s.displayName,
-              updatedAt: s.updatedAt
+              clientCount: s.clientCount,
+              hasActivePrompt: s.hasActivePrompt,
+              isArchived: s.isArchived === true
             })),
             ...result.nextCursor != null ? { nextCursor: result.nextCursor } : {}
           });
@@ -4905,19 +5318,47 @@ var AcpDispatcher = class {
           if (!this.requireOwned(conn, sessionId, id)) return;
           conn.ownedSessions.delete(sessionId);
           conn.closingSessions.add(sessionId);
+          let closeStarted = false;
+          const closeSession = /* @__PURE__ */ __name(async () => {
+            closeStarted = true;
+            try {
+              await this.bridge.closeSession(
+                sessionId,
+                this.sessionCtx(conn, sessionId, loopback)
+              );
+            } finally {
+              try {
+                conn.closeSessionStream(sessionId);
+              } catch (teardownErr) {
+                writeStderrLine(
+                  `qwen serve: /acp session/close local teardown failed (${logSafe(sessionId)}): ${logSafe(errMsg(teardownErr))}`
+                );
+              }
+            }
+          }, "closeSession");
           try {
-            await this.bridge.closeSession(
-              sessionId,
-              this.sessionCtx(conn, sessionId, loopback)
-            );
-          } finally {
             try {
-              conn.closeSessionStream(sessionId);
-            } catch (teardownErr) {
-              writeStderrLine(
-                `qwen serve: /acp session/close local teardown failed (${logSafe(sessionId)}): ${logSafe(errMsg(teardownErr))}`
+              await this.archiveCoordinator.runExclusiveMany(
+                [sessionId],
+                closeSession
               );
+            } catch (err) {
+              const promptAbort = conn.sessions.get(sessionId)?.promptAbort;
+              if (err instanceof SessionArchivingError && err.lockKind === "shared" && promptAbort !== void 0) {
+                await this.archiveCoordinator.runSharedMany(
+                  [sessionId],
+                  closeSession
+                );
+              } else {
+                throw err;
+              }
+            }
+          } catch (err) {
+            if (!closeStarted) {
+              conn.ownedSessions.add(sessionId);
             }
+            throw err;
+          } finally {
             conn.closingSessions.delete(sessionId);
           }
           this.replyConn(conn, id, {});
@@ -4935,51 +5376,54 @@ var AcpDispatcher = class {
             }
             return;
           }
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          const ctx = this.sessionCtx(conn, sessionId, loopback);
-          const result = await this.bridge.branchSession(
-            sessionId,
-            {
-              name: typeof params["name"] === "string" ? params["name"] : void 0
-            },
-            ctx
-          );
-          if (conn.destroyed) {
-            this.killOrphanSession(result.sessionId);
-            return;
-          }
-          conn.getOrCreateSession(result.sessionId).clientId = result.clientId;
-          conn.ownSession(result.sessionId);
-          const configOptions = await this.configOptionsFor(result.sessionId);
-          const models = this.extractModelState(configOptions);
-          const modes = this.extractModeState(configOptions);
-          this.replyConn(conn, id, {
-            sessionId: result.sessionId,
-            ...configOptions ? { configOptions } : {},
-            ...models ? { models } : {},
-            ...modes ? { modes } : {}
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const ctx = this.sessionCtx(conn, sessionId, loopback);
+            const result = await this.bridge.branchSession(
+              sessionId,
+              {
+                name: typeof params["name"] === "string" ? params["name"] : void 0
+              },
+              ctx
+            );
+            if (conn.destroyed) {
+              this.killOrphanSession(result.sessionId);
+              return;
+            }
+            conn.getOrCreateSession(result.sessionId).clientId = result.clientId;
+            conn.ownSession(result.sessionId);
+            const configOptions = await this.configOptionsFor(result.sessionId);
+            const models = this.extractModelState(configOptions);
+            const modes = this.extractModeState(configOptions);
+            this.replyConn(conn, id, {
+              sessionId: result.sessionId,
+              ...configOptions ? { configOptions } : {},
+              ...models ? { models } : {},
+              ...modes ? { modes } : {}
+            });
           });
           return;
         }
         case "session/cancel": {
           const sessionId = String(params["sessionId"] ?? "");
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          conn.sessions.get(sessionId)?.promptAbort?.abort();
-          await this.bridge.cancelSession(
-            sessionId,
-            // Forward client-supplied cancel fields (reason/context) while
-            // force-stamping sessionId — mirrors the REST surface.
-            { ...params, sessionId },
-            this.sessionCtx(conn, sessionId, loopback)
-          );
-          if (id !== void 0) this.replySession(conn, sessionId, id, {});
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            conn.sessions.get(sessionId)?.promptAbort?.abort();
+            await this.bridge.cancelSession(
+              sessionId,
+              // Forward client-supplied cancel fields (reason/context) while
+              // force-stamping sessionId — mirrors the REST surface.
+              { ...params, sessionId },
+              this.sessionCtx(conn, sessionId, loopback)
+            );
+            if (id !== void 0) this.replySession(conn, sessionId, id, {});
+          });
           return;
         }
         case "session/prompt": {
           const sessionId = String(params["sessionId"] ?? "");
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          validatePrompt(params);
-          await this.handlePrompt(conn, sessionId, id, params, loopback);
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            validatePrompt(params);
+            await this.handlePrompt(conn, sessionId, id, params, loopback);
+          });
           return;
         }
         case "session/permission": {
@@ -5198,34 +5642,11 @@ var AcpDispatcher = class {
         // setters. Replaces the old vendor `_qwen/session/set_model`.
         case "session/set_config_option": {
           const sessionId = String(params["sessionId"] ?? "");
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          const configId = String(params["configId"] ?? "");
-          const rawValue = params["value"];
-          const ctx = this.sessionCtx(conn, sessionId, loopback);
-          if (typeof rawValue !== "string" || rawValue.length === 0) {
-            if (id !== void 0) {
-              this.replySession(
-                conn,
-                sessionId,
-                id,
-                void 0,
-                error(
-                  id,
-                  RPC.INVALID_PARAMS,
-                  "`value` must be a non-empty string"
-                )
-              );
-            }
-            return;
-          }
-          if (configId === "model") {
-            await this.bridge.setSessionModel(
-              sessionId,
-              { modelId: rawValue },
-              ctx
-            );
-          } else if (configId === "mode") {
-            if (!APPROVAL_MODES.includes(rawValue)) {
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const configId = String(params["configId"] ?? "");
+            const rawValue = params["value"];
+            const ctx = this.sessionCtx(conn, sessionId, loopback);
+            if (typeof rawValue !== "string" || rawValue.length === 0) {
               if (id !== void 0) {
                 this.replySession(
                   conn,
@@ -5235,32 +5656,60 @@ var AcpDispatcher = class {
                   error(
                     id,
                     RPC.INVALID_PARAMS,
-                    `invalid mode "${rawValue}" (expected one of: ${APPROVAL_MODES.join(", ")})`
+                    "`value` must be a non-empty string"
                   )
                 );
               }
               return;
             }
-            await this.bridge.setSessionApprovalMode(
-              sessionId,
-              rawValue,
-              { persist: params["persist"] === true },
-              ctx
-            );
-          } else {
-            if (id !== void 0) {
-              this.replySession(
-                conn,
+            if (configId === "model") {
+              await this.bridge.setSessionModel(
+                sessionId,
+                { modelId: rawValue },
+                ctx
+              );
+            } else if (configId === "mode") {
+              if (!APPROVAL_MODES.includes(rawValue)) {
+                if (id !== void 0) {
+                  this.replySession(
+                    conn,
+                    sessionId,
+                    id,
+                    void 0,
+                    error(
+                      id,
+                      RPC.INVALID_PARAMS,
+                      `invalid mode "${rawValue}" (expected one of: ${APPROVAL_MODES.join(", ")})`
+                    )
+                  );
+                }
+                return;
+              }
+              await this.bridge.setSessionApprovalMode(
                 sessionId,
-                id,
-                void 0,
-                error(id, RPC.INVALID_PARAMS, `Unknown configId: ${configId}`)
+                rawValue,
+                { persist: params["persist"] === true },
+                ctx
               );
+            } else {
+              if (id !== void 0) {
+                this.replySession(
+                  conn,
+                  sessionId,
+                  id,
+                  void 0,
+                  error(
+                    id,
+                    RPC.INVALID_PARAMS,
+                    `Unknown configId: ${configId}`
+                  )
+                );
+              }
+              return;
             }
-            return;
-          }
-          const configOptions = await this.configOptionsFor(sessionId);
-          this.replySession(conn, sessionId, id, { configOptions });
+            const configOptions = await this.configOptionsFor(sessionId);
+            this.replySession(conn, sessionId, id, { configOptions });
+          });
           return;
         }
         // ACP standard: session/set_mode — dedicated method for mode changes.
@@ -5274,32 +5723,33 @@ var AcpDispatcher = class {
               );
             return;
           }
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          const modeId = String(params["modeId"] ?? "");
-          if (!modeId || !APPROVAL_MODES.includes(modeId)) {
-            if (id !== void 0) {
-              this.replySession(
-                conn,
-                sessionId,
-                id,
-                void 0,
-                error(
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const modeId = String(params["modeId"] ?? "");
+            if (!modeId || !APPROVAL_MODES.includes(modeId)) {
+              if (id !== void 0) {
+                this.replySession(
+                  conn,
+                  sessionId,
                   id,
-                  RPC.INVALID_PARAMS,
-                  `invalid modeId "${modeId}" (expected one of: ${APPROVAL_MODES.join(", ")})`
-                )
-              );
+                  void 0,
+                  error(
+                    id,
+                    RPC.INVALID_PARAMS,
+                    `invalid modeId "${modeId}" (expected one of: ${APPROVAL_MODES.join(", ")})`
+                  )
+                );
+              }
+              return;
             }
-            return;
-          }
-          const ctx = this.sessionCtx(conn, sessionId, loopback);
-          await this.bridge.setSessionApprovalMode(
-            sessionId,
-            modeId,
-            { persist: false },
-            ctx
-          );
-          this.replySession(conn, sessionId, id, {});
+            const ctx = this.sessionCtx(conn, sessionId, loopback);
+            await this.bridge.setSessionApprovalMode(
+              sessionId,
+              modeId,
+              { persist: false },
+              ctx
+            );
+            this.replySession(conn, sessionId, id, {});
+          });
           return;
         }
         // ACP standard (unstable): session/set_model — dedicated method for
@@ -5314,27 +5764,28 @@ var AcpDispatcher = class {
               );
             return;
           }
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          const modelId = String(params["modelId"] ?? "");
-          if (!modelId) {
-            if (id !== void 0) {
-              this.replySession(
-                conn,
-                sessionId,
-                id,
-                void 0,
-                error(id, RPC.INVALID_PARAMS, "`modelId` is required")
-              );
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const modelId = String(params["modelId"] ?? "");
+            if (!modelId) {
+              if (id !== void 0) {
+                this.replySession(
+                  conn,
+                  sessionId,
+                  id,
+                  void 0,
+                  error(id, RPC.INVALID_PARAMS, "`modelId` is required")
+                );
+              }
+              return;
             }
-            return;
-          }
-          const ctx = this.sessionCtx(conn, sessionId, loopback);
-          await this.bridge.setSessionModel(
-            sessionId,
-            { modelId, sessionId },
-            ctx
-          );
-          this.replySession(conn, sessionId, id, {});
+            const ctx = this.sessionCtx(conn, sessionId, loopback);
+            await this.bridge.setSessionModel(
+              sessionId,
+              { modelId, sessionId },
+              ctx
+            );
+            this.replySession(conn, sessionId, id, {});
+          });
           return;
         }
         case `${QWEN_METHOD_NS}session/heartbeat`: {
@@ -5369,14 +5820,15 @@ var AcpDispatcher = class {
         }
         case `${QWEN_METHOD_NS}session/update_metadata`: {
           const sessionId = String(params["sessionId"] ?? "");
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          const metadata = isObject(params["metadata"]) ? params["metadata"] : {};
-          const result = this.bridge.updateSessionMetadata(
-            sessionId,
-            metadata,
-            this.sessionCtx(conn, sessionId, loopback)
-          );
-          this.replyConn(conn, id, result);
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const metadata = isObject(params["metadata"]) ? params["metadata"] : {};
+            const result = this.bridge.updateSessionMetadata(
+              sessionId,
+              metadata,
+              this.sessionCtx(conn, sessionId, loopback)
+            );
+            this.replyConn(conn, id, result);
+          });
           return;
         }
         case `${QWEN_METHOD_NS}workspace/mcp`:
@@ -5718,36 +6170,38 @@ var AcpDispatcher = class {
         // ── Wave 1+2: ACP/REST parity methods ───────────────────────
         case `${QWEN_METHOD_NS}session/recap`: {
           const sessionId = String(params["sessionId"] ?? "");
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          const result = await this.bridge.generateSessionRecap(
-            sessionId,
-            this.sessionCtx(conn, sessionId, loopback)
-          );
-          this.replyConn(conn, id, result);
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const result = await this.bridge.generateSessionRecap(
+              sessionId,
+              this.sessionCtx(conn, sessionId, loopback)
+            );
+            this.replyConn(conn, id, result);
+          });
           return;
         }
         case `${QWEN_METHOD_NS}session/btw`: {
           const sessionId = String(params["sessionId"] ?? "");
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          const rawQ = params["question"];
-          if (typeof rawQ !== "string" || rawQ.trim().length === 0 || rawQ.length > BTW_MAX_INPUT_LENGTH) {
-            if (id !== void 0)
-              conn.sendConn(
-                error(
-                  id,
-                  RPC.INVALID_PARAMS,
-                  `\`question\` required, non-empty, max ${BTW_MAX_INPUT_LENGTH} chars`
-                )
-              );
-            return;
-          }
-          const result = await this.bridge.generateSessionBtw(
-            sessionId,
-            rawQ.trim(),
-            void 0,
-            this.sessionCtx(conn, sessionId, loopback)
-          );
-          this.replyConn(conn, id, result);
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const rawQ = params["question"];
+            if (typeof rawQ !== "string" || rawQ.trim().length === 0 || rawQ.length > BTW_MAX_INPUT_LENGTH) {
+              if (id !== void 0)
+                conn.sendConn(
+                  error(
+                    id,
+                    RPC.INVALID_PARAMS,
+                    `\`question\` required, non-empty, max ${BTW_MAX_INPUT_LENGTH} chars`
+                  )
+                );
+              return;
+            }
+            const result = await this.bridge.generateSessionBtw(
+              sessionId,
+              rawQ.trim(),
+              void 0,
+              this.sessionCtx(conn, sessionId, loopback)
+            );
+            this.replyConn(conn, id, result);
+          });
           return;
         }
         case `${QWEN_METHOD_NS}session/shell`: {
@@ -5758,50 +6212,52 @@ var AcpDispatcher = class {
             }
             return;
           }
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          const binding = conn.sessions.get(sessionId);
-          const clientId = binding?.clientId;
-          if (!clientId) {
-            if (id !== void 0) {
-              conn.sendConn(
-                rpcErrorFrame(id, new SessionShellClientRequiredError())
-              );
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const binding = conn.sessions.get(sessionId);
+            const clientId = binding?.clientId;
+            if (!clientId) {
+              if (id !== void 0) {
+                conn.sendConn(
+                  rpcErrorFrame(id, new SessionShellClientRequiredError())
+                );
+              }
+              return;
             }
-            return;
-          }
-          const rawCmd = params["command"];
-          if (typeof rawCmd !== "string" || rawCmd.trim().length === 0) {
-            if (id !== void 0)
-              conn.sendConn(
-                error(
-                  id,
-                  RPC.INVALID_PARAMS,
-                  "`command` required and must be non-empty"
-                )
-              );
-            return;
-          }
-          const logSessionId = logSafe(sessionId.slice(0, 8));
-          const logClientId = logSafe(String(conn.clientId?.slice(0, 8)));
-          const logCommand = logSafe(rawCmd.slice(0, 120));
-          writeStderrLine(
-            `qwen serve: /acp session/shell session=${logSessionId} client=${logClientId} cmd=${logCommand}`
-          );
-          const result = await this.bridge.executeShellCommand(
-            sessionId,
-            rawCmd,
-            binding.abort.signal,
-            this.sessionCtx(conn, sessionId, loopback)
-          );
-          this.replyConn(conn, id, result);
+            const rawCmd = params["command"];
+            if (typeof rawCmd !== "string" || rawCmd.trim().length === 0) {
+              if (id !== void 0)
+                conn.sendConn(
+                  error(
+                    id,
+                    RPC.INVALID_PARAMS,
+                    "`command` required and must be non-empty"
+                  )
+                );
+              return;
+            }
+            const logSessionId = logSafe(sessionId.slice(0, 8));
+            const logClientId = logSafe(String(conn.clientId?.slice(0, 8)));
+            const logCommand = logSafe(rawCmd.slice(0, 120));
+            writeStderrLine(
+              `qwen serve: /acp session/shell session=${logSessionId} client=${logClientId} cmd=${logCommand}`
+            );
+            const result = await this.bridge.executeShellCommand(
+              sessionId,
+              rawCmd,
+              binding.abort.signal,
+              this.sessionCtx(conn, sessionId, loopback)
+            );
+            this.replyConn(conn, id, result);
+          });
           return;
         }
         case `${QWEN_METHOD_NS}session/detach`: {
           const sessionId = String(params["sessionId"] ?? "");
-          if (!this.requireOwned(conn, sessionId, id)) return;
-          const ctx = this.sessionCtx(conn, sessionId, loopback);
-          await this.bridge.detachClient(sessionId, ctx.clientId);
-          this.replyConn(conn, id, { ok: true });
+          await this.withMutableOwned(conn, sessionId, id, async () => {
+            const ctx = this.sessionCtx(conn, sessionId, loopback);
+            await this.bridge.detachClient(sessionId, ctx.clientId);
+            this.replyConn(conn, id, { ok: true });
+          });
           return;
         }
         case `${QWEN_METHOD_NS}session/context_usage`: {
@@ -5913,6 +6369,110 @@ var AcpDispatcher = class {
           }
           return;
         }
+        case `${QWEN_METHOD_NS}workspace/memory/remember`: {
+          const content = params["content"];
+          if (typeof content !== "string" || !content.trim()) {
+            if (id !== void 0) {
+              conn.sendConn(
+                error(
+                  id,
+                  RPC.INVALID_PARAMS,
+                  "`content` must be a non-empty string"
+                )
+              );
+            }
+            return;
+          }
+          if (Buffer.byteLength(content, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
+            if (id !== void 0) {
+              conn.sendConn(
+                error(
+                  id,
+                  RPC.INVALID_PARAMS,
+                  `\`content\` exceeds the ${MAX_REMEMBER_CONTENT_BYTES}-byte limit`
+                )
+              );
+            }
+            return;
+          }
+          const rawContextMode = params["contextMode"] ?? "workspace";
+          if (rawContextMode !== "workspace" && rawContextMode !== "clean") {
+            if (id !== void 0) {
+              conn.sendConn(
+                error(
+                  id,
+                  RPC.INVALID_PARAMS,
+                  '`contextMode` must be "workspace", "clean", or omitted'
+                )
+              );
+            }
+            return;
+          }
+          try {
+            const available = await this.bridge.isWorkspaceMemoryRememberAvailable();
+            if (!available) {
+              if (id !== void 0) {
+                conn.sendConn(
+                  error(
+                    id,
+                    -32009,
+                    "Managed memory is unavailable for this daemon workspace",
+                    {
+                      errorKind: "managed_memory_unavailable",
+                      httpStatus: 409
+                    }
+                  )
+                );
+              }
+              return;
+            }
+            const task = this.workspaceRememberLane.enqueue({
+              content: content.trim(),
+              contextMode: rawContextMode,
+              ...conn.clientId ? { originatorClientId: conn.clientId } : {}
+            });
+            this.replyConn(conn, id, task);
+          } catch (err) {
+            const code = extractRememberErrorCode(err);
+            if (id !== void 0) {
+              conn.sendConn(
+                error(
+                  id,
+                  -32099,
+                  code === "remember_queue_full" ? "Workspace memory remember queue is full." : code === "managed_memory_unavailable" ? "Managed memory is unavailable for this daemon workspace" : "Workspace memory remember failed.",
+                  {
+                    errorKind: code,
+                    httpStatus: code === "remember_queue_full" ? 429 : code === "managed_memory_unavailable" ? 409 : 500
+                  }
+                )
+              );
+            }
+          }
+          return;
+        }
+        case `${QWEN_METHOD_NS}workspace/memory/remember/get`: {
+          const taskId = params["taskId"];
+          if (typeof taskId !== "string" || taskId.length === 0) {
+            if (id !== void 0) {
+              conn.sendConn(error(id, RPC.INVALID_PARAMS, "`taskId` required"));
+            }
+            return;
+          }
+          const task = this.workspaceRememberLane.get(taskId, conn.clientId);
+          if (!task) {
+            if (id !== void 0) {
+              conn.sendConn(
+                error(id, -32004, "Workspace memory remember task not found", {
+                  errorKind: "remember_task_not_found",
+                  httpStatus: 404
+                })
+              );
+            }
+            return;
+          }
+          this.replyConn(conn, id, task);
+          return;
+        }
         case `${QWEN_METHOD_NS}file/read`: {
           const p = String(params["path"] ?? "");
           if (!p) {
@@ -6428,60 +6988,58 @@ var AcpDispatcher = class {
           return;
         }
         case `${QWEN_METHOD_NS}sessions/delete`: {
-          const sessionIds = params["sessionIds"];
-          if (!Array.isArray(sessionIds) || sessionIds.length === 0 || sessionIds.length > 100 || !sessionIds.every((s) => typeof s === "string")) {
-            if (id !== void 0)
-              conn.sendConn(
-                error(
-                  id,
-                  RPC.INVALID_PARAMS,
-                  "`sessionIds` must be non-empty string array (max 100)"
-                )
-              );
-            return;
-          }
-          const ids = [...new Set(sessionIds)];
-          const closeErrors = [];
-          const closedIds = [];
-          await Promise.allSettled(
-            ids.map(async (sid) => {
-              try {
-                await this.bridge.closeSession(sid);
-                closedIds.push(sid);
-              } catch (err) {
-                const msg2 = err instanceof Error ? err.message : String(err);
-                if (err instanceof Error && err.name === "SessionNotFoundError") {
-                  closedIds.push(sid);
-                } else {
-                  const safeSessionId = logSafe(sid.slice(0, 8));
-                  const safeMessage = logSafe(msg2);
-                  writeStderrLine(
-                    `qwen serve: /acp sessions/delete closeSession(${safeSessionId}) failed: ${safeMessage}`
-                  );
-                  closeErrors.push({ sessionId: sid, error: msg2 });
-                }
-              }
-            })
-          );
+          const ids = this.parseSessionIds(params);
           const svc = new SessionService(this.boundWorkspace);
-          const removeResult = await svc.removeSessions(closedIds);
-          for (const e of removeResult.errors) {
-            const safeSessionId = logSafe(e.sessionId.slice(0, 8));
-            const safeMessage = logSafe(errMsg(e.error));
-            writeStderrLine(
-              `qwen serve: /acp sessions/delete removeSessions(${safeSessionId}) failed: ${safeMessage}`
-            );
-          }
+          const result = await deleteDaemonSessions({
+            sessionIds: ids,
+            service: svc,
+            bridge: this.bridge,
+            coordinator: this.archiveCoordinator,
+            onError: /* @__PURE__ */ __name(({ phase, sessionId, error: error2 }) => {
+              const safeSessionId = logSafe(sessionId.slice(0, 8));
+              const safeMessage = logSafe(error2);
+              writeStderrLine(
+                `qwen serve: /acp sessions/delete ${phase}Session(${safeSessionId}) failed: ${safeMessage}`
+              );
+            }, "onError")
+          });
+          this.replyConn(conn, id, result);
+          return;
+        }
+        case `${QWEN_METHOD_NS}sessions/archive`: {
+          const ids = this.parseSessionIds(params);
+          const svc = new SessionService(this.boundWorkspace, {
+            onWarning: logSessionArchiveWarning
+          });
+          const result = await archiveDaemonSessions({
+            sessionIds: ids,
+            service: svc,
+            bridge: this.bridge,
+            coordinator: this.archiveCoordinator
+          });
+          this.replyConn(conn, id, {
+            archived: result.archived,
+            alreadyArchived: result.alreadyArchived,
+            notFound: result.notFound,
+            errors: this.serializeSessionErrors(result.errors)
+          });
+          return;
+        }
+        case `${QWEN_METHOD_NS}sessions/unarchive`: {
+          const ids = this.parseSessionIds(params);
+          const svc = new SessionService(this.boundWorkspace, {
+            onWarning: logSessionArchiveWarning
+          });
+          const result = await unarchiveDaemonSessions({
+            sessionIds: ids,
+            service: svc,
+            coordinator: this.archiveCoordinator
+          });
           this.replyConn(conn, id, {
-            removed: removeResult.removed,
-            notFound: removeResult.notFound,
-            errors: [
-              ...closeErrors,
-              ...removeResult.errors.map((e) => ({
-                sessionId: e.sessionId,
-                error: errMsg(e.error)
-              }))
-            ]
+            unarchived: result.unarchived,
+            alreadyActive: result.alreadyActive,
+            notFound: result.notFound,
+            errors: this.serializeSessionErrors(result.errors)
           });
           return;
         }
@@ -7708,9 +8266,9 @@ var SseStream = class {
     return next;
   }
   doWrite(chunk) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       if (this.closed || this.res.writableEnded) {
-        resolve4();
+        resolve5();
         return;
       }
       let ok;
@@ -7721,7 +8279,7 @@ var SseStream = class {
         return;
       }
       if (ok) {
-        resolve4();
+        resolve5();
         return;
       }
       const cleanup = /* @__PURE__ */ __name(() => {
@@ -7731,11 +8289,11 @@ var SseStream = class {
       }, "cleanup");
       const onDrain = /* @__PURE__ */ __name(() => {
         cleanup();
-        resolve4();
+        resolve5();
       }, "onDrain");
       const onCloseEv = /* @__PURE__ */ __name(() => {
         cleanup();
-        resolve4();
+        resolve5();
       }, "onCloseEv");
       const onErrorEv = /* @__PURE__ */ __name((err) => {
         cleanup();
@@ -7797,14 +8355,14 @@ var WsStream = class {
   send(message, _id) {
     const data = JSON.stringify(message);
     const next = this.writeChain.then(
-      () => new Promise((resolve4, reject) => {
+      () => new Promise((resolve5, reject) => {
         if (this._closed) {
-          resolve4();
+          resolve5();
           return;
         }
         this.ws.send(data, (err) => {
           if (err) reject(err);
-          else resolve4();
+          else resolve5();
         });
       })
     );
@@ -8088,16 +8646,14 @@ var CdpReverseLink = class {
   nextId = 1;
   pending = /* @__PURE__ */ new Map();
   disposed = false;
+  attached = false;
+  attachPromise;
   /** Resolver for the in-flight `cdp_attach` (if any). */
   pendingAttach;
-  /**
-   * Opens once the initial `cdp_attach` settles (success OR failure).
-   * `forwardToTab` awaits this so page-domain commands never race the
-   * extension's async `chrome.debugger.attach`. Undefined until {@link attach}.
-   */
-  attachGate;
   /** Called when the extension reports the tab detached. */
   onDetach;
+  /** Called when lazy `cdp_attach` fails before any page command can run. */
+  onAttachFailure;
   /** Wire the emulator whose `forwardToTab` this link backs. */
   bindEmulator(emulator) {
     this.emulator = emulator;
@@ -8110,10 +8666,8 @@ var CdpReverseLink = class {
     if (this.disposed) {
       throw { code: -32e3, message: "CDP tunnel closed" };
     }
-    if (this.attachGate) {
-      await this.attachGate;
-    }
-    return new Promise((resolve4, reject) => {
+    await this.attach();
+    return new Promise((resolve5, reject) => {
       if (this.disposed) {
         reject({ code: -32e3, message: "CDP tunnel closed" });
         return;
@@ -8124,7 +8678,7 @@ var CdpReverseLink = class {
         `CDP command id=${id} method=${method} timed out after ${this.commandTimeoutMs}ms`
       );
       const progressTimer = this.armProgressLog(id, method);
-      this.pending.set(id, { resolve: resolve4, reject, timer, progressTimer });
+      this.pending.set(id, { resolve: resolve5, reject, timer, progressTimer });
       try {
         this.log?.(
           `qwen serve: /cdp forwarded command id=${id} method=${method} to extension`
@@ -8148,8 +8702,10 @@ var CdpReverseLink = class {
    * once the extension acks `cdp_attached` (or rejects on error/timeout).
    */
   attach() {
-    const result = new Promise(
-      (resolve4, reject) => {
+    if (this.attached) return Promise.resolve({});
+    if (this.attachPromise) return this.attachPromise;
+    this.attachPromise = new Promise(
+      (resolve5, reject) => {
         if (this.disposed) {
           reject({ code: -32e3, message: "CDP tunnel closed" });
           return;
@@ -8159,7 +8715,7 @@ var CdpReverseLink = class {
         this.pendingAttach = {
           id,
           pending: {
-            resolve: /* @__PURE__ */ __name((result2) => resolve4(result2 ?? {}), "resolve"),
+            resolve: /* @__PURE__ */ __name((result) => resolve5(result ?? {}), "resolve"),
             reject,
             timer
           }
@@ -8175,12 +8731,24 @@ var CdpReverseLink = class {
           });
         }
       }
+    ).then(
+      (info) => {
+        this.emulator?.setTabInfo(info);
+        return info;
+      },
+      (err) => {
+        this.attached = false;
+        this.onAttachFailure?.(
+          err instanceof Error ? err.message : err?.message ?? String(err)
+        );
+        throw err;
+      }
     );
-    this.attachGate = result.then(
-      () => void 0,
-      () => void 0
-    );
-    return result;
+    void this.attachPromise.finally(() => {
+      this.attachPromise = void 0;
+    }).catch(() => {
+    });
+    return this.attachPromise;
   }
   /**
    * Feed one inbound frame from the extension `/acp` socket. Returns true if
@@ -8236,16 +8804,24 @@ var CdpReverseLink = class {
     this.pendingAttach = void 0;
     clearTimeout(attach.pending.timer);
     if (frame.error) {
+      this.attached = false;
       attach.pending.reject({
         code: -32e3,
         message: frame.error.message ?? "cdp_attach failed"
       });
       return;
     }
+    this.attached = true;
     attach.pending.resolve({ url: frame.url, title: frame.title });
   }
   handleDetach(frame) {
     const reason = typeof frame.reason === "string" ? frame.reason : "tab detached";
+    this.attached = false;
+    if (this.pendingAttach) {
+      clearTimeout(this.pendingAttach.pending.timer);
+      this.pendingAttach.pending.reject({ code: -32e3, message: reason });
+      this.pendingAttach = void 0;
+    }
     this.onDetach?.(reason);
   }
   armTimeout(id, message) {
@@ -8261,13 +8837,13 @@ var CdpReverseLink = class {
   }
   armProgressLog(id, method) {
     if (!this.log) return void 0;
-    const delay = Math.min(COMMAND_PROGRESS_LOG_MS, this.commandTimeoutMs);
-    if (delay >= this.commandTimeoutMs) return void 0;
+    const delay2 = Math.min(COMMAND_PROGRESS_LOG_MS, this.commandTimeoutMs);
+    if (delay2 >= this.commandTimeoutMs) return void 0;
     const timer = setTimeout(() => {
       this.log?.(
-        `qwen serve: /cdp still waiting for command id=${id} method=${method} after ${delay}ms`
+        `qwen serve: /cdp still waiting for command id=${id} method=${method} after ${delay2}ms`
       );
-    }, delay);
+    }, delay2);
     timer.unref?.();
     return timer;
   }
@@ -8306,6 +8882,8 @@ var CdpReverseLink = class {
       this.pendingAttach.pending.reject({ code: -32e3, message: reason });
       this.pendingAttach = void 0;
     }
+    this.attached = false;
+    this.attachPromise = void 0;
     this.emulator = void 0;
   }
 };
@@ -8595,6 +9173,14 @@ function attachCdpClient(ws, registry, log) {
       bridge.onExtensionGone = void 0;
     }
   }, "dispose");
+  link.onAttachFailure = (reason) => {
+    log(`qwen serve: /cdp attach failed (${reason}); closing puppeteer socket`);
+    dispose(`cdp_attach failed: ${reason}`, false);
+    try {
+      ws.close(CLOSE_NO_BRIDGE, "cdp attach failed");
+    } catch {
+    }
+  };
   ws.on("pong", () => {
     heartbeatAlive = true;
   });
@@ -8627,15 +9213,6 @@ function attachCdpClient(ws, registry, log) {
     );
     dispose("puppeteer /cdp socket error");
   });
-  void link.attach().then((info) => emulator.setTabInfo(info)).catch((err) => {
-    log(
-      `qwen serve: /cdp attach failed: ${err && typeof err === "object" && "message" in err ? String(err.message) : String(err)}; closing puppeteer socket so a reconnect can retry attach`
-    );
-    try {
-      ws.close(CLOSE_NO_BRIDGE, "cdp_attach failed");
-    } catch {
-    }
-  });
   log("qwen serve: /cdp puppeteer client bound to extension bridge");
 }
 __name(attachCdpClient, "attachCdpClient");
@@ -8645,6 +9222,71 @@ var ACP_CONNECTION_HEADER = "acp-connection-id";
 var ACP_SESSION_HEADER = "acp-session-id";
 var CDP_PATH = "/cdp";
 var CDP_BRIDGE_CLIENT_NAME = "qwen-cdp-bridge";
+var CHROME_DEVTOOLS_MCP_SERVER_NAME = "chrome-devtools";
+var RUNTIME_MCP_RETRY_DELAY_MS = 250;
+var RUNTIME_MCP_RETRY_ATTEMPTS = 20;
+var requireFromHere = createRequire(import.meta.url);
+function formatCdpEndpointHost(hostname) {
+  const host = hostname?.trim() || "127.0.0.1";
+  if (host === "0.0.0.0" || host === "::" || host === "[::]") {
+    return "127.0.0.1";
+  }
+  const unbracketed = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  return unbracketed.includes(":") ? `[${unbracketed}]` : unbracketed;
+}
+__name(formatCdpEndpointHost, "formatCdpEndpointHost");
+function isAcpChannelUnavailable(err) {
+  return err?.data?.errorKind === "acp_channel_unavailable";
+}
+__name(isAcpChannelUnavailable, "isAcpChannelUnavailable");
+function delay(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+__name(delay, "delay");
+function buildChromeDevToolsMcpRuntimeConfigFromPackage(localPort, pkgJsonPath, pkgBin, hostname) {
+  if (localPort === void 0 || !Number.isInteger(localPort) || localPort <= 0) {
+    return void 0;
+  }
+  const binRel = typeof pkgBin === "string" ? pkgBin : Object.values(pkgBin ?? {})[0];
+  if (!binRel) return void 0;
+  const pkgDir = path9.dirname(pkgJsonPath);
+  const binPath = path9.resolve(pkgDir, binRel);
+  const binRelToPkg = path9.relative(pkgDir, binPath);
+  if (binRelToPkg.startsWith("..") || path9.isAbsolute(binRelToPkg)) {
+    return void 0;
+  }
+  return {
+    command: process.execPath,
+    args: [
+      binPath,
+      "--wsEndpoint",
+      `ws://${formatCdpEndpointHost(hostname)}:${localPort}/cdp`
+    ],
+    alwaysLoadTools: true,
+    [RUNTIME_MCP_IF_ABSENT_CONFIG_FLAG]: true
+  };
+}
+__name(buildChromeDevToolsMcpRuntimeConfigFromPackage, "buildChromeDevToolsMcpRuntimeConfigFromPackage");
+function buildChromeDevToolsMcpRuntimeConfig(localPort, hostname) {
+  try {
+    const pkgJsonPath = requireFromHere.resolve(
+      "chrome-devtools-mcp/package.json"
+    );
+    const pkg = requireFromHere("chrome-devtools-mcp/package.json");
+    return buildChromeDevToolsMcpRuntimeConfigFromPackage(
+      localPort,
+      pkgJsonPath,
+      pkg.bin,
+      hostname
+    );
+  } catch (err) {
+    writeStderrLine(
+      `qwen serve: chrome-devtools-mcp package not resolvable: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return void 0;
+  }
+}
+__name(buildChromeDevToolsMcpRuntimeConfig, "buildChromeDevToolsMcpRuntimeConfig");
 var WS_BEARER_SUBPROTOCOL_PREFIX = "qwen-bearer.";
 function extractUpgradeBearer(req) {
   const authHeader = req.headers["authorization"];
@@ -8695,6 +9337,7 @@ var WS_READ_METHODS = /* @__PURE__ */ new Set([
   "_qwen/workspace/agents/list",
   "_qwen/workspace/agents/get",
   "_qwen/workspace/memory",
+  "_qwen/workspace/memory/remember/get",
   "_qwen/workspace/auth/status",
   "_qwen/workspace/auth/device_flow/get",
   "_qwen/file/read",
@@ -8718,7 +9361,7 @@ var MAX_INFLIGHT_MCP_DISPATCH = 8;
 function mountAcpHttp(app, bridge, opts) {
   const enabled = opts.enabled ?? process.env["QWEN_SERVE_ACP_HTTP"] !== "0";
   if (!enabled) return void 0;
-  const path12 = opts.path ?? "/acp";
+  const path13 = opts.path ?? "/acp";
   const dispatcherRef = {};
   const registry = new ConnectionRegistry(
     (req, clientId) => {
@@ -8741,17 +9384,121 @@ function mountAcpHttp(app, bridge, opts) {
     },
     opts.maxConnections
   );
+  let cdpMcpRegistered = false;
+  let cdpMcpRegistering;
+  let cdpMcpTerminalSkipLogged = false;
+  async function removeChromeDevToolsMcp(originatorClientId) {
+    if (!cdpMcpRegistered) return;
+    cdpMcpRegistered = false;
+    try {
+      await bridge.removeRuntimeMcpServer(
+        CHROME_DEVTOOLS_MCP_SERVER_NAME,
+        originatorClientId
+      );
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: failed to remove ${CHROME_DEVTOOLS_MCP_SERVER_NAME} runtime MCP: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  __name(removeChromeDevToolsMcp, "removeChromeDevToolsMcp");
+  function removeChromeDevToolsMcpIfUnused(originatorClientId) {
+    void (async () => {
+      if (opts.cdpTunnelRegistry?.hasActive()) return;
+      if (cdpMcpRegistering) await cdpMcpRegistering;
+      if (opts.cdpTunnelRegistry?.hasActive()) return;
+      await removeChromeDevToolsMcp(originatorClientId);
+    })().catch((err) => {
+      writeStderrLine(
+        `qwen serve: failed to clean up ${CHROME_DEVTOOLS_MCP_SERVER_NAME} runtime MCP: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  }
+  __name(removeChromeDevToolsMcpIfUnused, "removeChromeDevToolsMcpIfUnused");
+  function ensureChromeDevToolsMcpRegistered(localPort, originatorClientId) {
+    if (opts.token) {
+      if (!cdpMcpTerminalSkipLogged) {
+        writeStderrLine(
+          `qwen serve: ${CHROME_DEVTOOLS_MCP_SERVER_NAME} runtime MCP skipped because /cdp requires bearer auth`
+        );
+        cdpMcpTerminalSkipLogged = true;
+      }
+      return;
+    }
+    if (cdpMcpRegistered || cdpMcpRegistering || cdpMcpTerminalSkipLogged) {
+      return;
+    }
+    const runtimeConfig = buildChromeDevToolsMcpRuntimeConfig(
+      localPort,
+      opts.hostname
+    );
+    if (!runtimeConfig) {
+      cdpMcpTerminalSkipLogged = true;
+      return;
+    }
+    cdpMcpRegistering = (async () => {
+      try {
+        let result;
+        for (let attempt = 0; ; attempt++) {
+          try {
+            result = await bridge.addRuntimeMcpServer(
+              CHROME_DEVTOOLS_MCP_SERVER_NAME,
+              runtimeConfig,
+              originatorClientId
+            );
+            break;
+          } catch (err) {
+            if (!isAcpChannelUnavailable(err) || attempt >= RUNTIME_MCP_RETRY_ATTEMPTS || !opts.cdpTunnelRegistry?.hasActive()) {
+              throw err;
+            }
+            await delay(RUNTIME_MCP_RETRY_DELAY_MS);
+          }
+        }
+        if (result.skipped) {
+          writeStderrLine(
+            `qwen serve: ${CHROME_DEVTOOLS_MCP_SERVER_NAME} runtime MCP skipped: ${result.reason ?? "unknown"}`
+          );
+          return;
+        }
+        if (result.shadowedSettings) {
+          await bridge.removeRuntimeMcpServer(
+            CHROME_DEVTOOLS_MCP_SERVER_NAME,
+            originatorClientId
+          ).catch(() => {
+          });
+          cdpMcpTerminalSkipLogged = true;
+          writeStderrLine(
+            `qwen serve: ${CHROME_DEVTOOLS_MCP_SERVER_NAME} runtime MCP skipped because settings already define it`
+          );
+          return;
+        }
+        cdpMcpRegistered = true;
+        if (!opts.cdpTunnelRegistry?.hasActive()) {
+          await removeChromeDevToolsMcp(originatorClientId);
+        }
+      } catch (err) {
+        writeStderrLine(
+          `qwen serve: failed to add ${CHROME_DEVTOOLS_MCP_SERVER_NAME} runtime MCP: ${err instanceof Error ? err.message : String(err)}`
+        );
+      } finally {
+        cdpMcpRegistering = void 0;
+      }
+    })();
+  }
+  __name(ensureChromeDevToolsMcpRegistered, "ensureChromeDevToolsMcpRegistered");
   const dispatcher = new AcpDispatcher(
     bridge,
     opts.boundWorkspace,
     opts.workspace,
+    opts.workspaceRememberLane,
     opts.fsFactory,
     opts.deviceFlowRegistry,
     opts.sessionShellCommandEnabled === true,
-    registry
+    registry,
+    opts.archiveCoordinator ?? new SessionArchiveCoordinator()
   );
   dispatcherRef.current = dispatcher;
-  app.post(path12, async (req, res) => {
+  app.post(path13, async (req, res) => {
     const ct = req.headers["content-type"];
     if (!ct || !ct.startsWith("application/json")) {
       res.status(415).json({ error: "Content-Type must be application/json" });
@@ -8855,7 +9602,7 @@ function mountAcpHttp(app, bridge, opts) {
       );
     });
   });
-  app.get(path12, (req, res) => {
+  app.get(path13, (req, res) => {
     const accept = req.headers["accept"] ?? "";
     if (!accept.includes("text/event-stream")) {
       res.status(406).json({ error: "Accept header must include text/event-stream" });
@@ -8941,7 +9688,7 @@ function mountAcpHttp(app, bridge, opts) {
       onPumpSettled();
     });
   });
-  app.delete(path12, (req, res) => {
+  app.delete(path13, (req, res) => {
     const connectionId = headerOf(req, ACP_CONNECTION_HEADER);
     if (!connectionId) {
       res.status(400).json({ error: "Missing Acp-Connection-Id" });
@@ -8983,6 +9730,7 @@ function mountAcpHttp(app, bridge, opts) {
     const expectedTokenHash = opts.token ? createHash3("sha256").update(opts.token).digest() : void 0;
     upgradeListener = /* @__PURE__ */ __name((req, socket, head) => {
       const rawAddr = socket.remoteAddress ?? "ws-unknown";
+      const localPort = socket.localPort;
       const logReject = /* @__PURE__ */ __name((reason) => {
         writeStderrLine(
           `qwen serve: WebSocket upgrade rejected (${reason}) from ${rawAddr}`
@@ -9003,7 +9751,7 @@ function mountAcpHttp(app, bridge, opts) {
       const extraRoute = opts.extraWsRoutes?.find(
         (route) => route.path === url.pathname
       );
-      if (url.pathname !== path12 && !isCdpPath && !extraRoute) {
+      if (url.pathname !== path13 && !isCdpPath && !extraRoute) {
         logReject(`unknown-path ${url.pathname}`);
         socket.destroy();
         return;
@@ -9011,7 +9759,6 @@ function mountAcpHttp(app, bridge, opts) {
       const fromLoopback = isLoopbackSocket(socket);
       if (fromLoopback) {
         const host = (req.headers["host"] ?? "").toLowerCase();
-        const localPort = socket.localPort;
         const allowed = /* @__PURE__ */ new Set([
           `localhost:${localPort}`,
           `127.0.0.1:${localPort}`,
@@ -9028,7 +9775,6 @@ function mountAcpHttp(app, bridge, opts) {
       const origin = req.headers["origin"];
       if (origin) {
         try {
-          const localPort = socket.localPort;
           const isLoopbackOrigin = isSameLoopbackOrigin(origin, localPort);
           const isAllowlistedOrigin = opts.allowedOrigins !== void 0 && opts.allowedOrigins.origins.has(origin.toLowerCase());
           if (!isLoopbackOrigin && !isAllowlistedOrigin) {
@@ -9101,6 +9847,9 @@ function mountAcpHttp(app, bridge, opts) {
           if (cdpBridgeUnregister) {
             cdpBridgeUnregister();
             cdpBridgeUnregister = void 0;
+            removeChromeDevToolsMcpIfUnused(
+              connRef?.connectionId ?? "cdp-bridge"
+            );
           }
         });
         ws.on("message", (rawData) => {
@@ -9322,6 +10071,7 @@ function mountAcpHttp(app, bridge, opts) {
                 routeInbound: /* @__PURE__ */ __name(() => false, "routeInbound")
               };
               cdpBridgeUnregister = opts.cdpTunnelRegistry.register(cdpEndpoint);
+              ensureChromeDevToolsMcpRegistered(localPort, conn2.connectionId);
               writeStderrLine(
                 `qwen serve: /acp connection ${conn2.connectionId.slice(0, 8)} registered as CDP bridge`
               );
@@ -9392,7 +10142,7 @@ function mountAcpHttp(app, bridge, opts) {
       });
     }, "upgradeListener");
     httpServer.on("upgrade", upgradeListener);
-    writeStderrLine(`qwen serve: /acp WebSocket transport enabled on ${path12}`);
+    writeStderrLine(`qwen serve: /acp WebSocket transport enabled on ${path13}`);
   }
   __name(setupWebSocket, "setupWebSocket");
   return {
@@ -9860,7 +10610,7 @@ var CdpTunnelRegistry = class {
 // packages/cli/src/serve/web-shell-static.ts
 init_esbuild_shims();
 var import_express2 = __toESM(require_express(), 1);
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 var WEB_SHELL_CSP_DIRECTIVES = [
   "default-src 'self'",
   "script-src 'self' 'unsafe-inline' 'unsafe-eval' 'wasm-unsafe-eval'",
@@ -9888,7 +10638,7 @@ function isDocumentNavigation(req) {
 }
 __name(isDocumentNavigation, "isDocumentNavigation");
 function createSendIndex(webShellDir, frameAncestors = []) {
-  const indexPath = path9.join(webShellDir, "index.html");
+  const indexPath = path10.join(webShellDir, "index.html");
   const csp = buildWebShellCsp(frameAncestors);
   return (res) => {
     res.status(200).set("Content-Security-Policy", csp).set("X-Content-Type-Options", "nosniff").set("Referrer-Policy", "no-referrer").set(
@@ -9924,7 +10674,7 @@ function mountWebShellAssets(app, webShellDir, frameAncestors = []) {
   const sendIndex = createSendIndex(webShellDir, frameAncestors);
   app.use(
     "/assets",
-    import_express2.default.static(path9.join(webShellDir, "assets"), {
+    import_express2.default.static(path10.join(webShellDir, "assets"), {
       index: false,
       immutable: true,
       maxAge: "1y"
@@ -9956,43 +10706,301 @@ function mountWebShellSpaFallback(app, webShellDir, frameAncestors = []) {
 }
 __name(mountWebShellSpaFallback, "mountWebShellSpaFallback");
 
-// packages/cli/src/serve/routes/daemon-status.ts
+// packages/cli/src/serve/workspace-remember.ts
 init_esbuild_shims();
-function registerDaemonStatusRoutes(app, deps) {
-  app.get("/daemon/status", async (req, res) => {
-    const detail = parseDaemonStatusDetail(req.query["detail"]);
-    if (!detail.ok || !detail.detail) {
-      res.status(400).json({
-        error: "detail must be one of: summary, full",
-        code: "invalid_detail"
+import { randomUUID as randomUUID2 } from "node:crypto";
+var debugLogger2 = createDebugLogger("WORKSPACE_REMEMBER");
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+__name(nowIso, "nowIso");
+function createRememberTaskId() {
+  return `remember-${randomUUID2()}`;
+}
+__name(createRememberTaskId, "createRememberTaskId");
+function cloneTask(task) {
+  return {
+    taskId: task.taskId,
+    status: task.status,
+    contextMode: task.contextMode,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    result: task.result ? {
+      ...task.result,
+      filesTouched: [...task.result.filesTouched],
+      touchedScopes: [...task.result.touchedScopes]
+    } : void 0,
+    error: task.error ? { ...task.error } : void 0
+  };
+}
+__name(cloneTask, "cloneTask");
+function publicErrorMessage(code) {
+  if (code === "managed_memory_unavailable") {
+    return "Managed memory is unavailable for this daemon workspace.";
+  }
+  if (code === "remember_path_escape") {
+    return "Remember agent touched a path outside managed memory.";
+  }
+  if (code === "remember_queue_full") {
+    return "Workspace memory remember queue is full.";
+  }
+  if (code === "remember_timeout") {
+    return "Workspace memory remember timed out.";
+  }
+  return "Workspace memory remember failed.";
+}
+__name(publicErrorMessage, "publicErrorMessage");
+function publicErrorStatus(code) {
+  if (code === "remember_queue_full") return 429;
+  if (code === "managed_memory_unavailable") return 409;
+  return 500;
+}
+__name(publicErrorStatus, "publicErrorStatus");
+var WorkspaceRememberTaskLane = class _WorkspaceRememberTaskLane {
+  constructor(bridge) {
+    this.bridge = bridge;
+  }
+  static {
+    __name(this, "WorkspaceRememberTaskLane");
+  }
+  static MAX_TASKS = 1e3;
+  static MAX_PENDING = 16;
+  tasks = /* @__PURE__ */ new Map();
+  tail = Promise.resolve();
+  pendingCount() {
+    let count = 0;
+    for (const task of this.tasks.values()) {
+      if (task.status === "queued" || task.status === "running") count++;
+    }
+    return count;
+  }
+  evictTerminalTasks() {
+    if (this.tasks.size <= _WorkspaceRememberTaskLane.MAX_TASKS) return;
+    for (const [id, task] of this.tasks) {
+      if (task.status === "completed" || task.status === "failed") {
+        this.tasks.delete(id);
+        if (this.tasks.size <= _WorkspaceRememberTaskLane.MAX_TASKS) break;
+      }
+    }
+  }
+  enqueue(params) {
+    if (this.pendingCount() >= _WorkspaceRememberTaskLane.MAX_PENDING) {
+      throw Object.assign(new Error("Remember queue is full"), {
+        code: "remember_queue_full"
       });
-      return;
     }
-    try {
-      res.status(200).json(
-        await buildDaemonStatusResponse(detail.detail, {
-          opts: deps.opts,
-          boundWorkspace: deps.boundWorkspace,
-          bridge: deps.bridge,
-          workspace: deps.workspace,
-          daemonLog: deps.daemonLog,
-          startup: deps.startup,
-          qwenCodeVersion: deps.qwenCodeVersion,
-          acpHandle: deps.getAcpHandle(),
-          rateLimiter: deps.getRateLimiter(),
-          getRestSseActive: deps.getRestSseActive,
-          features: deps.currentServeFeatures(),
-          protocolVersions: getServeProtocolVersions(),
-          supportedDeviceFlowProviders: deps.getSupportedDeviceFlowProviders(),
-          deviceFlowRegistry: deps.deviceFlowRegistry,
-          sessionShellCommandEnabled: deps.sessionShellCommandEnabled
-        })
-      );
-    } catch (err) {
-      writeStderrLine(
-        `qwen serve: /daemon/status failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-      res.status(500).json({
+    const task = {
+      taskId: createRememberTaskId(),
+      status: "queued",
+      contextMode: params.contextMode,
+      createdAt: nowIso(),
+      updatedAt: nowIso(),
+      ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
+    };
+    this.tasks.set(task.taskId, task);
+    this.evictTerminalTasks();
+    const run = /* @__PURE__ */ __name(async () => {
+      task.status = "running";
+      task.updatedAt = nowIso();
+      try {
+        const result = await this.bridge.runWorkspaceMemoryRemember({
+          content: params.content,
+          contextMode: params.contextMode
+        });
+        task.status = "completed";
+        task.result = {
+          summary: result.filesTouched.length > 0 ? "Memory update completed." : "No memory files updated.",
+          filesTouched: result.filesTouched,
+          touchedScopes: result.touchedScopes
+        };
+        task.updatedAt = nowIso();
+      } catch (err) {
+        const code = extractRememberErrorCode(err);
+        debugLogger2.error("Remember task failed:", err);
+        task.status = "failed";
+        task.error = {
+          code,
+          message: publicErrorMessage(code)
+        };
+        task.updatedAt = nowIso();
+      } finally {
+        this.evictTerminalTasks();
+      }
+      if (task.status === "completed" && task.result && task.result.touchedScopes.length > 0) {
+        try {
+          this.bridge.publishWorkspaceEvent({
+            type: "memory_changed",
+            data: {
+              scope: "managed",
+              source: "workspace_memory_remember",
+              taskId: task.taskId,
+              touchedScopes: task.result.touchedScopes
+            },
+            ...params.originatorClientId ? { originatorClientId: params.originatorClientId } : {}
+          });
+        } catch (err) {
+          debugLogger2.error("Failed to publish memory_changed event:", err);
+        }
+      }
+    }, "run");
+    this.tail = this.tail.then(run, run);
+    void this.tail.catch((err) => {
+      debugLogger2.error("Unhandled task lane error:", err);
+    });
+    return cloneTask(task);
+  }
+  get(taskId, requesterClientId) {
+    const task = this.tasks.get(taskId);
+    if (!task) return void 0;
+    if (task.originatorClientId) {
+      if (task.originatorClientId !== requesterClientId) return void 0;
+    } else if (requesterClientId) {
+      return void 0;
+    }
+    return cloneTask(task);
+  }
+};
+function validateOriginatorClientId(deps, req, res) {
+  const clientId = deps.parseClientId(req, res);
+  if (clientId === null) return null;
+  if (clientId === void 0) return void 0;
+  const known = deps.bridge.knownClientIds();
+  if (!known.has(clientId)) {
+    res.status(400).json({
+      error: `Client id "${clientId}" is not registered for this workspace`,
+      code: "invalid_client_id",
+      clientId
+    });
+    return null;
+  }
+  return clientId;
+}
+__name(validateOriginatorClientId, "validateOriginatorClientId");
+function mountWorkspaceMemoryRememberRoutes(app, deps) {
+  app.post(
+    "/workspace/memory/remember",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const body = deps.safeBody(req);
+      const content = body["content"];
+      const trimmedContent = typeof content === "string" ? content.trim() : "";
+      if (!trimmedContent) {
+        res.status(400).json({
+          error: "`content` must be a non-empty string",
+          code: "invalid_content"
+        });
+        return;
+      }
+      if (Buffer.byteLength(trimmedContent, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
+        res.status(400).json({
+          error: `\`content\` exceeds the ${MAX_REMEMBER_CONTENT_BYTES}-byte limit`,
+          code: "invalid_content"
+        });
+        return;
+      }
+      const contextModeRaw = body["contextMode"] ?? "workspace";
+      if (contextModeRaw !== "workspace" && contextModeRaw !== "clean") {
+        res.status(400).json({
+          error: '`contextMode` must be "workspace", "clean", or omitted',
+          code: "invalid_context_mode"
+        });
+        return;
+      }
+      const originatorClientId = validateOriginatorClientId(deps, req, res);
+      if (originatorClientId === null) return;
+      try {
+        const available = await deps.bridge.isWorkspaceMemoryRememberAvailable();
+        if (!available) {
+          res.status(409).json({
+            error: "Managed memory is unavailable for this daemon workspace",
+            code: "managed_memory_unavailable"
+          });
+          return;
+        }
+      } catch (err) {
+        debugLogger2.error("Availability check failed:", err);
+        res.status(500).json({
+          error: "Workspace memory remember failed.",
+          code: "remember_failed"
+        });
+        return;
+      }
+      let task;
+      try {
+        task = deps.lane.enqueue({
+          content: trimmedContent,
+          contextMode: contextModeRaw,
+          ...originatorClientId ? { originatorClientId } : {}
+        });
+      } catch (err) {
+        const code = extractRememberErrorCode(err);
+        res.status(publicErrorStatus(code)).json({
+          error: publicErrorMessage(code),
+          code
+        });
+        return;
+      }
+      res.status(202).json(task);
+    }
+  );
+  app.get(
+    "/workspace/memory/remember/:taskId",
+    deps.mutate({ strict: true }),
+    (req, res) => {
+      const requesterClientId = validateOriginatorClientId(deps, req, res);
+      if (requesterClientId === null) return;
+      const task = deps.lane.get(req.params["taskId"], requesterClientId);
+      if (!task) {
+        res.status(404).json({
+          error: "Workspace memory remember task not found",
+          code: "remember_task_not_found"
+        });
+        return;
+      }
+      res.status(200).json(task);
+    }
+  );
+}
+__name(mountWorkspaceMemoryRememberRoutes, "mountWorkspaceMemoryRememberRoutes");
+
+// packages/cli/src/serve/routes/daemon-status.ts
+init_esbuild_shims();
+function registerDaemonStatusRoutes(app, deps) {
+  app.get("/daemon/status", async (req, res) => {
+    const detail = parseDaemonStatusDetail(req.query["detail"]);
+    if (!detail.ok || !detail.detail) {
+      res.status(400).json({
+        error: "detail must be one of: summary, full",
+        code: "invalid_detail"
+      });
+      return;
+    }
+    try {
+      res.status(200).json(
+        await buildDaemonStatusResponse(detail.detail, {
+          opts: deps.opts,
+          boundWorkspace: deps.boundWorkspace,
+          bridge: deps.bridge,
+          workspace: deps.workspace,
+          daemonLog: deps.daemonLog,
+          startup: deps.startup,
+          qwenCodeVersion: deps.qwenCodeVersion,
+          acpHandle: deps.getAcpHandle(),
+          rateLimiter: deps.getRateLimiter(),
+          getRestSseActive: deps.getRestSseActive,
+          features: deps.currentServeFeatures(),
+          protocolVersions: getServeProtocolVersions(),
+          supportedDeviceFlowProviders: deps.getSupportedDeviceFlowProviders(),
+          deviceFlowRegistry: deps.deviceFlowRegistry,
+          sessionShellCommandEnabled: deps.sessionShellCommandEnabled,
+          getChannelWorkerSnapshot: deps.getChannelWorkerSnapshot
+        })
+      );
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: /daemon/status failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
         error: "Failed to build daemon status",
         code: "daemon_status_failed"
       });
@@ -11225,14 +12233,14 @@ function registerWorkspaceExtensionRoutes(app, deps) {
       code: "extension_queue_full"
     });
   }, "sendExtensionQueueFull");
-  const withExtensionTimeout = /* @__PURE__ */ __name(async (promise, timeoutMs, operation) => await new Promise((resolve4, reject) => {
+  const withExtensionTimeout = /* @__PURE__ */ __name(async (promise, timeoutMs, operation) => await new Promise((resolve5, reject) => {
     const timeout = setTimeout(() => {
       reject(new Error(`${operation} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     promise.then(
       (value) => {
         clearTimeout(timeout);
-        resolve4(value);
+        resolve5(value);
       },
       (err) => {
         clearTimeout(timeout);
@@ -12348,7 +13356,7 @@ __name(registerPermissionRoutes, "registerPermissionRoutes");
 // packages/cli/src/serve/routes/session.ts
 init_esbuild_shims();
 import * as crypto2 from "node:crypto";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 
 // packages/cli/src/serve/server/prompt-deadline.ts
 init_esbuild_shims();
@@ -12407,9 +13415,11 @@ async function listWorkspaceSessionsForResponse(bridge, workspaceCwd, options) {
   }
   const isFirstPage = numericCursor === void 0;
   const sessionService = new SessionService(workspaceCwd);
+  const archiveState = options?.archiveState ?? "active";
   const persisted = await sessionService.listSessions({
     cursor: numericCursor,
-    size: pageSize
+    size: pageSize,
+    archiveState
   });
   const bySessionId = /* @__PURE__ */ new Map();
   for (const item of persisted.items) {
@@ -12420,9 +13430,15 @@ async function listWorkspaceSessionsForResponse(bridge, workspaceCwd, options) {
       updatedAt: new Date(item.mtime).toISOString(),
       displayName: item.customTitle || item.prompt,
       clientCount: 0,
-      hasActivePrompt: false
+      hasActivePrompt: false,
+      isArchived: item.isArchived === true
     });
   }
+  if (archiveState === "archived") {
+    const sessions2 = [...bySessionId.values()];
+    const nextCursor2 = persisted.nextCursor != null ? String(persisted.nextCursor) : void 0;
+    return { sessions: sessions2, nextCursor: nextCursor2 };
+  }
   const liveSessions = bridge.listWorkspaceSessions(workspaceCwd);
   for (const live of liveSessions) {
     const existing = bySessionId.get(live.sessionId);
@@ -12434,14 +13450,16 @@ async function listWorkspaceSessionsForResponse(bridge, workspaceCwd, options) {
         displayName: live.displayName ?? existing.displayName,
         updatedAt: live.updatedAt ?? existing.updatedAt,
         clientCount: live.clientCount,
-        hasActivePrompt: live.hasActivePrompt
+        hasActivePrompt: live.hasActivePrompt,
+        isArchived: false
       });
     } else if (isFirstPage && !await sessionService.sessionExists(live.sessionId)) {
       bySessionId.set(live.sessionId, {
         ...live,
         createdAt: live.createdAt,
         clientCount: live.clientCount,
-        hasActivePrompt: live.hasActivePrompt
+        hasActivePrompt: live.hasActivePrompt,
+        isArchived: false
       });
     }
   }
@@ -12470,6 +13488,7 @@ function registerSessionRoutes(app, deps) {
   const {
     boundWorkspace,
     bridge,
+    archiveCoordinator,
     mutate,
     sendBridgeError: sendBridgeError2,
     daemonLog,
@@ -12477,6 +13496,33 @@ function registerSessionRoutes(app, deps) {
     sessionShellCommandEnabled
   } = deps;
   const LANGUAGE_CODES = deps.languageCodes;
+  const parseSessionIdsBody = /* @__PURE__ */ __name((req, res) => {
+    const body = safeBody(req);
+    const sessionIds = body["sessionIds"];
+    if (!Array.isArray(sessionIds) || sessionIds.length === 0 || sessionIds.length > 100 || !sessionIds.every((id) => typeof id === "string")) {
+      res.status(400).json({
+        error: "`sessionIds` must be a non-empty string array (max 100)",
+        code: "invalid_request"
+      });
+      return void 0;
+    }
+    return [...new Set(sessionIds)];
+  }, "parseSessionIdsBody");
+  const serializeSessionErrors = /* @__PURE__ */ __name((errors) => errors.map((e) => ({
+    sessionId: e.sessionId,
+    error: e.error instanceof Error ? e.error.message : String(e.error)
+  })), "serializeSessionErrors");
+  const withMutableSession = /* @__PURE__ */ __name((route, handler) => async (req, res) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    try {
+      await archiveCoordinator.runSharedMany([sessionId], async () => {
+        await handler(req, res, sessionId);
+      });
+    } catch (err) {
+      sendBridgeError2(res, err, { route, sessionId });
+    }
+  }, "withMutableSession");
   app.post("/session", mutate(), async (req, res) => {
     const body = safeBody(req);
     const cwd = parseOptionalWorkspaceCwd(body, boundWorkspace, res);
@@ -12542,15 +13588,21 @@ function registerSessionRoutes(app, deps) {
     const clientId = parseClientIdHeader(req, res);
     if (clientId === null) return;
     try {
-      const session = action === "load" ? await bridge.loadSession({
-        sessionId,
-        workspaceCwd: cwd,
-        ...clientId !== void 0 ? { clientId } : {}
-      }) : await bridge.resumeSession({
-        sessionId,
-        workspaceCwd: cwd,
-        ...clientId !== void 0 ? { clientId } : {}
-      });
+      const session = await archiveCoordinator.runSharedMany(
+        [sessionId],
+        async () => {
+          await assertSessionLoadable(cwd, sessionId);
+          return action === "load" ? await bridge.loadSession({
+            sessionId,
+            workspaceCwd: cwd,
+            ...clientId !== void 0 ? { clientId } : {}
+          }) : await bridge.resumeSession({
+            sessionId,
+            workspaceCwd: cwd,
+            ...clientId !== void 0 ? { clientId } : {}
+          });
+        }
+      );
       if (daemonLog) {
         daemonLog.info(
           `session ${action}${session.attached ? " (attached)" : ""}`,
@@ -12577,99 +13629,90 @@ function registerSessionRoutes(app, deps) {
   }, "restoreSessionHandler");
   app.post("/session/:id/load", mutate(), restoreSessionHandler("load"));
   app.post("/session/:id/resume", mutate(), restoreSessionHandler("resume"));
-  app.post("/session/:id/branch", mutate(), async (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const body = safeBody(req);
-    let name = typeof body?.["name"] === "string" ? body["name"] : void 0;
-    if (name) {
-      name = name.replace(/[\x00-\x1F\x7F-\x9F]/g, "");
-      if (name.length > 200) {
-        name = name.slice(0, 200);
+  app.post(
+    "/session/:id/branch",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/branch",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        let name = typeof body?.["name"] === "string" ? body["name"] : void 0;
+        if (name) {
+          name = name.replace(/[\x00-\x1F\x7F-\x9F]/g, "");
+          if (name.length > 200) {
+            name = name.slice(0, 200);
+          }
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const result = await bridge.branchSession(
+          sessionId,
+          { name },
+          { clientId }
+        );
+        if (!res.writable) {
+          if (!result.attached) {
+            bridge.killSession(result.sessionId, { requireZeroAttaches: true }).catch(() => {
+            });
+          } else {
+            bridge.detachClient(result.sessionId, result.clientId).catch(() => {
+            });
+          }
+          return;
+        }
+        res.status(201).json(result);
       }
-    }
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
-      const result = await bridge.branchSession(
-        sessionId,
-        { name },
-        { clientId }
-      );
-      if (!res.writable) {
-        if (!result.attached) {
-          bridge.killSession(result.sessionId, { requireZeroAttaches: true }).catch(() => {
-          });
-        } else {
-          bridge.detachClient(result.sessionId, result.clientId).catch(() => {
+    )
+  );
+  app.post(
+    "/session/:id/fork",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/fork",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        const directive = body["directive"];
+        if (typeof directive !== "string" || directive.trim().length === 0) {
+          res.status(400).json({
+            error: "`directive` is required and must be a non-empty string",
+            code: "missing_directive"
           });
+          return;
         }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const result = await bridge.launchSessionForkAgent(
+          sessionId,
+          directive,
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(202).json(result);
+      }
+    )
+  );
+  app.post(
+    "/session/:id/cd",
+    mutate(),
+    withMutableSession("POST /session/:id/cd", async (req, res, sessionId) => {
+      const body = safeBody(req);
+      const targetPath = body["path"];
+      if (typeof targetPath !== "string" || targetPath.length === 0 || !path11.isAbsolute(targetPath)) {
+        res.status(400).json({
+          error: "`path` is required and must be an absolute path",
+          code: "invalid_path"
+        });
         return;
       }
-      res.status(201).json(result);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/branch",
-        sessionId
-      });
-    }
-  });
-  app.post("/session/:id/fork", mutate(), async (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const body = safeBody(req);
-    const directive = body["directive"];
-    if (typeof directive !== "string" || directive.trim().length === 0) {
-      res.status(400).json({
-        error: "`directive` is required and must be a non-empty string",
-        code: "missing_directive"
-      });
-      return;
-    }
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
-      const result = await bridge.launchSessionForkAgent(
-        sessionId,
-        directive,
-        clientId !== void 0 ? { clientId } : void 0
-      );
-      res.status(202).json(result);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/fork",
-        sessionId
-      });
-    }
-  });
-  app.post("/session/:id/cd", mutate(), async (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const body = safeBody(req);
-    const targetPath = body["path"];
-    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"
-      });
-      return;
-    }
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
+      const clientId = parseClientIdHeader(req, res);
+      if (clientId === null) return;
       const result = await bridge.changeSessionCwd(
         sessionId,
         { path: targetPath },
         clientId !== void 0 ? { clientId } : void 0
       );
       res.status(200).json(result);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/cd",
-        sessionId
-      });
-    }
-  });
+    })
+  );
   app.get("/session/:id/status", (req, res) => {
     const sessionId = requireSessionId(req, res);
     if (sessionId === null) return;
@@ -12770,283 +13813,252 @@ function registerSessionRoutes(app, deps) {
   app.post(
     "/session/:id/tasks/:taskId/cancel",
     mutate({ strict: true }),
-    async (req, res) => {
-      const sessionId = req.params["id"];
-      const taskId = req.params["taskId"];
-      if (!sessionId || !taskId) {
-        res.status(400).json({
-          error: "`sessionId` and `taskId` route parameters are required"
-        });
-        return;
-      }
-      const body = safeBody(req);
-      const kind = body["kind"];
-      if (kind !== "agent" && kind !== "shell" && kind !== "monitor") {
-        res.status(400).json({ error: '`kind` must be "agent", "shell", or "monitor"' });
-        return;
-      }
-      try {
+    withMutableSession(
+      "POST /session/:id/tasks/:taskId/cancel",
+      async (req, res, sessionId) => {
+        const taskId = req.params["taskId"];
+        if (!taskId) {
+          res.status(400).json({
+            error: "`taskId` route parameter is required"
+          });
+          return;
+        }
+        const body = safeBody(req);
+        const kind = body["kind"];
+        if (kind !== "agent" && kind !== "shell" && kind !== "monitor") {
+          res.status(400).json({ error: '`kind` must be "agent", "shell", or "monitor"' });
+          return;
+        }
         res.status(200).json(await bridge.cancelSessionTask(sessionId, taskId, kind));
-      } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "POST /session/:id/tasks/:taskId/cancel",
-          sessionId
-        });
       }
-    }
+    )
   );
   app.post(
     "/session/:id/goal/clear",
     mutate({ strict: true }),
-    async (req, res) => {
-      const sessionId = req.params["id"];
-      if (!sessionId) {
-        res.status(400).json({ error: "`sessionId` route parameter is required" });
-        return;
-      }
-      try {
+    withMutableSession(
+      "POST /session/:id/goal/clear",
+      async (_req, res, sessionId) => {
         res.status(200).json(await bridge.clearSessionGoal(sessionId));
-      } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "POST /session/:id/goal/clear",
-          sessionId
-        });
       }
-    }
+    )
   );
   app.post(
     "/session/:id/continue",
     mutate({ strict: true }),
-    async (req, res) => {
-      const sessionId = req.params["id"];
-      if (!sessionId) {
-        res.status(400).json({ error: "`sessionId` route parameter is required" });
-        return;
-      }
-      const clientId = parseClientIdHeader(req, res);
-      if (clientId === null) return;
-      const promptId = crypto2.randomUUID();
-      try {
+    withMutableSession(
+      "POST /session/:id/continue",
+      async (req, res, sessionId) => {
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const promptId = crypto2.randomUUID();
         res.status(200).json(
           await bridge.continueSession(sessionId, {
             ...clientId !== void 0 ? { clientId } : {},
             promptId
           })
         );
-      } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "POST /session/:id/continue",
-          sessionId
-        });
       }
-    }
+    )
   );
-  app.post("/session/:id/prompt", mutate(), async (req, res) => {
-    const sessionId = req.params["id"];
-    const body = safeBody(req);
-    const prompt = body["prompt"];
-    if (!Array.isArray(prompt) || prompt.length === 0) {
-      res.status(400).json({
-        error: "`prompt` is required and must be a non-empty array of content blocks"
-      });
-      return;
-    }
-    if (!prompt.every(
-      (item) => typeof item === "object" && item !== null && !Array.isArray(item)
-    )) {
-      res.status(400).json({
-        error: "each `prompt` element must be an object (content block)"
-      });
-      return;
-    }
-    const rawRequestDeadline = body["deadlineMs"];
-    let requestDeadlineMs;
-    if (rawRequestDeadline !== void 0 && rawRequestDeadline !== null) {
-      if (typeof rawRequestDeadline !== "number" || !Number.isFinite(rawRequestDeadline) || !Number.isInteger(rawRequestDeadline) || rawRequestDeadline <= 0) {
-        res.status(400).json({
-          error: "`deadlineMs` must be a positive integer (milliseconds)",
-          code: "invalid_deadline_ms"
-        });
-        return;
-      }
-      requestDeadlineMs = rawRequestDeadline;
-    }
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    const promptId = crypto2.randomUUID();
-    const forwardedBody = { ...body };
-    delete forwardedBody["deadlineMs"];
-    let lastEventId;
-    try {
-      lastEventId = bridge.getSessionLastEventId(sessionId);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/prompt",
-        sessionId
-      });
-      return;
-    }
-    addDaemonRequestAttribute("qwen-code.prompt_id", promptId);
-    const abort = new AbortController();
-    let responseFinished = false;
-    const onResClose = /* @__PURE__ */ __name(() => {
-      if (!responseFinished) abort.abort();
-    }, "onResClose");
-    const onResFinish = /* @__PURE__ */ __name(() => {
-      responseFinished = true;
-      res.off("close", onResClose);
-    }, "onResFinish");
-    res.once("close", onResClose);
-    res.once("finish", onResFinish);
-    const effectiveDeadlineMs = resolvePromptDeadlineMs(
-      promptDeadlineMs,
-      requestDeadlineMs
-    );
-    let deadlineTimer;
-    if (effectiveDeadlineMs !== void 0) {
-      deadlineTimer = setTimeout(() => {
-        if (!abort.signal.aborted) {
-          abort.abort(new PromptDeadlineExceededError(effectiveDeadlineMs));
+  app.post(
+    "/session/:id/prompt",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/prompt",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        const prompt = body["prompt"];
+        if (!Array.isArray(prompt) || prompt.length === 0) {
+          res.status(400).json({
+            error: "`prompt` is required and must be a non-empty array of content blocks"
+          });
+          return;
         }
-      }, effectiveDeadlineMs);
-      deadlineTimer.unref();
-    }
-    let promptPromise;
-    try {
-      promptPromise = bridge.sendPrompt(
-        sessionId,
-        {
-          ...forwardedBody,
-          sessionId,
-          prompt
-        },
-        abort.signal,
-        {
-          ...clientId !== void 0 ? { clientId } : {},
-          promptId
+        if (!prompt.every(
+          (item) => typeof item === "object" && item !== null && !Array.isArray(item)
+        )) {
+          res.status(400).json({
+            error: "each `prompt` element must be an object (content block)"
+          });
+          return;
         }
-      );
-    } catch (err) {
-      if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
-      res.off("close", onResClose);
-      res.off("finish", onResFinish);
-      if (daemonLog && err instanceof PromptQueueFullError) {
-        daemonLog.warn("prompt admission rejected: queue full", {
-          sessionId,
-          promptId,
-          ...clientId !== void 0 ? { clientId } : {},
-          limit: err.limit,
-          pendingCount: err.pendingCount
-        });
-      }
-      if (daemonLog && err instanceof InvalidClientIdError) {
-        daemonLog.warn("prompt admission rejected: invalid client id", {
-          sessionId,
-          promptId,
-          ...clientId !== void 0 ? { clientId } : {}
-        });
-      }
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/prompt",
-        sessionId
-      });
-      return;
-    }
-    res.off("close", onResClose);
-    promptPromise.then(
-      () => {
-        if (daemonLog) {
-          daemonLog.info("prompt turn completed", {
+        const rawRequestDeadline = body["deadlineMs"];
+        let requestDeadlineMs;
+        if (rawRequestDeadline !== void 0 && rawRequestDeadline !== null) {
+          if (typeof rawRequestDeadline !== "number" || !Number.isFinite(rawRequestDeadline) || !Number.isInteger(rawRequestDeadline) || rawRequestDeadline <= 0) {
+            res.status(400).json({
+              error: "`deadlineMs` must be a positive integer (milliseconds)",
+              code: "invalid_deadline_ms"
+            });
+            return;
+          }
+          requestDeadlineMs = rawRequestDeadline;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const promptId = crypto2.randomUUID();
+        const forwardedBody = { ...body };
+        delete forwardedBody["deadlineMs"];
+        const lastEventId = bridge.getSessionLastEventId(sessionId);
+        addDaemonRequestAttribute("qwen-code.prompt_id", promptId);
+        const abort = new AbortController();
+        let responseFinished = false;
+        const onResClose = /* @__PURE__ */ __name(() => {
+          if (!responseFinished) abort.abort();
+        }, "onResClose");
+        const onResFinish = /* @__PURE__ */ __name(() => {
+          responseFinished = true;
+          res.off("close", onResClose);
+        }, "onResFinish");
+        res.once("close", onResClose);
+        res.once("finish", onResFinish);
+        const effectiveDeadlineMs = resolvePromptDeadlineMs(
+          promptDeadlineMs,
+          requestDeadlineMs
+        );
+        let deadlineTimer;
+        if (effectiveDeadlineMs !== void 0) {
+          deadlineTimer = setTimeout(() => {
+            if (!abort.signal.aborted) {
+              abort.abort(new PromptDeadlineExceededError(effectiveDeadlineMs));
+            }
+          }, effectiveDeadlineMs);
+          deadlineTimer.unref();
+        }
+        let promptPromise;
+        try {
+          promptPromise = bridge.sendPrompt(
             sessionId,
-            promptId,
-            clientId
+            {
+              ...forwardedBody,
+              sessionId,
+              prompt
+            },
+            abort.signal,
+            {
+              ...clientId !== void 0 ? { clientId } : {},
+              promptId
+            }
+          );
+        } catch (err) {
+          if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
+          res.off("close", onResClose);
+          res.off("finish", onResFinish);
+          if (daemonLog && err instanceof PromptQueueFullError) {
+            daemonLog.warn("prompt admission rejected: queue full", {
+              sessionId,
+              promptId,
+              ...clientId !== void 0 ? { clientId } : {},
+              limit: err.limit,
+              pendingCount: err.pendingCount
+            });
+          }
+          if (daemonLog && err instanceof InvalidClientIdError) {
+            daemonLog.warn("prompt admission rejected: invalid client id", {
+              sessionId,
+              promptId,
+              ...clientId !== void 0 ? { clientId } : {}
+            });
+          }
+          sendBridgeError2(res, err, {
+            route: "POST /session/:id/prompt",
+            sessionId
           });
+          return;
         }
-      },
-      (err) => {
+        res.off("close", onResClose);
+        promptPromise.then(
+          () => {
+            if (daemonLog) {
+              daemonLog.info("prompt turn completed", {
+                sessionId,
+                promptId,
+                clientId
+              });
+            }
+          },
+          (err) => {
+            if (daemonLog) {
+              const errName = err instanceof Error ? err.name : void 0;
+              daemonLog.warn(
+                `prompt turn failed: ${errName ? `[${errName}] ` : ""}${err instanceof Error ? err.message : String(err)}`,
+                { sessionId, promptId, clientId }
+              );
+            }
+          }
+        ).finally(() => {
+          if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
+        }).catch(() => {
+        });
         if (daemonLog) {
-          const errName = err instanceof Error ? err.name : void 0;
-          daemonLog.warn(
-            `prompt turn failed: ${errName ? `[${errName}] ` : ""}${err instanceof Error ? err.message : String(err)}`,
-            { sessionId, promptId, clientId }
-          );
+          daemonLog.info("prompt enqueued", { sessionId, promptId, clientId });
         }
+        res.status(202).json({ promptId, lastEventId });
       }
-    ).finally(() => {
-      if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
-    }).catch(() => {
-    });
-    if (daemonLog) {
-      daemonLog.info("prompt enqueued", { sessionId, promptId, clientId });
-    }
-    res.status(202).json({ promptId, lastEventId });
-  });
-  app.post("/session/:id/heartbeat", mutate(), (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
+    )
+  );
+  app.post(
+    "/session/:id/heartbeat",
+    mutate(),
+    withMutableSession("POST /session/:id/heartbeat", (req, res, sessionId) => {
+      const clientId = parseClientIdHeader(req, res);
+      if (clientId === null) return;
       const result = bridge.recordHeartbeat(
         sessionId,
         clientId !== void 0 ? { clientId } : void 0
       );
       res.status(200).json(result);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/heartbeat",
-        sessionId
-      });
-    }
-  });
-  app.post("/session/:id/detach", mutate(), async (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
-      await bridge.detachClient(sessionId, clientId);
-      res.status(204).end();
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/detach",
-        sessionId
-      });
-    }
-  });
-  app.post("/session/:id/cancel", mutate(), async (req, res) => {
-    const sessionId = req.params["id"];
-    const body = safeBody(req);
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
-      await bridge.cancelSession(
-        sessionId,
-        {
-          ...body,
-          sessionId
-        },
-        clientId !== void 0 ? { clientId } : void 0
-      );
-      if (daemonLog) {
-        daemonLog.info("cancel sent", { sessionId, clientId });
+    })
+  );
+  app.post(
+    "/session/:id/detach",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/detach",
+      async (req, res, sessionId) => {
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        await bridge.detachClient(sessionId, clientId);
+        res.status(204).end();
       }
-      res.status(204).end();
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/cancel",
-        sessionId
-      });
-    }
-  });
+    )
+  );
+  app.post(
+    "/session/:id/cancel",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/cancel",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        await bridge.cancelSession(
+          sessionId,
+          {
+            ...body,
+            sessionId
+          },
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        if (daemonLog) {
+          daemonLog.info("cancel sent", { sessionId, clientId });
+        }
+        res.status(204).end();
+      }
+    )
+  );
   app.delete("/session/:id", async (req, res) => {
     const sessionId = req.params["id"];
     const clientId = parseClientIdHeader(req, res);
     if (clientId === null) return;
     try {
-      await bridge.closeSession(
-        sessionId,
-        clientId !== void 0 ? { clientId } : void 0
+      await archiveCoordinator.runExclusiveMany(
+        [sessionId],
+        async () => bridge.closeSession(
+          sessionId,
+          clientId !== void 0 ? { clientId } : void 0
+        )
       );
       res.status(204).end();
     } catch (err) {
@@ -13059,106 +14071,98 @@ function registerSessionRoutes(app, deps) {
   app.post("/sessions/delete", mutate(), async (req, res) => {
     const clientId = parseClientIdHeader(req, res);
     if (clientId === null) return;
-    const body = safeBody(req);
-    const sessionIds = body["sessionIds"];
-    if (!Array.isArray(sessionIds) || sessionIds.length === 0 || sessionIds.length > 100 || !sessionIds.every((id) => typeof id === "string")) {
-      res.status(400).json({
-        error: "`sessionIds` must be a non-empty string array (max 100)",
-        code: "invalid_request"
+    const uniqueIds = parseSessionIdsBody(req, res);
+    if (uniqueIds === void 0) return;
+    try {
+      const service = new SessionService(boundWorkspace);
+      const result = await deleteDaemonSessions({
+        sessionIds: uniqueIds,
+        service,
+        bridge,
+        coordinator: archiveCoordinator,
+        onError: /* @__PURE__ */ __name(({ phase, sessionId, error: error2 }) => {
+          writeStderrLine(
+            `qwen serve: ${phase}Session failed for ${safeLogValue(sessionId)}: ${safeLogValue(error2)}`
+          );
+        }, "onError")
       });
-      return;
+      res.status(200).json(result);
+    } catch (err) {
+      sendBridgeError2(res, err, { route: "POST /sessions/delete" });
     }
+  });
+  app.post("/sessions/archive", mutate(), async (req, res) => {
+    const uniqueIds = parseSessionIdsBody(req, res);
+    if (uniqueIds === void 0) return;
+    const service = new SessionService(boundWorkspace, {
+      onWarning: logSessionArchiveWarning
+    });
     try {
-      const uniqueIds = [...new Set(sessionIds)];
-      const closeResults = await Promise.allSettled(
-        uniqueIds.map(async (id) => {
-          await bridge.closeSession(id);
-          return id;
-        })
-      );
-      const closeErrors = [];
-      const closedIds = [];
-      for (let i = 0; i < closeResults.length; i++) {
-        const r = closeResults[i];
-        const id = uniqueIds[i];
-        if (r.status === "fulfilled") {
-          closedIds.push(id);
-        } else {
-          const closeErr = r.reason;
-          if (closeErr instanceof SessionNotFoundError) {
-            closedIds.push(id);
-          } else {
-            const msg = closeErr instanceof Error ? closeErr.message : String(closeErr);
-            writeStderrLine(
-              `qwen serve: closeSession failed for ${safeLogValue(id)}: ${safeLogValue(msg)}`
-            );
-            closeErrors.push({ sessionId: id, error: msg });
-          }
-        }
-      }
-      const result = await new SessionService(boundWorkspace).removeSessions(
-        closedIds
-      );
-      for (const e of result.errors) {
-        const msg = e.error instanceof Error ? e.error.message : String(e.error);
-        writeStderrLine(
-          `qwen serve: removeSession failed for ${safeLogValue(e.sessionId)}: ${safeLogValue(msg)}`
-        );
-      }
+      const result = await archiveDaemonSessions({
+        sessionIds: uniqueIds,
+        service,
+        bridge,
+        coordinator: archiveCoordinator
+      });
       res.status(200).json({
-        removed: result.removed,
+        archived: result.archived,
+        alreadyArchived: result.alreadyArchived,
         notFound: result.notFound,
-        errors: [
-          ...closeErrors,
-          ...result.errors.map((e) => ({
-            sessionId: e.sessionId,
-            error: e.error instanceof Error ? e.error.message : String(e.error)
-          }))
-        ]
+        errors: serializeSessionErrors(result.errors)
       });
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      writeStderrLine(
-        `qwen serve: failed to batch delete sessions: ${safeLogValue(message)}`
-      );
-      res.status(500).json({
-        error: "Failed to delete sessions",
-        code: "sessions_delete_failed"
-      });
+      sendBridgeError2(res, err, { route: "POST /sessions/archive" });
     }
   });
-  app.patch("/session/:id/metadata", async (req, res) => {
-    const sessionId = req.params["id"];
-    const body = safeBody(req);
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    const rawDisplayName = body["displayName"];
-    if (rawDisplayName !== void 0 && typeof rawDisplayName !== "string") {
-      res.status(400).json({
-        error: "`displayName` must be a string",
-        code: "invalid_metadata",
-        field: "displayName"
+  app.post("/sessions/unarchive", mutate(), async (req, res) => {
+    const uniqueIds = parseSessionIdsBody(req, res);
+    if (uniqueIds === void 0) return;
+    const service = new SessionService(boundWorkspace, {
+      onWarning: logSessionArchiveWarning
+    });
+    try {
+      const result = await unarchiveDaemonSessions({
+        sessionIds: uniqueIds,
+        service,
+        coordinator: archiveCoordinator
       });
-      return;
+      res.status(200).json({
+        unarchived: result.unarchived,
+        alreadyActive: result.alreadyActive,
+        notFound: result.notFound,
+        errors: serializeSessionErrors(result.errors)
+      });
+    } catch (err) {
+      sendBridgeError2(res, err, { route: "POST /sessions/unarchive" });
     }
-    const displayName = typeof rawDisplayName === "string" ? rawDisplayName.slice(0, 256) : void 0;
-    try {
+  });
+  app.patch(
+    "/session/:id/metadata",
+    withMutableSession("PATCH /session/:id/metadata", (req, res, sessionId) => {
+      const body = safeBody(req);
+      const clientId = parseClientIdHeader(req, res);
+      if (clientId === null) return;
+      const rawDisplayName = body["displayName"];
+      if (rawDisplayName !== void 0 && typeof rawDisplayName !== "string") {
+        res.status(400).json({
+          error: "`displayName` must be a string",
+          code: "invalid_metadata",
+          field: "displayName"
+        });
+        return;
+      }
+      const displayName = typeof rawDisplayName === "string" ? rawDisplayName.slice(0, 256) : void 0;
       const effective = bridge.updateSessionMetadata(
         sessionId,
         { displayName },
         clientId !== void 0 ? { clientId } : void 0
       );
       res.status(200).json({ sessionId, ...effective });
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "PATCH /session/:id/metadata",
-        sessionId
-      });
-    }
-  });
+    })
+  );
   app.get("/workspace/:id/sessions", async (req, res) => {
     const workspaceCwd = req.params["id"] ?? "";
-    if (!path10.isAbsolute(workspaceCwd)) {
+    if (!path11.isAbsolute(workspaceCwd)) {
       res.status(400).json({ error: "`:id` must decode to an absolute workspace path" });
       return;
     }
@@ -13175,9 +14179,22 @@ function registerSessionRoutes(app, deps) {
     try {
       const cursor = typeof req.query["cursor"] === "string" ? req.query["cursor"] : void 0;
       const size = parseSessionPageSizeQuery(req.query["size"]);
+      const rawArchiveState = req.query["archiveState"];
+      let archiveState;
+      if (rawArchiveState !== void 0) {
+        if (typeof rawArchiveState !== "string" || rawArchiveState !== "active" && rawArchiveState !== "archived") {
+          res.status(400).json({
+            error: '`archiveState` must be "active" or "archived"',
+            code: "invalid_archive_state"
+          });
+          return;
+        }
+        archiveState = rawArchiveState;
+      }
       const result = await listWorkspaceSessionsForResponse(bridge, key, {
         cursor,
-        size
+        size,
+        archiveState
       });
       res.status(200).json({
         sessions: result.sessions,
@@ -13202,137 +14219,134 @@ function registerSessionRoutes(app, deps) {
       });
     }
   });
-  app.post("/session/:id/model", mutate(), async (req, res) => {
-    const sessionId = req.params["id"];
-    const body = safeBody(req);
-    const modelId = body["modelId"];
-    if (typeof modelId !== "string" || !modelId) {
-      res.status(400).json({
-        error: "`modelId` is required and must be a non-empty string"
-      });
-      return;
-    }
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
-      const response = await bridge.setSessionModel(
-        sessionId,
-        {
-          ...body,
+  app.post(
+    "/session/:id/model",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/model",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        const modelId = body["modelId"];
+        if (typeof modelId !== "string" || !modelId) {
+          res.status(400).json({
+            error: "`modelId` is required and must be a non-empty string"
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const response = await bridge.setSessionModel(
           sessionId,
-          modelId
-        },
-        clientId !== void 0 ? { clientId } : void 0
-      );
-      res.status(200).json(response);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/model",
-        sessionId
-      });
-    }
-  });
-  app.post("/session/:id/recap", mutate(), async (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
-      const response = await bridge.generateSessionRecap(
-        sessionId,
-        clientId !== void 0 ? { clientId } : void 0
-      );
-      if (daemonLog) {
-        const recap = response.recap;
-        daemonLog.info(
-          recap ? `recap generated len=${recap.length}` : "recap returned null",
-          { sessionId, clientId }
+          {
+            ...body,
+            sessionId,
+            modelId
+          },
+          clientId !== void 0 ? { clientId } : void 0
         );
+        res.status(200).json(response);
       }
-      res.status(200).json(response);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/recap",
-        sessionId
-      });
-    }
-  });
-  app.post("/session/:id/btw", mutate(), async (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const body = safeBody(req);
-    const question = body["question"];
-    if (typeof question !== "string" || question.trim().length === 0 || question.length > BTW_MAX_INPUT_LENGTH) {
-      res.status(400).json({
-        error: `\`question\` is required, must be a non-empty string, and at most ${BTW_MAX_INPUT_LENGTH} characters`
-      });
-      return;
-    }
-    const abort = new AbortController();
-    const onResClose = /* @__PURE__ */ __name(() => {
-      if (!res.writableEnded) abort.abort();
-    }, "onResClose");
-    res.once("close", onResClose);
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) {
-      res.off("close", onResClose);
-      return;
-    }
-    try {
-      const result = await bridge.generateSessionBtw(
-        sessionId,
-        question.trim(),
-        abort.signal,
-        clientId !== void 0 ? { clientId } : void 0
-      );
-      res.status(200).json(result);
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "AbortError" && abort.signal.aborted) {
+    )
+  );
+  app.post(
+    "/session/:id/recap",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/recap",
+      async (req, res, sessionId) => {
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const response = await bridge.generateSessionRecap(
+          sessionId,
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        if (daemonLog) {
+          const recap = response.recap;
+          daemonLog.info(
+            recap ? `recap generated len=${recap.length}` : "recap returned null",
+            { sessionId, clientId }
+          );
+        }
+        res.status(200).json(response);
+      }
+    )
+  );
+  app.post(
+    "/session/:id/btw",
+    mutate(),
+    withMutableSession("POST /session/:id/btw", async (req, res, sessionId) => {
+      const body = safeBody(req);
+      const question = body["question"];
+      if (typeof question !== "string" || question.trim().length === 0 || question.length > BTW_MAX_INPUT_LENGTH) {
+        res.status(400).json({
+          error: `\`question\` is required, must be a non-empty string, and at most ${BTW_MAX_INPUT_LENGTH} characters`
+        });
+        return;
+      }
+      const abort = new AbortController();
+      const onResClose = /* @__PURE__ */ __name(() => {
+        if (!res.writableEnded) abort.abort();
+      }, "onResClose");
+      res.once("close", onResClose);
+      const clientId = parseClientIdHeader(req, res);
+      if (clientId === null) {
+        res.off("close", onResClose);
         return;
       }
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/btw",
-        sessionId
-      });
-    } finally {
-      res.off("close", onResClose);
-    }
-  });
-  const MID_TURN_MESSAGE_MAX_LENGTH = 16 * 1024;
-  app.post("/session/:id/mid-turn-message", mutate(), (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const body = safeBody(req);
-    const message = body["message"];
-    const trimmed = typeof message === "string" ? message.trim() : "";
-    if (trimmed.length === 0) {
-      res.status(400).json({
-        error: "`message` is required and must be a non-empty string"
-      });
-      return;
-    }
-    if (trimmed.length > MID_TURN_MESSAGE_MAX_LENGTH) {
-      res.status(400).json({
-        error: `\`message\` must be at most ${MID_TURN_MESSAGE_MAX_LENGTH} characters`
-      });
-      return;
-    }
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
-      const result = bridge.enqueueMidTurnMessage(
-        sessionId,
-        trimmed,
-        clientId !== void 0 ? { clientId } : void 0
-      );
-      res.status(200).json(result);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/mid-turn-message",
-        sessionId
-      });
-    }
-  });
+      try {
+        const result = await bridge.generateSessionBtw(
+          sessionId,
+          question.trim(),
+          abort.signal,
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(200).json(result);
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError" && abort.signal.aborted) {
+          return;
+        }
+        sendBridgeError2(res, err, {
+          route: "POST /session/:id/btw",
+          sessionId
+        });
+      } finally {
+        res.off("close", onResClose);
+      }
+    })
+  );
+  const MID_TURN_MESSAGE_MAX_LENGTH = 16 * 1024;
+  app.post(
+    "/session/:id/mid-turn-message",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/mid-turn-message",
+      (req, res, sessionId) => {
+        const body = safeBody(req);
+        const message = body["message"];
+        const trimmed = typeof message === "string" ? message.trim() : "";
+        if (trimmed.length === 0) {
+          res.status(400).json({
+            error: "`message` is required and must be a non-empty string"
+          });
+          return;
+        }
+        if (trimmed.length > MID_TURN_MESSAGE_MAX_LENGTH) {
+          res.status(400).json({
+            error: `\`message\` must be at most ${MID_TURN_MESSAGE_MAX_LENGTH} characters`
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const result = bridge.enqueueMidTurnMessage(
+          sessionId,
+          trimmed,
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(200).json(result);
+      }
+    )
+  );
   app.get("/session/:id/pending-prompts", (req, res) => {
     const sessionId = requireSessionId(req, res);
     if (sessionId === null) return;
@@ -13351,90 +14365,94 @@ function registerSessionRoutes(app, deps) {
       });
     }
   });
-  app.delete("/session/:id/pending-prompts/:promptId", mutate(), (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    const promptId = req.params["promptId"];
-    if (!promptId) {
-      res.status(400).json({ error: "`promptId` route parameter is required" });
-      return;
-    }
-    try {
-      const result = bridge.removePendingPrompt(
-        sessionId,
-        promptId,
-        clientId !== void 0 ? { clientId } : void 0
-      );
-      res.status(200).json(result);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "DELETE /session/:id/pending-prompts/:promptId",
-        sessionId
-      });
-    }
-  });
-  app.post("/session/:id/shell", mutate({ strict: true }), async (req, res) => {
-    const sessionId = req.params["id"];
-    if (!sessionShellCommandEnabled) {
-      sendBridgeError2(res, new SessionShellDisabledError(), {
-        route: "POST /session/:id/shell",
-        sessionId
-      });
-      return;
-    }
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) {
-      return;
-    }
-    if (clientId === void 0) {
-      sendBridgeError2(res, new SessionShellClientRequiredError(), {
-        route: "POST /session/:id/shell",
-        sessionId
-      });
-      return;
-    }
-    const body = safeBody(req);
-    const command = body["command"];
-    if (typeof command !== "string" || command.trim().length === 0) {
-      res.status(400).json({
-        error: "`command` is required and must be a non-empty string"
-      });
-      return;
-    }
-    const abort = new AbortController();
-    const onResClose = /* @__PURE__ */ __name(() => {
-      if (!res.writableEnded) abort.abort();
-    }, "onResClose");
-    res.once("close", onResClose);
-    try {
-      const result = await bridge.executeShellCommand(
-        sessionId,
-        command.trim(),
-        abort.signal,
-        { clientId }
-      );
-      if (daemonLog) {
-        daemonLog.info("shell command completed", {
+  app.delete(
+    "/session/:id/pending-prompts/:promptId",
+    mutate(),
+    withMutableSession(
+      "DELETE /session/:id/pending-prompts/:promptId",
+      (req, res, sessionId) => {
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const promptId = req.params["promptId"];
+        if (!promptId) {
+          res.status(400).json({ error: "`promptId` route parameter is required" });
+          return;
+        }
+        const result = bridge.removePendingPrompt(
           sessionId,
-          clientId,
-          exitCode: result.exitCode
-        });
+          promptId,
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(200).json(result);
       }
-      res.status(200).json(result);
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "AbortError" && abort.signal.aborted) {
-        return;
+    )
+  );
+  app.post(
+    "/session/:id/shell",
+    mutate({ strict: true }),
+    withMutableSession(
+      "POST /session/:id/shell",
+      async (req, res, sessionId) => {
+        if (!sessionShellCommandEnabled) {
+          sendBridgeError2(res, new SessionShellDisabledError(), {
+            route: "POST /session/:id/shell",
+            sessionId
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) {
+          return;
+        }
+        if (clientId === void 0) {
+          sendBridgeError2(res, new SessionShellClientRequiredError(), {
+            route: "POST /session/:id/shell",
+            sessionId
+          });
+          return;
+        }
+        const body = safeBody(req);
+        const command = body["command"];
+        if (typeof command !== "string" || command.trim().length === 0) {
+          res.status(400).json({
+            error: "`command` is required and must be a non-empty string"
+          });
+          return;
+        }
+        const abort = new AbortController();
+        const onResClose = /* @__PURE__ */ __name(() => {
+          if (!res.writableEnded) abort.abort();
+        }, "onResClose");
+        res.once("close", onResClose);
+        try {
+          const result = await bridge.executeShellCommand(
+            sessionId,
+            command.trim(),
+            abort.signal,
+            { clientId }
+          );
+          if (daemonLog) {
+            daemonLog.info("shell command completed", {
+              sessionId,
+              clientId,
+              exitCode: result.exitCode
+            });
+          }
+          res.status(200).json(result);
+        } catch (err) {
+          if (err instanceof DOMException && err.name === "AbortError" && abort.signal.aborted) {
+            return;
+          }
+          sendBridgeError2(res, err, {
+            route: "POST /session/:id/shell",
+            sessionId
+          });
+        } finally {
+          res.off("close", onResClose);
+        }
       }
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/shell",
-        sessionId
-      });
-    } finally {
-      res.off("close", onResClose);
-    }
-  });
+    )
+  );
   app.get("/session/:id/rewind/snapshots", async (req, res) => {
     const sessionId = req.params["id"];
     if (!sessionId) {
@@ -13453,60 +14471,55 @@ function registerSessionRoutes(app, deps) {
   app.post(
     "/session/:id/rewind",
     mutate({ strict: true }),
-    async (req, res) => {
-      const sessionId = req.params["id"];
-      const body = safeBody(req);
-      const promptId = body["promptId"];
-      if (typeof promptId !== "string" || promptId.length === 0) {
-        res.status(400).json({
-          error: "`promptId` is required and must be a non-empty string",
-          code: "missing_prompt_id"
-        });
-        return;
-      }
-      const clientId = parseClientIdHeader(req, res);
-      if (clientId === null) return;
-      try {
+    withMutableSession(
+      "POST /session/:id/rewind",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        const promptId = body["promptId"];
+        if (typeof promptId !== "string" || promptId.length === 0) {
+          res.status(400).json({
+            error: "`promptId` is required and must be a non-empty string",
+            code: "missing_prompt_id"
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
         const response = await bridge.rewindSession(
           sessionId,
           { promptId, rewindFiles: body["rewindFiles"] !== false },
           clientId !== void 0 ? { clientId } : void 0
         );
         res.status(200).json(response);
-      } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "POST /session/:id/rewind",
-          sessionId
-        });
       }
-    }
+    )
   );
   app.post(
     "/session/:id/approval-mode",
     mutate({ strict: true }),
-    async (req, res) => {
-      const sessionId = req.params["id"];
-      const body = safeBody(req);
-      const mode = body["mode"];
-      const persist = body["persist"];
-      if (typeof mode !== "string" || !APPROVAL_MODES.includes(mode)) {
-        res.status(400).json({
-          error: "`mode` is required and must be one of the allowed values",
-          code: "invalid_approval_mode",
-          allowed: APPROVAL_MODES
-        });
-        return;
-      }
-      if (persist !== void 0 && typeof persist !== "boolean") {
-        res.status(400).json({
-          error: "`persist` must be a boolean when provided",
-          code: "invalid_persist_flag"
-        });
-        return;
-      }
-      const clientId = parseClientIdHeader(req, res);
-      if (clientId === null) return;
-      try {
+    withMutableSession(
+      "POST /session/:id/approval-mode",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        const mode = body["mode"];
+        const persist = body["persist"];
+        if (typeof mode !== "string" || !APPROVAL_MODES.includes(mode)) {
+          res.status(400).json({
+            error: "`mode` is required and must be one of the allowed values",
+            code: "invalid_approval_mode",
+            allowed: APPROVAL_MODES
+          });
+          return;
+        }
+        if (persist !== void 0 && typeof persist !== "boolean") {
+          res.status(400).json({
+            error: "`persist` must be a boolean when provided",
+            code: "invalid_persist_flag"
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
         const response = await bridge.setSessionApprovalMode(
           sessionId,
           mode,
@@ -13514,53 +14527,47 @@ function registerSessionRoutes(app, deps) {
           clientId !== void 0 ? { clientId } : void 0
         );
         res.status(200).json(response);
-      } catch (err) {
-        sendBridgeError2(res, err, {
-          route: "POST /session/:id/approval-mode",
-          sessionId
-        });
       }
-    }
+    )
+  );
+  app.post(
+    "/session/:id/language",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/language",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        const language = body["language"];
+        const syncOutputLanguage = body["syncOutputLanguage"];
+        if (typeof language !== "string" || !LANGUAGE_CODES.includes(language)) {
+          res.status(400).json({
+            error: "`language` is required and must be one of: " + LANGUAGE_CODES.join(", "),
+            code: "invalid_language",
+            allowed: LANGUAGE_CODES
+          });
+          return;
+        }
+        if (syncOutputLanguage !== void 0 && typeof syncOutputLanguage !== "boolean") {
+          res.status(400).json({
+            error: "`syncOutputLanguage` must be a boolean when provided",
+            code: "invalid_sync_flag"
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const response = await bridge.setSessionLanguage(
+          sessionId,
+          {
+            language,
+            syncOutputLanguage: syncOutputLanguage === true
+          },
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(200).json(response);
+      }
+    )
   );
-  app.post("/session/:id/language", mutate(), async (req, res) => {
-    const sessionId = req.params["id"];
-    const body = safeBody(req);
-    const language = body["language"];
-    const syncOutputLanguage = body["syncOutputLanguage"];
-    if (typeof language !== "string" || !LANGUAGE_CODES.includes(language)) {
-      res.status(400).json({
-        error: "`language` is required and must be one of: " + LANGUAGE_CODES.join(", "),
-        code: "invalid_language",
-        allowed: LANGUAGE_CODES
-      });
-      return;
-    }
-    if (syncOutputLanguage !== void 0 && typeof syncOutputLanguage !== "boolean") {
-      res.status(400).json({
-        error: "`syncOutputLanguage` must be a boolean when provided",
-        code: "invalid_sync_flag"
-      });
-      return;
-    }
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    try {
-      const response = await bridge.setSessionLanguage(
-        sessionId,
-        {
-          language,
-          syncOutputLanguage: syncOutputLanguage === true
-        },
-        clientId !== void 0 ? { clientId } : void 0
-      );
-      res.status(200).json(response);
-    } catch (err) {
-      sendBridgeError2(res, err, {
-        route: "POST /session/:id/language",
-        sessionId
-      });
-    }
-  });
 }
 __name(registerSessionRoutes, "registerSessionRoutes");
 
@@ -14213,6 +15220,31 @@ function sendBridgeError(res, err, ctx, daemonLog) {
     res.status(404).json({ error: err.message, sessionId: err.sessionId });
     return;
   }
+  if (err instanceof SessionArchivedError) {
+    res.status(409).json({
+      error: err.message,
+      code: "session_archived",
+      sessionId: err.sessionId
+    });
+    return;
+  }
+  if (err instanceof SessionConflictError) {
+    res.status(409).json({
+      error: err.message,
+      code: "session_conflict",
+      sessionId: err.sessionId
+    });
+    return;
+  }
+  if (err instanceof SessionArchivingError) {
+    res.set("Retry-After", "5");
+    res.status(409).json({
+      error: err.message,
+      code: "session_archiving",
+      sessionId: err.sessionId
+    });
+    return;
+  }
   if (err instanceof InvalidClientIdError) {
     res.status(400).json({
       error: err.message,
@@ -14320,7 +15352,7 @@ function sendBridgeError(res, err, ctx, daemonLog) {
       if (kind === "mcp_budget_would_exceed") {
         const d = data;
         res.status(409).json({
-          error: errorMessage(err),
+          error: errorMessage2(err),
           code: "mcp_budget_would_exceed",
           serverName: d.serverName
         });
@@ -14329,7 +15361,7 @@ function sendBridgeError(res, err, ctx, daemonLog) {
       if (kind === "mcp_server_spawn_failed") {
         const d = data;
         res.status(502).json({
-          error: errorMessage(err),
+          error: errorMessage2(err),
           code: "mcp_server_spawn_failed",
           serverName: d.serverName,
           exitCode: d.exitCode,
@@ -14341,7 +15373,7 @@ function sendBridgeError(res, err, ctx, daemonLog) {
       if (kind === "invalid_config") {
         const d = data;
         res.status(400).json({
-          error: errorMessage(err),
+          error: errorMessage2(err),
           code: "invalid_config",
           serverName: d.serverName,
           reason: d.reason
@@ -14350,14 +15382,14 @@ function sendBridgeError(res, err, ctx, daemonLog) {
       }
       if (kind === "acp_channel_unavailable") {
         res.status(503).json({
-          error: errorMessage(err),
+          error: errorMessage2(err),
           code: "acp_channel_unavailable"
         });
         return;
       }
       if (kind === "restrictive_sandbox") {
         res.status(403).json({
-          error: errorMessage(err),
+          error: errorMessage2(err),
           code: "restrictive_sandbox"
         });
         return;
@@ -14365,7 +15397,7 @@ function sendBridgeError(res, err, ctx, daemonLog) {
       if (kind === "directory_not_found") {
         const d = data;
         res.status(400).json({
-          error: errorMessage(err),
+          error: errorMessage2(err),
           code: "directory_not_found",
           path: d.path
         });
@@ -14374,7 +15406,7 @@ function sendBridgeError(res, err, ctx, daemonLog) {
       if (kind === "directory_not_trusted") {
         const d = data;
         res.status(403).json({
-          error: errorMessage(err),
+          error: errorMessage2(err),
           code: "directory_not_trusted",
           path: d.path
         });
@@ -14422,7 +15454,7 @@ function sendBridgeError(res, err, ctx, daemonLog) {
   res.status(500).json(errorPayload(err));
 }
 __name(sendBridgeError, "sendBridgeError");
-function errorMessage(err) {
+function errorMessage2(err) {
   if (err instanceof Error) return err.message;
   if (err && typeof err === "object") {
     const maybe = err.message;
@@ -14434,10 +15466,10 @@ function errorMessage(err) {
   }
   return String(err);
 }
-__name(errorMessage, "errorMessage");
+__name(errorMessage2, "errorMessage");
 function errorPayload(err) {
   const out = {
-    error: errorMessage(err)
+    error: errorMessage2(err)
   };
   if (err && typeof err === "object") {
     const obj = err;
@@ -14540,9 +15572,9 @@ function registerSseEventsRoutes(app, deps) {
     let writeChain = Promise.resolve();
     const trackWriterIdle = writerIdleTimeoutMs !== void 0 && writerIdleTimeoutMs > 0;
     let lastWriteAt = trackWriterIdle ? Date.now() : 0;
-    const doWrite = /* @__PURE__ */ __name((chunk) => new Promise((resolve4, reject) => {
+    const doWrite = /* @__PURE__ */ __name((chunk) => new Promise((resolve5, reject) => {
       if (res.writableEnded) {
-        resolve4();
+        resolve5();
         return;
       }
       let ok;
@@ -14554,19 +15586,19 @@ function registerSseEventsRoutes(app, deps) {
       }
       if (ok) {
         if (trackWriterIdle) lastWriteAt = Date.now();
-        resolve4();
+        resolve5();
         return;
       }
       const onDrain = /* @__PURE__ */ __name(() => {
         res.off("close", onClose);
         res.off("error", onError);
         if (trackWriterIdle) lastWriteAt = Date.now();
-        resolve4();
+        resolve5();
       }, "onDrain");
       const onClose = /* @__PURE__ */ __name(() => {
         res.off("drain", onDrain);
         res.off("error", onError);
-        resolve4();
+        resolve5();
       }, "onClose");
       const onError = /* @__PURE__ */ __name((err) => {
         res.off("drain", onDrain);
@@ -14662,14 +15694,14 @@ function registerSseEventsRoutes(app, deps) {
         if (!res.writableEnded) {
           const errorKind = mapDomainErrorToErrorKind(err);
           writeStderrLine(
-            `qwen serve: bridge iterator error (session ${sessionId}): ${errorMessage(err)}` + (errorKind ? ` [${errorKind}]` : "")
+            `qwen serve: bridge iterator error (session ${sessionId}): ${errorMessage2(err)}` + (errorKind ? ` [${errorKind}]` : "")
           );
           await writeWithBackpressure(
             formatSseFrame({
               v: 1,
               type: "stream_error",
               data: {
-                error: errorMessage(err),
+                error: errorMessage2(err),
                 ...errorKind ? { errorKind } : {}
               }
             })
@@ -14688,7 +15720,7 @@ __name(registerSseEventsRoutes, "registerSseEventsRoutes");
 // 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;
@@ -14708,7 +15740,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);
@@ -14866,17 +15898,17 @@ __name(resolveBridgeFsFactory, "resolveBridgeFsFactory");
 // packages/cli/src/serve/server/telemetry.ts
 init_esbuild_shims();
 function resolveDaemonTelemetryRoute(req) {
-  const path12 = req.path.replace(/\/$/, "") || "/";
-  if (req.method === "POST" && path12 === "/session") {
+  const path13 = req.path.replace(/\/$/, "") || "/";
+  if (req.method === "POST" && path13 === "/session") {
     return { route: "POST /session" };
   }
-  if (req.method === "POST" && path12 === "/sessions/delete") {
+  if (req.method === "POST" && path13 === "/sessions/delete") {
     return { route: "POST /sessions/delete" };
   }
-  if (req.method === "GET" && path12 === "/daemon/status") {
+  if (req.method === "GET" && path13 === "/daemon/status") {
     return { route: "GET /daemon/status" };
   }
-  const sessionAction = path12.match(
+  const sessionAction = path13.match(
     /^\/session\/([^/]+)\/(load|resume|prompt|cancel|recap|btw|mid-turn-message|model|shell|detach|rewind|approval-mode|language|a2ui-action)$/
   );
   const sessionActionId = sessionAction?.[1];
@@ -14887,14 +15919,14 @@ function resolveDaemonTelemetryRoute(req) {
       sessionId: sessionActionId
     };
   }
-  const sessionMetadata = path12.match(/^\/session\/([^/]+)\/metadata$/);
+  const sessionMetadata = path13.match(/^\/session\/([^/]+)\/metadata$/);
   if (sessionMetadata?.[1] && req.method === "PATCH") {
     return {
       route: "PATCH /session/:id/metadata",
       sessionId: sessionMetadata[1]
     };
   }
-  const sessionPermission = path12.match(
+  const sessionPermission = path13.match(
     /^\/session\/([^/]+)\/permission\/([^/]+)$/
   );
   if (sessionPermission?.[1] && sessionPermission?.[2] && req.method === "POST") {
@@ -14905,7 +15937,7 @@ function resolveDaemonTelemetryRoute(req) {
       ...rawRequestId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawRequestId) ? { permissionRequestId: rawRequestId } : {}
     };
   }
-  const globalPermission = path12.match(/^\/permission\/([^/]+)$/);
+  const globalPermission = path13.match(/^\/permission\/([^/]+)$/);
   if (globalPermission?.[1] && req.method === "POST") {
     const rawRequestId = globalPermission[1];
     return {
@@ -14913,66 +15945,66 @@ function resolveDaemonTelemetryRoute(req) {
       ...rawRequestId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawRequestId) ? { permissionRequestId: rawRequestId } : {}
     };
   }
-  const deleteSession = path12.match(/^\/session\/([^/]+)$/);
+  const deleteSession = path13.match(/^\/session\/([^/]+)$/);
   const deleteSessionId = deleteSession?.[1];
   if (deleteSessionId && req.method === "DELETE") {
     return { route: "DELETE /session/:id", sessionId: deleteSessionId };
   }
-  if (req.method === "GET" && /^\/workspace\/[^/]+\/sessions$/.test(path12)) {
+  if (req.method === "GET" && /^\/workspace\/[^/]+\/sessions$/.test(path13)) {
     return { route: "GET /workspace/:id/sessions" };
   }
-  if (req.method === "POST" && path12 === "/workspace/init") {
+  if (req.method === "POST" && path13 === "/workspace/init") {
     return { route: "POST /workspace/init" };
   }
-  if (req.method === "POST" && path12 === "/workspace/setup-github") {
+  if (req.method === "POST" && path13 === "/workspace/setup-github") {
     return { route: "POST /workspace/setup-github" };
   }
-  if (req.method === "POST" && path12 === "/workspace/reload") {
+  if (req.method === "POST" && path13 === "/workspace/reload") {
     return { route: "POST /workspace/reload" };
   }
-  const mcpRestart = path12.match(/^\/workspace\/mcp\/([^/]+)\/restart$/);
+  const mcpRestart = path13.match(/^\/workspace\/mcp\/([^/]+)\/restart$/);
   if (mcpRestart?.[1] && req.method === "POST") {
     return { route: "POST /workspace/mcp/:server/restart" };
   }
-  if (req.method === "POST" && path12 === "/workspace/mcp/servers") {
+  if (req.method === "POST" && path13 === "/workspace/mcp/servers") {
     return { route: "POST /workspace/mcp/servers" };
   }
-  const mcpDelete = path12.match(/^\/workspace\/mcp\/servers\/([^/]+)$/);
+  const mcpDelete = path13.match(/^\/workspace\/mcp\/servers\/([^/]+)$/);
   if (mcpDelete?.[1] && req.method === "DELETE") {
     return { route: "DELETE /workspace/mcp/servers/:name" };
   }
-  if (req.method === "POST" && path12 === "/workspace/auth/device-flow") {
+  if (req.method === "POST" && path13 === "/workspace/auth/device-flow") {
     return { route: "POST /workspace/auth/device-flow" };
   }
-  const deviceFlowDelete = path12.match(
+  const deviceFlowDelete = path13.match(
     /^\/workspace\/auth\/device-flow\/([^/]+)$/
   );
   if (deviceFlowDelete?.[1] && req.method === "DELETE") {
     return { route: "DELETE /workspace/auth/device-flow/:id" };
   }
-  const toolEnable = path12.match(/^\/workspace\/tools\/([^/]+)\/enable$/);
+  const toolEnable = path13.match(/^\/workspace\/tools\/([^/]+)\/enable$/);
   if (toolEnable?.[1] && req.method === "POST") {
     return { route: "POST /workspace/tools/:name/enable" };
   }
-  if (path12 === "/workspace/settings") {
+  if (path13 === "/workspace/settings") {
     if (req.method === "GET") return { route: "GET /workspace/settings" };
     if (req.method === "POST") return { route: "POST /workspace/settings" };
   }
-  if (path12 === "/workspace/permissions") {
+  if (path13 === "/workspace/permissions") {
     if (req.method === "GET") return { route: "GET /workspace/permissions" };
     if (req.method === "POST") return { route: "POST /workspace/permissions" };
   }
-  if (path12 === "/workspace/trust") {
+  if (path13 === "/workspace/trust") {
     if (req.method === "GET") return { route: "GET /workspace/trust" };
   }
-  if (req.method === "POST" && path12 === "/workspace/trust/request") {
+  if (req.method === "POST" && path13 === "/workspace/trust/request") {
     return { route: "POST /workspace/trust/request" };
   }
-  if (path12 === "/workspace/voice") {
+  if (path13 === "/workspace/voice") {
     if (req.method === "GET") return { route: "GET /workspace/voice" };
     if (req.method === "POST") return { route: "POST /workspace/voice" };
   }
-  if (req.method === "POST" && path12 === "/workspace/voice/transcribe") {
+  if (req.method === "POST" && path13 === "/workspace/voice/transcribe") {
     return { route: "POST /workspace/voice/transcribe" };
   }
   return void 0;
@@ -14998,7 +16030,7 @@ function daemonTelemetryMiddleware(boundWorkspace) {
         ...route.permissionRequestId ? { permissionRequestId: route.permissionRequestId } : {},
         ...clientId ? { clientId } : {}
       },
-      async (span) => await new Promise((resolve4, reject) => {
+      async (span) => await new Promise((resolve5, reject) => {
         let done = false;
         const finish = /* @__PURE__ */ __name(() => {
           if (done) return;
@@ -15009,7 +16041,7 @@ function daemonTelemetryMiddleware(boundWorkspace) {
             route.route,
             res.statusCode
           );
-          resolve4();
+          resolve5();
         }, "finish");
         res.once("finish", finish);
         res.once("close", finish);
@@ -15332,10 +16364,10 @@ function installRateLimiter(app, opts, daemonLog) {
         { tier, key: key.slice(0, 64) }
       );
     } : void 0,
-    onError: daemonLog ? (err, path12) => {
+    onError: daemonLog ? (err, path13) => {
       daemonLog.warn(
         `rate limiter error (fail-open): ${err instanceof Error ? err.message : String(err)}`,
-        { path: path12 }
+        { path: path13 }
       );
     } : void 0
   });
@@ -15716,6 +16748,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     // ext-method by reaching the WS connection that hosts the named server.
     clientMcpSender: clientMcpSenderRegistry.lookup
   });
+  const archiveCoordinator = new SessionArchiveCoordinator();
   installSelfOriginStripMiddleware(app, getPort);
   app.locals.fsFactory = fsFactory;
   app.locals.boundWorkspace = boundWorkspace;
@@ -15794,6 +16827,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   app.use(daemonTelemetryMiddleware(boundWorkspace));
   const buildWorkspaceCtx = createBuildWorkspaceCtx(boundWorkspace);
   const acpHandleRef = {};
+  const workspaceRememberLane = new WorkspaceRememberTaskLane(bridge);
   const cdpTunnelRegistry = opts.cdpTunnelOverWs === true ? new CdpTunnelRegistry() : void 0;
   registerDaemonStatusRoutes(app, {
     opts,
@@ -15809,7 +16843,8 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     currentServeFeatures,
     getSupportedDeviceFlowProviders,
     deviceFlowRegistry,
-    sessionShellCommandEnabled
+    sessionShellCommandEnabled,
+    getChannelWorkerSnapshot: deps.getChannelWorkerSnapshot
   });
   registerCapabilitiesRoutes(app, {
     qwenCodeVersion: deps.qwenCodeVersion,
@@ -15833,6 +16868,13 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     parseClientId: parseClientIdHeader,
     safeBody
   });
+  mountWorkspaceMemoryRememberRoutes(app, {
+    bridge,
+    lane: workspaceRememberLane,
+    mutate,
+    parseClientId: parseClientIdHeader,
+    safeBody
+  });
   mountWorkspaceAgentsRoutes(app, {
     bridge,
     boundWorkspace,
@@ -15940,6 +16982,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   registerSessionRoutes(app, {
     boundWorkspace,
     bridge,
+    archiveCoordinator,
     mutate,
     sendBridgeError: sendBridgeError2,
     daemonLog,
@@ -15986,6 +17029,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   });
   acpHandleRef.current = mountAcpHttp(app, bridge, {
     boundWorkspace,
+    archiveCoordinator,
     workspace,
     fsFactory,
     deviceFlowRegistry,
@@ -15994,7 +17038,9 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     // explicitly permitted origin (e.g. the extension's
     // `chrome-extension://<id>`) can open the reverse tool channel.
     allowedOrigins: opts.allowOrigins && opts.allowOrigins.length > 0 ? parseAllowOriginPatterns(opts.allowOrigins) : void 0,
+    hostname: opts.hostname,
     sessionShellCommandEnabled,
+    workspaceRememberLane,
     checkRate: rateLimiter?.checkRate,
     clientMcpOverWs: opts.clientMcpOverWs === true,
     // Reverse tool channel (issue #5626, Phase 2). Per-connection provider: