@qwen-code/qwen-code 0.21.2 → 0.21.3

package/chunks/{server-EP2LLAPD.js → server-GOTZFEEZ.js}

@@ -8,6 +8,7 @@ import {
   formatWorkspaceMemoryDreamSummary,
   formatWorkspaceMemoryForgetSummary,
   isValidServerName,
+  loadSettingsCached,
   normalizeChannelDelivery,
   parseChannelDelivery,
   redactMcpServersSetting,
@@ -16,12 +17,12 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-JLZ3RBQG.js";
+} from "./chunk-5JPVOYWA.js";
 import {
   openQwenAsrRealtimeStream,
   openVoiceStream,
   openVoiceStreamWithRetry
-} from "./chunk-YUFIEIWC.js";
+} from "./chunk-GTM6IHBB.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -33,17 +34,20 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-PZEXDV3H.js";
+} from "./chunk-VUNRNRN6.js";
 import {
   OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
   ObservedChannelContactStore
-} from "./chunk-675H6PLP.js";
-import "./chunk-YDLJGZHL.js";
-import "./chunk-PCK4B6LR.js";
+} from "./chunk-DYA25Y7U.js";
+import "./chunk-4NFY2S7N.js";
+import "./chunk-N42C2FU3.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
-import "./chunk-QTERJVPZ.js";
+import "./chunk-EKTCKZV5.js";
 import "./chunk-3Z43GZUQ.js";
+import {
+  assertValidChannelSecretUpdates
+} from "./chunk-HUIQ4FYC.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
   CLIENT_ID_HEADER,
@@ -101,18 +105,18 @@ import {
   setRateLimiter,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-MB32MS4U.js";
+} from "./chunk-RR224BUP.js";
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
 import {
   createWorkspaceSkillsStatusProvider
-} from "./chunk-BBIQAX4V.js";
-import "./chunk-L55JWS76.js";
+} from "./chunk-ZJES4C3I.js";
+import "./chunk-BGXZBI5B.js";
 import {
   evaluateDaemonWorkspaceTrust,
   readDaemonTrustPolicySnapshot
-} from "./chunk-TTJZAIFP.js";
+} from "./chunk-HEBW74ZW.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   MAX_WORKSPACE_SKILL_NAME_LENGTH,
@@ -126,14 +130,14 @@ import {
   validateWorkspaceSkillName,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-56Z7QEAQ.js";
+} from "./chunk-GMSBXEH4.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-YANIWTRZ.js";
+} from "./chunk-YPUHMQXV.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -141,13 +145,14 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-7KAXXBER.js";
+} from "./chunk-WY2ENRDN.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-P5VC5USY.js";
-import "./chunk-CNTR4GR6.js";
+} from "./chunk-BKGA75MU.js";
+import "./chunk-JELIWHXD.js";
+import "./chunk-Z4X5MTRT.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError,
@@ -156,28 +161,31 @@ import {
 } from "./chunk-OA4JVLSA.js";
 import {
   createTotalSessionAdmissionController
-} from "./chunk-SZ3KHTDR.js";
+} from "./chunk-AKA24BGO.js";
 import {
   WorkspaceGenerationClosedError,
   createSingleWorkspaceRegistry,
   createWorkspaceSessionOwnerIndex
-} from "./chunk-JYBU6YUE.js";
+} from "./chunk-2M5N3DHY.js";
 import "./chunk-GRC5HGPI.js";
 import {
-  assertValidChannelSecretUpdates
-} from "./chunk-EQNUDTL6.js";
+  daemonObservedContactsPath,
+  loadChannelsConfig
+} from "./chunk-2LZCLQIS.js";
+import "./chunk-D2GPKXCQ.js";
+import "./chunk-57OAHC2Y.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-GL4JOZXU.js";
+} from "./chunk-DSGJLHM3.js";
 import "./chunk-VXZBKKQR.js";
-import "./chunk-Q5WZTTWE.js";
-import "./chunk-E5Z2AVNV.js";
+import "./chunk-QWDVZH24.js";
+import "./chunk-3SH53ANB.js";
 import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge,
   parseSessionSource
-} from "./chunk-44F4LBWZ.js";
+} from "./chunk-HIXVWF7I.js";
 import {
   EVENT_SCHEMA_VERSION,
   EventBus,
@@ -185,37 +193,32 @@ import {
 } from "./chunk-GLWP3FDB.js";
 import "./chunk-XCGIMOLN.js";
 import "./chunk-OCPBI7J5.js";
-import "./chunk-XUGZYLDH.js";
+import "./chunk-UWSXFI6E.js";
 import {
   createWorkspaceProvidersStatusProvider
-} from "./chunk-NTDH4IML.js";
+} from "./chunk-MCXMWLFT.js";
 import {
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-6TAASXWL.js";
+} from "./chunk-5VYFXHY2.js";
 import {
   snapshotProcessEnv
-} from "./chunk-VEMNQMHA.js";
+} from "./chunk-H6ZYP74A.js";
 import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceMemoryStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-GURGAJTX.js";
-import "./chunk-Z4X5MTRT.js";
+} from "./chunk-PDDYAXL2.js";
+import "./chunk-K6KS3LTN.js";
 import "./chunk-FC4KQFCS.js";
-import {
-  daemonObservedContactsPath,
-  loadChannelsConfig
-} from "./chunk-D6MDRSZ6.js";
-import "./chunk-A7Y5H4TX.js";
-import "./chunk-57OAHC2Y.js";
+import "./chunk-T3CHYWJZ.js";
 import {
   parseChannelWebhookConfigLenient
-} from "./chunk-I5BT7ADR.js";
-import "./chunk-FANRZEAJ.js";
+} from "./chunk-LGT3YMLN.js";
 import {
   supportedChannelCatalog
-} from "./chunk-KWHKHSIS.js";
+} from "./chunk-X6WUYMOV.js";
+import "./chunk-VWOVHOTT.js";
 import "./chunk-V6WHFGST.js";
 import {
   MAX_REGISTERED_WORKSPACES,
@@ -224,8 +227,8 @@ import {
   WorkspaceRegistrationStoreLimitError,
   normalizeWorkspaceDisplayName,
   workspaceRegistrationId
-} from "./chunk-LYI2PZDK.js";
-import "./chunk-CPZAH673.js";
+} from "./chunk-3XF4WT3B.js";
+import "./chunk-UKZEXS6K.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -258,13 +261,13 @@ import {
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
-} from "./chunk-B4AJNNOL.js";
+} from "./chunk-J26HHFI5.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace,
   canonicalizeWorkspaces,
   translateAndCheckAbsoluteWorkspacePath
-} from "./chunk-2RFKHEXL.js";
+} from "./chunk-6PLDPT2C.js";
 import {
   ChannelDeliveryError,
   MAX_CHANNEL_STARTUP_FAILURES,
@@ -274,10 +277,10 @@ import {
   QWEN_SERVER_TOKEN_ENV,
   isChannelDeliveryError,
   isChannelWebhookEnqueueError
-} from "./chunk-U4VTUMMK.js";
+} from "./chunk-QONSRAEV.js";
 import {
   normalizeWorkerDiagnostic
-} from "./chunk-6MPDY6ZG.js";
+} from "./chunk-24ER7UV4.js";
 import {
   normalizeServeChannelSelection
 } from "./chunk-ALMR3E6Q.js";
@@ -286,11 +289,9 @@ import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-K6KS3LTN.js";
-import "./chunk-T3CHYWJZ.js";
 import {
   sanitizeLogText
-} from "./chunk-JCJ7LKNA.js";
+} from "./chunk-DIEFUBV6.js";
 import "./chunk-UDXSXLER.js";
 import {
   getDialogSettingKeys,
@@ -301,7 +302,7 @@ import {
   getWritableScopes,
   loadSettings,
   validateSettingValue
-} from "./chunk-W3UKBMSI.js";
+} from "./chunk-22YFMJBW.js";
 import "./chunk-RKUWKYED.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
@@ -310,22 +311,18 @@ import {
   detectSystemLanguage,
   resolveLanguageSetting,
   resolveSupportedLanguage
-} from "./chunk-3F2WDAV6.js";
-import "./chunk-EU5TBFJI.js";
+} from "./chunk-KXWERR6P.js";
+import "./chunk-6NE5NTHJ.js";
 import "./chunk-6PEXNQTX.js";
+import "./chunk-BKXTHMOZ.js";
+import "./chunk-VJNBRRZG.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-P755N4CS.js";
+} from "./chunk-M5LIY7Y6.js";
 import "./chunk-ALGGS7UH.js";
 import {
   isWithinRoot as isWithinRoot2
 } from "./chunk-MR3PXB6E.js";
-import "./chunk-2KKCCLPT.js";
-import "./chunk-VJNBRRZG.js";
-import {
-  writeStderrLine,
-  writeStderrLineSafe
-} from "./chunk-OWAK7LMW.js";
 import {
   ALL_PROVIDERS,
   BTW_MAX_INPUT_LENGTH,
@@ -399,20 +396,20 @@ import {
   writeWorkspaceContextFile,
   writeWorktreeSession,
   writeWorktreeSessionMarker
-} from "./chunk-54YCNSK5.js";
+} from "./chunk-UQDFEU47.js";
+import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-H6XPXXMH.js";
 import {
   MAX_JOBS,
   nextDurableFireMs
-} from "./chunk-AOHY3QJ3.js";
-import "./chunk-5NNHICSA.js";
-import "./chunk-SHN4KHDK.js";
-import "./chunk-JXVC2PL3.js";
-import "./chunk-KRXPRVGL.js";
+} from "./chunk-VA5NLVPT.js";
+import "./chunk-I7JDGNG6.js";
+import "./chunk-A6SX5TAH.js";
+import "./chunk-33FNCQSY.js";
 import "./chunk-6PVPNMXU.js";
-import "./chunk-ZMOJ7ISP.js";
+import "./chunk-XUMAD5IT.js";
 import {
   nextFireTime,
   parseCron
@@ -425,26 +422,29 @@ import {
   readCronTasks,
   taskHasLegacyCondition,
   updateCronTasks
-} from "./chunk-TEGJSJDF.js";
-import "./chunk-TIRRPCFS.js";
+} from "./chunk-MOHAWIAW.js";
+import "./chunk-X6QNZOTC.js";
 import "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
+import "./chunk-ZPJWUGCS.js";
 import "./chunk-CPBF7KYF.js";
-import "./chunk-4KP2F2TE.js";
-import "./chunk-3APUUXRF.js";
-import "./chunk-THVU3RNH.js";
-import "./chunk-LHKCY7DY.js";
-import "./chunk-6FMJLI5M.js";
+import "./chunk-MISUEWB4.js";
+import "./chunk-KRXPRVGL.js";
+import "./chunk-A5YZ3FA2.js";
+import "./chunk-YAVY33G4.js";
+import "./chunk-2UISUFHQ.js";
+import "./chunk-HFVW54NL.js";
+import {
+  APPROVAL_MODES
+} from "./chunk-TZTBZ25J.js";
+import "./chunk-S6LOFUVP.js";
 import {
-  APPROVAL_MODES,
   SubagentError,
   SubagentErrorCode
-} from "./chunk-CBBP4BMC.js";
-import "./chunk-S6LOFUVP.js";
+} from "./chunk-SRY26X4H.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
-import "./chunk-N4ACHWNH.js";
-import "./chunk-ZPJWUGCS.js";
+import "./chunk-432XCUHF.js";
 import {
   QwenOAuth2Client,
   QwenOAuthPollError,
@@ -453,15 +453,15 @@ import {
   isDeviceAuthorizationSuccess,
   isDeviceTokenPending,
   isDeviceTokenSuccess
-} from "./chunk-D4HTUMGX.js";
+} from "./chunk-XC656O42.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-LOY7RWQG.js";
-import "./chunk-E6CJ2SMM.js";
+import "./chunk-QYPT3QUD.js";
+import "./chunk-QMBEW7EW.js";
 import "./chunk-DGEIYUC3.js";
 import "./chunk-MPHPFVKK.js";
 import "./chunk-GLNBDYUX.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-6CQWRWUC.js";
+import "./chunk-EIMKVOSF.js";
 import {
   addDaemonRequestAttribute,
   emitDaemonLog,
@@ -471,12 +471,12 @@ import {
   recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   withDaemonRequestSpan
-} from "./chunk-Z3S5EMOW.js";
+} from "./chunk-RPYYTL7E.js";
 import "./chunk-2J3OJGTL.js";
 import "./chunk-P3QQPMQA.js";
-import "./chunk-XQK4XXTN.js";
+import "./chunk-6O5DVH27.js";
 import "./chunk-GLCZKT5V.js";
-import "./chunk-QDK4F2N5.js";
+import "./chunk-2DNKEBXY.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-XWRJCPHC.js";
 import {
@@ -489,18 +489,18 @@ import {
   isWithinRoot,
   parseLineTolerant,
   read
-} from "./chunk-DUNI4EBW.js";
+} from "./chunk-4K3RV3OA.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-3I6DUGQD.js";
-import "./chunk-7ULQIS27.js";
-import "./chunk-MM7TH7ZM.js";
-import "./chunk-HIVKI6O6.js";
+import "./chunk-E4WHKETF.js";
+import "./chunk-UEJESCS7.js";
+import "./chunk-CFDR3GNL.js";
+import "./chunk-H35Q5CEG.js";
 import "./chunk-46UV252V.js";
 import "./chunk-ZBVS26BY.js";
-import "./chunk-Q3T5KA2V.js";
-import "./chunk-R2XWGR75.js";
-import "./chunk-HC45LTEN.js";
-import "./chunk-QARJNL2V.js";
+import "./chunk-BFHXDAR7.js";
+import "./chunk-TYERNYH4.js";
+import "./chunk-UH7Z7Y45.js";
+import "./chunk-O2ZYHG33.js";
 import "./chunk-W4RQUHY3.js";
 import "./chunk-G7XXKQYS.js";
 import {
@@ -508,8 +508,12 @@ import {
   Storage,
   createDebugLogger,
   runWithoutDebugLogSession
-} from "./chunk-E2BHWIDT.js";
+} from "./chunk-3RXUYQJI.js";
 import "./chunk-VOQXFAY5.js";
+import {
+  writeStderrLine,
+  writeStderrLineSafe
+} from "./chunk-OWAK7LMW.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -4854,11 +4858,16 @@ async function validateManagedMemoryAvailable(deps, res, kind, assertGenerationO
   }
 }
 __name(validateManagedMemoryAvailable, "validateManagedMemoryAvailable");
-function mountWorkspaceMemoryRememberRoutes(app, deps) {
+function mountWorkspaceMemoryRememberRoutesAt(app, basePath, mutate, resolveRouteDeps) {
   app.post(
-    "/workspace/memory/remember",
-    deps.mutate({ strict: true }),
+    `${basePath}/remember`,
+    mutate({ strict: true }),
     async (req, res) => {
+      const deps = resolveRouteDeps(req, res, {
+        creating: true,
+        kind: "remember"
+      });
+      if (!deps) return;
       const assertGenerationOpen = deps.captureGenerationAssertion?.();
       if (!requireOpenGeneration(assertGenerationOpen, res)) return;
       if (!requireTrustedWorkspace(deps, res)) return;
@@ -4922,9 +4931,14 @@ function mountWorkspaceMemoryRememberRoutes(app, deps) {
     }
   );
   app.get(
-    "/workspace/memory/remember/:taskId",
-    deps.mutate({ strict: true }),
+    `${basePath}/remember/:taskId`,
+    mutate({ strict: true }),
     (req, res) => {
+      const deps = resolveRouteDeps(req, res, {
+        creating: false,
+        kind: "remember"
+      });
+      if (!deps) return;
       const assertGenerationOpen = deps.captureGenerationAssertion?.();
       if (!requireOpenGeneration(assertGenerationOpen, res)) return;
       if (!requireTrustedWorkspace(deps, res)) return;
@@ -4945,64 +4959,70 @@ function mountWorkspaceMemoryRememberRoutes(app, deps) {
       res.status(200).json(task);
     }
   );
-  app.post(
-    "/workspace/memory/forget",
-    deps.mutate({ strict: true }),
-    async (req, res) => {
-      const assertGenerationOpen = deps.captureGenerationAssertion?.();
-      if (!requireOpenGeneration(assertGenerationOpen, res)) return;
-      if (!requireTrustedWorkspace(deps, res)) return;
-      const body = deps.safeBody(req);
-      const query = body["query"];
-      const trimmedQuery = typeof query === "string" ? query.trim() : "";
-      if (!trimmedQuery) {
-        res.status(400).json({
-          error: "`query` must be a non-empty string",
-          code: "invalid_query"
-        });
-        return;
-      }
-      if (Buffer.byteLength(trimmedQuery, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
-        res.status(400).json({
-          error: `\`query\` exceeds the ${MAX_REMEMBER_CONTENT_BYTES}-byte limit`,
-          code: "invalid_query"
-        });
-        return;
-      }
-      const originatorClientId = validateOriginatorClientId(deps, req, res);
-      if (originatorClientId === null) return;
-      if (!await validateManagedMemoryAvailable(
-        deps,
-        res,
-        "forget",
-        assertGenerationOpen
-      ))
-        return;
-      if (!requireOpenGeneration(assertGenerationOpen, res)) return;
-      try {
-        const task = deps.lane.enqueueForget({
-          query: trimmedQuery,
-          ...originatorClientId ? { originatorClientId } : {},
-          ...assertGenerationOpen ? { assertGenerationOpen } : {}
-        });
-        res.status(202).json(task);
-      } catch (err) {
-        const code = workspaceMemoryFailureCode(
-          err,
-          "forget_failed",
-          logWorkspaceMemoryExtractionError
-        );
-        res.status(publicErrorStatus(code)).json({
-          error: publicErrorMessage(code, "forget"),
-          code
-        });
-      }
+  app.post(`${basePath}/forget`, mutate({ strict: true }), async (req, res) => {
+    const deps = resolveRouteDeps(req, res, {
+      creating: true,
+      kind: "forget"
+    });
+    if (!deps) return;
+    const assertGenerationOpen = deps.captureGenerationAssertion?.();
+    if (!requireOpenGeneration(assertGenerationOpen, res)) return;
+    if (!requireTrustedWorkspace(deps, res)) return;
+    const body = deps.safeBody(req);
+    const query = body["query"];
+    const trimmedQuery = typeof query === "string" ? query.trim() : "";
+    if (!trimmedQuery) {
+      res.status(400).json({
+        error: "`query` must be a non-empty string",
+        code: "invalid_query"
+      });
+      return;
     }
-  );
+    if (Buffer.byteLength(trimmedQuery, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
+      res.status(400).json({
+        error: `\`query\` exceeds the ${MAX_REMEMBER_CONTENT_BYTES}-byte limit`,
+        code: "invalid_query"
+      });
+      return;
+    }
+    const originatorClientId = validateOriginatorClientId(deps, req, res);
+    if (originatorClientId === null) return;
+    if (!await validateManagedMemoryAvailable(
+      deps,
+      res,
+      "forget",
+      assertGenerationOpen
+    ))
+      return;
+    if (!requireOpenGeneration(assertGenerationOpen, res)) return;
+    try {
+      const task = deps.lane.enqueueForget({
+        query: trimmedQuery,
+        ...originatorClientId ? { originatorClientId } : {},
+        ...assertGenerationOpen ? { assertGenerationOpen } : {}
+      });
+      res.status(202).json(task);
+    } catch (err) {
+      const code = workspaceMemoryFailureCode(
+        err,
+        "forget_failed",
+        logWorkspaceMemoryExtractionError
+      );
+      res.status(publicErrorStatus(code)).json({
+        error: publicErrorMessage(code, "forget"),
+        code
+      });
+    }
+  });
   app.get(
-    "/workspace/memory/forget/:taskId",
-    deps.mutate({ strict: true }),
+    `${basePath}/forget/:taskId`,
+    mutate({ strict: true }),
     (req, res) => {
+      const deps = resolveRouteDeps(req, res, {
+        creating: false,
+        kind: "forget"
+      });
+      if (!deps) return;
       const assertGenerationOpen = deps.captureGenerationAssertion?.();
       if (!requireOpenGeneration(assertGenerationOpen, res)) return;
       if (!requireTrustedWorkspace(deps, res)) return;
@@ -5023,68 +5043,88 @@ function mountWorkspaceMemoryRememberRoutes(app, deps) {
       res.status(200).json(task);
     }
   );
-  app.post(
-    "/workspace/memory/dream",
-    deps.mutate({ strict: true }),
-    async (req, res) => {
-      const assertGenerationOpen = deps.captureGenerationAssertion?.();
-      if (!requireOpenGeneration(assertGenerationOpen, res)) return;
-      if (!requireTrustedWorkspace(deps, res)) return;
-      const originatorClientId = validateOriginatorClientId(deps, req, res);
-      if (originatorClientId === null) return;
-      if (!await validateManagedMemoryAvailable(
-        deps,
-        res,
-        "dream",
-        assertGenerationOpen
-      ))
-        return;
-      if (!requireOpenGeneration(assertGenerationOpen, res)) return;
-      try {
-        const task = deps.lane.enqueueDream({
-          ...originatorClientId ? { originatorClientId } : {},
-          ...assertGenerationOpen ? { assertGenerationOpen } : {}
-        });
-        res.status(202).json(task);
-      } catch (err) {
-        const code = workspaceMemoryFailureCode(
-          err,
-          "dream_failed",
-          logWorkspaceMemoryExtractionError
-        );
-        res.status(publicErrorStatus(code)).json({
-          error: publicErrorMessage(code, "dream"),
-          code
-        });
-      }
-    }
-  );
-  app.get(
-    "/workspace/memory/dream/:taskId",
-    deps.mutate({ strict: true }),
-    (req, res) => {
-      const assertGenerationOpen = deps.captureGenerationAssertion?.();
-      if (!requireOpenGeneration(assertGenerationOpen, res)) return;
-      if (!requireTrustedWorkspace(deps, res)) return;
-      const requesterClientId = validateOriginatorClientId(deps, req, res);
-      if (requesterClientId === null) return;
-      const task = deps.lane.get(
-        req.params["taskId"],
-        requesterClientId,
-        "dream"
+  app.post(`${basePath}/dream`, mutate({ strict: true }), async (req, res) => {
+    const deps = resolveRouteDeps(req, res, {
+      creating: true,
+      kind: "dream"
+    });
+    if (!deps) return;
+    const assertGenerationOpen = deps.captureGenerationAssertion?.();
+    if (!requireOpenGeneration(assertGenerationOpen, res)) return;
+    if (!requireTrustedWorkspace(deps, res)) return;
+    const originatorClientId = validateOriginatorClientId(deps, req, res);
+    if (originatorClientId === null) return;
+    if (!await validateManagedMemoryAvailable(
+      deps,
+      res,
+      "dream",
+      assertGenerationOpen
+    ))
+      return;
+    if (!requireOpenGeneration(assertGenerationOpen, res)) return;
+    try {
+      const task = deps.lane.enqueueDream({
+        ...originatorClientId ? { originatorClientId } : {},
+        ...assertGenerationOpen ? { assertGenerationOpen } : {}
+      });
+      res.status(202).json(task);
+    } catch (err) {
+      const code = workspaceMemoryFailureCode(
+        err,
+        "dream_failed",
+        logWorkspaceMemoryExtractionError
       );
-      if (!task) {
-        res.status(404).json({
-          error: "Workspace memory dream task not found",
-          code: "dream_task_not_found"
-        });
-        return;
-      }
-      res.status(200).json(task);
+      res.status(publicErrorStatus(code)).json({
+        error: publicErrorMessage(code, "dream"),
+        code
+      });
     }
+  });
+  app.get(`${basePath}/dream/:taskId`, mutate({ strict: true }), (req, res) => {
+    const deps = resolveRouteDeps(req, res, {
+      creating: false,
+      kind: "dream"
+    });
+    if (!deps) return;
+    const assertGenerationOpen = deps.captureGenerationAssertion?.();
+    if (!requireOpenGeneration(assertGenerationOpen, res)) return;
+    if (!requireTrustedWorkspace(deps, res)) return;
+    const requesterClientId = validateOriginatorClientId(deps, req, res);
+    if (requesterClientId === null) return;
+    const task = deps.lane.get(
+      req.params["taskId"],
+      requesterClientId,
+      "dream"
+    );
+    if (!task) {
+      res.status(404).json({
+        error: "Workspace memory dream task not found",
+        code: "dream_task_not_found"
+      });
+      return;
+    }
+    res.status(200).json(task);
+  });
+}
+__name(mountWorkspaceMemoryRememberRoutesAt, "mountWorkspaceMemoryRememberRoutesAt");
+function mountWorkspaceMemoryRememberRoutes(app, deps) {
+  mountWorkspaceMemoryRememberRoutesAt(
+    app,
+    "/workspace/memory",
+    deps.mutate,
+    () => deps
   );
 }
 __name(mountWorkspaceMemoryRememberRoutes, "mountWorkspaceMemoryRememberRoutes");
+function mountWorkspaceQualifiedMemoryRememberRoutes(app, deps) {
+  mountWorkspaceMemoryRememberRoutesAt(
+    app,
+    "/workspaces/:workspace/memory",
+    deps.mutate,
+    deps.resolveRouteDeps
+  );
+}
+__name(mountWorkspaceQualifiedMemoryRememberRoutes, "mountWorkspaceQualifiedMemoryRememberRoutes");
 
 // packages/cli/src/serve/workspace-memory.ts
 init_esbuild_shims();
@@ -14850,6 +14890,16 @@ function mountAcpHttp(app, bridge, opts) {
         memoryTasks: mount?.workspaceRememberLane.pendingCount() ?? 0
       };
     }, "getWorkspaceActivity"),
+    ensureWorkspaceRememberLane: /* @__PURE__ */ __name((workspaceId) => {
+      if (disposed) return void 0;
+      const existing = mountForWorkspace(workspaceId);
+      if (existing) return existing.workspaceRememberLane;
+      const rt = opts.workspaceRegistry?.getByWorkspaceId(workspaceId);
+      if (!rt) return void 0;
+      const mount = getOrCreateSecondaryMount(rt);
+      return mount?.workspaceRememberLane;
+    }, "ensureWorkspaceRememberLane"),
+    getWorkspaceRememberLane: /* @__PURE__ */ __name((workspaceId) => mountForWorkspace(workspaceId)?.workspaceRememberLane, "getWorkspaceRememberLane"),
     commitWorkspaceRemoval: /* @__PURE__ */ __name((workspaceId) => {
       const mount = secondaryMounts.get(workspaceId);
       mount?.workspaceRememberLane.dispose();
@@ -20035,6 +20085,12 @@ var legacySessionTelemetryRoutes = [
     attribution: "handler_resolved",
     route: "POST /session/:id/mid-turn-message"
   },
+  {
+    method: "DELETE",
+    path: "/session/:id/mid-turn-messages/:messageId",
+    attribution: "handler_resolved",
+    route: "DELETE /session/:id/mid-turn-messages/:messageId"
+  },
   {
     method: "GET",
     path: "/session/:id/pending-prompts",
@@ -22013,6 +22069,7 @@ __name(createWorkspaceRuntimeSessionService, "createWorkspaceRuntimeSessionServi
 var GIT_RESERVED_BRANCH = "HEAD";
 var MAX_BRANCH_NAME_BYTES = 1e3;
 var MAX_BRANCH_COMPONENT_BYTES = 200;
+var HTTP_SESSION_ID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var WORKSPACE_TRANSCRIPT_RESPONSE_MAX_BYTES = 32 * 1024 * 1024;
 var WORKSPACE_TRANSCRIPT_CURSOR_MAX_BYTES = 64 * 1024;
 var TRANSCRIPT_CURSOR_TOO_LARGE_REPLAY_ERROR = "Transcript pagination state exceeds the safe limit";
@@ -22172,6 +22229,15 @@ function shouldPreserveTranscriptResolutionError(err) {
   return err instanceof SessionArchivedError || err instanceof SessionConflictError || err instanceof SessionNotFoundError;
 }
 __name(shouldPreserveTranscriptResolutionError, "shouldPreserveTranscriptResolutionError");
+function isSessionLive(bridge, sessionId) {
+  try {
+    bridge.getSessionSummary(sessionId);
+    return true;
+  } catch (err) {
+    return !(err instanceof SessionNotFoundError);
+  }
+}
+__name(isSessionLive, "isSessionLive");
 function parseOptionalApprovalMode(body, res) {
   const rawApprovalMode = body["approvalMode"];
   if (rawApprovalMode === void 0) {
@@ -22206,6 +22272,7 @@ function registerSessionRoutes(app, deps) {
   const transcriptCursorCodecs = /* @__PURE__ */ new Map();
   const activeBranchSessions = /* @__PURE__ */ new Map();
   const inFlightBranchWorkspaces = /* @__PURE__ */ new Set();
+  const inFlightSessionIds = /* @__PURE__ */ new Set();
   const clearBranchSessionEntry = /* @__PURE__ */ __name((sessionId) => {
     for (const [cwd, sid] of activeBranchSessions) {
       if (sid === sessionId) {
@@ -22833,201 +22900,246 @@ function registerSessionRoutes(app, deps) {
     }
     const clientId = parseClientIdHeader(req, res);
     if (clientId === null) return;
-    let branchMeta;
-    let branchBaseCommit;
-    const rawBranch = body["branch"];
-    if (rawBranch !== void 0 && rawBranch !== null) {
-      if (body["worktree"] !== void 0 && body["worktree"] !== null) {
+    const rawSessionId = body["sessionId"];
+    let requestedSessionId;
+    if (rawSessionId !== void 0 && rawSessionId !== null) {
+      if (typeof rawSessionId !== "string" || !HTTP_SESSION_ID_REGEX.test(rawSessionId)) {
         res.status(400).json({
-          error: "`branch` and `worktree` are mutually exclusive",
-          code: "branch_and_worktree_conflict"
+          error: '`sessionId` must be a UUID (e.g. "550e8400-e29b-41d4-a716-446655440000")',
+          code: "invalid_session_id"
         });
         return;
       }
-      if (typeof rawBranch !== "object" || Array.isArray(rawBranch)) {
-        res.status(400).json({
-          error: '`branch` must be an object (e.g. `{"name":"feat/my-feature"}`)',
-          code: "invalid_branch"
+      requestedSessionId = rawSessionId.toLowerCase();
+      const sessionIdToCheck = requestedSessionId;
+      if (isSessionLive(runtime.bridge, sessionIdToCheck)) {
+        res.status(409).json({
+          error: `Session "${requestedSessionId}" already exists`,
+          code: "session_id_conflict"
         });
         return;
       }
-      const branchReq = rawBranch;
-      const branchName = branchReq["name"];
-      if (typeof branchName !== "string" || branchName.length === 0) {
-        res.status(400).json({
-          error: "`branch.name` must be a non-empty string",
-          code: "branch_invalid_name"
+      const runtimeOutputDir = loadSettingsCached(workspaceCwd).merged.advanced?.runtimeOutputDir;
+      if (await Storage.runWithRuntimeBaseDir(
+        runtimeOutputDir,
+        workspaceCwd,
+        () => new SessionService(workspaceCwd).sessionExistsInAnyState(
+          sessionIdToCheck
+        )
+      )) {
+        res.status(409).json({
+          error: `Session "${requestedSessionId}" already exists`,
+          code: "session_id_conflict"
         });
         return;
       }
-      if (/[^\p{L}\p{N}._/-]/u.test(branchName) || branchName.includes("..") || branchName.includes("//") || branchName.startsWith(".") || branchName.startsWith("-") || branchName.startsWith("/") || branchName.endsWith("/") || branchName.endsWith(".") || branchName.endsWith(".git") || branchName.includes("@{") || branchName.split("/").some((c) => c.startsWith(".") || c.endsWith(".lock")) || branchName.toUpperCase() === GIT_RESERVED_BRANCH || Buffer.byteLength(branchName, "utf8") > MAX_BRANCH_NAME_BYTES || branchName.split("/").some(
-        (c) => Buffer.byteLength(c, "utf8") > MAX_BRANCH_COMPONENT_BYTES
-      )) {
-        res.status(400).json({
-          error: `Invalid branch name: ${branchName}`,
-          code: "branch_invalid_name"
+      if (inFlightSessionIds.has(requestedSessionId)) {
+        res.status(409).json({
+          error: `Session "${requestedSessionId}" creation already in progress`,
+          code: "session_id_conflict"
         });
         return;
       }
-      const existingBranchSession = activeBranchSessions.get(workspaceCwd);
-      if (existingBranchSession) {
-        try {
-          runtime.bridge.getSessionSummary(existingBranchSession);
+      inFlightSessionIds.add(requestedSessionId);
+    }
+    let branchMeta;
+    let branchBaseCommit;
+    let worktreeMeta;
+    try {
+      const rawBranch = body["branch"];
+      if (rawBranch !== void 0 && rawBranch !== null) {
+        if (body["worktree"] !== void 0 && body["worktree"] !== null) {
+          res.status(400).json({
+            error: "`branch` and `worktree` are mutually exclusive",
+            code: "branch_and_worktree_conflict"
+          });
+          return;
+        }
+        if (typeof rawBranch !== "object" || Array.isArray(rawBranch)) {
+          res.status(400).json({
+            error: '`branch` must be an object (e.g. `{"name":"feat/my-feature"}`)',
+            code: "invalid_branch"
+          });
+          return;
+        }
+        const branchReq = rawBranch;
+        const branchName = branchReq["name"];
+        if (typeof branchName !== "string" || branchName.length === 0) {
+          res.status(400).json({
+            error: "`branch.name` must be a non-empty string",
+            code: "branch_invalid_name"
+          });
+          return;
+        }
+        if (/[^\p{L}\p{N}._/-]/u.test(branchName) || branchName.includes("..") || branchName.includes("//") || branchName.startsWith(".") || branchName.startsWith("-") || branchName.startsWith("/") || branchName.endsWith("/") || branchName.endsWith(".") || branchName.endsWith(".git") || branchName.includes("@{") || branchName.split("/").some((c) => c.startsWith(".") || c.endsWith(".lock")) || branchName.toUpperCase() === GIT_RESERVED_BRANCH || Buffer.byteLength(branchName, "utf8") > MAX_BRANCH_NAME_BYTES || branchName.split("/").some(
+          (c) => Buffer.byteLength(c, "utf8") > MAX_BRANCH_COMPONENT_BYTES
+        )) {
+          res.status(400).json({
+            error: `Invalid branch name: ${branchName}`,
+            code: "branch_invalid_name"
+          });
+          return;
+        }
+        const existingBranchSession = activeBranchSessions.get(workspaceCwd);
+        if (existingBranchSession) {
+          try {
+            runtime.bridge.getSessionSummary(existingBranchSession);
+            res.status(409).json({
+              error: "A branch session is already active for this workspace",
+              code: "branch_session_conflict",
+              existingSessionId: existingBranchSession
+            });
+            return;
+          } catch {
+            activeBranchSessions.delete(workspaceCwd);
+          }
+        }
+        const sharedCheckoutSession = runtime.bridge.listWorkspaceSessions(workspaceCwd).find((session2) => !session2.worktree && session2.clientCount > 0);
+        if (sharedCheckoutSession) {
           res.status(409).json({
-            error: "A branch session is already active for this workspace",
+            error: "Another session is already active in this workspace; creating a branch would move its shared checkout",
             code: "branch_session_conflict",
-            existingSessionId: existingBranchSession
+            existingSessionId: sharedCheckoutSession.sessionId
           });
           return;
+        }
+        let wtService;
+        try {
+          wtService = new GitWorktreeService(workspaceCwd);
         } catch {
-          activeBranchSessions.delete(workspaceCwd);
+          res.status(500).json({
+            error: "Failed to initialize git service",
+            code: "branch_init_failed"
+          });
+          return;
         }
+        if (!await wtService.isGitRepository()) {
+          res.status(400).json({
+            error: "Branch creation requires a git repository",
+            code: "branch_not_git_repo"
+          });
+          return;
+        }
+        if (await branchExists(workspaceCwd, branchName)) {
+          res.status(409).json({
+            error: `Branch "${branchName}" already exists`,
+            code: "branch_already_exists"
+          });
+          return;
+        }
+        let dirty;
+        try {
+          dirty = await isDirtyTree(workspaceCwd);
+        } catch {
+          res.status(500).json({
+            error: "Failed to check working tree status",
+            code: "branch_status_failed"
+          });
+          return;
+        }
+        if (dirty) {
+          res.status(409).json({
+            error: "Uncommitted changes detected. Commit or stash first.",
+            code: "branch_dirty_tree"
+          });
+          return;
+        }
+        const baseCommit = await getHeadCommit(workspaceCwd);
+        const baseBranch = await wtService.getCurrentBranch().catch(() => "HEAD");
+        if (inFlightBranchWorkspaces.has(workspaceCwd) || activeBranchSessions.has(workspaceCwd)) {
+          res.status(409).json({
+            error: "A branch session is already being created for this workspace",
+            code: "branch_session_conflict"
+          });
+          return;
+        }
+        inFlightBranchWorkspaces.add(workspaceCwd);
+        try {
+          await createBranch(workspaceCwd, branchName);
+        } catch (checkoutErr) {
+          daemonLog?.warn("branch checkout failed", {
+            error: checkoutErr instanceof Error ? checkoutErr.message : String(checkoutErr)
+          });
+          await rollbackBranchCreation(
+            workspaceCwd,
+            { name: branchName, baseBranch },
+            baseCommit,
+            daemonLog
+          );
+          res.status(500).json({
+            error: "Failed to create branch",
+            code: "branch_checkout_failed"
+          });
+          return;
+        }
+        branchMeta = { name: branchName, baseBranch };
+        branchBaseCommit = baseCommit;
+        sessionScope = "thread";
       }
-      const sharedCheckoutSession = runtime.bridge.listWorkspaceSessions(workspaceCwd).find((session) => !session.worktree && session.clientCount > 0);
-      if (sharedCheckoutSession) {
-        res.status(409).json({
-          error: "Another session is already active in this workspace; creating a branch would move its shared checkout",
-          code: "branch_session_conflict",
-          existingSessionId: sharedCheckoutSession.sessionId
-        });
-        return;
-      }
-      let wtService;
-      try {
-        wtService = new GitWorktreeService(workspaceCwd);
-      } catch {
-        res.status(500).json({
-          error: "Failed to initialize git service",
-          code: "branch_init_failed"
-        });
-        return;
-      }
-      if (!await wtService.isGitRepository()) {
-        res.status(400).json({
-          error: "Branch creation requires a git repository",
-          code: "branch_not_git_repo"
-        });
-        return;
-      }
-      if (await branchExists(workspaceCwd, branchName)) {
-        res.status(409).json({
-          error: `Branch "${branchName}" already exists`,
-          code: "branch_already_exists"
-        });
-        return;
-      }
-      let dirty;
-      try {
-        dirty = await isDirtyTree(workspaceCwd);
-      } catch {
-        res.status(500).json({
-          error: "Failed to check working tree status",
-          code: "branch_status_failed"
-        });
-        return;
-      }
-      if (dirty) {
-        res.status(409).json({
-          error: "Uncommitted changes detected. Commit or stash first.",
-          code: "branch_dirty_tree"
-        });
-        return;
-      }
-      const baseCommit = await getHeadCommit(workspaceCwd);
-      const baseBranch = await wtService.getCurrentBranch().catch(() => "HEAD");
-      if (inFlightBranchWorkspaces.has(workspaceCwd) || activeBranchSessions.has(workspaceCwd)) {
-        res.status(409).json({
-          error: "A branch session is already being created for this workspace",
-          code: "branch_session_conflict"
-        });
-        return;
-      }
-      inFlightBranchWorkspaces.add(workspaceCwd);
-      try {
-        await createBranch(workspaceCwd, branchName);
-      } catch (checkoutErr) {
-        daemonLog?.warn("branch checkout failed", {
-          error: checkoutErr instanceof Error ? checkoutErr.message : String(checkoutErr)
-        });
-        await rollbackBranchCreation(
-          workspaceCwd,
-          { name: branchName, baseBranch },
-          baseCommit,
-          daemonLog
-        );
-        res.status(500).json({
-          error: "Failed to create branch",
-          code: "branch_checkout_failed"
-        });
-        return;
-      }
-      branchMeta = { name: branchName, baseBranch };
-      branchBaseCommit = baseCommit;
-      sessionScope = "thread";
-    }
-    let worktreeMeta;
-    const rawWorktree = body["worktree"];
-    if (rawWorktree !== void 0 && rawWorktree !== null) {
-      if (typeof rawWorktree !== "object" || Array.isArray(rawWorktree)) {
-        res.status(400).json({
-          error: '`worktree` must be an object (e.g. `{}` or `{"slug":"my-task"}`)',
-          code: "invalid_worktree"
-        });
-        return;
-      }
-      const wtReq = rawWorktree;
-      let wtService;
-      try {
-        wtService = new GitWorktreeService(workspaceCwd);
-      } catch {
-        res.status(500).json({
-          error: "Failed to initialize worktree service",
-          code: "worktree_init_failed"
-        });
-        return;
-      }
-      if (!await wtService.isGitRepository()) {
-        res.status(400).json({
-          error: "Worktree isolation requires a git repository",
-          code: "worktree_not_git_repo"
-        });
-        return;
-      }
-      const rawSlug = wtReq["slug"];
-      let slug;
-      if (rawSlug === void 0 || rawSlug === null) {
-        slug = GitWorktreeService.generateAutoSlug();
-      } else if (typeof rawSlug !== "string" || rawSlug.length === 0) {
-        res.status(400).json({
-          error: "`worktree.slug` must be a non-empty string when provided",
-          code: "worktree_invalid_slug"
-        });
-        return;
-      } else {
-        slug = rawSlug;
-      }
-      const slugError = GitWorktreeService.validateUserWorktreeSlug(slug);
-      if (slugError) {
-        res.status(400).json({ error: slugError, code: "worktree_invalid_slug" });
-        return;
+      const rawWorktree = body["worktree"];
+      if (rawWorktree !== void 0 && rawWorktree !== null) {
+        if (typeof rawWorktree !== "object" || Array.isArray(rawWorktree)) {
+          res.status(400).json({
+            error: '`worktree` must be an object (e.g. `{}` or `{"slug":"my-task"}`)',
+            code: "invalid_worktree"
+          });
+          return;
+        }
+        const wtReq = rawWorktree;
+        let wtService;
+        try {
+          wtService = new GitWorktreeService(workspaceCwd);
+        } catch {
+          res.status(500).json({
+            error: "Failed to initialize worktree service",
+            code: "worktree_init_failed"
+          });
+          return;
+        }
+        if (!await wtService.isGitRepository()) {
+          res.status(400).json({
+            error: "Worktree isolation requires a git repository",
+            code: "worktree_not_git_repo"
+          });
+          return;
+        }
+        const rawSlug = wtReq["slug"];
+        let slug;
+        if (rawSlug === void 0 || rawSlug === null) {
+          slug = GitWorktreeService.generateAutoSlug();
+        } else if (typeof rawSlug !== "string" || rawSlug.length === 0) {
+          res.status(400).json({
+            error: "`worktree.slug` must be a non-empty string when provided",
+            code: "worktree_invalid_slug"
+          });
+          return;
+        } else {
+          slug = rawSlug;
+        }
+        const slugError = GitWorktreeService.validateUserWorktreeSlug(slug);
+        if (slugError) {
+          res.status(400).json({ error: slugError, code: "worktree_invalid_slug" });
+          return;
+        }
+        const baseBranch = await wtService.getCurrentBranch().catch(() => void 0);
+        const wtResult = await wtService.createUserWorktree(slug, baseBranch);
+        if (!wtResult.success || !wtResult.worktree) {
+          res.status(500).json({
+            error: wtResult.error ?? "Failed to create worktree",
+            code: "worktree_create_failed"
+          });
+          return;
+        }
+        worktreeMeta = {
+          slug,
+          path: wtResult.worktree.path,
+          branch: wtResult.worktree.branch
+        };
+        sessionScope = "thread";
       }
-      const baseBranch = await wtService.getCurrentBranch().catch(() => void 0);
-      const wtResult = await wtService.createUserWorktree(slug, baseBranch);
-      if (!wtResult.success || !wtResult.worktree) {
-        res.status(500).json({
-          error: wtResult.error ?? "Failed to create worktree",
-          code: "worktree_create_failed"
-        });
-        return;
+      if (requestedSessionId !== void 0) {
+        sessionScope = "thread";
       }
-      worktreeMeta = {
-        slug,
-        path: wtResult.worktree.path,
-        branch: wtResult.worktree.branch
-      };
-      sessionScope = "thread";
-    }
-    try {
       const session = await runtime.bridge.spawnOrAttach({
         workspaceCwd,
         modelServiceId,
@@ -23037,8 +23149,45 @@ function registerSessionRoutes(app, deps) {
         ...source.sourceType !== void 0 ? { sourceType: source.sourceType } : {},
         ...source.sourceId !== void 0 ? { sourceId: source.sourceId } : {},
         ...worktreeMeta ? { worktree: worktreeMeta } : {},
-        ...branchMeta ? { branch: branchMeta } : {}
+        ...branchMeta ? { branch: branchMeta } : {},
+        ...requestedSessionId !== void 0 ? { sessionId: requestedSessionId } : {}
       });
+      if (requestedSessionId !== void 0 && session.sessionId !== requestedSessionId) {
+        if (daemonLog) {
+          daemonLog.warn("session id not honored by agent", {
+            requested: requestedSessionId,
+            actual: session.sessionId
+          });
+        }
+        if (!session.attached) {
+          await runWithWorkspaceRuntimeStorage(
+            runtime,
+            () => deleteDaemonSessionIfOrphan({
+              sessionId: session.sessionId,
+              service: createWorkspaceRuntimeSessionService(runtime),
+              bridge: runtime.bridge,
+              coordinator: archiveCoordinator
+            })
+          ).catch(() => false);
+        }
+        if (worktreeMeta) {
+          await new GitWorktreeService(workspaceCwd).removeUserWorktree(worktreeMeta.slug, { deleteBranch: true }).catch(() => {
+          });
+        }
+        if (branchMeta) {
+          await rollbackBranchCreation(
+            workspaceCwd,
+            branchMeta,
+            branchBaseCommit,
+            daemonLog
+          );
+        }
+        res.status(500).json({
+          error: "Agent did not honor the requested session id",
+          code: "session_id_not_honored"
+        });
+        return;
+      }
       try {
         runtime.generationGuard?.assertOpen();
       } catch (error2) {
@@ -23210,6 +23359,10 @@ function registerSessionRoutes(app, deps) {
         );
       }
       sendBridgeError2(res, err, { route: "POST /session" });
+    } finally {
+      if (requestedSessionId !== void 0) {
+        inFlightSessionIds.delete(requestedSessionId);
+      }
     }
   });
   const restoreSessionHandler = /* @__PURE__ */ __name((action) => async (req, res) => {
@@ -25346,6 +25499,28 @@ function registerSessionRoutes(app, deps) {
       }
     )
   );
+  app.delete(
+    "/session/:id/mid-turn-messages/:messageId",
+    mutate(),
+    withOwnerMutableSession(
+      "DELETE /session/:id/mid-turn-messages/:messageId",
+      (req, res, sessionId, runtime) => {
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const messageId = req.params["messageId"];
+        if (!messageId) {
+          res.status(400).json({ error: "`messageId` route parameter is required" });
+          return;
+        }
+        const result = runtime.bridge.removeMidTurnMessage(
+          sessionId,
+          messageId,
+          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;
@@ -27423,7 +27598,7 @@ init_esbuild_shims();
 
 // packages/cli/src/serve/server/serve-features.ts
 init_esbuild_shims();
-var DEFAULT_MAX_SESSIONS = 20;
+var DEFAULT_MAX_SESSIONS = 32;
 var DEFAULT_MAX_PENDING_PROMPTS_PER_SESSION = 5;
 var SERVE_LANGUAGE_CODES = [
   ...SUPPORTED_LANGUAGES.map((language) => language.code),
@@ -27843,6 +28018,8 @@ var TUI_ONLY_SETTINGS = /* @__PURE__ */ new Set([
   "ui.showLineNumbers",
   "ui.renderMode",
   "ui.useTerminalBuffer",
+  "ui.mouseTracking",
+  "ui.showScrollbar",
   "ui.hideBanner",
   "ui.accessibility.enableLoadingPhrases",
   "ui.enableWelcomeBack"
@@ -30596,9 +30773,18 @@ function registerWorkspaceManagementRoutes(app, deps) {
       }
     }
   );
+  const protectExistingWorkspaceRegistration = mutate({ strict: true });
   app.post(
     "/workspaces",
-    mutate({ strict: true }),
+    mutate(),
+    (req, res, next) => {
+      const body = safeBody2(req);
+      if (body["kind"] === "scratch") {
+        next();
+        return;
+      }
+      protectExistingWorkspaceRegistration(req, res, next);
+    },
     async (req, res) => {
       const body = safeBody2(req);
       if ("kind" in body) {
@@ -35387,6 +35573,49 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     isWorkspaceTrusted: isPrimaryWorkspaceTrusted,
     captureGenerationAssertion: capturePrimaryGenerationAssertion
   });
+  mountWorkspaceQualifiedMemoryRememberRoutes(app, {
+    mutate,
+    resolveRouteDeps: /* @__PURE__ */ __name((req, res, { creating, kind }) => {
+      const runtime = resolveWorkspaceRuntimeFromParam(
+        workspaceRegistry,
+        req,
+        res
+      );
+      if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res))
+        return null;
+      const handle = acpHandleRef.current;
+      const lane = runtime.primary ? workspaceRememberLane : creating ? handle?.ensureWorkspaceRememberLane(runtime.workspaceId) : handle?.getWorkspaceRememberLane(runtime.workspaceId);
+      if (!lane) {
+        if (!handle) {
+          res.status(501).json({
+            error: "Workspace-qualified memory is not enabled on this daemon.",
+            code: "workspace_memory_unavailable",
+            workspaceCwd: runtime.workspaceCwd,
+            workspaceId: runtime.workspaceId
+          });
+        } else if (!creating) {
+          res.status(404).json({
+            error: `Workspace memory ${kind} task not found`,
+            code: `${kind}_task_not_found`
+          });
+        } else {
+          sendWorkspaceRuntimeUnavailable(res, runtime);
+        }
+        return null;
+      }
+      return {
+        bridge: runtime.bridge,
+        lane,
+        parseClientId: parseClientIdHeader,
+        safeBody,
+        isWorkspaceTrusted: /* @__PURE__ */ __name(() => runtime.trusted, "isWorkspaceTrusted"),
+        captureGenerationAssertion: /* @__PURE__ */ __name(() => {
+          const guard = runtime.generationGuard;
+          return guard ? () => guard.assertOpen() : void 0;
+        }, "captureGenerationAssertion")
+      };
+    }, "resolveRouteDeps")
+  });
   mountWorkspaceAgentsRoutes(app, {
     bridge: primaryBridge,
     boundWorkspace: primaryBoundWorkspace,