@qwen-code/qwen-code 0.21.13 → 0.21.14-nightly.20260822.7a4566cb3b

package/chunks/{server-TC4A7AAZ.js → server-KU7XIDVT.js}

@@ -10,6 +10,7 @@ import {
   formatWorkspaceMemoryForgetSummary,
   isCompatibleLiveSessionSource,
   isReservedLiveSessionSource,
+  isReservedStandaloneSessionSource,
   isValidServerName,
   normalizeChannelDelivery,
   parseChannelDelivery,
@@ -20,13 +21,13 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-ZZO74WKW.js";
+} from "./chunk-TNAIZBPQ.js";
 import {
   deriveWebSocketBase,
   openQwenAsrRealtimeStream,
   openVoiceStream,
   openVoiceStreamWithRetry
-} from "./chunk-AXN7UPYQ.js";
+} from "./chunk-RQJJZQOH.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -38,18 +39,18 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-RLKC46YT.js";
+} from "./chunk-3SIGAHUX.js";
 import {
   OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
   ObservedChannelContactStore
-} from "./chunk-BZ263IKX.js";
+} from "./chunk-UZPYR3EV.js";
+import "./chunk-FV6PXZRO.js";
 import {
   escapeAnsiCtrlCodes
-} from "./chunk-4NFY2S7N.js";
-import "./chunk-3U3VAL47.js";
+} from "./chunk-E7REAOTN.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
-import "./chunk-3Z43GZUQ.js";
+import "./chunk-TXASDT2M.js";
 import {
   ACP_PRE_ATTACH_MAX_FRAMES_GLOBAL,
   ACP_PRE_ATTACH_MAX_FRAMES_PER_CONNECTION,
@@ -62,11 +63,13 @@ import {
   CLIENT_ID_RE,
   ClientMcpSenderRegistry,
   ConversationRuntimeOwnershipError,
+  CredentialStore,
   DeviceFlowRegistry,
   MAX_CLIENT_ID_LENGTH,
   MAX_CONCURRENT_VOICE_SESSIONS,
   MAX_SERVER_NAME_LENGTH,
   MAX_TOOL_NAME_LENGTH,
+  MutableOriginAllowlist,
   PathMutexRegistry,
   QWEN_CDP_MCP_COMMAND_ENV,
   TooManyActiveDeviceFlowsError,
@@ -88,7 +91,8 @@ import {
   createManagedScratchDirectory,
   createMutationGate,
   createRateLimiter,
-  denyBrowserOriginCors,
+  daemonInboundTraceIdContext,
+  daemonTelemetryResponseContext,
   detectFromLoopback,
   getAdvertisedServeFeatures,
   getDeferredRuntimeRequestTiming,
@@ -99,6 +103,8 @@ import {
   isBrowserAutomationMcpAvailable,
   isDeepHealthQuery,
   isScratchRootCompatible,
+  listenerIdentityOf,
+  listenerIdentityOfSocket,
   parseAllowOriginPatterns,
   parseAndValidateWorkspaceClientId,
   parseClientIdHeader,
@@ -107,6 +113,7 @@ import {
   parseMaxQueuedQuery,
   parseOptionalWorkspaceCwd,
   parsePermissionVoteBody,
+  requestWasAuthenticated,
   requireSessionId,
   resolveAcpHttpEnabled,
   resolveCdpMcpCommand,
@@ -116,9 +123,11 @@ import {
   sendJsonBodyParserError,
   setDeviceFlowRegistry,
   setRateLimiter,
+  singleTokenCredentials,
+  tagListener,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-O565M6A4.js";
+} from "./chunk-DRVS6K7A.js";
 import "./chunk-VGHZT6JR.js";
 import {
   isLoopbackBind,
@@ -126,10 +135,38 @@ import {
   parseCallerSuppliedSessionId
 } from "./chunk-TQOF5KBL.js";
 import "./chunk-UXEO7E3V.js";
+import {
+  WorkspaceGenerationClosedError,
+  createSingleWorkspaceRegistry,
+  createWorkspaceSessionOwnerIndex
+} from "./chunk-K3LPAED5.js";
+import {
+  isInternalWorkspaceRuntime
+} from "./chunk-NYWWQ437.js";
+import {
+  assertValidChannelSecretUpdates
+} from "./chunk-Q7RPLE33.js";
+import {
+  createWorkspaceSkillsStatusProvider
+} from "./chunk-AGCLK4G7.js";
+import "./chunk-BGXZBI5B.js";
+import {
+  isServeDebugMode,
+  mountWebShellAssets,
+  mountWebShellSpaFallback
+} from "./chunk-KSPRQSB4.js";
+import {
+  require_express
+} from "./chunk-O5Z7EB6Y.js";
 import {
   evaluateDaemonWorkspaceTrust,
   readDaemonTrustPolicySnapshot
-} from "./chunk-XIT3GURH.js";
+} from "./chunk-HGBACZGD.js";
+import {
+  readRecentPromptTerminals,
+  reconcileDanglingPromptTerminals,
+  withPromptTerminals
+} from "./chunk-64LXOKG4.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   MAX_WORKSPACE_SKILL_NAME_LENGTH,
@@ -143,14 +180,14 @@ import {
   validateWorkspaceSkillName,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-EZ5RP345.js";
+} from "./chunk-UYQTX2P6.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-7UXUJ5T3.js";
+} from "./chunk-PLECQWDB.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -158,24 +195,22 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-6ORZ2EDC.js";
+} from "./chunk-EW2IQ3ID.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-QIH2HAEN.js";
-import "./chunk-WGHHA7ZH.js";
+} from "./chunk-GXG4PYQB.js";
+import "./chunk-Z3JMO2CH.js";
+import "./chunk-Z4X5MTRT.js";
+import {
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError,
+  mapWorkspaceSkillToggleError
+} from "./chunk-Z7VOMGDC.js";
 import {
   createTotalSessionAdmissionController
 } from "./chunk-X2UOOG5V.js";
-import {
-  WorkspaceGenerationClosedError,
-  createSingleWorkspaceRegistry,
-  createWorkspaceSessionOwnerIndex
-} from "./chunk-K3LPAED5.js";
-import {
-  isInternalWorkspaceRuntime
-} from "./chunk-NYWWQ437.js";
 import "./chunk-OIBUG24X.js";
 import {
   MAX_SESSION_RESTORE_TIMEOUT_MS,
@@ -183,19 +218,24 @@ import {
   restoreRetryAfterSeconds
 } from "./chunk-4JRM2BSM.js";
 import {
-  assertValidChannelSecretUpdates
-} from "./chunk-PP4FUZNV.js";
+  getStableLiveDiscoveryBaseDir
+} from "./chunk-5MK45KZ3.js";
+import {
+  LIVE_HOST_BUNDLE_ID,
+  LIVE_HOST_PROTOCOL_VERSION,
+  LIVE_INPUT_AUDIO_EPOCH_BYTES
+} from "./chunk-NKLP3DCK.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-OOQUVWIG.js";
-import "./chunk-NTTBXH7U.js";
-import "./chunk-XHRY7BXD.js";
+} from "./chunk-K5OIW3I7.js";
+import "./chunk-JS73NNWF.js";
+import "./chunk-J6SIP2IT.js";
 import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge,
   parseSessionSource
-} from "./chunk-LJQAUZMR.js";
+} from "./chunk-7CPJMZVJ.js";
 import {
   EVENT_SCHEMA_VERSION,
   EventBus,
@@ -203,66 +243,38 @@ import {
 } from "./chunk-7U5G6JXI.js";
 import "./chunk-WCCLLK7X.js";
 import "./chunk-OCPBI7J5.js";
+import "./chunk-VMJL7RH6.js";
 import {
   createWorkspaceProvidersStatusProvider
-} from "./chunk-YEYY7TEP.js";
+} from "./chunk-Y2FEAXLP.js";
 import {
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-ZYYTZUI2.js";
+} from "./chunk-3LYGXZ2H.js";
 import {
   snapshotProcessEnv
-} from "./chunk-NM5V5OVW.js";
-import {
-  createWorkspaceSkillsStatusProvider
-} from "./chunk-OY5RNSV4.js";
-import "./chunk-BGXZBI5B.js";
-import "./chunk-Z4X5MTRT.js";
-import {
-  WorkspacePermissionRulesSessionRequiredError,
-  WorkspaceSettingsPartialPersistError,
-  mapWorkspaceSkillToggleError
-} from "./chunk-Z7VOMGDC.js";
-import {
-  isServeDebugMode,
-  mountWebShellAssets,
-  mountWebShellSpaFallback
-} from "./chunk-SOORFWKY.js";
+} from "./chunk-WJJYJVQE.js";
 import {
-  require_express
-} from "./chunk-GDXET5XU.js";
+  STATUS_SCHEMA_VERSION,
+  SessionRestoreTimeoutError,
+  createIdleWorkspaceMemoryStatus,
+  mapDomainErrorToErrorKind
+} from "./chunk-URN2JIAQ.js";
+import "./chunk-HMJ2P3SV.js";
 import {
   daemonObservedContactsPath,
   loadChannelsConfig
-} from "./chunk-TUGSVUJB.js";
-import "./chunk-QV5YN5YD.js";
+} from "./chunk-ROV6B34L.js";
+import "./chunk-XJOHLP2A.js";
 import "./chunk-57OAHC2Y.js";
 import {
   parseChannelWebhookConfigLenient
-} from "./chunk-OD2WU5QY.js";
+} from "./chunk-J7JQXYVL.js";
 import "./chunk-45NQKMYB.js";
 import {
   supportedChannelCatalog
-} from "./chunk-A4QRWUDE.js";
+} from "./chunk-2NWPB6T4.js";
 import "./chunk-V6WHFGST.js";
-import {
-  getStableLiveDiscoveryBaseDir
-} from "./chunk-TS6625XH.js";
-import {
-  LIVE_HOST_BUNDLE_ID,
-  LIVE_HOST_PROTOCOL_VERSION,
-  LIVE_INPUT_AUDIO_EPOCH_BYTES
-} from "./chunk-NKLP3DCK.js";
-import "./chunk-NHDR76JX.js";
-import {
-  STATUS_SCHEMA_VERSION,
-  SessionRestoreTimeoutError,
-  createIdleWorkspaceMemoryStatus,
-  mapDomainErrorToErrorKind
-} from "./chunk-QNQAPSN2.js";
-import "./chunk-K6KS3LTN.js";
-import "./chunk-FC4KQFCS.js";
-import "./chunk-T3CHYWJZ.js";
 import {
   MAX_REGISTERED_WORKSPACES,
   WorkspaceDisplayNameValidationError,
@@ -270,13 +282,13 @@ import {
   WorkspaceRegistrationStoreLimitError,
   normalizeWorkspaceDisplayName,
   workspaceRegistrationId
-} from "./chunk-JNDY2MDR.js";
+} from "./chunk-TLDZKNZP.js";
 import {
   CHANNEL_PROMPT_META_KEY,
   DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
   REQUESTED_SESSION_ID_META_KEY,
   gradeActiveWorkCoverage
-} from "./chunk-S5DWMTHO.js";
+} from "./chunk-QQUVPMMZ.js";
 import {
   BranchWhilePromptActiveError,
   BridgeChannelQuarantinedError,
@@ -330,23 +342,25 @@ import {
   QWEN_SERVER_TOKEN_ENV,
   isChannelDeliveryError,
   isChannelWebhookEnqueueError
-} from "./chunk-YP5KH5Y7.js";
+} from "./chunk-ND7NOI4P.js";
 import {
   normalizeWorkerDiagnostic
 } from "./chunk-A6NRNRKE.js";
 import {
   normalizeServeChannelSelection
 } from "./chunk-ALMR3E6Q.js";
-import "./chunk-HIBNSEJE.js";
+import "./chunk-UDG5EZJI.js";
+import "./chunk-3VUENPWF.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
-import "./chunk-3VUENPWF.js";
+import "./chunk-5HBA2Z7V.js";
+import "./chunk-K6KS3LTN.js";
+import "./chunk-7E7UCJHS.js";
 import {
   sanitizeLogText
 } from "./chunk-AW27A43Y.js";
 import "./chunk-IW6RQPQB.js";
-import "./chunk-5HBA2Z7V.js";
 import {
   getDialogSettingKeys,
   getModelProvidersOwnerScope,
@@ -356,30 +370,31 @@ import {
   getWritableScopes,
   loadSettings,
   validateSettingValue
-} from "./chunk-A267JX7H.js";
+} from "./chunk-3HWN4E7N.js";
+import "./chunk-VOTDAZR7.js";
 import "./chunk-RKUWKYED.js";
-import "./chunk-E23IPNGS.js";
-import "./chunk-GOXKNSDZ.js";
-import "./chunk-IDS7MSUP.js";
 import {
   detectSystemLanguage,
   resolveLanguageSetting
-} from "./chunk-HUTNYWBG.js";
+} from "./chunk-45UD2TU4.js";
 import {
   SUPPORTED_LANGUAGES,
   resolveSupportedLanguage
 } from "./chunk-5EJZE3FP.js";
-import "./chunk-MC4TLKEI.js";
-import "./chunk-MS7GNABG.js";
-import "./chunk-CU6GJD55.js";
+import "./chunk-5PHLBWBL.js";
+import "./chunk-GOXKNSDZ.js";
+import "./chunk-IDS7MSUP.js";
+import "./chunk-CXJHQVEK.js";
+import "./chunk-7WLFSDLG.js";
 import "./chunk-WZMH7II3.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-IWPYVAO2.js";
+} from "./chunk-PSQJ24ZZ.js";
 import "./chunk-NPQ5ZKRP.js";
 import {
   isWithinRoot as isWithinRoot2
 } from "./chunk-MR3PXB6E.js";
+import "./chunk-LJZSMWOH.js";
 import {
   ALL_PROVIDERS,
   BTW_MAX_INPUT_LENGTH,
@@ -388,6 +403,7 @@ import {
   ClientMcpRegistrar,
   DEFAULT_LOG_LIMIT,
   ExtensionManager,
+  ExtensionNotUpdatableError,
   GITHUB_PR_ERROR_MESSAGE_MAX,
   GROUP_COLOR_OPTIONS,
   GitWorktreeService,
@@ -401,6 +417,7 @@ import {
   SESSION_TRANSCRIPT_MAX_LIMIT,
   SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
   SESSION_WRITER_RPC_CODES,
+  SessionIdCaseConflictError,
   SessionOrganizationError,
   SessionOrganizationService,
   SessionService,
@@ -437,6 +454,7 @@ import {
   gitPull,
   gitPush,
   glob,
+  isSupportedArchiveUrl,
   isValidCheckoutRef,
   isValidRefName,
   loadIgnoreRules,
@@ -448,25 +466,26 @@ import {
   resolveBranchName,
   resolveProviderProtocol,
   shouldShowStep,
+  sleepInhibitor,
   stripTerminalControlSequences,
   watchRepoBranch,
   writeWorkspaceContextFile,
   writeWorktreeSession,
   writeWorktreeSessionMarker
-} from "./chunk-4S5337WV.js";
+} from "./chunk-SVU5KGR7.js";
 import "./chunk-GOFAQQZA.js";
-import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-CQ35AJ4Z.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-KVGR4MCF.js";
+import "./chunk-XZJKSETB.js";
+import "./chunk-YMVFIYHV.js";
+import "./chunk-6PVPNMXU.js";
+import "./chunk-OTXXOZKW.js";
 import {
   MAX_JOBS,
   nextDurableFireMs
-} from "./chunk-DGZEMW5R.js";
-import "./chunk-WSH6GRKG.js";
-import "./chunk-CKSJECTU.js";
-import "./chunk-OVZPVYZB.js";
-import "./chunk-6PVPNMXU.js";
-import "./chunk-5EYKMUUY.js";
+} from "./chunk-DJEHYM4H.js";
 import {
   nextFireTime,
   parseCron
@@ -479,71 +498,72 @@ import {
   readCronTasks,
   taskHasLegacyCondition,
   updateCronTasks
-} from "./chunk-Y3YCSWG5.js";
-import "./chunk-UPDOZBWO.js";
+} from "./chunk-AZF6SME3.js";
+import "./chunk-TBVSALA3.js";
 import "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
-import "./chunk-ZPJWUGCS.js";
 import "./chunk-CPBF7KYF.js";
+import "./chunk-VUMLT7E5.js";
+import "./chunk-ISJMN3ML.js";
+import "./chunk-2TRNCJK4.js";
+import "./chunk-NUGZAFR2.js";
+import {
+  parseGoalControlRequest
+} from "./chunk-LDGWX737.js";
 import {
   APPROVAL_MODES
-} from "./chunk-RWDNJBWN.js";
-import "./chunk-25EYDK42.js";
-import "./chunk-MIPFDQAF.js";
+} from "./chunk-VLRBJ24J.js";
+import "./chunk-ZPJWUGCS.js";
 import "./chunk-MLXTMF7H.js";
-import "./chunk-KV27IEHM.js";
-import "./chunk-E3DYKPYZ.js";
-import "./chunk-OMLJNPBE.js";
-import "./chunk-OXCMMLED.js";
+import {
+  QwenOAuth2Client,
+  QwenOAuthPollError,
+  cacheQwenCredentials,
+  generatePKCEPair,
+  isDeviceAuthorizationSuccess,
+  isDeviceTokenPending,
+  isDeviceTokenSuccess
+} from "./chunk-O5BDEWBC.js";
+import "./chunk-NAVJD2PQ.js";
+import "./chunk-WRT324N6.js";
+import "./chunk-YDJRMQU4.js";
+import "./chunk-KM73TBQ4.js";
+import "./chunk-E63A23D7.js";
+import {
+  recordDaemonBridgeError,
+  recordDaemonHttpRequest
+} from "./chunk-6NJIPX6W.js";
+import "./chunk-P3QQPMQA.js";
 import {
   addDaemonRequestAttribute,
   captureDaemonTelemetryContext,
   emitDaemonLog,
+  extractDaemonHttpTraceContext,
+  extractInboundTraceId,
   hashDaemonWorkspace,
-  recordDaemonBridgeError,
   recordDaemonError,
-  recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   runWithDaemonTelemetryContext,
   withDaemonRequestSpan
-} from "./chunk-TIGA2IVL.js";
+} from "./chunk-6S2OXVJT.js";
+import "./chunk-XWRJCPHC.js";
 import "./chunk-SAH4BD2J.js";
-import "./chunk-XLLKYULU.js";
-import "./chunk-PT4I7NBA.js";
+import "./chunk-VSNPOSDN.js";
+import "./chunk-I432KXWD.js";
 import "./chunk-S6LOFUVP.js";
-import "./chunk-2J3OJGTL.js";
-import {
-  SubagentError,
-  SubagentErrorCode
-} from "./chunk-SG7ZP5PG.js";
-import "./chunk-K623ENWT.js";
-import {
-  escapeXml
-} from "./chunk-AQ37AY7B.js";
-import "./chunk-KBXKR5R2.js";
-import {
-  QwenOAuth2Client,
-  QwenOAuthPollError,
-  cacheQwenCredentials,
-  generatePKCEPair,
-  isDeviceAuthorizationSuccess,
-  isDeviceTokenPending,
-  isDeviceTokenSuccess
-} from "./chunk-GMIEIY3Y.js";
-import "./chunk-NAVJD2PQ.js";
-import "./chunk-ROIYNTHJ.js";
-import "./chunk-2B2BF7P7.js";
-import "./chunk-P3QQPMQA.js";
-import "./chunk-YZHRN3CF.js";
-import "./chunk-FAAUPSY2.js";
-import "./chunk-KM73TBQ4.js";
-import "./chunk-MPHPFVKK.js";
+import "./chunk-7IV52LTO.js";
 import "./chunk-AXMWHKXA.js";
-import "./chunk-GLCZKT5V.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-QFJ5JHQR.js";
-import "./chunk-CR3C7WXL.js";
-import "./chunk-XWRJCPHC.js";
+import "./chunk-2J3OJGTL.js";
+import "./chunk-LI4YHTQK.js";
+import "./chunk-GLCZKT5V.js";
+import "./chunk-C72BXMJ5.js";
+import {
+  parseLineTolerant,
+  read
+} from "./chunk-RPJOOK6N.js";
+import "./chunk-YRLW2MSX.js";
+import "./chunk-VGC4I5JJ.js";
 import {
   CursorNotAtLineBoundaryError,
   LargeNonUtf8TextError,
@@ -551,40 +571,47 @@ import {
   decodeBufferWithEncodingInfoAsync,
   getAllGeminiMdFilenames,
   isUtf8CompatibleEncoding,
-  isWithinRoot,
-  parseLineTolerant,
-  read
-} from "./chunk-RVOJ2FBP.js";
-import "./chunk-YRLW2MSX.js";
-import "./chunk-VGC4I5JJ.js";
-import "./chunk-CHHABXPE.js";
-import "./chunk-MA2HEDVP.js";
-import "./chunk-XUJNK7Y6.js";
-import "./chunk-6HY6IF3Z.js";
-import "./chunk-4PKCUT7F.js";
+  isWithinRoot
+} from "./chunk-IWOWEENB.js";
+import "./chunk-HIK2OF33.js";
+import "./chunk-ZRYQMWEP.js";
+import "./chunk-7JDGSJQH.js";
 import "./chunk-F6WFNA7U.js";
-import "./chunk-46UV252V.js";
+import "./chunk-WZAD4ZNJ.js";
 import "./chunk-FPGTNKCP.js";
-import "./chunk-CPHEPGAO.js";
-import "./chunk-P7MPQI75.js";
-import "./chunk-FDGGZIYW.js";
+import "./chunk-YHC2EYYG.js";
+import "./chunk-PZRUV52H.js";
+import "./chunk-JGUBDRBC.js";
+import "./chunk-HDKCKCYO.js";
+import "./chunk-HHJLM3WQ.js";
 import {
+  isTelemetrySdkInitialized,
   redactUrlCredentials,
   stripAnsiAndControl
-} from "./chunk-EL5SXY3T.js";
-import "./chunk-HHJLM3WQ.js";
-import "./chunk-K5IDV3PC.js";
+} from "./chunk-32CHFLGV.js";
+import "./chunk-74TONY4F.js";
+import "./chunk-XL5K4SVK.js";
+import {
+  SubagentError,
+  SubagentErrorCode
+} from "./chunk-WZDM44SB.js";
+import "./chunk-K623ENWT.js";
+import {
+  escapeXml
+} from "./chunk-AQ37AY7B.js";
+import "./chunk-K52PZNU4.js";
+import "./chunk-6NFAEG54.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger,
   getErrorMessage,
   runWithoutDebugLogSession
-} from "./chunk-BUQDLC2G.js";
-import "./chunk-VOQXFAY5.js";
+} from "./chunk-A5F2YNO6.js";
 import {
   writeStderrLine,
-  writeStderrLineSafe
+  writeStderrLineSafe,
+  writeStdoutLineSafe
 } from "./chunk-KGJGEEVR.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
@@ -596,7 +623,7 @@ import {
 } from "./chunk-TYAMGABM.js";
 import "./chunk-FCMNKVXT.js";
 import "./chunk-AMDSOFFV.js";
-import "./chunk-QUGAUQGJ.js";
+import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -607,12 +634,435 @@ import {
 
 // packages/cli/src/serve/server.ts
 init_esbuild_shims();
-var import_express6 = __toESM(require_express(), 1);
+var import_express7 = __toESM(require_express(), 1);
 import * as path18 from "node:path";
 
+// packages/cli/src/serve/local-control/index.ts
+init_esbuild_shims();
+
+// packages/cli/src/serve/local-control/lan-interfaces.ts
+init_esbuild_shims();
+import { networkInterfaces } from "node:os";
+function isLanIpv4(address) {
+  const octets = address.split(".").map((part) => Number(part));
+  if (octets.length !== 4 || octets.some((o) => !Number.isInteger(o))) {
+    return false;
+  }
+  const [a, b] = octets;
+  if (a === 10) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 169 && b === 254) return true;
+  return false;
+}
+__name(isLanIpv4, "isLanIpv4");
+function isSoftwareNetwork(interfaceName) {
+  if (/vpn/i.test(interfaceName)) return true;
+  return /(^|[\s_.-])(utun|tun|tap|ppp|ipsec|wg|wireguard|tailscale|zerotier|zt[a-z0-9]*|hamachi|nordlynx|proton|wintun|docker|veth[0-9a-f]+|vmnet|vboxnet|vethernet|virtualbox|host[- ]only|podman|cni|lxcbr|lxdbr|flannel|virbr|br-[0-9a-f]+|bridge\d|anyconnect|globalprotect|pulse[\s-]secure|forticlient|fortinet|ivanti|cisco[\s_-]secure|citrix|sonicwall|cloudflare)(\d|[\s_.-]|$)/i.test(
+    interfaceName
+  );
+}
+__name(isSoftwareNetwork, "isSoftwareNetwork");
+function listLanCandidates(interfaces = networkInterfaces()) {
+  const candidates = [];
+  for (const [interfaceName, addresses] of Object.entries(interfaces).sort()) {
+    if (isSoftwareNetwork(interfaceName)) continue;
+    for (const address of addresses ?? []) {
+      if (address.family !== "IPv4" || address.internal) continue;
+      if (!isLanIpv4(address.address)) continue;
+      candidates.push({ interfaceName, address: address.address });
+    }
+  }
+  return candidates;
+}
+__name(listLanCandidates, "listLanCandidates");
+var NoLanInterfaceError = class extends Error {
+  static {
+    __name(this, "NoLanInterfaceError");
+  }
+  code = "no_lan_interface";
+  constructor() {
+    super(
+      "No private IPv4 address is available. Local Control needs the host to be on a local network (Wi-Fi or Ethernet)."
+    );
+    this.name = "NoLanInterfaceError";
+  }
+};
+var AmbiguousLanInterfaceError = class extends Error {
+  static {
+    __name(this, "AmbiguousLanInterfaceError");
+  }
+  code = "ambiguous_lan_interface";
+  candidates;
+  constructor(candidates) {
+    super(
+      "Multiple local networks are available; choose which one to expose: " + candidates.map((c) => `${c.interfaceName} (${c.address})`).join(", ")
+    );
+    this.name = "AmbiguousLanInterfaceError";
+    this.candidates = candidates;
+  }
+};
+var UnknownLanInterfaceError = class extends Error {
+  static {
+    __name(this, "UnknownLanInterfaceError");
+  }
+  code = "unknown_lan_interface";
+  constructor(requested) {
+    super(
+      `${requested} is not a private IPv4 address on this host right now. The network may have changed since the list was fetched.`
+    );
+    this.name = "UnknownLanInterfaceError";
+  }
+};
+function selectLanAddress(preferredAddress, interfaces = networkInterfaces()) {
+  const candidates = listLanCandidates(interfaces);
+  if (candidates.length === 0) throw new NoLanInterfaceError();
+  if (preferredAddress !== void 0) {
+    const match = candidates.find((c) => c.address === preferredAddress);
+    if (!match) throw new UnknownLanInterfaceError(preferredAddress);
+    return match;
+  }
+  if (candidates.length > 1) throw new AmbiguousLanInterfaceError(candidates);
+  return candidates[0];
+}
+__name(selectLanAddress, "selectLanAddress");
+
+// packages/cli/src/serve/local-control/service.ts
+init_esbuild_shims();
+import { randomBytes, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { createServer as createSecureServer } from "node:https";
+var CORS_KEY = "local-control";
+var MAX_CONNECTIONS = 64;
+var HEADERS_TIMEOUT_MS = 1e4;
+var KEEP_ALIVE_TIMEOUT_MS = 5e3;
+var REQUEST_TIMEOUT_MS = 30 * 6e4;
+var InvalidLocalControlTargetError = class extends Error {
+  static {
+    __name(this, "InvalidLocalControlTargetError");
+  }
+  code = "invalid_local_control_target";
+  constructor() {
+    super("Local Control target must be a valid URL target.");
+    this.name = "InvalidLocalControlTargetError";
+  }
+};
+var LocalControlService = class {
+  static {
+    __name(this, "LocalControlService");
+  }
+  #deps;
+  #server;
+  #token;
+  #selected;
+  #sleep;
+  #url;
+  #transition = Promise.resolve();
+  constructor(deps) {
+    this.#deps = deps;
+  }
+  get active() {
+    return this.#server !== void 0;
+  }
+  status() {
+    if (!this.#server || !this.#token || !this.#selected) {
+      return { active: false };
+    }
+    return {
+      active: true,
+      url: this.#url,
+      interfaceName: this.#selected.interfaceName,
+      address: this.#selected.address,
+      port: this.#deps.getPort(),
+      sleepInhibited: this.#sleep !== void 0 && sleepInhibitor.isRunning(),
+      encrypted: this.#deps.tlsPaths !== void 0
+    };
+  }
+  /**
+   * Bring the LAN listener up. Enabling while already active is a no-op that
+   * returns the existing status rather than re-minting: a second scan of the
+   * same QR must keep working, and silently invalidating the token the user is
+   * mid-pairing with would be indistinguishable from a bug.
+   */
+  async enable(options = {}) {
+    return this.#serialize(() => this.#enable(options));
+  }
+  async #enable(options) {
+    if (this.active) return this.status();
+    const selected = selectLanAddress(options.address);
+    const port = this.#deps.getPort();
+    const authority = `${selected.address}:${port}`;
+    const token = mintPairingToken();
+    const tls = this.#deps.tlsPaths;
+    const scheme = tls ? "https" : "http";
+    const origin = new URL(`${scheme}://${authority}`).origin;
+    const url = buildPairedUrl(scheme, authority, token.secret, options.target);
+    const server = tls ? createSecureServer(
+      { cert: readFileSync(tls.cert), key: readFileSync(tls.key) },
+      this.#deps.app
+    ) : createServer(this.#deps.app);
+    server.maxConnections = MAX_CONNECTIONS;
+    server.headersTimeout = HEADERS_TIMEOUT_MS;
+    server.requestTimeout = REQUEST_TIMEOUT_MS;
+    server.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;
+    tagListener(server, { kind: "local-control", authority, origin });
+    this.#deps.credentials.addPairingToken(token.id, token.secret);
+    this.#deps.originAllowlist.add(CORS_KEY, origin);
+    try {
+      this.#deps.attachWebSocket(server);
+      await listen(server, port, selected.address);
+    } catch (error2) {
+      this.#deps.detachWebSocket(server);
+      this.#deps.credentials.revokePairingToken(token.id);
+      this.#deps.originAllowlist.remove(CORS_KEY);
+      throw error2;
+    }
+    server.on("error", (error2) => {
+      writeStderrLine(
+        `qwen serve: Local Control listener error: ${error2.message}`
+      );
+    });
+    this.#server = server;
+    this.#token = token;
+    this.#selected = selected;
+    this.#url = url;
+    this.#sleep = sleepInhibitor.acquire("Qwen Code Local Control is active");
+    return this.status();
+  }
+  /**
+   * Take the LAN listener down and invalidate its credential.
+   *
+   * Revocation happens first and unconditionally. If closing the socket fails
+   * or hangs, the outcome is a listener that accepts connections no credential
+   * can authenticate — inert. The reverse order would leave a live, reachable
+   * listener with a valid token if teardown failed partway.
+   */
+  async disable() {
+    return this.#serialize(() => this.#disable());
+  }
+  async #disable() {
+    const server = this.#server;
+    const token = this.#token;
+    this.#server = void 0;
+    this.#token = void 0;
+    this.#selected = void 0;
+    this.#url = void 0;
+    if (token) this.#deps.credentials.revokePairingToken(token.id);
+    this.#deps.originAllowlist.remove(CORS_KEY);
+    this.#sleep?.release();
+    this.#sleep = void 0;
+    if (server) {
+      this.#deps.detachWebSocket(server);
+      await close(server);
+    }
+    return { active: false };
+  }
+  /**
+   * Called from the daemon's drain path. Local Control must not outlive the
+   * daemon that owns it: a listener surviving drain would hold the port and
+   * keep answering with a token nothing can revoke anymore.
+   */
+  async dispose() {
+    await this.disable();
+  }
+  async #serialize(operation) {
+    const previous = this.#transition;
+    let release;
+    this.#transition = new Promise((resolve7) => {
+      release = resolve7;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+};
+function mintPairingToken() {
+  const secret = randomBytes(32).toString("base64url");
+  return { id: randomUUID(), secret };
+}
+__name(mintPairingToken, "mintPairingToken");
+function buildPairedUrl(scheme, authority, secret, target) {
+  const url = new URL(`${scheme}://${authority}`);
+  if (target) {
+    let resolved;
+    try {
+      resolved = new URL(target, url);
+    } catch {
+      throw new InvalidLocalControlTargetError();
+    }
+    url.pathname = resolved.pathname;
+    url.search = resolved.search;
+  }
+  url.hash = `token=${encodeURIComponent(secret)}`;
+  return url.toString();
+}
+__name(buildPairedUrl, "buildPairedUrl");
+function listen(server, port, host) {
+  return new Promise((resolve7, reject) => {
+    const onError = /* @__PURE__ */ __name((error2) => {
+      server.removeListener("listening", onListening);
+      reject(error2);
+    }, "onError");
+    const onListening = /* @__PURE__ */ __name(() => {
+      server.removeListener("error", onError);
+      resolve7();
+    }, "onListening");
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+}
+__name(listen, "listen");
+function close(server) {
+  return new Promise((resolve7) => {
+    server.closeAllConnections?.();
+    server.close(() => resolve7());
+  });
+}
+__name(close, "close");
+
+// packages/cli/src/serve/routes/workspace-local-control.ts
+init_esbuild_shims();
+async function withUiData(status) {
+  let qrText;
+  if (status.url) {
+    try {
+      const { default: qrcode } = await import("./main-PXAUXNF2.js");
+      qrcode.setErrorLevel("Q");
+      qrcode.generate(status.url, { small: true }, (code) => {
+        qrText = code.trimEnd();
+      });
+    } catch {
+      qrText = void 0;
+    }
+  }
+  return { ...status, qrText, interfaces: listLanCandidates() };
+}
+__name(withUiData, "withUiData");
+function presentStatus(req, ui) {
+  if (requestWasAuthenticated(req)) return ui;
+  const { url: _url, qrText: _qrText, ...rest } = ui;
+  return { ...rest, urlRedacted: ui.url !== void 0 };
+}
+__name(presentStatus, "presentStatus");
+function requirePrimaryListener(req, res) {
+  if (listenerIdentityOf(req).kind === "primary") return true;
+  res.status(403).json({
+    error: "Local Control can only be enabled from the machine running the daemon.",
+    code: "local_control_remote_enable_denied"
+  });
+  return false;
+}
+__name(requirePrimaryListener, "requirePrimaryListener");
+function registerWorkspaceLocalControlRoutes(app, deps) {
+  app.get("/workspace/local-control", async (req, res) => {
+    res.status(200).json(presentStatus(req, await withUiData(deps.service.status())));
+  });
+  app.post(
+    "/workspace/local-control/enable",
+    deps.mutate(),
+    async (req, res) => {
+      if (!requirePrimaryListener(req, res)) return;
+      if (deps.webShellAvailable === false) {
+        res.status(409).json({
+          error: "Local Control requires the Web Shell.",
+          code: "local_control_web_shell_unavailable"
+        });
+        return;
+      }
+      if (deps.primaryBindHostname !== void 0 && !isLoopbackBind(deps.primaryBindHostname)) {
+        res.status(409).json({
+          error: "Local Control requires the daemon to be bound to loopback; restart it with --hostname 127.0.0.1.",
+          code: "local_control_non_loopback_bind"
+        });
+        return;
+      }
+      if (deps.isDaemonDraining?.()) {
+        res.status(503).json({
+          error: "Daemon is shutting down.",
+          code: "daemon_draining"
+        });
+        return;
+      }
+      const body = deps.safeBody(req) ?? {};
+      try {
+        const ui = await withUiData(
+          await deps.service.enable({
+            address: typeof body.address === "string" ? body.address : void 0,
+            target: typeof body.target === "string" ? body.target : void 0
+          })
+        );
+        if (!requestWasAuthenticated(req) && ui.url) {
+          writeStdoutLineSafe(
+            `qwen serve: Local Control pairing URL: ${ui.url}`
+          );
+        }
+        res.status(200).json(presentStatus(req, ui));
+      } catch (error2) {
+        sendEnableError(res, error2);
+      }
+    }
+  );
+  app.post(
+    "/workspace/local-control/disable",
+    deps.mutate(),
+    async (req, res) => {
+      if (listenerIdentityOf(req).kind === "local-control") {
+        queueMicrotask(() => {
+          void deps.service.disable().catch((error2) => {
+            writeStderrLine(
+              `qwen serve: Local Control disable failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+            );
+          });
+        });
+        res.status(200).json({ active: false });
+        return;
+      }
+      res.status(200).json(
+        presentStatus(req, await withUiData(await deps.service.disable()))
+      );
+    }
+  );
+}
+__name(registerWorkspaceLocalControlRoutes, "registerWorkspaceLocalControlRoutes");
+function sendEnableError(res, error2) {
+  if (error2 instanceof AmbiguousLanInterfaceError) {
+    res.status(409).json({
+      error: error2.message,
+      code: error2.code,
+      interfaces: error2.candidates
+    });
+    return;
+  }
+  if (error2 instanceof NoLanInterfaceError) {
+    res.status(409).json({ error: error2.message, code: error2.code });
+    return;
+  }
+  if (error2 instanceof UnknownLanInterfaceError) {
+    res.status(409).json({
+      error: error2.message,
+      code: error2.code,
+      interfaces: listLanCandidates()
+    });
+    return;
+  }
+  if (error2 instanceof InvalidLocalControlTargetError) {
+    res.status(400).json({ error: error2.message, code: error2.code });
+    return;
+  }
+  res.status(500).json({
+    error: error2 instanceof Error ? error2.message : String(error2),
+    code: "local_control_enable_failed"
+  });
+}
+__name(sendEnableError, "sendEnableError");
+
 // packages/cli/src/serve/acp-http/index.ts
 init_esbuild_shims();
-import { createHash as createHash3, timingSafeEqual } from "node:crypto";
 
 // packages/cli/src/serve/acp-http/dispatch.ts
 init_esbuild_shims();
@@ -1131,6 +1581,7 @@ function createAuditPublisher(deps) {
       if (record.sizeBytes !== void 0) payload.sizeBytes = record.sizeBytes;
       if (record.truncated) payload.truncated = true;
       if (record.matchedIgnore) payload.matchedIgnore = record.matchedIgnore;
+      if (record.operation !== void 0) payload.operation = record.operation;
       if (record.pattern !== void 0 && includeRawPaths) {
         payload.pattern = record.pattern;
       }
@@ -1177,7 +1628,7 @@ __name(createAuditPublisher, "createAuditPublisher");
 
 // packages/cli/src/serve/fs/workspace-file-system.ts
 init_esbuild_shims();
-import { createHash as createHash2, randomBytes } from "node:crypto";
+import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
 import { constants as fsConstants, promises as fsp2 } from "node:fs";
 import * as path4 from "node:path";
 
@@ -1238,6 +1689,11 @@ function assertCursorMatchesFile(cursor, stats, path19) {
 __name(assertCursorMatchesFile, "assertCursorMatchesFile");
 
 // packages/cli/src/serve/fs/workspace-file-system.ts
+var OWNER_ONLY_NEW_FILE_MODE = 384;
+function resolveNewFileModeBits(policy, umask) {
+  return policy === "system" ? 438 & ~(umask ?? process.umask()) : OWNER_ONLY_NEW_FILE_MODE;
+}
+__name(resolveNewFileModeBits, "resolveNewFileModeBits");
 function createWorkspaceFileSystemFactory(deps) {
   const boundWorkspaces = canonicalizeWorkspaces(deps.boundWorkspaces);
   if (boundWorkspaces.length === 0) {
@@ -1263,6 +1719,7 @@ function createWorkspaceFileSystemFactory(deps) {
   });
   const lowFs = new StandardFileSystemService();
   const pathLocks = deps.pathLocks ?? new PathMutexRegistry();
+  const newFileMode = deps.newFileMode ?? "owner";
   const forRequest = /* @__PURE__ */ __name((ctx) => new WorkspaceFileSystemImpl({
     primaryWorkspace,
     workspaces,
@@ -1271,7 +1728,8 @@ function createWorkspaceFileSystemFactory(deps) {
     ctx,
     lowFs,
     pathLocks,
-    generationGuard: deps.generationGuard
+    generationGuard: deps.generationGuard,
+    newFileMode
   }), "forRequest");
   return {
     assertCanWrite() {
@@ -1304,7 +1762,8 @@ function createWorkspaceFileSystemFactory(deps) {
             audit,
             ctx,
             pathLocks,
-            generationGuard: deps.generationGuard
+            generationGuard: deps.generationGuard,
+            newFileMode
           });
           return;
         } catch (outsideErr) {
@@ -1343,6 +1802,7 @@ async function writeSameHostToolTextOutsideWorkspace(deps) {
       content,
       mode: "overwrite",
       meta,
+      newFileModeBits: resolveNewFileModeBits(deps.newFileMode),
       assertGenerationOpen: /* @__PURE__ */ __name(() => deps.generationGuard?.assertOpen(), "assertGenerationOpen")
     });
     deps.audit.recordAccess(deps.ctx, {
@@ -1862,6 +2322,7 @@ var WorkspaceFileSystemImpl = class {
             mode: opts.mode,
             expectedHash: opts.expectedHash,
             meta,
+            newFileModeBits: resolveNewFileModeBits(this.deps.newFileMode),
             assertGenerationOpen: /* @__PURE__ */ __name(() => this.deps.generationGuard?.assertOpen(), "assertGenerationOpen")
           });
           const verdict = this.ignoreVerdict(p, "file");
@@ -1924,6 +2385,7 @@ var WorkspaceFileSystemImpl = class {
             content,
             mode: "overwrite",
             meta,
+            newFileModeBits: resolveNewFileModeBits(this.deps.newFileMode),
             assertGenerationOpen: /* @__PURE__ */ __name(() => this.deps.generationGuard?.assertOpen(), "assertGenerationOpen")
           });
           const verdict = this.ignoreVerdict(p, "file");
@@ -2035,6 +2497,7 @@ var WorkspaceFileSystemImpl = class {
             mode: "replace",
             expectedHash: opts.expectedHash,
             meta,
+            newFileModeBits: resolveNewFileModeBits(this.deps.newFileMode),
             assertGenerationOpen: /* @__PURE__ */ __name(() => this.deps.generationGuard?.assertOpen(), "assertGenerationOpen")
           });
           const verdict = this.ignoreVerdict(p, "file");
@@ -2098,6 +2561,7 @@ var WorkspaceFileSystemImpl = class {
           content: next,
           mode: "overwrite",
           meta: mergeWriteMeta(snapshot.meta, {}),
+          newFileModeBits: resolveNewFileModeBits(this.deps.newFileMode),
           assertGenerationOpen: /* @__PURE__ */ __name(() => this.deps.generationGuard?.assertOpen(), "assertGenerationOpen")
         });
         const verdict = this.ignoreVerdict(p, "file");
@@ -2149,6 +2613,36 @@ var WorkspaceFileSystemImpl = class {
       });
     }
   }
+  async mkdir(p, opts) {
+    const start = performance.now();
+    try {
+      this.deps.generationGuard?.assertOpen();
+      assertTrustedForIntent(this.deps.trusted, "write");
+      const out = await this.deps.pathLocks.runExclusive(
+        p,
+        async () => {
+          await ensureResolvedDirectory(p, {
+            recursive: opts?.recursive ?? false,
+            assertGenerationOpen: /* @__PURE__ */ __name(() => this.deps.generationGuard?.assertOpen(), "assertGenerationOpen")
+          });
+          this.deps.generationGuard?.assertOpen();
+          const verdict = this.ignoreVerdict(p, "directory");
+          this.deps.audit.recordAccess(this.deps.ctx, {
+            intent: "write",
+            absolute: p,
+            durationMs: performance.now() - start,
+            sizeBytes: 0,
+            operation: "mkdir",
+            matchedIgnore: verdict.ignored ? verdict.category : void 0
+          });
+          return void 0;
+        }
+      );
+      return out;
+    } catch (err) {
+      throw this.recordAndWrap(err, "write", p);
+    }
+  }
   /**
    * Coerce an arbitrary thrown value into an `FsError`, emit the
    * matching `fs.denied` audit event, and return the typed error
@@ -2632,10 +3126,82 @@ async function atomicWriteTextResolvedFile(input) {
     buf,
     mode: input.mode,
     expectedHash: input.expectedHash,
+    newFileModeBits: input.newFileModeBits,
     assertGenerationOpen: input.assertGenerationOpen
   });
 }
 __name(atomicWriteTextResolvedFile, "atomicWriteTextResolvedFile");
+async function ensureResolvedDirectory(target, opts) {
+  const assertRealDirectory = /* @__PURE__ */ __name(async (p) => {
+    const st = await fsp2.lstat(p);
+    if (st.isSymbolicLink()) {
+      throw new FsError("symlink_escape", `directory path is a symlink: ${p}`, {
+        hint: "re-resolve the target after detecting symlink swaps"
+      });
+    }
+    if (!st.isDirectory()) {
+      throw new FsError(
+        "parse_error",
+        `path exists and is not a directory: ${p}`
+      );
+    }
+  }, "assertRealDirectory");
+  const assertParentNotSymlink = /* @__PURE__ */ __name(async (p) => {
+    const parent = path4.dirname(p);
+    const st = await fsp2.lstat(parent);
+    if (st.isSymbolicLink()) {
+      throw new FsError(
+        "symlink_escape",
+        `directory parent is a symlink: ${parent}`,
+        { hint: "re-resolve the target after detecting symlink swaps" }
+      );
+    }
+  }, "assertParentNotSymlink");
+  try {
+    await assertRealDirectory(target);
+    return;
+  } catch (err) {
+    if (isFsError(err)) throw err;
+    if (err.code !== "ENOENT") throw err;
+  }
+  if (!opts.recursive) {
+    opts.assertGenerationOpen();
+    await assertParentNotSymlink(target);
+    try {
+      await fsp2.mkdir(target, { mode: 493 });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    await assertRealDirectory(target);
+    return;
+  }
+  const missing = [];
+  let current = target;
+  while (true) {
+    try {
+      await assertRealDirectory(current);
+      break;
+    } catch (err) {
+      if (isFsError(err)) throw err;
+      if (err.code !== "ENOENT") throw err;
+      missing.push(current);
+      const parent = path4.dirname(current);
+      if (parent === current) throw err;
+      current = parent;
+    }
+  }
+  for (const entry of missing.reverse()) {
+    opts.assertGenerationOpen();
+    await assertParentNotSymlink(entry);
+    try {
+      await fsp2.mkdir(entry, { mode: 493 });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    await assertRealDirectory(entry);
+  }
+}
+__name(ensureResolvedDirectory, "ensureResolvedDirectory");
 async function atomicPublishResolvedFile(input) {
   const target = input.target;
   const parent = path4.dirname(target);
@@ -2651,7 +3217,7 @@ async function atomicPublishResolvedFile(input) {
       `parent path is not a directory: ${parent}`
     );
   }
-  const tmpSuffix = `.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  const tmpSuffix = `.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
   const tmpNameMaxBytes = 255;
   const tmpBaseMaxBytes = tmpNameMaxBytes - 1 - Buffer.byteLength(tmpSuffix, "utf-8");
   let tmpBase = path4.basename(target);
@@ -2679,7 +3245,10 @@ async function atomicPublishResolvedFile(input) {
       mode: input.mode,
       expectedHash: input.expectedHash
     });
-    await chmodHandleBestEffort(tempHandle, targetState.mode ?? 384);
+    await chmodHandleBestEffort(
+      tempHandle,
+      targetState.mode ?? input.newFileModeBits ?? OWNER_ONLY_NEW_FILE_MODE
+    );
     await assertTempPathMatchesStat(tmpPath, tempStat);
     await tempHandle.close();
     tempHandle = void 0;
@@ -4658,7 +5227,7 @@ __name(registerWorkspaceQualifiedVoiceRoutes, "registerWorkspaceQualifiedVoiceRo
 
 // packages/cli/src/serve/workspace-remember.ts
 init_esbuild_shims();
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 var debugLogger = createDebugLogger("WORKSPACE_REMEMBER");
 function requireTrustedWorkspace(deps, res) {
   if (deps.isWorkspaceTrusted?.() !== false) return true;
@@ -4688,7 +5257,7 @@ function nowIso() {
 }
 __name(nowIso, "nowIso");
 function createMemoryTaskId(kind) {
-  return `${kind}-${randomUUID()}`;
+  return `${kind}-${randomUUID2()}`;
 }
 __name(createMemoryTaskId, "createMemoryTaskId");
 function touchedScopesFromTopics(topics) {
@@ -5446,11 +6015,13 @@ var RequestedSessionIdAdmissionError = class extends Error {
   name = "RequestedSessionIdAdmissionError";
 };
 async function persistedSessionExists(sessionService, sessionId) {
-  if (await sessionService.getSessionLocation(sessionId) !== void 0) {
-    return true;
-  }
-  if (await sessionService.findSessionIdIgnoringCase?.(sessionId) !== void 0) {
-    return true;
+  try {
+    if (await sessionService.findSessionIdIgnoringCase(sessionId) !== void 0) {
+      return true;
+    }
+  } catch (error2) {
+    if (error2 instanceof SessionIdCaseConflictError) return true;
+    throw error2;
   }
   for (const state of ["active", "archived"]) {
     try {
@@ -7759,8 +8330,13 @@ var SessionArchiveCoordinator = class {
   maintenanceSealed = false;
   activeMaintenance = 0;
   maintenanceDrain;
+  // Lock keys are canonicalized like every other session-id lookup: batch
+  // delete/archive/unarchive lock raw caller spellings while restore locks
+  // the request spelling, and on a case-insensitive filesystem both reach
+  // the same transcript file — uncanonicalized keys would let a differently
+  // cased caller id slip past a held guard and unlink it mid-restore.
   assertNotTransitioning(sessionId) {
-    if (this.exclusive.has(sessionId)) {
+    if (this.exclusive.has(normalizeSessionIdForLookup(sessionId))) {
       throw new SessionArchivingError(sessionId);
     }
   }
@@ -7768,7 +8344,9 @@ var SessionArchiveCoordinator = class {
     if (this.maintenanceSealed) {
       throw new DaemonDrainingError();
     }
-    const uniqueSessionIds = [...new Set(sessionIds)];
+    const uniqueSessionIds = [
+      ...new Set(sessionIds.map(normalizeSessionIdForLookup))
+    ];
     for (const sessionId of uniqueSessionIds) {
       this.assertNotTransitioning(sessionId);
       if ((this.shared.get(sessionId) ?? 0) > 0) {
@@ -7810,7 +8388,9 @@ var SessionArchiveCoordinator = class {
     if (this.maintenanceSealed) {
       throw new DaemonDrainingError();
     }
-    const uniqueSessionIds = [...new Set(sessionIds)];
+    const uniqueSessionIds = [
+      ...new Set(sessionIds.map(normalizeSessionIdForLookup))
+    ];
     for (const sessionId of uniqueSessionIds) {
       this.assertNotTransitioning(sessionId);
     }
@@ -8004,7 +8584,9 @@ async function deleteDaemonSessions(params) {
     coordinatorLockHeld = false,
     onError
   } = params;
-  const uniqueSessionIds = [...new Set(sessionIds)];
+  const uniqueSessionIds = [
+    ...new Set(sessionIds.map(normalizeSessionIdForLookup))
+  ];
   if (!coordinatorLockHeld) {
     for (const sessionId of uniqueSessionIds) {
       coordinator.assertNotTransitioning(sessionId);
@@ -8014,22 +8596,40 @@ async function deleteDaemonSessions(params) {
     uniqueSessionIds.map(async (sessionId) => {
       try {
         const mutateSession = /* @__PURE__ */ __name(async () => {
+          const removePersistedSession = /* @__PURE__ */ __name(async () => {
+            const result = await deletePersistedSessionWithLease(
+              service,
+              sessionId
+            );
+            if (result.kind === "error") {
+              onError?.({
+                phase: "remove",
+                sessionId,
+                error: errorMessage(result.error)
+              });
+              return result;
+            }
+            try {
+              await bridge.deleteSessionAttachments(sessionId);
+              return result;
+            } catch (error2) {
+              onError?.({
+                phase: "delete",
+                sessionId,
+                error: errorMessage(error2)
+              });
+              return {
+                kind: "error",
+                error: error2,
+                mutationApplied: result.mutationApplied
+              };
+            }
+          }, "removePersistedSession");
           try {
             await bridge.closeSession(sessionId);
           } catch (error2) {
             if (isSessionNotFoundError(error2)) {
-              const result2 = await deletePersistedSessionWithLease(
-                service,
-                sessionId
-              );
-              if (result2.kind === "error") {
-                onError?.({
-                  phase: "remove",
-                  sessionId,
-                  error: errorMessage(result2.error)
-                });
-              }
-              return result2;
+              return await removePersistedSession();
             }
             onError?.({
               phase: "close",
@@ -8042,18 +8642,7 @@ async function deleteDaemonSessions(params) {
               mutationApplied: false
             };
           }
-          const result = await deletePersistedSessionWithLease(
-            service,
-            sessionId
-          );
-          if (result.kind === "error") {
-            onError?.({
-              phase: "remove",
-              sessionId,
-              error: errorMessage(result.error)
-            });
-          }
-          return result;
+          return await removePersistedSession();
         }, "mutateSession");
         return await (coordinatorLockHeld ? mutateSession() : coordinator.runExclusiveMany([sessionId], mutateSession));
       } catch (error2) {
@@ -8114,6 +8703,7 @@ async function deleteDaemonSessionIfOrphan(params) {
   if (result.kind === "error") {
     throw result.error;
   }
+  bridge.markSessionCatalogChanged();
   return true;
 }
 __name(deleteDaemonSessionIfOrphan, "deleteDaemonSessionIfOrphan");
@@ -8193,7 +8783,9 @@ async function archiveDaemonSessions(params) {
     coordinator,
     coordinatorLockHeld = false
   } = params;
-  const uniqueSessionIds = [...new Set(sessionIds)];
+  const uniqueSessionIds = [
+    ...new Set(sessionIds.map(normalizeSessionIdForLookup))
+  ];
   if (!coordinatorLockHeld) {
     for (const sessionId of uniqueSessionIds) {
       coordinator.assertNotTransitioning(sessionId);
@@ -8335,7 +8927,9 @@ async function unarchiveDaemonSessions(params) {
     coordinator,
     coordinatorLockHeld = false
   } = params;
-  const uniqueSessionIds = [...new Set(sessionIds)];
+  const uniqueSessionIds = [
+    ...new Set(sessionIds.map(normalizeSessionIdForLookup))
+  ];
   if (!coordinatorLockHeld) {
     for (const sessionId of uniqueSessionIds) {
       coordinator.assertNotTransitioning(sessionId);
@@ -9123,6 +9717,15 @@ function toRpcError(err) {
           sessionId: err.sessionId
         }
       };
+    case "SessionIdCaseConflictError":
+      return {
+        code: RPC.INTERNAL_ERROR,
+        message: errMsg(err),
+        data: {
+          errorKind: "session_conflict",
+          sessionId: err.sessionId
+        }
+      };
     case "SessionArchivingError":
       return {
         code: RPC.INTERNAL_ERROR,
@@ -9231,11 +9834,20 @@ var AcpDispatcher = class {
       archiveStates
     });
   }
+  // Combined invalidate-and-mark for catalog mutations whose conservative
+  // finally-semantics match (delete/archive/unarchive). The revision advance
+  // always follows the cache invalidation so a newly exposed version never
+  // precedes it. Exact no-op paths (e.g. metadata rename) gate the mark on
+  // an actual change via the bridge instead of using this helper.
+  invalidateSessionListsAndMarkCatalog(archiveStates) {
+    this.invalidateSessionLists(archiveStates);
+    this.bridge.markSessionCatalogChanged();
+  }
   async runWithSessionListInvalidation(archiveStates, mutation) {
     try {
       return await mutation();
     } finally {
-      this.invalidateSessionLists(archiveStates);
+      this.invalidateSessionListsAndMarkCatalog(archiveStates);
     }
   }
   removeOrphanSession(sessionId, removePersistedSession = false, runtime = this.getSessionRuntimeContext()) {
@@ -9710,6 +10322,19 @@ var AcpDispatcher = class {
             return;
           }
           const sessionRuntime = this.getSessionRuntimeContext();
+          if (isReservedStandaloneSessionSource({
+            sourceType: typeof params["sourceType"] === "string" ? params["sourceType"] : void 0
+          })) {
+            conn.sendConn(
+              error(
+                id,
+                RPC.INVALID_PARAMS,
+                "The requested session source is reserved for daemon-owned standalone sessions.",
+                { errorKind: "reserved_session_source" }
+              )
+            );
+            return;
+          }
           const source = parseSessionSource(
             params["sourceType"],
             params["sourceId"]
@@ -9843,23 +10468,54 @@ var AcpDispatcher = class {
             }
           );
           try {
+            const guardSessionService = new SessionService(cwd, {
+              runtimeBaseDir: sessionRuntime.sessionRuntimeBaseDir
+            });
+            let persistedGuardId;
+            try {
+              persistedGuardId = await guardSessionService.findSessionIdIgnoringCase(sessionId);
+            } catch (error2) {
+              if (error2 instanceof SessionIdCaseConflictError && await guardSessionService.getSessionLocation(
+                error2.candidateSessionId ?? sessionId
+              ) === "conflict") {
+                throw new SessionConflictError(sessionId);
+              }
+              throw error2;
+            }
             const restored = await this.archiveCoordinator.runSharedMany(
               [sessionId],
               async () => {
                 assertGenerationOpen?.();
+                const sessionService = new SessionService(cwd, {
+                  runtimeBaseDir: sessionRuntime.sessionRuntimeBaseDir
+                });
+                let storageSessionId = persistedGuardId ?? sessionId;
+                let persistedSessionId;
+                try {
+                  persistedSessionId = await sessionService.findSessionIdIgnoringCase(sessionId);
+                } catch (error2) {
+                  if (error2 instanceof SessionIdCaseConflictError && await sessionService.getSessionLocation(
+                    error2.candidateSessionId ?? sessionId
+                  ) === "conflict") {
+                    throw new SessionConflictError(sessionId);
+                  }
+                  throw error2;
+                }
+                if (persistedSessionId) {
+                  storageSessionId = persistedSessionId;
+                } else if (this.liveSessionIsolation) {
+                  throw new SessionNotFoundError(sessionId);
+                }
                 await assertSessionLoadable(
                   cwd,
-                  sessionId,
+                  storageSessionId,
                   sessionRuntime.sessionRuntimeBaseDir
                 );
-                const sessionService = new SessionService(cwd, {
-                  runtimeBaseDir: sessionRuntime.sessionRuntimeBaseDir
-                });
                 const metadata = this.liveSessionIsolation ? await readLoadableLiveConversationMetadata(
-                  sessionId,
-                  (candidateId) => sessionService.readCreationMetadata(candidateId)
-                ) : await sessionService.readCreationMetadata(sessionId);
-                if (metadata === void 0) {
+                  storageSessionId,
+                  sessionService
+                ) : await sessionService.readCreationMetadata(storageSessionId);
+                if (metadata === void 0 || this.liveSessionIsolation !== void 0 && isReservedStandaloneSessionSource(metadata)) {
                   throw new SessionNotFoundError(sessionId);
                 }
                 const liveConversationCwd = this.liveSessionIsolation ? await this.liveSessionIsolation.materializeConversationDirectory(
@@ -10718,6 +11374,7 @@ var AcpDispatcher = class {
               ..."groupId" in params ? { groupId: params["groupId"] } : {},
               ..."color" in params ? { color: params["color"] } : {}
             });
+            this.invalidateSessionListsAndMarkCatalog(["active", "archived"]);
             this.replyConn(conn, id, { sessionId, ...organization });
           });
           return;
@@ -10736,6 +11393,7 @@ var AcpDispatcher = class {
             name: params["name"],
             color: params["color"]
           });
+          this.invalidateSessionListsAndMarkCatalog(["active", "archived"]);
           assertGenerationOpen?.();
           this.replyConn(conn, id, { group });
           return;
@@ -10753,6 +11411,7 @@ var AcpDispatcher = class {
             ..."color" in params ? { color: params["color"] } : {},
             ..."order" in params ? { order: params["order"] } : {}
           });
+          this.invalidateSessionListsAndMarkCatalog(["active", "archived"]);
           assertGenerationOpen?.();
           this.replyConn(conn, id, { group });
           return;
@@ -10766,6 +11425,9 @@ var AcpDispatcher = class {
           const deleted = await createSessionOrganizationService(workspaceCwd).deleteGroup(
             groupId
           );
+          if (deleted) {
+            this.invalidateSessionListsAndMarkCatalog(["active", "archived"]);
+          }
           assertGenerationOpen?.();
           this.replyConn(conn, id, { deleted });
           return;
@@ -12869,7 +13531,7 @@ var AcpDispatcher = class {
 
 // packages/cli/src/serve/acp-http/connection-registry.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 var DEFAULT_MAX_CONNECTIONS = 64;
 var AcpConnection = class {
   constructor(connectionId, fromLoopback, onAbandonPending, onDetachSession, preAttachBudget = new AcpPreAttachBudget(), onFatalConnection, maxFramesPerConnection = ACP_PRE_ATTACH_MAX_FRAMES_PER_CONNECTION, maxPayloadBytesPerConnection = ACP_PRE_ATTACH_MAX_PAYLOAD_BYTES_PER_CONNECTION, onPreAttachGuardFailure) {
@@ -12880,8 +13542,8 @@ var AcpConnection = class {
     this.maxFramesPerConnection = maxFramesPerConnection;
     this.maxPayloadBytesPerConnection = maxPayloadBytesPerConnection;
     this.onPreAttachGuardFailure = onPreAttachGuardFailure;
-    this.connectionId = connectionId ?? randomUUID2();
-    this.clientId = randomUUID2();
+    this.connectionId = connectionId ?? randomUUID3();
+    this.clientId = randomUUID3();
     this.fromLoopback = fromLoopback;
   }
   static {
@@ -15985,9 +16647,15 @@ function mountAcpHttp(app, bridge, opts) {
   }
   let wss;
   let upgradeListener;
-  let upgradeServer;
+  const upgradeServers = /* @__PURE__ */ new Set();
+  const upgradeCredentials = opts.credentials ?? singleTokenCredentials(opts.token);
   function setupWebSocket(httpServer) {
-    if (disposed || wss) return;
+    if (disposed || upgradeServers.has(httpServer)) return;
+    if (wss) {
+      upgradeServers.add(httpServer);
+      httpServer.on("upgrade", upgradeListener);
+      return;
+    }
     wss = new import_websocket_server.default({
       noServer: true,
       maxPayload: 10 * 1024 * 1024,
@@ -16007,8 +16675,7 @@ function mountAcpHttp(app, bridge, opts) {
         return false;
       }, "handleProtocols")
     });
-    upgradeServer = httpServer;
-    const expectedTokenHash = opts.token ? createHash3("sha256").update(opts.token).digest() : void 0;
+    upgradeServers.add(httpServer);
     upgradeListener = /* @__PURE__ */ __name((req, socket, head) => {
       if (disposed) {
         socket.destroy();
@@ -16036,8 +16703,18 @@ function mountAcpHttp(app, bridge, opts) {
         return;
       }
       const fromLoopback = isLoopbackSocket(socket);
-      if (fromLoopback) {
-        const host = (req.headers["host"] ?? "").toLowerCase();
+      const upgradeListenerIdentity = listenerIdentityOfSocket(socket);
+      const host = (req.headers["host"] ?? "").toLowerCase();
+      if (upgradeListenerIdentity.kind === "local-control") {
+        const authority = upgradeListenerIdentity.authority;
+        const browserHost = upgradeListenerIdentity.origin === void 0 ? void 0 : new URL(upgradeListenerIdentity.origin).host.toLowerCase();
+        if (authority === void 0 || host !== authority && host !== browserHost) {
+          logReject(`host-not-allowed ${host || "(missing)"}`);
+          socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+      } else if (fromLoopback) {
         const allowed = /* @__PURE__ */ new Set([
           `localhost:${localPort}`,
           `127.0.0.1:${localPort}`,
@@ -16062,7 +16739,8 @@ function mountAcpHttp(app, bridge, opts) {
         try {
           const isLoopbackOrigin = isSameLoopbackOrigin(origin, localPort);
           const isAllowlistedOrigin = opts.allowedOrigins !== void 0 && opts.allowedOrigins.origins.has(origin.toLowerCase());
-          if (!isLoopbackOrigin && !isAllowlistedOrigin) {
+          const isListenerOrigin = upgradeListenerIdentity.kind === "local-control" && upgradeListenerIdentity.origin === origin.toLowerCase();
+          if (!isLoopbackOrigin && !isAllowlistedOrigin && !isListenerOrigin) {
             logReject(`origin-not-allowed ${origin}`);
             socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
             socket.destroy();
@@ -16075,10 +16753,9 @@ function mountAcpHttp(app, bridge, opts) {
           return;
         }
       }
-      if (opts.token) {
-        const credentials = extractUpgradeBearer(req);
-        const actual = credentials ? createHash3("sha256").update(credentials).digest() : void 0;
-        if (!actual || !expectedTokenHash || actual.length !== expectedTokenHash.length || !timingSafeEqual(expectedTokenHash, actual)) {
+      if (!upgradeCredentials.isOpen(upgradeListenerIdentity)) {
+        const presented = extractUpgradeBearer(req);
+        if (!presented || !upgradeCredentials.verify(presented, upgradeListenerIdentity)) {
           logReject("auth-mismatch");
           socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
           socket.destroy();
@@ -16587,10 +17264,12 @@ function mountAcpHttp(app, bridge, opts) {
     dispose: /* @__PURE__ */ __name(() => {
       if (disposed) return;
       disposed = true;
-      if (upgradeServer && upgradeListener) {
-        upgradeServer.removeListener("upgrade", upgradeListener);
+      if (upgradeListener) {
+        for (const server of upgradeServers) {
+          server.removeListener("upgrade", upgradeListener);
+        }
+        upgradeServers.clear();
         upgradeListener = void 0;
-        upgradeServer = void 0;
       }
       registry.dispose();
       opts.workspaceRememberLane.dispose();
@@ -16730,6 +17409,17 @@ function mountAcpHttp(app, bridge, opts) {
     }, "getSnapshot"),
     attachServer(server) {
       setupWebSocket(server);
+    },
+    detachServer(server) {
+      if (!upgradeServers.delete(server)) return;
+      if (upgradeListener) server.removeListener("upgrade", upgradeListener);
+      if (!wss) return;
+      for (const client of wss.clients) {
+        const clientSocket = client._socket;
+        if (clientSocket?.server === server) {
+          client.terminate();
+        }
+      }
     }
   };
 }
@@ -18752,7 +19442,7 @@ function createExtensionsController(deps) {
         version: ext.version,
         isActive: ext.isActive,
         path: ext.path,
-        ...ext.installMetadata?.source ? {
+        ...ext.installMetadata?.source && ext.installMetadata.type !== "snapshot" ? {
           source: redactExtensionDisplaySource(
             ext.installMetadata.source
           )
@@ -18761,7 +19451,8 @@ function createExtensionsController(deps) {
         ...ext.installMetadata?.originSource ? { originSource: ext.installMetadata.originSource } : {},
         ...ext.installMetadata?.ref ? { ref: ext.installMetadata.ref } : {},
         ...ext.installMetadata?.autoUpdate !== void 0 ? { autoUpdate: ext.installMetadata.autoUpdate } : {},
-        updateState: ext.installMetadata ? "unknown" : "not updatable",
+        ...ext.installMetadata?.type === "snapshot" ? { credentialPersistence: "one_time" } : ext.installMetadata?.credentialPersistence === "stored" ? { credentialPersistence: "stored" } : {},
+        updateState: ext.installMetadata?.type === "snapshot" ? "not updatable" : ext.installMetadata ? "unknown" : "not updatable",
         capabilities,
         details: {
           mcpServers: ext.mcpServers ? Object.keys(ext.mcpServers) : [],
@@ -18811,6 +19502,7 @@ var EXTENSION_INTERACTION_DEADLINE_MS = 10 * 6e4;
 var EXTENSION_INTERACTIVE_PREPARE_DEADLINE_MS = EXTENSION_PREPARE_DEADLINE_MS + EXTENSION_INTERACTION_DEADLINE_MS;
 var EXTENSION_UPDATE_CHECK_DEADLINE_MS = 2 * 6e4;
 var EXTENSION_ARCHIVE_UPLOAD_LIMIT = "10mb";
+var MAX_EXTENSION_BATCH_SIZE = 100;
 var extensionArchiveBodyParser = import_express2.default.raw({
   type: "application/octet-stream",
   limit: EXTENSION_ARCHIVE_UPLOAD_LIMIT
@@ -18851,6 +19543,32 @@ var parseExtensionScope = /* @__PURE__ */ __name((body, res) => {
   }
   return scope === "user" ? "User" /* User */ : "Workspace" /* Workspace */;
 }, "parseExtensionScope");
+var parseExtensionBatchNames = /* @__PURE__ */ __name((req, res, safeBody2) => {
+  const rawNames = safeBody2(req)["extensionNames"];
+  if (!Array.isArray(rawNames) || rawNames.length === 0 || rawNames.length > MAX_EXTENSION_BATCH_SIZE || !rawNames.every((name) => typeof name === "string")) {
+    res.status(400).json({
+      error: `\`extensionNames\` must be a non-empty string array (max ${MAX_EXTENSION_BATCH_SIZE})`,
+      code: "invalid_extension_names"
+    });
+    return void 0;
+  }
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of rawNames) {
+    if (!/^[a-zA-Z0-9-_.]+$/.test(name)) {
+      res.status(400).json({
+        error: `Invalid extension name "${name}"`,
+        code: "invalid_extension_name"
+      });
+      return void 0;
+    }
+    const normalizedName = name.toLowerCase();
+    if (seen.has(normalizedName)) continue;
+    seen.add(normalizedName);
+    names.push(name);
+  }
+  return names;
+}, "parseExtensionBatchNames");
 var parseExtensionRegistryUrl = /* @__PURE__ */ __name((value, res) => {
   let parsed;
   try {
@@ -18891,23 +19609,76 @@ var parsePotentialSourceUrl = /* @__PURE__ */ __name((source) => {
     }
   }
 }, "parsePotentialSourceUrl");
-var validateExtensionSourceHost = /* @__PURE__ */ __name((source, res) => {
+var parseExtensionInstallSource = /* @__PURE__ */ __name((source, persistence, res) => {
+  if (persistence !== void 0 && persistence !== "stored" && persistence !== "one_time") {
+    res.status(400).json({
+      error: '`credentialPersistence` must be "stored" or "one_time"'
+    });
+    return null;
+  }
   const parsed = parsePotentialSourceUrl(source);
-  if (!parsed) return true;
-  if (parsed.username || parsed.password) {
-    res.status(400).json({ error: "`source` must not include credentials" });
-    return false;
+  if (!parsed) {
+    if (persistence !== void 0) {
+      res.status(400).json({
+        error: "`credentialPersistence` requires source URL credentials"
+      });
+      return null;
+    }
+    return { source };
   }
   if (isBlockedAuthProviderHost(parsed.hostname)) {
     res.status(400).json({ error: "`source` host is not allowed" });
-    return false;
+    return null;
   }
   if (parsed.protocol !== "https:") {
     res.status(400).json({ error: "`source` must use https" });
-    return false;
+    return null;
   }
-  return true;
-}, "validateExtensionSourceHost");
+  const authority = /^[a-z][a-z\d+.-]*:\/\/([^/?#]*)/i.exec(source)?.[1];
+  const hasUserInfo = !!parsed.username || !!parsed.password || authority?.includes("@") === true;
+  if (!hasUserInfo) {
+    if (persistence !== void 0) {
+      res.status(400).json({
+        error: "`credentialPersistence` requires source URL credentials"
+      });
+      return null;
+    }
+    return { source };
+  }
+  const hasControlCharacter = /* @__PURE__ */ __name((value) => Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  }), "hasControlCharacter");
+  if (hasControlCharacter(source)) {
+    res.status(400).json({ error: "`source` credentials are invalid" });
+    return null;
+  }
+  let username;
+  let password;
+  try {
+    username = decodeURIComponent(parsed.username);
+    password = decodeURIComponent(parsed.password);
+  } catch {
+    res.status(400).json({ error: "`source` credentials are invalid" });
+    return null;
+  }
+  const invalidText = /* @__PURE__ */ __name((value, maxBytes) => Buffer.byteLength(value, "utf8") > maxBytes || hasControlCharacter(value), "invalidText");
+  if (!username && !password || invalidText(username, 256) || invalidText(password, 4096)) {
+    res.status(400).json({ error: "`source` credentials are invalid" });
+    return null;
+  }
+  parsed.username = "";
+  parsed.password = "";
+  const credentialPersistence = persistence ?? "one_time";
+  return {
+    source: parsed.toString(),
+    gitCredential: {
+      username,
+      password,
+      persistence: credentialPersistence
+    }
+  };
+}, "parseExtensionInstallSource");
 var validateExtensionSourceMetadata = /* @__PURE__ */ __name((installMetadata) => {
   if (installMetadata.type !== "git") return true;
   const parsed = parsePotentialSourceUrl(installMetadata.source);
@@ -19424,6 +20195,7 @@ function registerWorkspaceExtensionRoutes(app, deps) {
         const allowPreRelease = body["allowPreRelease"];
         const registry = body["registry"];
         const consent = body["consent"];
+        const credentialPersistence = body["credentialPersistence"];
         if (!source || typeof source !== "string") {
           res.status(400).json({ error: "Missing or invalid source" });
           return;
@@ -19448,7 +20220,6 @@ function registerWorkspaceExtensionRoutes(app, deps) {
           res.status(400).json({ error: "`registry` must be a string" });
           return;
         }
-        const sourceValue = source;
         const refValue = typeof ref === "string" ? ref : void 0;
         const autoUpdateValue = typeof autoUpdate === "boolean" ? autoUpdate : void 0;
         const allowPreReleaseValue = typeof allowPreRelease === "boolean" ? allowPreRelease : void 0;
@@ -19461,7 +20232,25 @@ function registerWorkspaceExtensionRoutes(app, deps) {
           });
           return;
         }
-        if (!validateExtensionSourceHost(sourceValue, res)) {
+        const parsedSource = parseExtensionInstallSource(
+          source,
+          credentialPersistence,
+          res
+        );
+        if (!parsedSource) return;
+        const sourceValue = parsedSource.source;
+        body["source"] = sourceValue;
+        const gitCredential = parsedSource.gitCredential;
+        if (gitCredential?.persistence === "one_time" && autoUpdateValue) {
+          res.status(400).json({
+            error: "`autoUpdate` is not supported with one-time credentials"
+          });
+          return;
+        }
+        if (gitCredential && isSupportedArchiveUrl(sourceValue)) {
+          res.status(400).json({
+            error: "Git credentials require an HTTPS Git install source."
+          });
           return;
         }
         const localSource = /^[A-Za-z]:[\\/]/.test(sourceValue) || sourceValue.startsWith("/") || sourceValue.startsWith(".");
@@ -19511,7 +20300,7 @@ function registerWorkspaceExtensionRoutes(app, deps) {
         }
         ctrl.runQueuedExtensionMutation(
           "install",
-          { source: sourceValue },
+          gitCredential?.persistence === "one_time" ? {} : { source: sourceValue },
           res,
           async (extensionManager, _signal, context, operationId) => {
             const prepared = await context.prepare(async (signal) => {
@@ -19523,6 +20312,11 @@ function registerWorkspaceExtensionRoutes(app, deps) {
                   "Only GitHub, Git, and npm extension installs are supported over the daemon endpoint."
                 );
               }
+              if (gitCredential && installMetadata.type !== "git" && installMetadata.type !== "github-release") {
+                throw new Error(
+                  "Git credentials require an HTTPS Git install source."
+                );
+              }
               if (installMetadata.type === "npm" && refValue) {
                 throw new Error("--ref is not applicable for npm extensions.");
               }
@@ -19547,7 +20341,8 @@ function registerWorkspaceExtensionRoutes(app, deps) {
                 },
                 initialActivation: { scope: "user" },
                 requestConsent: /* @__PURE__ */ __name(() => Promise.resolve(), "requestConsent"),
-                signal
+                signal,
+                ...gitCredential ? { gitCredential } : {}
               });
             });
             try {
@@ -19559,9 +20354,13 @@ function registerWorkspaceExtensionRoutes(app, deps) {
               );
               return {
                 status: "installed",
-                source: sourceValue,
+                ...gitCredential?.persistence === "one_time" ? {} : { source: sourceValue },
                 name: committed.identity.name,
-                version: committed.version
+                version: committed.version,
+                ...gitCredential ? {
+                  credentialPersistence: gitCredential.persistence,
+                  ...prepared.credentialStorage ? { credentialStorage: prepared.credentialStorage } : {}
+                } : {}
               };
             } finally {
               await extensionManager.disposePreparedExtension(prepared);
@@ -19934,6 +20733,17 @@ function registerWorkspaceExtensionRoutes(app, deps) {
     }
     return state;
   }, "parseActivationState");
+  const parseWorkspaceBatchActivationState = /* @__PURE__ */ __name((req, res) => {
+    const state = safeBody2(req)["state"];
+    if (state !== "enabled" && state !== "disabled" && state !== "inherit") {
+      res.status(400).json({
+        error: '`state` must be "enabled", "disabled", or "inherit"',
+        code: "invalid_extension_activation"
+      });
+      return null;
+    }
+    return state;
+  }, "parseWorkspaceBatchActivationState");
   const sendOperation = /* @__PURE__ */ __name((req, res, route, manager, operation, failureContext, run2, options = {}) => {
     if (!primaryController.validateExtensionMutationClient(req, res, {
       requireClientId: false,
@@ -19972,6 +20782,7 @@ function registerWorkspaceExtensionRoutes(app, deps) {
             name: extension.name,
             version: extension.version,
             ...extension.installMetadata?.type ? { installType: extension.installMetadata.type } : {},
+            ...extension.installMetadata?.type === "snapshot" ? { credentialPersistence: "one_time" } : extension.installMetadata?.credentialPersistence === "stored" ? { credentialPersistence: "stored" } : {},
             defaultActivation: policy?.defaultActivation ?? "enabled",
             workspaceOverrideCount: Object.values(
               policy?.workspaceOverrides ?? {}
@@ -19999,6 +20810,43 @@ function registerWorkspaceExtensionRoutes(app, deps) {
     }
     res.status(200).json(operation);
   });
+  app.put("/extensions/activation", mutate({ strict: true }), (req, res) => {
+    const names = parseExtensionBatchNames(req, res, safeBody2);
+    if (!names) return;
+    const state = parseActivationState(req, res);
+    if (!state) return;
+    const manager = primaryController.createExtensionManager(
+      boundWorkspace,
+      true
+    );
+    sendOperation(
+      req,
+      res,
+      "PUT /extensions/activation",
+      manager,
+      "set_default_activation_batch",
+      {},
+      async (extensionManager, _signal, context) => {
+        await context.commit(
+          async (onCommitted) => await extensionManager.setExtensionDefaultActivations(
+            names,
+            state,
+            onCommitted
+          )
+        );
+        return {
+          status: "updated",
+          results: names.map((name) => ({
+            name,
+            defaultActivation: state
+          }))
+        };
+      },
+      {
+        ...workspaceRegistry ? { refreshRuntimes: /* @__PURE__ */ __name(() => workspaceRegistry.listAll(), "refreshRuntimes") } : {}
+      }
+    );
+  });
   app.put(
     "/extensions/:extensionId/activation",
     mutate({ strict: true }),
@@ -20048,6 +20896,7 @@ function registerWorkspaceExtensionRoutes(app, deps) {
     const autoUpdate = body["autoUpdate"];
     const allowPreRelease = body["allowPreRelease"];
     const registry = body["registry"];
+    const credentialPersistence = body["credentialPersistence"];
     if (typeof source !== "string" || !source) {
       res.status(400).json({ error: "Missing or invalid source" });
       return;
@@ -20080,7 +20929,27 @@ function registerWorkspaceExtensionRoutes(app, deps) {
       });
       return;
     }
-    if (!validateExtensionSourceHost(source, res)) return;
+    const parsedSource = parseExtensionInstallSource(
+      source,
+      credentialPersistence,
+      res
+    );
+    if (!parsedSource) return;
+    const sourceValue = parsedSource.source;
+    body["source"] = sourceValue;
+    const gitCredential = parsedSource.gitCredential;
+    if (gitCredential?.persistence === "one_time" && autoUpdate === true) {
+      res.status(400).json({
+        error: "`autoUpdate` is not supported with one-time credentials"
+      });
+      return;
+    }
+    if (gitCredential && isSupportedArchiveUrl(sourceValue)) {
+      res.status(400).json({
+        error: "Git credentials require an HTTPS Git install source."
+      });
+      return;
+    }
     if (!activation || typeof activation !== "object") {
       res.status(400).json({ error: "Missing initial activation" });
       return;
@@ -20119,10 +20988,10 @@ function registerWorkspaceExtensionRoutes(app, deps) {
       "POST /extensions/install",
       manager,
       "install",
-      { source },
+      gitCredential?.persistence === "one_time" ? {} : { source: sourceValue },
       async (extensionManager, _signal, context) => {
         const prepared = await context.prepare(async (signal) => {
-          const metadata = await parseInstallSource(source, {
+          const metadata = await parseInstallSource(sourceValue, {
             networkPolicy: "public"
           });
           if (metadata.type !== "git" && metadata.type !== "github-release" && metadata.type !== "npm") {
@@ -20130,6 +20999,11 @@ function registerWorkspaceExtensionRoutes(app, deps) {
               "Only GitHub, Git, and npm extension installs are supported over the daemon endpoint."
             );
           }
+          if (gitCredential && metadata.type !== "git" && metadata.type !== "github-release") {
+            throw new Error(
+              "Git credentials require an HTTPS Git install source."
+            );
+          }
           if (!validateExtensionSourceMetadata(metadata)) {
             throw new Error("`source` host is not allowed");
           }
@@ -20154,7 +21028,8 @@ function registerWorkspaceExtensionRoutes(app, deps) {
             requestConsent: /* @__PURE__ */ __name(() => Promise.resolve(), "requestConsent"),
             cwd: boundWorkspace,
             initialActivation,
-            signal
+            signal,
+            ...gitCredential ? { gitCredential } : {}
           });
         });
         try {
@@ -20166,9 +21041,13 @@ function registerWorkspaceExtensionRoutes(app, deps) {
           );
           return {
             status: "installed",
-            source,
+            ...gitCredential?.persistence === "one_time" ? {} : { source: sourceValue },
             name: committed.identity.name,
-            version: committed.version
+            version: committed.version,
+            ...gitCredential ? {
+              credentialPersistence: gitCredential.persistence,
+              ...prepared.credentialStorage ? { credentialStorage: prepared.credentialStorage } : {}
+            } : {}
           };
         } finally {
           await extensionManager.disposePreparedExtension(prepared);
@@ -20235,9 +21114,7 @@ function registerWorkspaceExtensionRoutes(app, deps) {
           if (!extension)
             throw new Error(`Extension "${extensionId}" not found`);
           if (extension.installMetadata?.type !== "git" && extension.installMetadata?.type !== "archive-url" && extension.installMetadata?.type !== "github-release" && extension.installMetadata?.type !== "npm") {
-            throw new Error(
-              `Extension "${extension.name}" is not remotely updatable.`
-            );
+            throw new ExtensionNotUpdatableError(extension.name);
           }
           const preparedResult = await context.prepare(
             async (signal) => await extensionManager.prepareExtensionUpdate({
@@ -20299,7 +21176,7 @@ function registerWorkspaceExtensionRoutes(app, deps) {
         );
         const snapshot = await manager.getExtensionStoreSnapshot();
         const policy = snapshot.extensions[extensionId];
-        if (!policy) {
+        if (!policy || policy.declarationOnly) {
           res.status(204).end();
           return;
         }
@@ -20373,6 +21250,57 @@ function registerWorkspaceExtensionRoutes(app, deps) {
         });
       }
     });
+    app.put(
+      "/workspaces/:workspace/extensions/activation",
+      mutate({ strict: true }),
+      (req, res) => {
+        const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
+        if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+        const names = parseExtensionBatchNames(req, res, safeBody2);
+        if (!names) return;
+        const state = parseWorkspaceBatchActivationState(req, res);
+        if (!state) return;
+        const manager = primaryController.createExtensionManager(
+          runtime.workspaceCwd,
+          true
+        );
+        sendOperation(
+          req,
+          res,
+          "PUT /workspaces/:workspace/extensions/activation",
+          manager,
+          "set_workspace_activation_batch",
+          {},
+          async (extensionManager, _signal, context) => {
+            const snapshot = await context.commit(
+              async (onCommitted) => await extensionManager.setExtensionWorkspaceActivations(
+                names,
+                runtime.workspaceCwd,
+                state,
+                onCommitted
+              )
+            );
+            return {
+              status: "updated",
+              updated: snapshot.updated,
+              results: names.map((name) => ({
+                name,
+                workspaceActivation: state === "inherit" ? null : state,
+                effectiveActivation: extensionManager.getExtensionActivationForNameFromSnapshot(
+                  name,
+                  snapshot,
+                  runtime.workspaceCwd
+                ).effective
+              }))
+            };
+          },
+          {
+            refreshRuntimes: [runtime],
+            assertGenerationOpen: /* @__PURE__ */ __name(() => runtime.generationGuard?.assertOpen(), "assertGenerationOpen")
+          }
+        );
+      }
+    );
     app.put(
       "/workspaces/:workspace/extensions/:extensionId/activation",
       mutate({ strict: true }),
@@ -20777,6 +21705,7 @@ __name(registerWorkspaceQualifiedFileWriteRoutes, "registerWorkspaceQualifiedFil
 var MAX_CONCURRENT_UPLOADS = 4;
 var MAX_UPLOAD_FILENAME_BYTES = 255;
 var NUMBERED_CANDIDATE_CAP = 1e3;
+var MAX_UPLOAD_DIR_DEPTH = 64;
 var uploadGateLeases = /* @__PURE__ */ new WeakMap();
 function createUploadConcurrencyGate(max = MAX_CONCURRENT_UPLOADS) {
   let active = 0;
@@ -20934,6 +21863,14 @@ function fileUploadAdmission(deps, opts) {
           sendParseError(res, ROUTE2, "`path` must name a file");
           return;
         }
+        if (dir.split("/").filter(Boolean).length > MAX_UPLOAD_DIR_DEPTH) {
+          sendParseError(
+            res,
+            ROUTE2,
+            `directory path exceeds ${MAX_UPLOAD_DIR_DEPTH} components`
+          );
+          return;
+        }
         if (queryPath.includes("\0")) {
           sendParseError(res, ROUTE2, "path must not contain null bytes");
           return;
@@ -20979,10 +21916,11 @@ function fileUploadAdmission(deps, opts) {
           dirStat = await fs9.stat(resolvedDir);
         } catch (err) {
           if (isFsError(err) && err.kind === "path_not_found") {
-            sendParseError(res, ROUTE2, "parent directory does not exist");
-            return;
+            await fs9.mkdir(resolvedDir, { recursive: true });
+            dirStat = await fs9.stat(resolvedDir);
+          } else {
+            throw err;
           }
-          throw err;
         }
         if (dirStat.kind !== "directory") {
           sendParseError(res, ROUTE2, "parent path is not a directory");
@@ -21380,6 +22318,7 @@ init_esbuild_shims();
 
 // packages/cli/src/serve/server/telemetry.ts
 init_esbuild_shims();
+import { performance as performance2 } from "node:perf_hooks";
 var legacySessionTelemetryRoutes = [
   {
     method: "POST",
@@ -21519,6 +22458,18 @@ var legacySessionTelemetryRoutes = [
     attribution: "handler_resolved",
     route: "POST /session/:id/tasks/:taskId/cancel"
   },
+  {
+    method: "POST",
+    path: "/session/:id/goal",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/goal"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/goal",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/goal"
+  },
   {
     method: "POST",
     path: "/session/:id/goal/clear",
@@ -21531,6 +22482,24 @@ var legacySessionTelemetryRoutes = [
     attribution: "handler_resolved",
     route: "POST /session/:id/continue"
   },
+  {
+    method: "POST",
+    path: "/session/:id/attachments",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/attachments"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/attachments/:attachmentId",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/attachments/:attachmentId"
+  },
+  {
+    method: "DELETE",
+    path: "/session/:id/attachments/:attachmentId",
+    attribution: "handler_resolved",
+    route: "DELETE /session/:id/attachments/:attachmentId"
+  },
   {
     method: "POST",
     path: "/session/:id/prompt",
@@ -21651,6 +22620,18 @@ var legacySessionTelemetryRoutes = [
     attribution: "handler_resolved",
     route: "DELETE /session/:id/pending-prompts/:promptId"
   },
+  {
+    method: "GET",
+    path: "/session/:id/turns/current",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/turns/current"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/turns/:promptId",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/turns/:promptId"
+  },
   {
     method: "POST",
     path: "/session/:id/shell",
@@ -21706,7 +22687,6 @@ var legacySessionTelemetryRoutes = [
     route: "POST /session/:id/a2ui-action"
   }
 ];
-var daemonTelemetryResponseContext = Symbol("daemonTelemetryResponseContext");
 function decodePathSegment(value) {
   try {
     return decodeURIComponent(value);
@@ -21779,6 +22759,9 @@ function resolveDaemonTelemetryRoute(req) {
   if (req.method === "GET" && /^\/workspaces\/[^/]+\/sessions$/.test(path19)) {
     return { route: "GET /workspace/:id/sessions" };
   }
+  if (req.method === "GET" && /^\/workspaces\/[^/]+\/sessions\/live-state$/.test(path19)) {
+    return { route: "GET /workspaces/:workspace/sessions/live-state" };
+  }
   if (req.method === "GET" && /^\/workspace\/[^/]+\/session-info$/.test(path19)) {
     return { route: "GET /workspace/:id/session-info" };
   }
@@ -21930,8 +22913,34 @@ function resolveDaemonTelemetryRoute(req) {
   return void 0;
 }
 __name(resolveDaemonTelemetryRoute, "resolveDaemonTelemetryRoute");
+var TRACEPARENT_BREADCRUMB_BURST = 60;
+var TRACEPARENT_BREADCRUMB_REFILL_PER_SECOND = 2;
+function daemonInboundTraceIdCaptureMiddleware(req, res, next) {
+  try {
+    const inboundTraceId = extractInboundTraceId(req.headers);
+    if (inboundTraceId !== void 0) {
+      res[daemonInboundTraceIdContext] = inboundTraceId;
+    }
+  } catch {
+  }
+  next();
+}
+__name(daemonInboundTraceIdCaptureMiddleware, "daemonInboundTraceIdCaptureMiddleware");
 function daemonTelemetryMiddleware(resolveWorkspaceCwd, recordRequest) {
   const workspaceHashByCwd = /* @__PURE__ */ new Map();
+  let breadcrumbTokens = TRACEPARENT_BREADCRUMB_BURST;
+  let breadcrumbRefillBaseline = performance2.now();
+  const acquireBreadcrumbToken = /* @__PURE__ */ __name(() => {
+    const now = Math.max(performance2.now(), breadcrumbRefillBaseline);
+    breadcrumbTokens = Math.min(
+      TRACEPARENT_BREADCRUMB_BURST,
+      breadcrumbTokens + (now - breadcrumbRefillBaseline) / 1e3 * TRACEPARENT_BREADCRUMB_REFILL_PER_SECOND
+    );
+    breadcrumbRefillBaseline = now;
+    if (breadcrumbTokens < 1) return false;
+    breadcrumbTokens -= 1;
+    return true;
+  }, "acquireBreadcrumbToken");
   const resolveWorkspaceHash = /* @__PURE__ */ __name((workspaceCwd) => {
     const existing = workspaceHashByCwd.get(workspaceCwd);
     if (existing !== void 0) return existing;
@@ -21960,10 +22969,39 @@ function daemonTelemetryMiddleware(resolveWorkspaceCwd, recordRequest) {
     const clientId = rawClientId !== void 0 && rawClientId !== "" && rawClientId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawClientId) ? rawClientId : void 0;
     const deferredRuntime = getDeferredRuntimeRequestTiming(req);
     const startMs = deferredRuntime?.startedAt.getTime() ?? Date.now();
+    let parentContext;
+    if (isTelemetrySdkInitialized()) {
+      try {
+        parentContext = extractDaemonHttpTraceContext(req.headers);
+      } catch {
+        parentContext = void 0;
+      }
+      try {
+        const inboundTraceparent = req.headers?.["traceparent"];
+        if (!parentContext && typeof inboundTraceparent === "string" && inboundTraceparent.length > 0 && acquireBreadcrumbToken()) {
+          emitDaemonLog(
+            "Rejected invalid inbound traceparent header.",
+            {
+              "http.route": route.route,
+              "http.request.header.traceparent": sanitizeLogText(
+                inboundTraceparent,
+                128
+              )
+            },
+            {
+              eventName: "qwen-code.daemon.traceparent.invalid",
+              severityNumber: 5
+              // SeverityNumber.DEBUG
+            }
+          );
+        }
+      } catch {
+      }
+    }
     const telemetryRes = res;
     if (route.attribution === "handler_resolved") {
       try {
-        telemetryRes[daemonTelemetryResponseContext] = {};
+        telemetryRes[daemonTelemetryResponseContext] ??= {};
       } catch {
       }
     }
@@ -21975,6 +23013,7 @@ function daemonTelemetryMiddleware(resolveWorkspaceCwd, recordRequest) {
         ...sessionId ? { sessionId } : {},
         ...route.permissionRequestId ? { permissionRequestId: route.permissionRequestId } : {},
         ...clientId ? { clientId } : {},
+        ...parentContext ? { parentContext } : {},
         ...deferredRuntime?.waitMs !== void 0 ? {
           startTime: deferredRuntime.startedAt,
           deferredRuntimeWaitMs: deferredRuntime.waitMs,
@@ -22212,6 +23251,7 @@ init_esbuild_shims();
 import * as crypto3 from "node:crypto";
 import * as fs6 from "node:fs";
 import * as path12 from "node:path";
+var import_express4 = __toESM(require_express(), 1);
 
 // packages/cli/src/serve/server/prompt-deadline.ts
 init_esbuild_shims();
@@ -22409,10 +23449,27 @@ var PersistedSessionListCache = class {
   }
 };
 
+// packages/cli/src/serve/server/activity-timestamp.ts
+init_esbuild_shims();
+function laterActivityTimestamp(live, persisted) {
+  const liveTime = live === void 0 ? Number.NaN : Date.parse(live);
+  const persistedTime = persisted === void 0 ? Number.NaN : Date.parse(persisted);
+  const liveValid = Number.isFinite(liveTime);
+  const persistedValid = Number.isFinite(persistedTime);
+  if (liveValid && persistedValid) {
+    return liveTime >= persistedTime ? live : persisted;
+  }
+  if (liveValid) return live;
+  if (persistedValid) return persisted;
+  return live ?? persisted;
+}
+__name(laterActivityTimestamp, "laterActivityTimestamp");
+
 // packages/cli/src/serve/server/session-list.ts
 var DEFAULT_SESSION_PAGE_SIZE = 20;
 var MAX_SESSION_PAGE_SIZE = 100;
 var MAX_ORGANIZED_SESSIONS = 5e4;
+var MAX_EMITTED_CURSOR_SESSION_IDS = 64;
 var PERSISTED_SESSION_LIST_CACHE_TTL_MS = 2e3;
 var persistedSessionListCache = new PersistedSessionListCache(
   PERSISTED_SESSION_LIST_CACHE_TTL_MS,
@@ -22447,6 +23504,14 @@ function parseSessionCursor(cursor) {
   return parsed;
 }
 __name(parseSessionCursor, "parseSessionCursor");
+function parseEmittedSessionIds(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((id) => typeof id !== "string" || id.length === 0)) {
+    return void 0;
+  }
+  return value;
+}
+__name(parseEmittedSessionIds, "parseEmittedSessionIds");
 function parseOrganizedCursor(cursor, expected) {
   if (cursor === "") return void 0;
   try {
@@ -22456,15 +23521,26 @@ function parseOrganizedCursor(cursor, expected) {
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof last !== "object" || last === null || Array.isArray(last) || typeof last.isPinned !== "boolean" || typeof last.activityTime !== "number" || !Number.isFinite(last.activityTime) || typeof last.sessionId !== "string" || last.sessionId.length === 0 || parsed.group !== expected.group || parsed.archiveState !== expected.archiveState || parsed.sourceType !== expected.sourceType || parsed.sourceId !== expected.sourceId) {
       throw new Error("invalid organized cursor");
     }
-    return last;
+    const emitted = parseEmittedSessionIds(parsed.emitted);
+    if (emitted === void 0) {
+      throw new Error("invalid organized cursor");
+    }
+    return { last, emitted };
   } catch {
     throw new InvalidCursorError(cursor, "organized");
   }
 }
 __name(parseOrganizedCursor, "parseOrganizedCursor");
-function encodeOrganizedCursor(last, group, archiveState, sourceType, sourceId) {
+function encodeOrganizedCursor(last, group, archiveState, sourceType, sourceId, emitted = []) {
   return Buffer.from(
-    JSON.stringify({ group, archiveState, sourceType, sourceId, last }),
+    JSON.stringify({
+      group,
+      archiveState,
+      sourceType,
+      sourceId,
+      last,
+      ...emitted.length > 0 ? { emitted } : {}
+    }),
     "utf8"
   ).toString("base64url");
 }
@@ -22505,7 +23581,16 @@ function parseMetadataSessionCursor(cursor, expected) {
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof last !== "object" || last === null || Array.isArray(last) || typeof last.activityTime !== "number" || !Number.isFinite(last.activityTime) || typeof last.sessionId !== "string" || last.sessionId.length === 0 || parsed.parentSessionId !== expected.parentSessionId || parsed.sourceType !== expected.sourceType || parsed.sourceId !== expected.sourceId || parsed.archiveState !== expected.archiveState) {
       throw new Error("invalid metadata cursor");
     }
-    return { activityTime: last.activityTime, sessionId: last.sessionId };
+    const emitted = parseEmittedSessionIds(
+      parsed.emitted
+    );
+    if (emitted === void 0) {
+      throw new Error("invalid metadata cursor");
+    }
+    return {
+      last: { activityTime: last.activityTime, sessionId: last.sessionId },
+      emitted
+    };
   } catch {
     throw new InvalidCursorError(
       cursor,
@@ -22514,9 +23599,14 @@ function parseMetadataSessionCursor(cursor, expected) {
   }
 }
 __name(parseMetadataSessionCursor, "parseMetadataSessionCursor");
-function encodeMetadataSessionCursor(last, filter, archiveState) {
+function encodeMetadataSessionCursor(last, filter, archiveState, emitted = []) {
   return Buffer.from(
-    JSON.stringify({ ...filter, archiveState, last }),
+    JSON.stringify({
+      ...filter,
+      archiveState,
+      last,
+      ...emitted.length > 0 ? { emitted } : {}
+    }),
     "utf8"
   ).toString("base64url");
 }
@@ -22576,7 +23666,7 @@ function mergeLiveSessionSummary(existing, live) {
     parentSessionId: existing.parentSessionId ?? live.parentSessionId,
     sourceType: existing.sourceType ?? live.sourceType,
     sourceId: existing.sourceType !== void 0 ? existing.sourceId : live.sourceId,
-    updatedAt: live.updatedAt ?? existing.updatedAt,
+    updatedAt: laterActivityTimestamp(live.updatedAt, existing.updatedAt),
     clientCount: live.clientCount,
     hasActivePrompt: live.hasActivePrompt,
     isArchived: false
@@ -22726,6 +23816,36 @@ function compareOrganizedCursorKeys(a, b) {
   return a.sessionId.localeCompare(b.sessionId);
 }
 __name(compareOrganizedCursorKeys, "compareOrganizedCursorKeys");
+function nextEmittedSessionIds(options) {
+  const candidates = new Set(options.carried);
+  for (const row of options.page) {
+    if (options.liveSessionIds.has(row.sessionId)) {
+      candidates.add(row.sessionId);
+    }
+  }
+  const kept = [];
+  for (const sessionId of candidates) {
+    const row = options.listedById.get(sessionId);
+    if (!row) {
+      kept.push({ sessionId, persistedTime: Number.NEGATIVE_INFINITY });
+      continue;
+    }
+    const persistedTime = options.persistedTimeById.get(sessionId);
+    if (persistedTime === void 0) {
+      kept.push({ sessionId, persistedTime: Number.NEGATIVE_INFINITY });
+      continue;
+    }
+    if (options.reenters(row, persistedTime)) {
+      kept.push({ sessionId, persistedTime });
+    }
+  }
+  if (kept.length > MAX_EMITTED_CURSOR_SESSION_IDS) {
+    kept.sort((a, b) => a.persistedTime - b.persistedTime);
+    kept.length = MAX_EMITTED_CURSOR_SESSION_IDS;
+  }
+  return kept.map((entry) => entry.sessionId);
+}
+__name(nextEmittedSessionIds, "nextEmittedSessionIds");
 function applyOrganization(session, organization) {
   return {
     ...session,
@@ -22752,12 +23872,14 @@ async function listOrganizedWorkspaceSessionsForResponse(bridge, workspaceCwd, o
       "group"
     );
   }
-  const cursorKey = options.cursor !== void 0 ? parseOrganizedCursor(options.cursor, {
+  const cursor = options.cursor !== void 0 ? parseOrganizedCursor(options.cursor, {
     group,
     archiveState,
     sourceType: options.sourceType,
     sourceId: options.sourceId
   }) : void 0;
+  const cursorKey = cursor?.last;
+  const emittedBeforePage = new Set(cursor?.emitted ?? []);
   const isFirstPage = cursorKey === void 0;
   let liveMergeFailed = false;
   const bySessionId = /* @__PURE__ */ new Map();
@@ -22779,10 +23901,18 @@ async function listOrganizedWorkspaceSessionsForResponse(bridge, workspaceCwd, o
       )
     );
   }
-  if (readOptions.mergeLive !== false && archiveState !== "archived" && isFirstPage) {
+  const persistedTimeById = new Map(
+    persisted.sessions.map((session) => [
+      session.sessionId,
+      getSummaryActivityTime(session)
+    ])
+  );
+  const liveSessionIds = /* @__PURE__ */ new Set();
+  if (readOptions.mergeLive !== false && archiveState !== "archived") {
     try {
       const liveSessions = bridge.listWorkspaceSessions(workspaceCwd);
       for (const live of liveSessions) {
+        liveSessionIds.add(live.sessionId);
         const existing = bySessionId.get(live.sessionId);
         const organization = snapshot.sessions.get(live.sessionId);
         if (existing) {
@@ -22794,7 +23924,9 @@ async function listOrganizedWorkspaceSessionsForResponse(bridge, workspaceCwd, o
             )
           );
         } else if (
-          // `listAllPersistedSummaries` already scanned every persisted
+          // A live-only row has no persisted key to page by, so it stays a
+          // first-page-only insertion as before.
+          isFirstPage && // `listAllPersistedSummaries` already scanned every persisted
           // session when the scan wasn't truncated, so a `sessionId` missing
           // from `bySessionId` is definitively new — no disk re-check
           // needed. Re-checking here raced a session that persists its
@@ -22802,9 +23934,9 @@ async function listOrganizedWorkspaceSessionsForResponse(bridge, workspaceCwd, o
           // above and this point: `existing` stayed undefined but
           // `sessionExists` flipped to true, silently dropping the live
           // session from the response instead of merging it.
-          !persisted.truncated || !await (readOptions.signal ? sessionService.sessionExists(live.sessionId, {
+          (!persisted.truncated || !await (readOptions.signal ? sessionService.sessionExists(live.sessionId, {
             signal: readOptions.signal
-          }) : sessionService.sessionExists(live.sessionId))
+          }) : sessionService.sessionExists(live.sessionId)))
         ) {
           bySessionId.set(
             live.sessionId,
@@ -22847,19 +23979,52 @@ async function listOrganizedWorkspaceSessionsForResponse(bridge, workspaceCwd, o
   filtered.sort((a, b) => compareOrganizedSessions(activityTimeById, a, b));
   readOptions.signal?.throwIfAborted();
   const afterCursor = cursorKey === void 0 ? filtered : filtered.filter(
-    (session) => compareOrganizedCursorKeys(
-      cursorKey,
-      getOrganizedCursorKey(activityTimeById, session)
-    ) < 0
+    (session) => (
+      // A row already emitted at a live-derived key stays excluded even
+      // if its key regressed behind the cursor (live retirement, or a
+      // live-only row that persisted mid-pass).
+      !emittedBeforePage.has(session.sessionId) && compareOrganizedCursorKeys(
+        cursorKey,
+        getOrganizedCursorKey(activityTimeById, session)
+      ) < 0
+    )
   );
   const page = afterCursor.slice(0, pageSize);
-  const nextCursor = page.length < afterCursor.length ? encodeOrganizedCursor(
-    getOrganizedCursorKey(activityTimeById, page[page.length - 1]),
-    group,
-    archiveState,
-    options.sourceType,
-    options.sourceId
-  ) : void 0;
+  let nextCursor;
+  if (page.length < afterCursor.length) {
+    const boundary = getOrganizedCursorKey(
+      activityTimeById,
+      page[page.length - 1]
+    );
+    const emitted = nextEmittedSessionIds({
+      carried: emittedBeforePage,
+      page,
+      liveSessionIds,
+      listedById: new Map(
+        filtered.map((session) => [session.sessionId, session])
+      ),
+      persistedTimeById,
+      // `isPinned` is re-read from the organization snapshot on every page
+      // request, so a pin flip between fetches can move the persisted key
+      // across the pinned/unpinned blocks. Keep the identity while the key
+      // could re-enter under either state.
+      reenters: /* @__PURE__ */ __name((row, persistedTime) => [true, false].some(
+        (isPinned) => compareOrganizedCursorKeys(boundary, {
+          isPinned,
+          activityTime: persistedTime,
+          sessionId: row.sessionId
+        }) < 0
+      ), "reenters")
+    });
+    nextCursor = encodeOrganizedCursor(
+      boundary,
+      group,
+      archiveState,
+      options.sourceType,
+      options.sourceId,
+      emitted
+    );
+  }
   return {
     sessions: page,
     ...nextCursor !== void 0 ? { nextCursor } : {},
@@ -22884,10 +24049,18 @@ async function listWorkspaceSessionsByMetadataForResponse(bridge, workspaceCwd,
   for (const session of persisted.sessions) {
     bySessionId.set(session.sessionId, clonePersistedSummary(session));
   }
+  const persistedTimeById = new Map(
+    persisted.sessions.map((session) => [
+      session.sessionId,
+      getSummaryActivityTime(session)
+    ])
+  );
+  const liveSessionIds = /* @__PURE__ */ new Set();
   let liveMergeFailed = false;
   if (readOptions.mergeLive !== false && archiveState !== "archived") {
     try {
       for (const live of bridge.listWorkspaceSessions(workspaceCwd)) {
+        liveSessionIds.add(live.sessionId);
         const existing = bySessionId.get(live.sessionId);
         if (existing) {
           bySessionId.set(
@@ -22929,22 +24102,46 @@ async function listWorkspaceSessionsByMetadataForResponse(bridge, workspaceCwd,
     )
   );
   readOptions.signal?.throwIfAborted();
-  const cursorKey = options.cursor !== void 0 && options.cursor !== "" ? parseMetadataSessionCursor(options.cursor, {
+  const cursor = options.cursor !== void 0 && options.cursor !== "" ? parseMetadataSessionCursor(options.cursor, {
     ...filter,
     archiveState
   }) : void 0;
+  const cursorKey = cursor?.last;
+  const emittedBeforePage = new Set(cursor?.emitted ?? []);
   const afterCursor = cursorKey === void 0 ? matches : matches.filter(
-    (session) => compareLiveSessionCursorKeys(
-      cursorKey,
-      getLiveSessionCursorKey(session)
-    ) < 0
+    (session) => (
+      // See the organized path: exclude rows already emitted at a
+      // live-derived key whose key regressed behind the cursor.
+      !emittedBeforePage.has(session.sessionId) && compareLiveSessionCursorKeys(
+        cursorKey,
+        getLiveSessionCursorKey(session)
+      ) < 0
+    )
   );
   const page = afterCursor.slice(0, pageSize);
-  const nextCursor = page.length < afterCursor.length ? encodeMetadataSessionCursor(
-    getLiveSessionCursorKey(page[page.length - 1]),
-    filter,
-    archiveState
-  ) : void 0;
+  let nextCursor;
+  if (page.length < afterCursor.length) {
+    const boundary = getLiveSessionCursorKey(page[page.length - 1]);
+    const emitted = nextEmittedSessionIds({
+      carried: emittedBeforePage,
+      page,
+      liveSessionIds,
+      listedById: new Map(
+        matches.map((session) => [session.sessionId, session])
+      ),
+      persistedTimeById,
+      reenters: /* @__PURE__ */ __name((row, persistedTime) => compareLiveSessionCursorKeys(boundary, {
+        activityTime: persistedTime,
+        sessionId: row.sessionId
+      }) < 0, "reenters")
+    });
+    nextCursor = encodeMetadataSessionCursor(
+      boundary,
+      filter,
+      archiveState,
+      emitted
+    );
+  }
   return {
     sessions: page,
     ...nextCursor !== void 0 ? { nextCursor } : {},
@@ -24036,6 +25233,58 @@ var WORKSPACE_TRANSCRIPT_RESPONSE_MAX_BYTES = 2 * SESSION_TRANSCRIPT_MAX_EXPANDE
 var WORKSPACE_TRANSCRIPT_CURSOR_MAX_BYTES = 64 * 1024;
 var TRANSCRIPT_CURSOR_TOO_LARGE_REPLAY_ERROR = "Transcript pagination state exceeds the safe limit";
 var CHANNEL_DELIVERY_AUTHORIZATION_GRACE_MS = 6e4;
+var MEDIA_CONTENT_MAX_BLOCKS = 256;
+function isSvgMimeType(mimeType) {
+  return mimeType?.split(";", 1)[0]?.trim().toLowerCase() === "image/svg+xml";
+}
+__name(isSvgMimeType, "isSvgMimeType");
+function parseMediaContentBlock(block) {
+  if (typeof block !== "object" || block === null || Array.isArray(block)) {
+    return { valid: false, code: "not-object" };
+  }
+  const record = block;
+  const type = record["type"];
+  const data = record["data"];
+  const attachmentId = record["attachmentId"];
+  const mimeType = record["mimeType"];
+  const size = record["size"];
+  const inline = typeof data === "string" && data.length > 0;
+  const reference = typeof attachmentId === "string" && attachmentId.length > 0 && typeof size === "number" && Number.isSafeInteger(size) && size >= 0 && (type !== "image" || size > 0);
+  if (type === "resource" && !reference) {
+    const resource = record["resource"];
+    if (typeof resource !== "object" || resource === null) {
+      return { valid: false, code: "invalid-shape" };
+    }
+    const value = resource;
+    const hasText = typeof value["text"] === "string";
+    const hasBlob = typeof value["blob"] === "string";
+    if (typeof value["uri"] !== "string" || value["uri"].length === 0 || hasText === hasBlob) {
+      return { valid: false, code: "invalid-shape" };
+    }
+    return { valid: true, block };
+  }
+  if (type !== "image" && type !== "resource" || (type === "image" ? inline === reference : inline || !reference) || typeof mimeType !== "string" || type === "image" && !mimeType.startsWith("image/")) {
+    return { valid: false, code: "invalid-shape" };
+  }
+  if (type === "image" && isSvgMimeType(mimeType)) {
+    return { valid: false, code: "svg" };
+  }
+  return {
+    valid: true,
+    block: inline ? { type, data, mimeType } : { type, attachmentId, mimeType, size }
+  };
+}
+__name(parseMediaContentBlock, "parseMediaContentBlock");
+function mediaBlockParseError(code, entryLabel) {
+  if (code === "not-object") {
+    return `each ${entryLabel} must be a media content block`;
+  }
+  if (code === "svg") {
+    return "SVG images are not supported";
+  }
+  return `each ${entryLabel} must be an inline content block or carry \`attachmentId\`, \`size\`, and \`mimeType\``;
+}
+__name(mediaBlockParseError, "mediaBlockParseError");
 var PRIMARY_ONLY_LIVE_SESSION_ROUTES = ["POST /session/:id/cd"];
 var PRIMARY_OR_INTERNAL_LIVE_SESSION_ROUTES = [
   "POST /session/:id/branch",
@@ -24243,11 +25492,15 @@ function registerSessionRoutes(app, deps) {
       archiveStates
     });
   }, "invalidateSessionLists");
+  const invalidateSessionListsAndMarkCatalog = /* @__PURE__ */ __name((runtime, archiveStates) => {
+    invalidateSessionLists(runtime, archiveStates);
+    runtime.bridge.markSessionCatalogChanged();
+  }, "invalidateSessionListsAndMarkCatalog");
   const runWithSessionListInvalidation = /* @__PURE__ */ __name(async (runtime, archiveStates, mutation) => {
     try {
       return await mutation();
     } finally {
-      invalidateSessionLists(runtime, archiveStates);
+      invalidateSessionListsAndMarkCatalog(runtime, archiveStates);
     }
   }, "runWithSessionListInvalidation");
   const requestedSessionIdAdmission = deps.requestedSessionIdAdmission ?? createRequestedSessionIdAdmission({
@@ -24617,7 +25870,7 @@ function registerSessionRoutes(app, deps) {
       }
       const metadata = await readLoadableLiveConversationMetadata(
         sessionId,
-        (candidateId) => service.readCreationMetadata(candidateId)
+        service
       );
       if (!metadata) throw new SessionNotFoundError(sessionId);
     }
@@ -24941,10 +26194,7 @@ function registerSessionRoutes(app, deps) {
       if (location !== "active") return false;
       if (!isInternalWorkspaceRuntime(runtime)) return true;
       const service = createWorkspaceRuntimeSessionService(runtime);
-      return await readLoadableLiveConversationMetadata(
-        sessionId,
-        (candidateId) => service.readCreationMetadata(candidateId)
-      ) !== void 0;
+      return await readLoadableLiveConversationMetadata(sessionId, service) !== void 0;
     }, "activeInRuntime");
     const throwMissingActiveTranscript = /* @__PURE__ */ __name(() => {
       if (hasCursor) {
@@ -25140,7 +26390,7 @@ function registerSessionRoutes(app, deps) {
       if (!exists) continue;
       const metadata = await readLoadableLiveConversationMetadata(
         sessionId,
-        (candidateId) => service.readCreationMetadata(candidateId)
+        service
       );
       if (!assertCurrentInternalGeneration(entry, generation, res)) {
         return void 0;
@@ -25227,7 +26477,7 @@ function registerSessionRoutes(app, deps) {
         if (!exists) continue;
         const metadata = await readLoadableLiveConversationMetadata(
           sessionId,
-          (candidateId) => service.readCreationMetadata(candidateId)
+          service
         );
         if (!assertCurrentInternalGeneration(entry, generation2, res)) {
           return void 0;
@@ -25281,7 +26531,7 @@ function registerSessionRoutes(app, deps) {
       }
       const metadata = await readLoadableLiveConversationMetadata(
         sessionId,
-        (candidateId) => service.readCreationMetadata(candidateId)
+        service
       );
       if (!metadata) {
         throw new SessionNotFoundError(sessionId);
@@ -25481,6 +26731,15 @@ function registerSessionRoutes(app, deps) {
     }
     const approvalMode = parseOptionalApprovalMode(body, res);
     if (approvalMode === null) return;
+    if (isReservedStandaloneSessionSource({
+      sourceType: typeof body["sourceType"] === "string" ? body["sourceType"] : void 0
+    })) {
+      res.status(400).json({
+        error: "The requested session source is reserved for daemon-owned standalone sessions.",
+        code: "reserved_session_source"
+      });
+      return;
+    }
     const source = parseSessionSource(body["sourceType"], body["sourceId"]);
     if ("error" in source) {
       res.status(400).json({
@@ -26051,24 +27310,54 @@ function registerSessionRoutes(app, deps) {
         throw error2;
       }
     }
+    let restoredStorageSessionId = sessionId;
     try {
+      const guardSessionService = createWorkspaceRuntimeSessionService(runtime);
+      try {
+        await guardSessionService.findSessionIdIgnoringCase(sessionId);
+      } catch (error2) {
+        if (error2 instanceof SessionIdCaseConflictError && await guardSessionService.getSessionLocation(
+          error2.candidateSessionId ?? sessionId
+        ) === "conflict") {
+          throw new SessionConflictError(sessionId);
+        }
+        throw error2;
+      }
       const session = await archiveCoordinator.runSharedMany(
         [sessionId],
         async () => {
+          const sessionService = createWorkspaceRuntimeSessionService(runtime);
+          let persistedSessionId;
+          try {
+            persistedSessionId = await sessionService.findSessionIdIgnoringCase(sessionId);
+          } catch (error2) {
+            if (error2 instanceof SessionIdCaseConflictError && await sessionService.getSessionLocation(
+              error2.candidateSessionId ?? sessionId
+            ) === "conflict") {
+              throw new SessionConflictError(sessionId);
+            }
+            throw error2;
+          }
+          if (persistedSessionId) {
+            restoredStorageSessionId = persistedSessionId;
+          } else if (isInternalWorkspaceRuntime(runtime)) {
+            throw new SessionNotFoundError(sessionId);
+          }
           const location = await assertSessionLoadable(
             workspaceCwd,
-            sessionId,
+            restoredStorageSessionId,
             runtime.sessionRuntimeBaseDir
           );
           if (location === void 0 && isInternalWorkspaceRuntime(runtime)) {
             throw new SessionNotFoundError(sessionId);
           }
-          const sessionService = createWorkspaceRuntimeSessionService(runtime);
           const metadata = runtime.provenance === "live-conversation" ? await readLoadableLiveConversationMetadata(
-            sessionId,
-            (candidateId) => sessionService.readCreationMetadata(candidateId)
-          ) : await sessionService.readCreationMetadata(sessionId);
-          if (metadata === void 0) {
+            restoredStorageSessionId,
+            sessionService
+          ) : await sessionService.readCreationMetadata(
+            restoredStorageSessionId
+          );
+          if (metadata === void 0 || isInternalWorkspaceRuntime(runtime) && isReservedStandaloneSessionSource(metadata)) {
             throw new SessionNotFoundError(sessionId);
           }
           assertRuntimeGenerationOpen?.();
@@ -26160,7 +27449,19 @@ function registerSessionRoutes(app, deps) {
               throw error2;
             }
           }
-          return restored;
+          if (action === "load" && !restored.attached && !restored.hasActivePrompt && runtime.provenance !== "live-conversation") {
+            try {
+              await reconcileDanglingPromptTerminals(
+                sessionService,
+                sessionId
+              );
+            } catch {
+            }
+          }
+          return withPromptTerminals(
+            restored,
+            action === "load" ? readRecentPromptTerminals(sessionService, sessionId) : void 0
+          );
         }
       );
       try {
@@ -26195,7 +27496,7 @@ function registerSessionRoutes(app, deps) {
         const sidecar = await readWorktreeSession(
           createWorkspaceRuntimeSessionService(
             runtime
-          ).getWorktreeSessionPath(sessionId)
+          ).getWorktreeSessionPath(restoredStorageSessionId)
         ).catch(() => null);
         if (sidecar) {
           let realTarget;
@@ -26459,8 +27760,10 @@ function registerSessionRoutes(app, deps) {
           if (!result.attached) {
             const killed = await runtime.bridge.killSession(result.sessionId, { requireZeroAttaches: true }).catch(() => false);
             if (killed) {
-              await createWorkspaceRuntimeSessionService(runtime).removeSession(result.sessionId).catch(() => {
-              });
+              const removed = await createWorkspaceRuntimeSessionService(
+                runtime
+              ).removeSession(result.sessionId).catch(() => false);
+              if (removed) runtime.bridge.markSessionCatalogChanged();
             }
           } else {
             await runtime.bridge.detachClient(result.sessionId, result.clientId).catch(() => {
@@ -26470,11 +27773,12 @@ function registerSessionRoutes(app, deps) {
         }
         if (!res.writable) {
           if (!result.attached) {
-            runtime.bridge.killSession(result.sessionId, { requireZeroAttaches: true }).then((killed) => {
-              if (!killed) return void 0;
-              return createWorkspaceRuntimeSessionService(
+            runtime.bridge.killSession(result.sessionId, { requireZeroAttaches: true }).then(async (killed) => {
+              if (!killed) return;
+              const removed = await createWorkspaceRuntimeSessionService(
                 runtime
               ).removeSession(result.sessionId);
+              if (removed) runtime.bridge.markSessionCatalogChanged();
             }).catch(() => {
             });
           } else {
@@ -27027,6 +28331,42 @@ function registerSessionRoutes(app, deps) {
       }
     )
   );
+  app.post(
+    "/session/:id/goal",
+    mutate({ strict: true }),
+    withOwnerMutableSession(
+      "POST /session/:id/goal",
+      async (req, res, sessionId, runtime) => {
+        const request2 = parseGoalControlRequest(safeBody(req));
+        if (!request2) {
+          res.status(400).json({
+            error: "Invalid Goal control request",
+            code: "invalid_goal_control_request"
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        res.status(200).json(
+          await runtime.bridge.controlSessionGoal(
+            sessionId,
+            request2,
+            clientId === void 0 ? void 0 : { clientId }
+          )
+        );
+      }
+    )
+  );
+  app.get(
+    "/session/:id/goal",
+    withOwnerReadSession(
+      "GET /session/:id/goal",
+      async (_req, res, sessionId, runtime) => {
+        const goal = await runtime.bridge.getSessionGoal(sessionId);
+        res.status(200).json({ snapshot: goal.snapshot });
+      }
+    )
+  );
   app.post(
     "/session/:id/goal/clear",
     mutate({ strict: true }),
@@ -27061,6 +28401,115 @@ function registerSessionRoutes(app, deps) {
       }
     )
   );
+  app.post(
+    "/session/:id/attachments",
+    mutate(),
+    import_express4.default.raw({ type: "*/*", limit: "8mb" }),
+    (error2, _req, res, next) => {
+      if (error2 && typeof error2 === "object" && "status" in error2 && error2.status === 413) {
+        res.status(413).json({ error: "Request body too large (max 8 MiB)" });
+        return;
+      }
+      next(error2);
+    },
+    withOwnerMutableSession(
+      "POST /session/:id/attachments",
+      async (req, res, sessionId, runtime) => {
+        const name = req.query["name"];
+        const contentType = req.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+        if (typeof name !== "string" || !contentType || !Buffer.isBuffer(req.body)) {
+          res.status(400).json({
+            error: "request body, Content-Type, and name query parameter are required"
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        if (req.body.length === 0 && [
+          "image/bmp",
+          "image/gif",
+          "image/jpeg",
+          "image/png",
+          "image/webp"
+        ].includes(contentType)) {
+          res.status(400).json({ error: "Image attachments cannot be empty" });
+          return;
+        }
+        try {
+          const reference = await runtime.bridge.storeSessionAttachment(
+            sessionId,
+            req.body,
+            contentType,
+            clientId !== void 0 ? { clientId } : void 0,
+            name
+          );
+          res.status(201).json(reference);
+        } catch (error2) {
+          if (error2 instanceof RangeError) {
+            res.status(413).json({ error: error2.message });
+            return;
+          }
+          if (error2 instanceof TypeError) {
+            res.status(400).json({ error: error2.message });
+            return;
+          }
+          throw error2;
+        }
+      }
+    )
+  );
+  app.get(
+    "/session/:id/attachments/:attachmentId",
+    withOwnerReadSession(
+      "GET /session/:id/attachments/:attachmentId",
+      async (req, res, sessionId, runtime) => {
+        const attachmentId = req.params["attachmentId"];
+        if (!attachmentId) {
+          res.status(400).json({ error: "`attachmentId` is required" });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const attachment = await runtime.bridge.readSessionAttachment(
+          sessionId,
+          attachmentId,
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        if (!attachment) {
+          res.status(404).json({ error: "session attachment not found" });
+          return;
+        }
+        res.setHeader("Content-Type", attachment.mimeType);
+        res.setHeader("Content-Length", String(attachment.data.byteLength));
+        res.setHeader("Cache-Control", "private, max-age=300");
+        res.setHeader("Content-Disposition", "attachment");
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        res.status(200).send(attachment.data);
+      }
+    )
+  );
+  app.delete(
+    "/session/:id/attachments/:attachmentId",
+    mutate(),
+    withOwnerMutableSession(
+      "DELETE /session/:id/attachments/:attachmentId",
+      async (req, res, sessionId, runtime) => {
+        const attachmentId = req.params["attachmentId"];
+        if (!attachmentId) {
+          res.status(400).json({ error: "`attachmentId` is required" });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const removed = await runtime.bridge.removeSessionAttachment(
+          sessionId,
+          attachmentId,
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(200).json({ removed });
+      }
+    )
+  );
   app.post(
     "/session/:id/prompt",
     mutate(),
@@ -27084,6 +28533,25 @@ function registerSessionRoutes(app, deps) {
           });
           return;
         }
+        const mediaBlockCount = prompt.filter(
+          (item) => item["type"] !== "text"
+        ).length;
+        if (mediaBlockCount > MEDIA_CONTENT_MAX_BLOCKS) {
+          res.status(400).json({
+            error: `\`prompt\` must carry at most ${MEDIA_CONTENT_MAX_BLOCKS} media blocks`
+          });
+          return;
+        }
+        for (const item of prompt) {
+          if (item["type"] !== "image") continue;
+          const parsed = parseMediaContentBlock(item);
+          if (!parsed.valid) {
+            res.status(400).json({
+              error: mediaBlockParseError(parsed.code, "`prompt` image block")
+            });
+            return;
+          }
+        }
         const rawRequestDeadline = body["deadlineMs"];
         let requestDeadlineMs;
         if (rawRequestDeadline !== void 0 && rawRequestDeadline !== null) {
@@ -27638,6 +29106,113 @@ function registerSessionRoutes(app, deps) {
       }
     )
   );
+  app.patch(
+    "/workspaces/:workspace/session/:id/metadata",
+    mutate({ strict: true }),
+    async (req, res) => {
+      const route = "PATCH /workspaces/:workspace/session/:id/metadata";
+      const runtime = requireTrustedRuntimeForWorkspaceRoute(req, res, route);
+      if (!runtime) return;
+      const sessionId = requireSessionId(req, res);
+      if (sessionId === null) return;
+      const clientId = parseClientIdHeader(req, res);
+      if (clientId === null) return;
+      const rawDisplayName = safeBody(req)["displayName"];
+      if (typeof rawDisplayName !== "string") {
+        res.status(400).json({
+          error: "`displayName` must be a string",
+          code: "invalid_metadata",
+          field: "displayName"
+        });
+        return;
+      }
+      try {
+        const displayName = rawDisplayName.slice(0, 256);
+        if (displayName.trim() === "") {
+          throw new InvalidSessionMetadataError(
+            "displayName",
+            "must not be empty"
+          );
+        }
+        if (Array.from(displayName).some((character) => {
+          const code = character.charCodeAt(0);
+          return code <= 31 || code === 127;
+        })) {
+          throw new InvalidSessionMetadataError(
+            "displayName",
+            "must not contain control characters"
+          );
+        }
+        await archiveCoordinator.runExclusiveMany([sessionId], async () => {
+          const assertRuntimeGenerationOpen = captureRuntimeGenerationAssertion(runtime);
+          assertRuntimeGenerationOpen?.();
+          const liveOwner = workspaceRegistry.resolveLiveSessionOwner(sessionId);
+          if (liveOwner.kind === "unavailable") {
+            sendWorkspaceRuntimeUnavailable(res);
+            return;
+          }
+          if (liveOwner.kind === "ambiguous") {
+            sendAmbiguousSessionOwner(
+              res,
+              route,
+              sessionId,
+              liveOwner.runtimes
+            );
+            return;
+          }
+          if (liveOwner.kind === "found" && liveOwner.runtime.workspaceCwd !== runtime.workspaceCwd) {
+            sendSessionWorkspaceConflict(
+              res,
+              route,
+              sessionId,
+              runtime,
+              liveOwner.runtime
+            );
+            return;
+          }
+          await runWithWorkspaceRuntimeStorage(runtime, async () => {
+            let effective;
+            try {
+              effective = runtime.bridge.updateSessionMetadata(
+                sessionId,
+                { displayName },
+                clientId !== void 0 ? { clientId } : void 0
+              );
+              assertRuntimeGenerationOpen?.();
+            } catch (err) {
+              if (!(err instanceof SessionNotFoundError)) throw err;
+              const service = createWorkspaceRuntimeSessionService(runtime);
+              const location = await service.getSessionLocation(sessionId);
+              assertRuntimeGenerationOpen?.();
+              if (location === "conflict") {
+                throw new SessionConflictError(sessionId);
+              }
+              const renamed = location ? await service.renameSession(
+                sessionId,
+                displayName,
+                "manual",
+                location
+              ) : false;
+              assertRuntimeGenerationOpen?.();
+              if (!renamed) {
+                throw new SessionNotFoundError(sessionId);
+              }
+              runtime.bridge.markSessionCatalogChanged();
+              effective = { displayName: displayName || void 0 };
+            }
+            invalidateSessionLists(runtime, ["active", "archived"]);
+            res.status(200).json({ sessionId, ...effective });
+          });
+        });
+      } catch (err) {
+        sendBridgeError2(res, err, {
+          route,
+          sessionId,
+          workspaceCwd: runtime.workspaceCwd
+        });
+      }
+    }
+  );
   const handleSessionOrganizationUpdate = /* @__PURE__ */ __name(async (req, res, target) => {
     const sessionId = requireSessionId(req, res);
     if (sessionId === null) return;
@@ -27705,6 +29280,10 @@ function registerSessionRoutes(app, deps) {
               ...rawGroupId !== void 0 ? { groupId: rawGroupId } : {},
               ...rawColor !== void 0 ? { color: rawColor } : {}
             });
+            invalidateSessionListsAndMarkCatalog(runtime, [
+              "active",
+              "archived"
+            ]);
             res.status(200).json({ sessionId, ...organization });
           });
         })()
@@ -27767,6 +29346,7 @@ function registerSessionRoutes(app, deps) {
           color: body["color"]
         })
       );
+      invalidateSessionListsAndMarkCatalog(runtime, ["active", "archived"]);
       res.status(201).json({ group });
     } catch (err) {
       if (sendSessionOrganizationError(res, err)) return;
@@ -27794,6 +29374,7 @@ function registerSessionRoutes(app, deps) {
             }
           )
         );
+        invalidateSessionListsAndMarkCatalog(runtime, ["active", "archived"]);
         res.status(200).json({ group });
       } catch (err) {
         if (sendSessionOrganizationError(res, err)) return;
@@ -27816,6 +29397,9 @@ function registerSessionRoutes(app, deps) {
             req.params["groupId"] ?? ""
           )
         );
+        if (deleted) {
+          invalidateSessionListsAndMarkCatalog(runtime, ["active", "archived"]);
+        }
         res.status(200).json({ deleted });
       } catch (err) {
         if (sendSessionOrganizationError(res, err)) return;
@@ -27856,6 +29440,7 @@ function registerSessionRoutes(app, deps) {
             color: body["color"]
           })
         );
+        invalidateSessionListsAndMarkCatalog(runtime, ["active", "archived"]);
         res.status(201).json({ group });
       } catch (err) {
         if (sendSessionOrganizationError(res, err)) return;
@@ -27883,6 +29468,7 @@ function registerSessionRoutes(app, deps) {
             }
           )
         );
+        invalidateSessionListsAndMarkCatalog(runtime, ["active", "archived"]);
         res.status(200).json({ group });
       } catch (err) {
         if (sendSessionOrganizationError(res, err)) return;
@@ -27904,6 +29490,9 @@ function registerSessionRoutes(app, deps) {
             req.params["groupId"] ?? ""
           )
         );
+        if (deleted) {
+          invalidateSessionListsAndMarkCatalog(runtime, ["active", "archived"]);
+        }
         res.status(200).json({ deleted });
       } catch (err) {
         if (sendSessionOrganizationError(res, err)) return;
@@ -28089,6 +29678,39 @@ function registerSessionRoutes(app, deps) {
     "/workspaces/:workspace/sessions",
     listWorkspaceSessionsHandler("workspace")
   );
+  const lastExposedCatalogVersions = /* @__PURE__ */ new WeakMap();
+  app.get("/workspaces/:workspace/sessions/live-state", async (req, res) => {
+    const route = "GET /workspaces/:workspace/sessions/live-state";
+    const runtime = requireTrustedRuntimeForWorkspaceRoute(req, res, route);
+    if (runtime === null) return;
+    const assertRuntimeOpen = captureRuntimeGenerationAssertion(runtime);
+    const bridge = runtime.bridge;
+    try {
+      assertRuntimeOpen?.();
+      const catalogVersion = bridge.getSessionCatalogVersion();
+      const lastExposed = lastExposedCatalogVersions.get(bridge);
+      if (lastExposed === void 0 || lastExposed.generation !== catalogVersion.generation || lastExposed.revision !== catalogVersion.revision) {
+        invalidateSessionLists(runtime, ["active", "archived"]);
+      }
+      const sessions = bridge.listWorkspaceSessions(runtime.workspaceCwd).map((session) => ({
+        sessionId: session.sessionId,
+        clientCount: session.clientCount,
+        hasActivePrompt: session.hasActivePrompt,
+        isWaitingForPermission: session.isWaitingForPermission ?? false,
+        isWaitingForUserQuestion: session.isWaitingForUserQuestion ?? false,
+        // Bridge-local activity watermark, absent until a running prompt in
+        // this bridge publishes its first terminal. Reading it costs nothing
+        // extra: the summary is already in memory.
+        ...session.updatedAt !== void 0 ? { updatedAt: session.updatedAt } : {}
+      }));
+      assertRuntimeOpen?.();
+      lastExposedCatalogVersions.set(bridge, catalogVersion);
+      res.setHeader("Cache-Control", "no-store");
+      res.status(200).json({ v: 1, catalogVersion, sessions });
+    } catch (err) {
+      sendBridgeError2(res, err, { route });
+    }
+  });
   const workspaceSessionInfoHandler = /* @__PURE__ */ __name((paramName) => async (req, res) => {
     const route = paramName === "workspace" ? "GET /workspaces/:workspace/session-info" : "GET /workspace/:id/session-info";
     const runtime = resolveRuntimeForCatalogRoute(req, res, paramName, route);
@@ -28257,9 +29879,36 @@ function registerSessionRoutes(app, deps) {
         const message = body["message"];
         const messageId = body["messageId"];
         const trimmed = typeof message === "string" ? message.trim() : "";
-        if (trimmed.length === 0) {
+        const rawContent = body["content"];
+        let mediaBlocks;
+        if (rawContent !== void 0) {
+          if (!Array.isArray(rawContent) || rawContent.length === 0) {
+            res.status(400).json({
+              error: "`content` must be a non-empty array of media blocks"
+            });
+            return;
+          }
+          if (rawContent.length > MEDIA_CONTENT_MAX_BLOCKS) {
+            res.status(400).json({
+              error: `\`content\` must carry at most ${MEDIA_CONTENT_MAX_BLOCKS} media blocks`
+            });
+            return;
+          }
+          mediaBlocks = [];
+          for (const block of rawContent) {
+            const parsed = parseMediaContentBlock(block);
+            if (!parsed.valid) {
+              res.status(400).json({
+                error: mediaBlockParseError(parsed.code, "`content` entry")
+              });
+              return;
+            }
+            mediaBlocks.push(parsed.block);
+          }
+        }
+        if (trimmed.length === 0 && mediaBlocks === void 0) {
           res.status(400).json({
-            error: "`message` is required and must be a non-empty string"
+            error: "`message` must be a non-empty string, or `content` must carry at least one media block"
           });
           return;
         }
@@ -28281,7 +29930,11 @@ function registerSessionRoutes(app, deps) {
           sessionId,
           trimmed,
           clientId !== void 0 ? { clientId } : void 0,
-          typeof messageId === "string" ? messageId : void 0
+          typeof messageId === "string" ? messageId : void 0,
+          {
+            rejectIfIdle: true,
+            ...mediaBlocks ? { content: mediaBlocks } : {}
+          }
         );
         res.status(200).json(result);
       }
@@ -28373,6 +30026,73 @@ function registerSessionRoutes(app, deps) {
       }
     )
   );
+  app.get("/session/:id/turns/current", (req, res) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    const runtime = resolveLiveSessionRuntime(
+      sessionId,
+      res,
+      "GET /session/:id/turns/current"
+    );
+    if (!runtime) return;
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    void (async () => {
+      try {
+        const status = await runtime.bridge.getSessionTurnStatus(
+          sessionId,
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(200).json(status);
+      } catch (err) {
+        sendBridgeError2(res, err, {
+          route: "GET /session/:id/turns/current",
+          sessionId
+        });
+      }
+    })();
+  });
+  app.get("/session/:id/turns/:promptId", (req, res) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    const runtime = resolveLiveSessionRuntime(
+      sessionId,
+      res,
+      "GET /session/:id/turns/:promptId"
+    );
+    if (!runtime) return;
+    const promptId = req.params["promptId"];
+    if (!promptId) {
+      res.status(400).json({ error: "`promptId` route parameter is required" });
+      return;
+    }
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    void (async () => {
+      try {
+        const status = await runtime.bridge.getSessionTurnStatus(
+          sessionId,
+          clientId !== void 0 ? { clientId } : void 0,
+          promptId
+        );
+        if (!status) {
+          res.status(404).json({
+            error: `Prompt ${promptId} not found in session ${sessionId}`,
+            code: "prompt_not_found",
+            sessionId,
+            promptId
+          });
+          return;
+        }
+        res.status(200).json(status);
+      } catch (err) {
+        sendBridgeError2(res, err, {
+          route: "GET /session/:id/turns/:promptId",
+          sessionId
+        });
+      }
+    })();
+  });
   app.post(
     "/session/:id/shell",
     mutate({ strict: true }),
@@ -28634,10 +30354,10 @@ async function teardownBoundSession(target, sessionId) {
   } else if (target.bridge) {
     await target.bridge.closeSession(sessionId).catch(() => {
     });
-    await new SessionService(target.workspaceCwd, {
+    const removed = await new SessionService(target.workspaceCwd, {
       runtimeBaseDir: target.runtimeBaseDir
-    }).removeSession(sessionId).catch(() => {
-    });
+    }).removeSession(sessionId).catch(() => false);
+    if (removed) target.bridge.markSessionCatalogChanged?.();
   }
 }
 __name(teardownBoundSession, "teardownBoundSession");
@@ -29523,7 +31243,7 @@ __name(parseNameField, "parseNameField");
 
 // packages/cli/src/serve/routes/channel-notify.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 function sendDeliveryError(res, error2) {
   if (!isChannelDeliveryError(error2)) {
     res.status(502).json({
@@ -29544,7 +31264,7 @@ function parseNotifyBody(body) {
     );
   }
   return normalizeChannelDelivery(
-    randomUUID6(),
+    randomUUID7(),
     parseChannelDelivery(body["delivery"]),
     body["text"]
   );
@@ -29649,15 +31369,17 @@ function registerGoalsRoutes(app, deps) {
           continue;
         }
         const { session, goal } = outcome.value;
-        if (!goal.active) continue;
+        const record = goal.snapshot.goal;
+        if (!record || record.status === "complete") continue;
         goals.push({
           sessionId: session.sessionId,
           displayName: session.displayName ?? null,
-          condition: goal.active.condition,
-          iterations: goal.active.iterations,
-          setAt: goal.active.setAt,
-          ...goal.active.lastReason !== void 0 ? { lastReason: goal.active.lastReason } : {},
-          hasActivePrompt: session.hasActivePrompt
+          condition: record.objective,
+          iterations: record.turnCount,
+          setAt: record.createdAt,
+          ...record.lastReason !== void 0 ? { lastReason: record.lastReason } : {},
+          hasActivePrompt: session.hasActivePrompt,
+          snapshot: goal.snapshot
         });
       }
       if (dropped.length > 0) {
@@ -29863,9 +31585,10 @@ function startScheduledTaskKeepalive(opts) {
   const spawnTimeoutMs = opts.spawnTimeoutMs ?? KEEPALIVE_SPAWN_TIMEOUT_MS;
   const cleanupSession = opts.cleanupSession ?? (async (sessionId) => {
     await bridge.closeSession(sessionId);
-    await new SessionService(boundWorkspace, {
+    const removed = await new SessionService(boundWorkspace, {
       runtimeBaseDir: opts.runtimeBaseDir
     }).removeSession(sessionId);
+    if (removed) bridge.markSessionCatalogChanged?.();
   });
   const reviveState = /* @__PURE__ */ new Map();
   const reviving = /* @__PURE__ */ new Set();
@@ -31443,8 +33166,8 @@ __name(registerWorkspaceQualifiedSettingsRoutes, "registerWorkspaceQualifiedSett
 
 // packages/cli/src/serve/routes/sse-events.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID7 } from "node:crypto";
-import { performance as performance2 } from "node:perf_hooks";
+import { randomUUID as randomUUID8 } from "node:crypto";
+import { performance as performance3 } from "node:perf_hooks";
 
 // packages/cli/src/serve/server/error-response.ts
 init_esbuild_shims();
@@ -31561,6 +33284,10 @@ function sendBridgeError(res, err, ctx, daemonLog) {
     return;
   }
   if (sendGenerationClosedError(res, err)) return;
+  if (err instanceof Error && "code" in err && (err.code === "session_attachment_gone" || err.code === "invalid_session_attachment_reference")) {
+    res.status(err.code === "session_attachment_gone" ? 410 : 400).json({ error: err.message, code: err.code });
+    return;
+  }
   if (err instanceof SessionWriterError) {
     res.status(err.httpStatus).json({
       error: err.message,
@@ -31725,6 +33452,14 @@ function sendBridgeError(res, err, ctx, daemonLog) {
     });
     return;
   }
+  if (err instanceof SessionIdCaseConflictError) {
+    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({
@@ -31886,6 +33621,22 @@ function sendBridgeError(res, err, ctx, daemonLog) {
         });
         return;
       }
+      if (kind === "untrusted_workspace") {
+        res.status(403).json({
+          error: errorMessage2(err),
+          code: kind
+        });
+        return;
+      }
+      if (kind === "goal_conflict" || kind === "goal_invalid_transition" || kind === "goal_persist_failed") {
+        const d = data;
+        res.status(kind === "goal_persist_failed" ? 500 : 409).json({
+          error: errorMessage2(err),
+          code: kind,
+          ...d.current !== void 0 ? { current: d.current } : {}
+        });
+        return;
+      }
       if (kind === "branch_point_invalid") {
         res.status(409).json({
           error: errorMessage2(err),
@@ -32132,7 +33883,7 @@ function registerSseEventsRoutes(app, deps) {
   app.get("/session/:id/events", async (req, res) => {
     const sessionId = req.params["id"];
     const diagnosticSessionId = boundedDiagnosticString(sessionId);
-    const streamId = randomUUID7();
+    const streamId = randomUUID8();
     const clientId = parseSseClientId(req.headers["x-qwen-client-id"]);
     const connectReason = parseSseConnectReason(req.query["connectReason"]);
     const previousStreamId = parsePreviousSseStreamId(
@@ -32325,7 +34076,7 @@ function registerSseEventsRoutes(app, deps) {
       });
       return;
     }
-    const openedAt = performance2.now();
+    const openedAt = performance3.now();
     let closeReason;
     let terminalCandidate;
     let terminalEventType;
@@ -32344,10 +34095,10 @@ function registerSseEventsRoutes(app, deps) {
       if (activeDrainStartedAt !== void 0) {
         maxDrainWaitMs = Math.max(
           maxDrainWaitMs,
-          performance2.now() - activeDrainStartedAt
+          performance3.now() - activeDrainStartedAt
         );
       }
-      const durationMs = Math.max(0, performance2.now() - openedAt);
+      const durationMs = Math.max(0, performance3.now() - openedAt);
       const resolvedCloseReason = closeReason ?? terminalCandidate ?? "client_disconnect";
       const closeAttributes = {
         "qwen-code.daemon.sse.duration_ms": durationMs,
@@ -32456,7 +34207,7 @@ function registerSseEventsRoutes(app, deps) {
       if (activeDrainStartedAt === void 0) return;
       maxDrainWaitMs = Math.max(
         maxDrainWaitMs,
-        performance2.now() - activeDrainStartedAt
+        performance3.now() - activeDrainStartedAt
       );
       activeDrainStartedAt = void 0;
     }, "settleDrainMeasurement");
@@ -32479,7 +34230,7 @@ function registerSseEventsRoutes(app, deps) {
         return;
       }
       backpressureCount += 1;
-      activeDrainStartedAt = performance2.now();
+      activeDrainStartedAt = performance3.now();
       const onDrain = /* @__PURE__ */ __name(() => {
         res.off("close", onClose);
         res.off("error", onError);
@@ -33154,6 +34905,19 @@ __name(registerA2uiActionRoutes, "registerA2uiActionRoutes");
 init_esbuild_shims();
 import * as path15 from "node:path";
 var IDE_WORKSPACE_PATH_ENV_VAR = "QWEN_CODE_IDE_WORKSPACE_PATH";
+var NEW_FILE_MODE_ENV_VAR = "QWEN_SERVE_NEW_FILE_MODE";
+function parseNewFileModePolicy(env = process.env) {
+  const raw = env[NEW_FILE_MODE_ENV_VAR];
+  if (raw === void 0 || raw.trim() === "") return "owner";
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "system") return "system";
+  if (normalized === "owner" || normalized === "0600") return "owner";
+  writeStderrLine(
+    `qwen serve: ignoring invalid ${NEW_FILE_MODE_ENV_VAR}=${raw} (expected 'system' or 'owner'); new files keep the 0600 default`
+  );
+  return "owner";
+}
+__name(parseNewFileModePolicy, "parseNewFileModePolicy");
 function createDefaultFsAuditEmit() {
   const WARN_EVERY = 100;
   let droppedCount = 0;
@@ -33181,6 +34945,7 @@ function resolveBridgeFsFactory(input) {
     emit: input.emit ?? createDefaultFsAuditEmit(),
     pathLocks: input.pathLocks,
     generationGuard: input.generationGuard,
+    newFileMode: input.newFileMode ?? parseNewFileModePolicy(),
     ...input.customIgnoreFiles !== void 0 ? { customIgnoreFiles: input.customIgnoreFiles } : {}
   });
 }
@@ -33503,9 +35268,16 @@ __name(setupDeviceFlowRegistry, "setupDeviceFlowRegistry");
 
 // packages/cli/src/serve/server/error-handlers.ts
 init_esbuild_shims();
-var import_express4 = __toESM(require_express(), 1);
+var import_express5 = __toESM(require_express(), 1);
 function installJsonBodyParser(app) {
-  app.use(import_express4.default.json({ limit: "10mb" }));
+  const parseJson = import_express5.default.json({ limit: "10mb" });
+  app.use((req, res, next) => {
+    if (req.method === "POST" && /^\/session\/[^/]+\/attachments\/?$/i.test(req.path)) {
+      next();
+      return;
+    }
+    parseJson(req, res, next);
+  });
   app.use((err, _req, res, next) => {
     if (sendJsonBodyParserError(res, err)) return;
     next(err);
@@ -38355,8 +40127,8 @@ __name(registerWorkspaceQualifiedSkillsRoutes, "registerWorkspaceQualifiedSkills
 
 // packages/cli/src/serve/routes/channel-webhooks.ts
 init_esbuild_shims();
-var import_express5 = __toESM(require_express(), 1);
-import { createHash as createHash4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+var import_express6 = __toESM(require_express(), 1);
+import { createHash as createHash3, timingSafeEqual } from "node:crypto";
 var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
   "__proto__",
   "constructor",
@@ -38404,7 +40176,7 @@ function registerChannelWebhookRoutes(app, deps) {
       locals.channelWebhook = { channelName, source, sourceConfig };
       next();
     },
-    import_express5.default.json({ limit: "1mb" }),
+    import_express6.default.json({ limit: "1mb" }),
     async (req, res) => {
       const locals = res.locals;
       const webhook = locals.channelWebhook;
@@ -38518,9 +40290,9 @@ function matchesWebhookSecret(candidate, expected) {
   if (typeof candidate !== "string") {
     return false;
   }
-  const expectedDigest = createHash4("sha256").update(expected).digest();
-  const candidateDigest = createHash4("sha256").update(candidate).digest();
-  return timingSafeEqual2(expectedDigest, candidateDigest);
+  const expectedDigest = createHash3("sha256").update(expected).digest();
+  const candidateDigest = createHash3("sha256").update(candidate).digest();
+  return timingSafeEqual(expectedDigest, candidateDigest);
 }
 __name(matchesWebhookSecret, "matchesWebhookSecret");
 function readPayload(body, res) {
@@ -38599,7 +40371,7 @@ init_esbuild_shims();
 
 // packages/cli/src/serve/live/live-host-coordinator.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID8, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
+import { randomUUID as randomUUID9, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 var DEFAULT_HELLO_TIMEOUT_MS = 5e3;
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 5e3;
 var DEFAULT_HEARTBEAT_TIMEOUT_MS = 15e3;
@@ -38776,7 +40548,7 @@ __name(projectStatusForHost, "projectStatusForHost");
 var LiveHostCoordinator = class {
   constructor(options) {
     this.options = options;
-    this.daemonInstanceNonce = options.daemonInstanceNonce ?? randomUUID8();
+    this.daemonInstanceNonce = options.daemonInstanceNonce ?? randomUUID9();
     this.handlers = options.handlers ?? {};
     this.now = options.now ?? Date.now;
     this.helloTimeoutMs = options.helloTimeoutMs ?? DEFAULT_HELLO_TIMEOUT_MS;
@@ -38845,7 +40617,7 @@ var LiveHostCoordinator = class {
   attachHost(socket, daemonNonce) {
     const expectedNonce = Buffer.from(this.daemonInstanceNonce);
     const presentedNonce = Buffer.from(daemonNonce ?? "");
-    if (expectedNonce.byteLength !== presentedNonce.byteLength || !timingSafeEqual3(expectedNonce, presentedNonce)) {
+    if (expectedNonce.byteLength !== presentedNonce.byteLength || !timingSafeEqual2(expectedNonce, presentedNonce)) {
       socket.close(4003, "Invalid daemon instance nonce.");
       return;
     }
@@ -38968,7 +40740,7 @@ var LiveHostCoordinator = class {
   startCall(mode) {
     const call = {
       epoch: ++this.nextEpoch,
-      callId: randomUUID8(),
+      callId: randomUUID9(),
       mode,
       state: "starting",
       pendingPermission: false,
@@ -39027,7 +40799,7 @@ var LiveHostCoordinator = class {
         new Error("Qwen Live Host must be connected to change the shortcut.")
       );
     }
-    const requestId = randomUUID8();
+    const requestId = randomUUID9();
     return new Promise((resolve7, reject) => {
       const timer = setTimeout(() => {
         this.rejectPendingShortcut(
@@ -39117,7 +40889,7 @@ var LiveHostCoordinator = class {
         )
       );
     }
-    const requestId = randomUUID8();
+    const requestId = randomUUID9();
     return new Promise((resolve7, reject) => {
       const timer = setTimeout(() => {
         this.pendingAppshots.delete(requestId);
@@ -39457,7 +41229,7 @@ var LiveHostCoordinator = class {
       this.disconnectHost(lease, 4008, "Live Host heartbeat timed out.");
       return;
     }
-    const pingId = randomUUID8();
+    const pingId = randomUUID9();
     lease.pingId = pingId;
     this.sendHost({ type: "host.ping", pingId });
   }
@@ -39725,7 +41497,7 @@ init_esbuild_shims();
 
 // packages/cli/src/serve/live/live-setup-controller.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 
 // packages/cli/src/serve/live/provider-credentials.ts
 init_esbuild_shims();
@@ -39823,7 +41595,7 @@ __name(resolveLiveProviderCredential, "resolveLiveProviderCredential");
 
 // packages/cli/src/serve/live/qwen-realtime-session.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 var QWEN_REALTIME_LIMITS = {
   maxInputAudioFrameBytes: 64 * 1024,
   maxOutputAudioFrameBytes: 256 * 1024,
@@ -40238,7 +42010,7 @@ function openQwenRealtimeSession(config, callbacks = {}, deps = {}) {
     const sendJson = /* @__PURE__ */ __name((body) => {
       if (terminal || closedByClient || ws.readyState !== ws.OPEN) return false;
       try {
-        ws.send(JSON.stringify({ event_id: randomUUID9(), ...body }));
+        ws.send(JSON.stringify({ event_id: randomUUID10(), ...body }));
         return true;
       } catch (error2) {
         fail(
@@ -41601,7 +43373,7 @@ async function validateCredential(credential) {
     apiKey: credential.apiKey,
     model: credential.realtimeModel,
     voice: credential.voice,
-    callEpoch: `setup-${randomUUID10()}`
+    callEpoch: `setup-${randomUUID11()}`
   });
   session.close({ discardPendingInput: true });
 }
@@ -41908,7 +43680,7 @@ __name(registerLiveSetupRoutes, "registerLiveSetupRoutes");
 // packages/cli/src/serve/live/live-host-installer.ts
 init_esbuild_shims();
 import { execFile as execFile3 } from "node:child_process";
-import { createHash as createHash5, randomUUID as randomUUID11 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID12 } from "node:crypto";
 import * as fs7 from "node:fs";
 import * as fsp5 from "node:fs/promises";
 import * as os2 from "node:os";
@@ -42083,7 +43855,7 @@ async function downloadAsset(asset, url, destination, onProgress, fetchImpl) {
     });
     throw new Error("Live Host download size does not match its manifest.");
   }
-  const hash = createHash5("sha256");
+  const hash = createHash4("sha256");
   let received = 0;
   const guard = new Transform({
     transform(chunk, _encoding, callback) {
@@ -42139,8 +43911,8 @@ async function installLatestHost(currentArchitecture, onStatus) {
   const archivePath = path16.join(temporaryDirectory, "Qwen-Live-Host.zip");
   const extractedPath = path16.join(temporaryDirectory, "extracted");
   const candidatePath = path16.join(extractedPath, LIVE_HOST_APP_NAME);
-  const stagingPath = `/Applications/.Qwen Live Host.install-${randomUUID11()}.app`;
-  const backupPath = `/Applications/.Qwen Live Host.backup-${randomUUID11()}.app`;
+  const stagingPath = `/Applications/.Qwen Live Host.install-${randomUUID12()}.app`;
+  const backupPath = `/Applications/.Qwen Live Host.backup-${randomUUID12()}.app`;
   let movedExisting = false;
   let installedCandidate = false;
   try {
@@ -42288,7 +44060,7 @@ var LiveHostInstaller = class {
 
 // packages/cli/src/serve/live/live-session-coordinator.ts
 init_esbuild_shims();
-import { createHash as createHash6, randomUUID as randomUUID12 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID13 } from "node:crypto";
 import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync2 } from "node:fs";
 import { join as join12 } from "node:path";
 
@@ -42663,7 +44435,7 @@ function openLiveAudioCapture(source, identifier) {
     );
     const stream = createWriteStream2(path19, { flags: "wx", mode: 384 });
     stream.on("error", () => void 0);
-    return { source, path: path19, stream, hash: createHash6("sha256"), bytes: 0 };
+    return { source, path: path19, stream, hash: createHash5("sha256"), bytes: 0 };
   } catch {
     return void 0;
   }
@@ -43018,7 +44790,7 @@ var LiveSessionCoordinator = class {
         context.speechInProgress = true;
         context.inputCommitPending = true;
         context.inputAwaitingResponse = false;
-        const partialItemId = itemId ?? `partial:${randomUUID12()}`;
+        const partialItemId = itemId ?? `partial:${randomUUID13()}`;
         context.activePartialInputItemId = partialItemId;
         if (!context.partialInputTranscripts.has(partialItemId)) {
           context.partialInputTranscripts.set(partialItemId, "");
@@ -43048,7 +44820,7 @@ var LiveSessionCoordinator = class {
       }, "onInputCommitted"),
       onInputTranscriptDelta: /* @__PURE__ */ __name(({ itemId, text }) => {
         if (this.isCurrentSocket(context, generation)) {
-          const partialItemId = itemId ?? context.activePartialInputItemId ?? `partial:${randomUUID12()}`;
+          const partialItemId = itemId ?? context.activePartialInputItemId ?? `partial:${randomUUID13()}`;
           context.activePartialInputItemId = partialItemId;
           context.partialInputTranscripts.set(partialItemId, text);
           this.options.host.setTranscript?.(context.epoch, text);
@@ -43058,7 +44830,7 @@ var LiveSessionCoordinator = class {
         if (this.isCurrentSocket(context, generation)) {
           context.speechInProgress = false;
           context.inputCommitPending = false;
-          const completedItemId = itemId ?? context.activePartialInputItemId ?? `unattributed:${randomUUID12()}`;
+          const completedItemId = itemId ?? context.activePartialInputItemId ?? `unattributed:${randomUUID13()}`;
           context.partialInputTranscripts.delete(completedItemId);
           if (context.activePartialInputItemId === completedItemId) {
             context.activePartialInputItemId = void 0;
@@ -43774,9 +45546,10 @@ var LiveSessionCoordinator = class {
     if (!sessionClosed) return;
     if (removeFreshTranscript) {
       try {
-        await new SessionService(runtime.workspaceCwd).removeSession(
-          session.sessionId
-        );
+        const transcriptRemoved = await new SessionService(
+          runtime.workspaceCwd
+        ).removeSession(session.sessionId);
+        if (transcriptRemoved) bridge.markSessionCatalogChanged();
       } catch {
       }
     }
@@ -43789,7 +45562,7 @@ var LiveSessionCoordinator = class {
     const runtime = context.runtime;
     if (!runtime) throw new Error("Conversation workspace is unavailable.");
     const bridge = runtime.bridge;
-    const promptId = randomUUID12();
+    const promptId = randomUUID13();
     const lastEventId = bridge.getSessionLastEventId(locator.sessionId);
     const turnAbort = new AbortController();
     this.inFlightTurnAborts.add(turnAbort);
@@ -44106,7 +45879,7 @@ var LiveSessionCoordinator = class {
 
 // packages/cli/src/serve/live/live-task-service.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 var DEFAULT_LIST_LIMIT = 20;
 var DEFAULT_READ_TURN_LIMIT = 3;
 var DEFAULT_WAIT_TIMEOUT_MS = 12e4;
@@ -44538,7 +46311,10 @@ var LiveTaskService = class {
         cwd: located.summary.workspaceCwd,
         createdAt: epochSeconds(located.summary.createdAt),
         updatedAt: epochSeconds(
-          located.summary.updatedAt ?? located.persisted?.conversation.lastUpdated
+          laterActivityTimestamp(
+            located.summary.updatedAt,
+            located.persisted?.conversation.lastUpdated
+          )
         )
       },
       page: {
@@ -44677,7 +46453,10 @@ var LiveTaskService = class {
         ),
         eventId: task.runtime.bridge.getSessionLastEventId(target.threadId)
       } : {},
-      updatedAt: task.summary.updatedAt ?? task.persisted?.conversation.lastUpdated
+      updatedAt: laterActivityTimestamp(
+        task.summary.updatedAt,
+        task.persisted?.conversation.lastUpdated
+      )
     });
     const { reset: cursorReset } = decodeCursor(
       target.afterCursor,
@@ -44691,7 +46470,10 @@ var LiveTaskService = class {
     const completedAt = latestTurnRecords.at(-1)?.timestamp ?? task.persisted?.conversation.lastUpdated;
     const failed = task.summary.hasTurnError === true;
     const revision = task.summary.clientCount > 0 ? task.runtime.bridge.getSessionLastEventId(target.threadId) : epochSeconds(
-      task.summary.updatedAt ?? task.persisted?.conversation.lastUpdated ?? task.summary.createdAt
+      laterActivityTimestamp(
+        task.summary.updatedAt,
+        task.persisted?.conversation.lastUpdated
+      ) ?? task.summary.createdAt
     );
     return {
       schemaVersion: 1,
@@ -44823,7 +46605,7 @@ var LiveTaskService = class {
       { sessionId, prompt: [{ type: "text", text: prompt }] },
       void 0,
       {
-        promptId: randomUUID13(),
+        promptId: randomUUID14(),
         onPromptAdmitted: /* @__PURE__ */ __name(() => {
           admitted = true;
           onAdmitted?.();
@@ -44843,7 +46625,7 @@ var LiveTaskService = class {
     const service = createWorkspaceRuntimeSessionService(task.runtime);
     const metadata = task.runtime.provenance === "live-conversation" ? await readLoadableLiveConversationMetadata(
       task.summary.sessionId,
-      (sessionId) => service.readCreationMetadata(sessionId)
+      service
     ) : await service.readCreationMetadata(task.summary.sessionId);
     if (metadata === void 0) {
       throw new SessionNotFoundError(task.summary.sessionId);
@@ -44889,10 +46671,11 @@ var LiveTaskService = class {
       removed = false;
     }
     if (removed) {
-      await runWithWorkspaceRuntimeStorage(
+      const persistedRemoved = await runWithWorkspaceRuntimeStorage(
         runtime,
-        () => createWorkspaceRuntimeSessionService(runtime).removeSession(session.sessionId).catch(() => void 0)
+        () => createWorkspaceRuntimeSessionService(runtime).removeSession(session.sessionId).catch(() => false)
       );
+      if (persistedRemoved) runtime.bridge.markSessionCatalogChanged();
     }
     if (projectless && removed) {
       await this.options.discardEmptyConversationDirectory(session.sessionId).catch(() => void 0);
@@ -45078,7 +46861,7 @@ var ConversationRuntimeManager = class {
 
 // packages/cli/src/serve/conversations/conversation-runtime-ownership.ts
 init_esbuild_shims();
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import { constants as fsConstants2 } from "node:fs";
 import * as fs8 from "node:fs/promises";
 import * as path17 from "node:path";
@@ -45214,16 +46997,20 @@ async function readOwnerRecord(ownerPath) {
       process.platform === "win32" ? fsConstants2.O_RDONLY : fsConstants2.O_RDONLY | fsConstants2.O_NOFOLLOW
     );
   } catch (error2) {
-    throw new UnsafeOwnershipStateError(void 0, { cause: error2 });
+    if (error2.code === "ELOOP") {
+      throw new UnsafeOwnershipStateError(void 0, { cause: error2 });
+    }
+    throw error2;
   }
   try {
     const handleStat = await handle.stat();
     if (!handleStat.isFile() || handleStat.nlink !== 1 || handleStat.dev !== pathStat.dev || handleStat.ino !== pathStat.ino || handleStat.size !== pathStat.size || process.platform !== "win32" && ((handleStat.mode & 511) !== 384 || typeof process.getuid === "function" && handleStat.uid !== process.getuid())) {
       throw new UnsafeOwnershipStateError();
     }
+    const serialized = await handle.readFile("utf8");
     let parsed;
     try {
-      parsed = JSON.parse(await handle.readFile("utf8"));
+      parsed = JSON.parse(serialized);
     } catch (error2) {
       throw new UnsafeOwnershipStateError(void 0, { cause: error2 });
     }
@@ -45349,7 +47136,7 @@ var FileConversationRuntimeOwnership = class {
           await this.commitRecord(identity, void 0);
         }
       }, "commitOwner");
-      const liveDiscovery = await import("./discovery-ORA5J7YP.js");
+      const liveDiscovery = await import("./discovery-X2NV535U.js");
       const handoff = await liveDiscovery.handoffLiveDiscoveryOwner(
         this.stableBaseDir,
         this.current,
@@ -45466,7 +47253,7 @@ var FileConversationRuntimeOwnership = class {
   async commitRecord(identity, expected) {
     const temporaryPath = path17.join(
       this.ownerDirectory,
-      `.runtime-owner.${this.current.pid}.${randomUUID14()}.tmp`
+      `.runtime-owner.${this.current.pid}.${randomUUID15()}.tmp`
     );
     let handle;
     let renamed = false;
@@ -45646,7 +47433,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       "createServeApp: runtime replacement/removal requires deps.getSessionBridges so session-id admission can inspect draining generations."
     );
   }
-  const app = (0, import_express6.default)();
+  const app = (0, import_express7.default)();
   const serveAppLifecycle = installServeAppLifecycle(
     app,
     deps.serveAppLifecycle
@@ -45810,6 +47597,10 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   }) : void 0;
   const defaultSessionOwnerIndex = !injectedWorkspaceRegistry ? createWorkspaceSessionOwnerIndex() : void 0;
   const bridge = injectedWorkspaceRegistry?.primary.bridge ?? deps.bridge ?? createAcpSessionBridge({
+    sessionAttachmentsRoot: path18.join(
+      new Storage(boundWorkspace).getProjectTempDir(),
+      "attachments"
+    ),
     maxSessions: opts.maxSessions,
     ...totalSessionAdmission ? { freshSessionAdmission: totalSessionAdmission.admit } : {},
     ...defaultSessionOwnerIndex ? {
@@ -46307,18 +48098,17 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   app.locals.stopWorkspaceGitState = () => workspaceGitState.dispose();
   app.locals.stopWorkspaceGitStateForWorkspace = (workspaceCwd) => workspaceGitState.disposeWorkspace(workspaceCwd);
   const workspaceQualifiedAcpEnabled = acpHttpEnabledAtBoot;
-  if (opts.allowOrigins && opts.allowOrigins.length > 0) {
-    const parsedAllowOrigins = parseAllowOriginPatterns(opts.allowOrigins);
-    if (parsedAllowOrigins.allowAny && !opts.token) {
-      throw new Error(
-        `Refusing to start with --allow-origin '*' but no bearer token configured. '*' admits any cross-origin browser to the API; without a token, any local page can drive the daemon. Set a token or list specific origins instead of '*'.`
-      );
-    }
-    app.use(allowOriginCors(parsedAllowOrigins));
-  } else {
-    app.use(denyBrowserOriginCors);
+  const parsedAllowOrigins = parseAllowOriginPatterns(opts.allowOrigins ?? []);
+  if (parsedAllowOrigins.allowAny && !opts.token) {
+    throw new Error(
+      `Refusing to start with --allow-origin '*' but no bearer token configured. '*' admits any cross-origin browser to the API; without a token, any local page can drive the daemon. Set a token or list specific origins instead of '*'.`
+    );
   }
+  const originAllowlist = new MutableOriginAllowlist(parsedAllowOrigins);
+  app.use(allowOriginCors(originAllowlist));
   app.use(hostAllowlist(opts.hostname, getPort));
+  const credentials = new CredentialStore(opts.token);
+  const authenticate = bearerAuth(credentials);
   const rateLimiter = installRateLimiter(app, opts, daemonLog, {
     mount: false,
     workspaceQualifiedAcpEnabled
@@ -46330,9 +48120,17 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     getRateLimiter: /* @__PURE__ */ __name(() => rateLimiter, "getRateLimiter")
   });
   if (healthRoutes.exposeHealthPreAuth) {
+    app.use("/health", (req, res, next) => {
+      if (listenerIdentityOf(req).kind === "local-control") {
+        authenticate(req, res, next);
+        return;
+      }
+      next();
+    });
     healthRoutes.register(app);
   }
   installAccessLogMiddleware(app, daemonLog);
+  app.use(daemonInboundTraceIdCaptureMiddleware);
   const webShellDir = opts.serveWebShell !== false ? deps.webShellDir : void 0;
   const webShellFrameAncestors = opts.allowOrigins && opts.allowOrigins.length > 0 ? [...parseAllowOriginPatterns(opts.allowOrigins).origins].filter(
     (o) => o.startsWith("chrome-extension://") || o.startsWith("moz-extension://")
@@ -46373,7 +48171,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       daemonLog
     });
   }
-  app.use(bearerAuth(opts.token));
+  app.use(authenticate);
   if (rateLimiter) {
     app.use(rateLimiter.middleware);
   }
@@ -47151,6 +48949,10 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     fsFactory: primaryRouteFileSystemFactory,
     deviceFlowRegistry,
     token: opts.token,
+    // The WS upgrade bypasses Express middleware, so it needs the same
+    // listener-scoped credentials the REST gate uses — otherwise the
+    // `qwen-bearer.*` subprotocol would be a way around the scoping.
+    credentials,
     // Mirror the REST CORS allowlist onto the WS CSRF wall so an
     // explicitly permitted origin (e.g. the extension's
     // `chrome-extension://<id>`) can open the reverse tool channel.
@@ -47222,6 +49024,26 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   if (acpHandleRef.current) {
     app.locals["acpHandle"] = acpHandleRef.current;
   }
+  const localControlService = new LocalControlService({
+    app,
+    credentials,
+    originAllowlist,
+    // Resolved through the ref on each call rather than captured so Local
+    // Control cannot attach to a stale ACP mount.
+    attachWebSocket: /* @__PURE__ */ __name((server) => acpHandleRef.current?.attachServer(server), "attachWebSocket"),
+    detachWebSocket: /* @__PURE__ */ __name((server) => acpHandleRef.current?.detachServer(server), "detachWebSocket"),
+    getPort,
+    tlsPaths: opts.tlsCert && opts.tlsKey ? { cert: opts.tlsCert, key: opts.tlsKey } : void 0
+  });
+  app.locals["localControlService"] = localControlService;
+  registerWorkspaceLocalControlRoutes(app, {
+    service: localControlService,
+    mutate,
+    safeBody,
+    isDaemonDraining: deps.isChannelControlDraining,
+    webShellAvailable: Boolean(webShellDir),
+    primaryBindHostname: opts.hostname
+  });
   if (webShellDir) {
     mountWebShellSpaFallback(app, webShellDir, webShellFrameAncestors);
   }