@qwen-code/qwen-code 0.22.3-nightly.20260831.3a0c4c6108 → 0.23.0

package/chunks/{server-7W6C3SOW.js → server-AOYZVVOM.js}

@@ -1,5 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  deriveWebSocketBase,
+  openQwenAsrRealtimeStream,
+  openVoiceStream,
+  openVoiceStreamWithRetry
+} from "./chunk-XLXAZLDR.js";
 import {
   GENERATION_MAX_PROMPT_BYTES,
   MAX_REMEMBER_CONTENT_BYTES,
@@ -14,13 +20,7 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-BY24DZ4J.js";
-import {
-  deriveWebSocketBase,
-  openQwenAsrRealtimeStream,
-  openVoiceStream,
-  openVoiceStreamWithRetry
-} from "./chunk-X7C7KFWA.js";
+} from "./chunk-WP4AX3XD.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -32,15 +32,15 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-L2OKAIUK.js";
+} from "./chunk-QI27MKNQ.js";
 import {
   OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
   ObservedChannelContactStore
 } from "./chunk-XEAAO654.js";
+import "./chunk-NRL5CUZT.js";
 import {
   escapeAnsiCtrlCodes
 } from "./chunk-47ECGEJC.js";
-import "./chunk-OQYXJK2V.js";
 import "./chunk-2MIN6GRR.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-TXASDT2M.js";
@@ -56,6 +56,7 @@ import {
   ConversationRuntimeOwnershipError,
   CredentialStore,
   DeviceFlowRegistry,
+  LocalPathOpenUnavailableError,
   MAX_CONCURRENT_VOICE_SESSIONS,
   MutableOriginAllowlist,
   NativeDirectoryPickerUnavailableError,
@@ -91,11 +92,15 @@ import {
   installServeAppLifecycle,
   isBrowserAutomationMcpAvailable,
   isDeepHealthQuery,
+  isLocalPathOpenAvailable,
+  isLocalTerminalAvailable,
   isNativeDirectoryPickerAvailable,
   isScratchRootCompatible,
   isTrustedLoopbackMode,
   listenerIdentityOf,
   listenerIdentityOfSocket,
+  openPathLocally,
+  openTerminalLocally,
   parseAllowOriginPatterns,
   parseDaemonStatusDetail,
   pickNativeDirectory,
@@ -108,7 +113,7 @@ import {
   singleTokenCredentials,
   tagListener,
   unsafeRevealSecret
-} from "./chunk-MBZ5ORJB.js";
+} from "./chunk-SI7WDR3U.js";
 import "./chunk-VGHZT6JR.js";
 import {
   ConversationDirectoryIdentityError,
@@ -119,7 +124,9 @@ import {
 } from "./chunk-PB7JBAHF.js";
 import "./chunk-UXEO7E3V.js";
 import {
-  AONE_BACKFILL_PAGES_PER_STATE,
+  assertValidChannelSecretUpdates
+} from "./chunk-7RB56BRJ.js";
+import {
   AONE_MAX_MR_VIEW_CALLS_PER_RUN,
   DaemonDrainingError,
   InvalidCursorError,
@@ -144,8 +151,9 @@ import {
   resolveAoneWorkspaceRepo,
   resolveSessionIdForRestore,
   runWithWorkspaceRuntimeStorage,
+  searchWorkspaceSessionsForResponse,
   unarchiveDaemonSessions
-} from "./chunk-6OO7QEWV.js";
+} from "./chunk-EVFDRBUM.js";
 import {
   LIVE_SESSION_SOURCE_PREFIX,
   isCompatibleLiveSessionSource,
@@ -181,16 +189,23 @@ import {
   STANDALONE_SESSION_SOURCE_TYPE,
   isReservedStandaloneSessionSourceType
 } from "./chunk-N4QWUPDM.js";
+import {
+  evaluateDaemonWorkspaceTrust,
+  readDaemonTrustPolicySnapshot
+} from "./chunk-YPWZTR7F.js";
 import {
   readRecentPromptTerminals,
   reconcileDanglingPromptTerminals,
   withPromptTerminals
-} from "./chunk-5ICKESC3.js";
+} from "./chunk-UPFRILIL.js";
 import {
   WorkspaceGenerationClosedError,
   createSingleWorkspaceRegistry,
   createWorkspaceSessionOwnerIndex
-} from "./chunk-IVUWTA2D.js";
+} from "./chunk-QJVZLILI.js";
+import {
+  sessionAttachmentsRoots
+} from "./chunk-NUHOLAQ6.js";
 import {
   getWorkspaceRouteContext,
   isGenerationClosedError,
@@ -213,11 +228,11 @@ import {
   sendUntrustedWorkspaceResponse,
   sendWorkspaceRuntimeUnavailable,
   setWorkspaceRouteContext
-} from "./chunk-RGEV5AUD.js";
+} from "./chunk-3L724BJ5.js";
 import {
   normalizeChannelDelivery,
   parseChannelDelivery
-} from "./chunk-PNIGAVY6.js";
+} from "./chunk-DTVQSSNM.js";
 import {
   isValidSessionId,
   normalizeSessionIdForLookup,
@@ -229,9 +244,10 @@ import {
 import {
   WorkspaceRuntimeInitializationError,
   WorkspaceRuntimeStillStartingError,
+  getWorkspaceRuntimeCoordinator,
   getWorkspaceRuntimeCoordinatorIfSupported,
   supportsWorkspaceRuntimeLifecycle
-} from "./chunk-MZYWNU66.js";
+} from "./chunk-P6UIF2OW.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
   MAX_WORKSPACE_SKILL_NAME_LENGTH,
@@ -245,14 +261,14 @@ import {
   validateWorkspaceSkillName,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-U5RTYI7D.js";
+} from "./chunk-4M24B5J5.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-JPKTAQS3.js";
+} from "./chunk-I5N4EAS6.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -260,37 +276,36 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-YNG7XAJU.js";
+} from "./chunk-LEPCWS5A.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-BE5FGT5Z.js";
+} from "./chunk-BA4WJC4L.js";
 import "./chunk-QAK5475D.js";
 import {
   createTotalSessionAdmissionController
-} from "./chunk-OTTNXUT5.js";
+} from "./chunk-7IKXTGZT.js";
 import "./chunk-OIBUG24X.js";
 import {
   MAX_SESSION_RESTORE_TIMEOUT_MS,
   resolveSessionRestoreTimeoutMs,
   restoreRetryAfterSeconds
 } from "./chunk-4JRM2BSM.js";
-import {
-  assertValidChannelSecretUpdates
-} from "./chunk-YOFULAHO.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-RVCGAHC7.js";
-import "./chunk-6YXNJXQW.js";
-import "./chunk-AN3KFCNH.js";
+} from "./chunk-RM4WT2XB.js";
+import "./chunk-RN3YGDCA.js";
+import "./chunk-3JQZVCBI.js";
 import "./chunk-JS73NNWF.js";
 import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge,
+  extractErrorCode,
+  extractErrorMessage,
   parseSessionSource
-} from "./chunk-RLSPPTWH.js";
+} from "./chunk-DSX7KQPM.js";
 import {
   EVENT_SCHEMA_VERSION,
   EventBus,
@@ -298,21 +313,35 @@ import {
 } from "./chunk-7U5G6JXI.js";
 import "./chunk-WCCLLK7X.js";
 import "./chunk-OCPBI7J5.js";
+import {
+  createSpawnChannelFactory
+} from "./chunk-4HVH57J3.js";
 import {
   createWorkspaceProvidersStatusProvider
-} from "./chunk-3CZGSTZX.js";
-import "./chunk-T4EFG2P5.js";
+} from "./chunk-EBDGRBZX.js";
+import {
+  PERSIST_REASONING_SELECTION_META_KEY,
+  REASONING_SELECTION_PERSISTED_META_KEY
+} from "./chunk-ZJ2LM2SI.js";
 import {
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-W7KWB6AH.js";
+} from "./chunk-6A2D4QSO.js";
 import {
   snapshotProcessEnv
-} from "./chunk-ERRJA23L.js";
+} from "./chunk-KMU3ZHH4.js";
 import {
   createWorkspaceSkillsStatusProvider
-} from "./chunk-CM4F4JBB.js";
+} from "./chunk-4BGDFKQE.js";
 import "./chunk-BHTYRHJF.js";
+import {
+  BridgeTimeoutError,
+  SERVE_CONTROL_EXT_METHODS,
+  STATUS_SCHEMA_VERSION,
+  SessionRestoreTimeoutError,
+  createIdleWorkspaceMemoryStatus,
+  mapDomainErrorToErrorKind
+} from "./chunk-64QH2UC6.js";
 import {
   resolveSkillSettings
 } from "./chunk-HWVUSYSN.js";
@@ -325,54 +354,40 @@ import {
   isServeDebugMode,
   mountWebShellAssets,
   mountWebShellSpaFallback
-} from "./chunk-GDXSXL3H.js";
+} from "./chunk-NFIDVZND.js";
 import {
   require_express
-} from "./chunk-AYHQZBJ4.js";
+} from "./chunk-IRKQ4YYX.js";
 import "./chunk-FBX2SDQ4.js";
 import {
   formatHostForAuthority,
   isLoopbackBind
 } from "./chunk-DMEUXLSS.js";
-import {
-  evaluateDaemonWorkspaceTrust,
-  readDaemonTrustPolicySnapshot
-} from "./chunk-ZQ3FKEWA.js";
 import {
   daemonObservedContactsPath,
   loadChannelsConfig
-} from "./chunk-OE5AQVNB.js";
-import "./chunk-H2A2GJGL.js";
+} from "./chunk-F7NF2IOE.js";
+import "./chunk-AZJLY2XZ.js";
 import "./chunk-57OAHC2Y.js";
 import {
   parseChannelWebhookConfigLenient
-} from "./chunk-V4HN35IF.js";
+} from "./chunk-PCRBLMIN.js";
 import {
   supportedChannelCatalog
-} from "./chunk-CAZADEU7.js";
-import "./chunk-GN422P4J.js";
+} from "./chunk-NXKOVOM5.js";
+import "./chunk-TSZSGQ3N.js";
 import "./chunk-V6WHFGST.js";
 import {
   getStableLiveDiscoveryBaseDir
-} from "./chunk-5MK45KZ3.js";
+} from "./chunk-OHOO527W.js";
 import {
   LIVE_HOST_BUNDLE_ID,
   LIVE_HOST_PROTOCOL_VERSION,
   LIVE_INPUT_AUDIO_EPOCH_BYTES
-} from "./chunk-NKLP3DCK.js";
-import {
-  createSpawnChannelFactory
-} from "./chunk-JMRE4WJQ.js";
-import {
-  BridgeTimeoutError,
-  STATUS_SCHEMA_VERSION,
-  SessionRestoreTimeoutError,
-  createIdleWorkspaceMemoryStatus,
-  mapDomainErrorToErrorKind
-} from "./chunk-J4Y3QJHF.js";
+} from "./chunk-IQAFKVXS.js";
+import "./chunk-ZL4HFSL6.js";
 import "./chunk-K6KS3LTN.js";
-import "./chunk-HMJ2P3SV.js";
-import "./chunk-7E7UCJHS.js";
+import "./chunk-OSHQMOBS.js";
 import {
   MAX_REGISTERED_WORKSPACES,
   WorkspaceDisplayNameValidationError,
@@ -380,7 +395,7 @@ import {
   WorkspaceRegistrationStoreLimitError,
   normalizeWorkspaceDisplayName,
   workspaceRegistrationId
-} from "./chunk-RY7DL5IF.js";
+} from "./chunk-BJXCYUGM.js";
 import {
   CHANNEL_PROMPT_META_KEY,
   DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
@@ -397,6 +412,7 @@ import {
   InvalidRewindTargetError,
   InvalidSessionMetadataError,
   InvalidSessionScopeError,
+  McpAuthenticationInProgressError,
   McpServerNotFoundError,
   McpServerRestartFailedError,
   PermissionForbiddenError,
@@ -421,7 +437,7 @@ import {
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
-} from "./chunk-YPISTYEI.js";
+} from "./chunk-F47DITLZ.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace,
@@ -444,7 +460,7 @@ import {
 } from "./chunk-GYTKQYDB.js";
 import {
   normalizeWorkerDiagnostic
-} from "./chunk-3EGEBDTW.js";
+} from "./chunk-M4KFODIP.js";
 import {
   normalizeServeChannelSelection
 } from "./chunk-ALMR3E6Q.js";
@@ -457,11 +473,11 @@ import "./chunk-3VUENPWF.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
-import "./chunk-5HBA2Z7V.js";
 import {
   sanitizeLogText
-} from "./chunk-IXEZHTDR.js";
+} from "./chunk-U4DJ5XB3.js";
 import "./chunk-IW6RQPQB.js";
+import "./chunk-5HBA2Z7V.js";
 import {
   WORKSPACE_RESTRICTED_SETTING_KEYS,
   getDialogSettingKeys,
@@ -471,27 +487,31 @@ import {
   getSettingDefinition,
   getWritableScopes,
   loadSettings,
+  resolveOutputLanguageOrPreserveAuto,
+  updateOutputLanguageFile,
   validateSettingValue
-} from "./chunk-AAX236AR.js";
-import "./chunk-NT5XIL5H.js";
+} from "./chunk-VWTSRH6C.js";
+import "./chunk-NQ4L2CMD.js";
 import "./chunk-RKUWKYED.js";
-import "./chunk-GOXKNSDZ.js";
+import "./chunk-O5CD7T4T.js";
 import "./chunk-IDS7MSUP.js";
 import {
   detectSystemLanguage,
-  resolveLanguageSetting
-} from "./chunk-EU2B4P3D.js";
+  getCurrentLanguage,
+  resolveLanguageSetting,
+  setLanguageAsync
+} from "./chunk-I4NRYS6A.js";
 import {
   SUPPORTED_LANGUAGES,
   resolveSupportedLanguage
 } from "./chunk-5EJZE3FP.js";
-import "./chunk-T4RMUTTT.js";
-import "./chunk-3452WXOK.js";
-import "./chunk-ZYPJ7HVZ.js";
+import "./chunk-C4TIXFDZ.js";
+import "./chunk-2M3EWQNG.js";
+import "./chunk-VBWD6C27.js";
 import "./chunk-W3N5XAZ6.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-I75VKFCJ.js";
+} from "./chunk-65HWLGA7.js";
 import "./chunk-NPQ5ZKRP.js";
 import {
   isWithinRoot as isWithinRoot2
@@ -500,45 +520,30 @@ import {
   ALL_PROVIDERS,
   BTW_MAX_INPUT_LENGTH,
   ClientMcpRegistrar,
-  GITHUB_PR_ERROR_MESSAGE_MAX,
   IMAGE_CAPABILITY,
   WebTerminalRegistry,
   WorkspaceMemoryFileTooLargeError,
   WorkspaceMemoryWriteTimeoutError,
   buildUsageDashboard,
-  createGitHubPullRequest,
-  fetchGitBranches,
-  fetchGitHubPullRequests,
-  getDefaultBranch,
-  gitCheckout,
-  gitCommit,
-  gitCreateBranch,
-  gitEnv,
-  gitPull,
-  gitPush,
-  isValidCheckoutRef,
-  isValidRefName,
   loadIgnoreRules,
-  resolveBranchName,
   shouldShowStep,
-  watchRepoBranch,
   writeWorkspaceContextFile
-} from "./chunk-NT7LXVV5.js";
-import "./chunk-DBTMP3P4.js";
-import "./chunk-ERHAMGAA.js";
+} from "./chunk-JUARRUMA.js";
+import "./chunk-I2TMJPCV.js";
+import "./chunk-JR42V4UY.js";
 import "./chunk-LJZSMWOH.js";
-import "./chunk-6NWPR2EB.js";
-import "./chunk-GCUR24KK.js";
-import "./chunk-W4BDHLRT.js";
 import {
   readWorktreeSession,
   writeWorktreeSession
-} from "./chunk-ED7DD7MV.js";
-import "./chunk-AYYKUUKP.js";
-import "./chunk-PWR2NQBS.js";
+} from "./chunk-RAFQIHN2.js";
+import "./chunk-L26ONV2Y.js";
+import "./chunk-47RYEQW5.js";
+import "./chunk-IG4W5SJR.js";
+import "./chunk-ZPJWUGCS.js";
+import "./chunk-4UANMABT.js";
+import "./chunk-ZKFTS3OV.js";
 import "./chunk-ENYUKMFK.js";
 import "./chunk-UKYXYWI2.js";
-import "./chunk-ZPJWUGCS.js";
 import {
   QwenOAuth2Client,
   QwenOAuthPollError,
@@ -548,14 +553,17 @@ import {
   isDeviceTokenPending,
   isDeviceTokenSuccess
 } from "./chunk-3AKCBZVW.js";
-import "./chunk-JDIO45X7.js";
+import "./chunk-SULZPKTA.js";
+import "./chunk-VNOVK4I7.js";
 import {
   BuiltinAgentRegistry,
   Client,
   DEFAULT_LOG_LIMIT,
   ExtensionManager,
   ExtensionNotUpdatableError,
+  GITHUB_PR_ERROR_MESSAGE_MAX,
   GROUP_COLOR_OPTIONS,
+  GitPullFailure,
   InvalidSessionTranscriptCursorError,
   MAX_LOG_LIMIT,
   ModelsConfig,
@@ -588,37 +596,62 @@ import {
   SubagentManager,
   TrustGateError,
   canonicalSessionPrUrl,
+  createGitHubPullRequest,
   detectLineEnding,
   encodeTextFileContentAsync,
+  fetchAttributionRepoKeys,
+  fetchGitBranches,
   fetchGitCommitDetail,
   fetchGitDiff,
   fetchGitDiffHunksForFile,
+  fetchGitHubPullRequests,
   fetchGitLog,
+  fetchRemoteWebUrl,
+  getDefaultBranch,
   getGitWorkingTreeStatus,
   getSubagentSessionDir,
+  gitCheckout,
+  gitCommit,
+  gitCreateBranch,
+  gitPull,
+  gitPush,
   isSupportedArchiveUrl,
+  isValidCheckoutRef,
+  isValidRefName,
+  isValidSessionPrUrl,
   loadUsageHistoryWithLive,
+  matchesAnyServerPattern,
+  parseGoalControlRequest,
   parseInstallSource,
   partToString,
   readAgentMeta,
   readSessionPrs,
   replaceSessionPrs,
+  repoKeyFromWebUrl,
+  resolveBranchName,
   resolveProviderProtocol,
+  sessionPrSourceAuthority,
   sleepInhibitor,
   stripTerminalControlSequences,
-  upsertSessionPr
-} from "./chunk-ZBDYI7VM.js";
+  toSessionPrInfo,
+  upsertSessionPr,
+  watchRepoBranch
+} from "./chunk-4F7GQGXB.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-6HUXPLB5.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-CQ35AJ4Z.js";
-import "./chunk-SMJYTKTB.js";
+import "./chunk-NSUKQ4DN.js";
+import "./chunk-DQCKVAF5.js";
 import "./chunk-AI35S34R.js";
-import "./chunk-FIWZOMBF.js";
+import {
+  GitWorktreeService,
+  writeWorktreeSessionMarker
+} from "./chunk-KM3XVTMO.js";
 import "./chunk-6PVPNMXU.js";
 import "./chunk-OKTNXDVO.js";
-import "./chunk-DJBQCO2E.js";
+import "./chunk-EFTPIZIC.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
 import {
@@ -627,44 +660,45 @@ import {
   taskHasLegacyCondition,
   updateCronTasks
 } from "./chunk-UJ4DUYIH.js";
+import {
+  glob
+} from "./chunk-QJNDUTOL.js";
 import "./chunk-O6GEWCJA.js";
-import "./chunk-YDQ4OCDK.js";
+import "./chunk-OSSTATJF.js";
 import {
-  GitWorktreeService,
-  writeWorktreeSessionMarker
-} from "./chunk-SDCHI64N.js";
-import "./chunk-B2RIIK3K.js";
+  findGitRoot
+} from "./chunk-ZHO2CW6D.js";
+import "./chunk-CVX63TFJ.js";
 import "./chunk-373DQUVA.js";
 import {
   recordDaemonBridgeError,
   recordDaemonHttpRequest,
   validateSkillName
-} from "./chunk-OSTQZIOY.js";
+} from "./chunk-H43PSPYS.js";
 import "./chunk-U6D2PPMN.js";
-import "./chunk-PDXYZBBQ.js";
-import {
-  glob
-} from "./chunk-QJNDUTOL.js";
-import {
-  findGitRoot
-} from "./chunk-ZHO2CW6D.js";
-import "./chunk-AF3QB6OL.js";
+import "./chunk-VYIUNFEA.js";
+import "./chunk-KGV55H53.js";
 import "./chunk-7TBU7PU2.js";
 import "./chunk-E4JNFXNI.js";
-import {
-  parseGoalControlRequest
-} from "./chunk-4P7PPAHN.js";
-import "./chunk-7J6OTNGO.js";
 import "./chunk-CHEIIBT3.js";
-import "./chunk-VYSZUQGU.js";
+import "./chunk-TJYRTS4S.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";
 import "./chunk-MLXTMF7H.js";
+import "./chunk-PQEISIKS.js";
+import "./chunk-FD5SJOWT.js";
+import "./chunk-4LIFGNI4.js";
+import "./chunk-S6LOFUVP.js";
 import "./chunk-NAVJD2PQ.js";
 import "./chunk-KFN2IZYR.js";
 import "./chunk-GB4UKWY5.js";
 import "./chunk-QHMLYMMS.js";
+import "./chunk-CFKIH3D3.js";
+import "./chunk-2LD5U7Q3.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-S2T7H5MI.js";
+import "./chunk-LKODFJRD.js";
 import {
   addDaemonRequestAttribute,
   captureDaemonTelemetryContext,
@@ -676,22 +710,12 @@ import {
   recordDaemonHttpResponse,
   runWithDaemonTelemetryContext,
   withDaemonRequestSpan
-} from "./chunk-UXEW7TQS.js";
+} from "./chunk-LB3WQQJK.js";
 import "./chunk-XWRJCPHC.js";
-import "./chunk-VNOVK4I7.js";
-import "./chunk-PQEISIKS.js";
-import "./chunk-RT4QNQ5P.js";
-import "./chunk-26SIKQIC.js";
-import "./chunk-S6LOFUVP.js";
-import "./chunk-CFKIH3D3.js";
-import "./chunk-2LD5U7Q3.js";
-import "./chunk-DJ2GSRLV.js";
-import "./chunk-S2T7H5MI.js";
-import "./chunk-LKODFJRD.js";
 import {
   parseLineTolerant,
   read
-} from "./chunk-FXUSWLBF.js";
+} from "./chunk-GH2S4GD5.js";
 import "./chunk-XBVNNDPK.js";
 import "./chunk-VGC4I5JJ.js";
 import {
@@ -702,14 +726,12 @@ import {
   getAllMemoryFilenames,
   isUtf8CompatibleEncoding,
   isWithinRoot
-} from "./chunk-67AY5D3M.js";
+} from "./chunk-DYTW3QVG.js";
 import "./chunk-HT5S5TRQ.js";
-import "./chunk-LMMHS3RS.js";
 import "./chunk-WZAD4ZNJ.js";
 import "./chunk-FPGTNKCP.js";
 import "./chunk-EIJT2PQ6.js";
-import "./chunk-H5GPPDGY.js";
-import "./chunk-XZA32HII.js";
+import "./chunk-BFY33IB4.js";
 import "./chunk-KHP66DFN.js";
 import "./chunk-22UH7VTP.js";
 import "./chunk-HHJLM3WQ.js";
@@ -717,19 +739,19 @@ import {
   isTelemetrySdkInitialized,
   redactUrlCredentials,
   stripAnsiAndControl
-} from "./chunk-TBJ3SNS3.js";
+} from "./chunk-QKDNS6FU.js";
 import "./chunk-74TONY4F.js";
-import "./chunk-IXHV5MIC.js";
+import "./chunk-ZDFQGHZH.js";
 import {
   SubagentError,
   SubagentErrorCode
-} from "./chunk-D7D3HSYQ.js";
-import "./chunk-YKADANK6.js";
+} from "./chunk-G7HBEEX7.js";
+import "./chunk-QQD2GART.js";
 import {
   escapeXml
 } from "./chunk-AQ37AY7B.js";
 import "./chunk-ODZF64DM.js";
-import "./chunk-LYSZVCCD.js";
+import "./chunk-7JMGTOH7.js";
 import {
   FatalConfigError,
   Storage,
@@ -745,13 +767,13 @@ import {
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
+import "./chunk-AMDSOFFV.js";
 import {
   import_websocket,
   import_websocket_server,
   wrapper_default
-} from "./chunk-J3NNHTV6.js";
+} from "./chunk-J5TTWBZK.js";
 import "./chunk-RVIGZBIT.js";
-import "./chunk-AMDSOFFV.js";
 import "./chunk-TBWQLLFO.js";
 import {
   init_esbuild_shims
@@ -6535,7 +6557,7 @@ var FileConversationRuntimeOwnership = class {
           await this.commitRecord(identity, void 0);
         }
       }, "commitOwner");
-      const liveDiscovery = await import("./discovery-X2NV535U.js");
+      const liveDiscovery = await import("./discovery-TUM3ZQ6U.js");
       const handoff = await liveDiscovery.handoffLiveDiscoveryOwner(
         this.stableBaseDir,
         this.current,
@@ -7312,6 +7334,7 @@ function toStandaloneSummary(item, workspaceCwd, canonicalSessionId, isArchived,
     createdAt: item.startTime,
     updatedAt: new Date(item.mtime).toISOString(),
     ...displayName ? { displayName } : {},
+    ...item.customTitle && item.titleSource ? { titleSource: item.titleSource } : {},
     sourceType: STANDALONE_SESSION_SOURCE_TYPE,
     context: { kind: "standalone" },
     ...source.metadata.parentSessionId !== void 0 ? {
@@ -7376,6 +7399,35 @@ var StandaloneSessionService = class {
   directoryStates = /* @__PURE__ */ new Map();
   reconciliations = /* @__PURE__ */ new WeakMap();
   terminal = false;
+  async getOptions() {
+    const runtime = await this.options.ensureRuntime();
+    return this.options.runRuntimeActivity(runtime, async () => {
+      this.options.assertRuntimeCurrent(runtime);
+      await this.options.workspace.assertExactRoot(runtime.workspaceCwd);
+      this.options.assertRuntimeCurrent(runtime);
+      const status = await runtime.workspaceService.getWorkspaceProvidersStatus(
+        {
+          route: "GET /standalone/session-options",
+          workspaceCwd: runtime.workspaceCwd
+        }
+      );
+      this.options.assertRuntimeCurrent(runtime);
+      if (status.workspaceCwd !== runtime.workspaceCwd) {
+        throw new ConversationRuntimeOwnershipError(
+          "conversation_runtime_ownership_compromised",
+          false
+        );
+      }
+      return {
+        v: status.v,
+        initialized: status.initialized,
+        ...status.current !== void 0 ? { current: status.current } : {},
+        ...status.approvalMode !== void 0 ? { approvalMode: status.approvalMode } : {},
+        providers: status.providers,
+        ...status.errors !== void 0 ? { errors: status.errors } : {}
+      };
+    });
+  }
   freezeForTerminalQuarantine(runtime) {
     this.terminal = true;
     for (const entry of this.creating.values()) {
@@ -13887,13 +13939,11 @@ var AcpDispatcher = class {
                   {
                     number: boundPr["number"],
                     url: boundPr["url"],
+                    source: "create",
                     ...boundState === "open" || boundState === "merged" || boundState === "closed" ? { state: boundState } : {}
                   }
-                )).map(({ number, url, state }) => ({
-                  number,
-                  url,
-                  ...state ? { state } : {}
-                }));
+                )).map(toSessionPrInfo);
+                this.bridge.setSessionPrs?.(sessionId, persistedPrs);
                 result = { ...result, prs: persistedPrs };
               }
             } finally {
@@ -23168,7 +23218,7 @@ function registerWorkspaceExtensionRoutes(app, deps) {
     generationPoller.unref();
     app.locals.stopExtensionGenerationReconciler = () => clearInterval(generationPoller);
   }
-  const registerFor2 = /* @__PURE__ */ __name((base, resolve7) => {
+  const registerFor4 = /* @__PURE__ */ __name((base, resolve7) => {
     app.get(base, async (req, res) => {
       const assertGenerationOpen = deps.captureGenerationAssertion?.();
       const ctrl = resolve7(req, res, false);
@@ -23936,7 +23986,7 @@ function registerWorkspaceExtensionRoutes(app, deps) {
       }
     });
   }, "registerFor");
-  registerFor2("/workspace/extensions", (_req, res, requireTrust) => {
+  registerFor4("/workspace/extensions", (_req, res, requireTrust) => {
     try {
       deps.captureGenerationAssertion?.()?.();
     } catch (error2) {
@@ -26225,6 +26275,9 @@ function resolveDaemonTelemetryRoute(req) {
   if (req.method === "POST" && path19 === "/workspace/reload") {
     return { route: "POST /workspace/reload" };
   }
+  if (req.method === "POST" && path19 === "/language") {
+    return { route: "POST /language" };
+  }
   const mcpRestart = path19.match(/^\/workspace\/mcp\/([^/]+)\/restart$/);
   if (mcpRestart?.[1] && req.method === "POST") {
     return { route: "POST /workspace/mcp/:server/restart" };
@@ -26621,6 +26674,7 @@ init_esbuild_shims();
 import * as crypto3 from "node:crypto";
 import * as fs7 from "node:fs";
 import * as path12 from "node:path";
+import { inspect } from "node:util";
 var import_express4 = __toESM(require_express(), 1);
 
 // packages/cli/src/serve/server/prompt-deadline.ts
@@ -27608,6 +27662,16 @@ function sendSessionOrganizationError(res, err) {
   return true;
 }
 __name(sendSessionOrganizationError, "sendSessionOrganizationError");
+function describePromptTurnFailure(err) {
+  const detail = extractErrorMessage(err);
+  if (err instanceof Error) {
+    return `[${err.name}] ${detail}`;
+  }
+  const code = extractErrorCode(err);
+  const rendered = typeof err === "object" && err !== null && (detail === "" || detail === String(err)) ? inspect(err, { depth: 2, breakLength: Infinity }) : detail;
+  return code === void 0 ? rendered : `[code ${code}] ${rendered}`;
+}
+__name(describePromptTurnFailure, "describePromptTurnFailure");
 function parseTranscriptLimitQuery(rawLimit, res) {
   if (rawLimit === void 0) return void 0;
   if (typeof rawLimit !== "string" || rawLimit.trim() === "") {
@@ -29040,7 +29104,7 @@ function registerSessionRoutes(app, deps) {
     // characters would let a caller forge log lines.
     hasControlCharacter(url) || state !== void 0 && state !== "open" && state !== "merged" && state !== "closed") {
       res.status(400).json({
-        error: `\`pr\` must be an object with a positive integer \`number\` and an http(s) \`url\` of at most ${SESSION_PR_URL_MAX_LENGTH} characters, without control characters, and an optional \`state\` of \`open\`, \`merged\`, or \`closed\``,
+        error: `\`pr\` must be an object with a positive integer \`number\` and an http(s) \`url\` of at most ${SESSION_PR_URL_MAX_LENGTH} characters, without control characters, and an optional \`state\` that is one of \`open\`, \`merged\`, or \`closed\``,
         code: "invalid_metadata",
         field: "pr"
       });
@@ -29711,7 +29775,10 @@ function registerSessionRoutes(app, deps) {
           daemonLog
         );
       }
-      sendBridgeError2(res, err, { route: "POST /session" });
+      sendBridgeError2(res, err, {
+        route: "POST /session",
+        ...branchMeta || worktreeMeta ? {} : { initPrecedesMutations: true }
+      });
     } finally {
       sessionIdReservation?.release();
     }
@@ -31358,9 +31425,8 @@ function registerSessionRoutes(app, deps) {
           },
           (err) => {
             if (daemonLog) {
-              const errName = err instanceof Error ? err.name : void 0;
               daemonLog.warn(
-                `prompt turn failed: ${errName ? `[${errName}] ` : ""}${err instanceof Error ? err.message : String(err)}`,
+                `prompt turn failed: ${describePromptTurnFailure(err)}`,
                 { sessionId, promptId, clientId }
               );
             }
@@ -31844,12 +31910,9 @@ function registerSessionRoutes(app, deps) {
           if (pr) {
             const persistedPrs = (await upsertSessionPr(
               service.getPrSessionPathForArchiveState(sessionId, "active"),
-              pr
-            )).map(({ number, url, state }) => ({
-              number,
-              url,
-              ...state ? { state } : {}
-            }));
+              { ...pr, source: "create" }
+            )).map(toSessionPrInfo);
+            runtime.bridge.setSessionPrs?.(sessionId, persistedPrs);
             effective = { ...effective, prs: persistedPrs };
           }
         } finally {
@@ -31969,13 +32032,10 @@ function registerSessionRoutes(app, deps) {
                     sessionId,
                     "active"
                   ),
-                  pr
-                )).map(({ number, url, state }) => ({
-                  number,
-                  url,
-                  ...state ? { state } : {}
-                }));
+                  { ...pr, source: "create" }
+                )).map(toSessionPrInfo);
                 assertRuntimeGenerationOpen?.();
+                runtime.bridge.setSessionPrs?.(sessionId, persistedPrs);
                 effective = { ...effective, prs: persistedPrs };
               }
             } catch (err) {
@@ -31992,14 +32052,10 @@ function registerSessionRoutes(app, deps) {
               if (pr) {
                 const persisted = await upsertSessionPr(
                   service.getPrSessionPathForArchiveState(sessionId, location),
-                  pr
+                  { ...pr, source: "create" }
                 );
                 assertRuntimeGenerationOpen?.();
-                effective.prs = persisted.map(({ number, url, state }) => ({
-                  number,
-                  url,
-                  ...state ? { state } : {}
-                }));
+                effective.prs = persisted.map(toSessionPrInfo);
               }
               if (displayName !== void 0) {
                 const renamed = await service.renameSession(
@@ -32496,6 +32552,103 @@ function registerSessionRoutes(app, deps) {
     "/workspaces/:workspace/sessions",
     listWorkspaceSessionsHandler("workspace")
   );
+  const SESSION_SEARCH_QUERY_MAX_LENGTH = 200;
+  const SESSION_SEARCH_MAX_RESULTS_LIMIT = 50;
+  const searchWorkspaceSessionsHandler = /* @__PURE__ */ __name((paramName) => async (req, res) => {
+    const route = paramName === "workspace" ? "GET /workspaces/:workspace/sessions/search" : "GET /workspace/:id/sessions/search";
+    const liveRuntime = await resolveLiveCatalogRuntime(req, res, paramName);
+    if (liveRuntime === null) return;
+    const runtime = liveRuntime ?? resolveRuntimeForCatalogRoute(req, res, paramName, route);
+    if (runtime === null) return;
+    const key = runtime.workspaceCwd;
+    try {
+      const rawQuery = req.query["q"];
+      const trimmedQuery = typeof rawQuery === "string" ? rawQuery.trim() : "";
+      if (trimmedQuery.length === 0 || trimmedQuery.length > SESSION_SEARCH_QUERY_MAX_LENGTH) {
+        res.status(400).json({
+          error: `\`q\` must be a non-empty string of at most ${SESSION_SEARCH_QUERY_MAX_LENGTH} characters`,
+          code: "invalid_search_query"
+        });
+        return;
+      }
+      let maxResults;
+      const rawMaxResults = req.query["maxResults"];
+      if (rawMaxResults !== void 0) {
+        const parsed = typeof rawMaxResults === "string" && /^\d+$/.test(rawMaxResults) ? Number.parseInt(rawMaxResults, 10) : Number.NaN;
+        if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > SESSION_SEARCH_MAX_RESULTS_LIMIT) {
+          res.status(400).json({
+            error: `\`maxResults\` must be an integer between 1 and ${SESSION_SEARCH_MAX_RESULTS_LIMIT}`,
+            code: "invalid_search_max_results"
+          });
+          return;
+        }
+        maxResults = parsed;
+      }
+      const controller = new AbortController();
+      const onRequestAborted = /* @__PURE__ */ __name(() => {
+        controller.abort(new DOMException("Request aborted", "AbortError"));
+      }, "onRequestAborted");
+      const onResponseClosed = /* @__PURE__ */ __name(() => {
+        if (!res.writableEnded) {
+          controller.abort(new DOMException("Response closed", "AbortError"));
+        }
+      }, "onResponseClosed");
+      req.once("aborted", onRequestAborted);
+      res.once("close", onResponseClosed);
+      if (req.aborted || res.destroyed) onRequestAborted();
+      try {
+        const search = /* @__PURE__ */ __name(() => runWorkspaceInspectionWithLogPolicy(
+          runtime,
+          () => searchWorkspaceSessionsForResponse(
+            key,
+            trimmedQuery,
+            { ...maxResults !== void 0 ? { maxResults } : {} },
+            {
+              runtimeBaseDir: runtime.sessionRuntimeBaseDir,
+              signal: controller.signal
+            }
+          )
+        ), "search");
+        const result = liveRuntime && deps.conversationRuntimeActivity ? await deps.conversationRuntimeActivity.run(search) : await search();
+        controller.signal.throwIfAborted();
+        if (res.destroyed) return;
+        res.status(200).json({ results: result.results });
+      } catch (err) {
+        if (controller.signal.aborted || res.destroyed) {
+          return;
+        }
+        throw err;
+      } finally {
+        req.off("aborted", onRequestAborted);
+        res.off("close", onResponseClosed);
+      }
+    } catch (err) {
+      if (err && typeof err === "object" && err.code === "daemon_draining") {
+        res.status(503).json({
+          error: "The daemon is draining and no longer accepts work.",
+          code: "daemon_draining"
+        });
+        return;
+      }
+      writeStderrLine(
+        `qwen serve: failed to search sessions for workspace ${safeLogValue(
+          key
+        )}: ${safeLogValue(err instanceof Error ? err.message : String(err))}`
+      );
+      res.status(500).json({
+        error: "Failed to search sessions",
+        code: "session_search_failed"
+      });
+    }
+  }, "searchWorkspaceSessionsHandler");
+  app.get(
+    "/workspace/:id/sessions/search",
+    searchWorkspaceSessionsHandler("id")
+  );
+  app.get(
+    "/workspaces/:workspace/sessions/search",
+    searchWorkspaceSessionsHandler("workspace")
+  );
   const lastExposedCatalogVersions = /* @__PURE__ */ new WeakMap();
   app.get("/workspaces/:workspace/sessions/live-state", async (req, res) => {
     const route = "GET /workspaces/:workspace/sessions/live-state";
@@ -32597,6 +32750,7 @@ function registerSessionRoutes(app, deps) {
         const body = safeBody(req);
         const configId = body["configId"];
         const value = body["value"];
+        const persist = body["persist"];
         if (configId !== "reasoning_effort") {
           res.status(400).json({
             error: "`configId` must be reasoning_effort"
@@ -32609,11 +32763,29 @@ function registerSessionRoutes(app, deps) {
           });
           return;
         }
+        if (persist !== void 0 && typeof persist !== "boolean") {
+          res.status(400).json({
+            error: "`persist` must be a boolean when provided"
+          });
+          return;
+        }
         const response = await runtime.bridge.setSessionConfigOption(
           sessionId,
-          { sessionId, configId, value }
+          {
+            sessionId,
+            configId,
+            value,
+            ...persist === true ? {
+              _meta: {
+                [PERSIST_REASONING_SELECTION_META_KEY]: true
+              }
+            } : {}
+          }
         );
-        res.status(200).json(response);
+        res.status(200).json({
+          configOptions: response.configOptions,
+          persisted: response._meta?.[REASONING_SELECTION_PERSISTED_META_KEY] === true
+        });
       }
     )
   );
@@ -33091,97 +33263,71 @@ __name(registerSessionRoutes, "registerSessionRoutes");
 
 // packages/cli/src/serve/routes/session-pr-backfill.ts
 init_esbuild_shims();
-import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import * as fs8 from "node:fs/promises";
 import * as path13 from "node:path";
-var SLUG_PR_PATTERN = /^pr-(\d{1,9})$/;
-var BRANCH_PR_PATTERN = /^worktree-pr-(\d{1,9})$/;
+var SLUG_PR_PATTERN = /^pr-([1-9]\d{0,8})$/;
+var BRANCH_PR_PATTERN = /^worktree-pr-([1-9]\d{0,8})$/;
 function parsePrNumberFromWorktree(slug, branch) {
   const slugMatch = SLUG_PR_PATTERN.exec(slug ?? "");
-  if (slugMatch) {
-    const number = Number(slugMatch[1]);
-    return number > 0 ? number : void 0;
-  }
+  if (slugMatch) return Number(slugMatch[1]);
   const branchMatch = BRANCH_PR_PATTERN.exec(branch ?? "");
-  if (branchMatch) {
-    const number = Number(branchMatch[1]);
-    return number > 0 ? number : void 0;
-  }
+  if (branchMatch) return Number(branchMatch[1]);
   return void 0;
 }
 __name(parsePrNumberFromWorktree, "parsePrNumberFromWorktree");
-function normalizeRemoteToWebUrl(remote) {
-  const trimmed = remote.trim();
-  if (!trimmed) return void 0;
-  let input = trimmed;
-  let sshDerived = false;
-  if (input.startsWith("git@")) {
-    input = `https://${input.slice("git@".length).replace(":", "/")}`;
-    sshDerived = true;
-  } else if (input.startsWith("ssh://")) {
-    input = `https://${input.slice("ssh://".length)}`;
-    sshDerived = true;
-  }
-  let url;
-  try {
-    url = new URL(input);
-  } catch {
-    return void 0;
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
-  const pathname = url.pathname.replace(/\.git\/?$/, "");
-  if (!pathname || pathname === "/") return void 0;
-  const host = sshDerived ? url.hostname : url.host;
-  return `${url.protocol}//${host}${pathname}`.replace(/\/$/, "");
-}
-__name(normalizeRemoteToWebUrl, "normalizeRemoteToWebUrl");
-function getRemoteWebUrl(cwd) {
-  try {
-    const remote = execSync("git remote get-url origin", {
-      cwd,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      // Sanitize like every sibling git/gh call in this path: without an
-      // env option the spawn inherits the daemon's raw process.env, and an
-      // inherited GIT_DIR/GIT_WORK_TREE/GIT_CONFIG_* would resolve origin
-      // against a different repository despite the cwd.
-      env: gitEnv()
-    }).trim();
-    return normalizeRemoteToWebUrl(remote);
-  } catch {
-    return void 0;
-  }
-}
-__name(getRemoteWebUrl, "getRemoteWebUrl");
-var MAX_DISTINCT_BRANCHES = 64;
-async function collectTranscriptBranches(filePath) {
-  let raw;
-  try {
-    raw = await fs8.readFile(filePath, "utf8");
-  } catch {
-    return [];
-  }
-  const branches = /* @__PURE__ */ new Set();
+var REVIEW_COMMAND_PATTERN = /^\s*\/review(?:[ \t]+#?(\d{1,9})(?![\w./-])|[ \t]+[^\n"\\]*?(https?:\/\/[A-Za-z0-9][^\s"'<>)]*\/pull\/(\d{1,9})(?!\d)))/;
+function collectReviewedPrNumbers(raw) {
+  const mentions = [];
+  const mentionByNumber = /* @__PURE__ */ new Map();
+  const noteMention = /* @__PURE__ */ __name((number, bare) => {
+    const known = mentionByNumber.get(number);
+    if (known) {
+      if (bare) known.bare = true;
+      return;
+    }
+    const mention = { number, bare };
+    mentionByNumber.set(number, mention);
+    mentions.push(mention);
+  }, "noteMention");
+  const urlForms = [];
   for (const line of raw.split("\n")) {
-    if (!line) continue;
+    if (!line.includes("/review")) continue;
     let record;
     try {
       record = JSON.parse(line);
     } catch {
       continue;
     }
-    if (record === null || typeof record !== "object") continue;
-    const branch = record["gitBranch"];
-    if (typeof branch === "string" && branch.length > 0) {
-      branches.add(branch);
-      if (branches.size >= MAX_DISTINCT_BRANCHES) break;
+    let prompt;
+    if (record.type === "system" && record.subtype === "slash_command" && record.systemPayload?.phase === "invocation" && typeof record.systemPayload.rawCommand === "string") {
+      prompt = record.systemPayload.rawCommand;
+    } else if (record.type === "user") {
+      const firstPart = record.message?.parts?.[0];
+      if (typeof firstPart?.text === "string" && !firstPart.functionResponse) {
+        prompt = firstPart.text;
+      }
+    }
+    if (prompt === void 0) continue;
+    const match = REVIEW_COMMAND_PATTERN.exec(prompt);
+    if (!match) continue;
+    const bareNumber = match[1];
+    if (bareNumber !== void 0) {
+      if (Number(bareNumber) > 0) noteMention(Number(bareNumber), true);
+      continue;
+    }
+    const url = match[2];
+    const urlNumber = match[3];
+    if (url === void 0 || urlNumber === void 0) continue;
+    if (Number(urlNumber) > 0) {
+      noteMention(Number(urlNumber), false);
+      urlForms.push({ number: Number(urlNumber), url });
     }
   }
-  return [...branches];
+  return { mentions, reviewedUrlForms: urlForms };
 }
-__name(collectTranscriptBranches, "collectTranscriptBranches");
-async function backfillWorkspaceSessionPrs(runtime, fetchPullRequests = fetchGitHubPullRequests, options = {}) {
+__name(collectReviewedPrNumbers, "collectReviewedPrNumbers");
+async function backfillWorkspaceSessionPrs(runtime, fetchPullRequests = fetchGitHubPullRequests, fetchRepoKeys = fetchAttributionRepoKeys, options = {}) {
   const assertGenerationOpen = /* @__PURE__ */ __name(() => runtime.generationGuard?.assertOpen(), "assertGenerationOpen");
   const result = {
     workspaceCwd: runtime.workspaceCwd,
@@ -33193,10 +33339,20 @@ async function backfillWorkspaceSessionPrs(runtime, fetchPullRequests = fetchGit
     unresolved: 0
   };
   const sessionService = createWorkspaceRuntimeSessionService(runtime);
+  const remote = await fetchRemoteWebUrl(
+    runtime.workspaceCwd,
+    runtime.env.effectiveEnv
+  );
+  const workspaceRepoKey = remote ? repoKeyFromWebUrl(remote) : void 0;
+  const aoneRepo = await resolveAoneWorkspaceRepo(
+    runtime.workspaceCwd,
+    runtime.env.effectiveEnv
+  );
   const candidates = [];
   for (const archiveState of ["active", "archived"]) {
     const sessionIds = await sessionService.listAllProjectSessionIds(archiveState);
     for (const sessionId of sessionIds) {
+      if (!isValidSessionId(sessionId)) continue;
       result.scanned += 1;
       const dir = path13.dirname(
         sessionService.getWorktreeSessionPathForArchiveState(
@@ -33212,75 +33368,51 @@ async function backfillWorkspaceSessionPrs(runtime, fetchPullRequests = fetchGit
       } catch {
         worktree = null;
       }
-      const transcriptPath = path13.join(dir, `${sessionId}.jsonl`);
-      const branches = [
-        ...worktree ? [worktree.worktreeBranch] : [],
-        ...await collectTranscriptBranches(transcriptPath)
-      ];
+      let transcriptRaw;
+      try {
+        transcriptRaw = await fs8.readFile(
+          path13.join(dir, `${sessionId}.jsonl`),
+          "utf8"
+        );
+      } catch {
+        transcriptRaw = "";
+      }
+      const reviewed = collectReviewedPrNumbers(transcriptRaw);
       const conventionNumber = worktree ? parsePrNumberFromWorktree(worktree.slug, worktree.worktreeBranch) : void 0;
-      if (branches.length === 0 && conventionNumber === void 0) {
+      const hasSidecar = aoneRepo !== void 0 && existsSync(
+        sessionService.getPrSessionPathForArchiveState(
+          sessionId,
+          archiveState
+        )
+      );
+      if (conventionNumber === void 0 && reviewed.mentions.length === 0 && !hasSidecar) {
         continue;
       }
       candidates.push({
         sessionId,
         archiveState,
-        transcriptPath,
+        transcriptPath: path13.join(dir, `${sessionId}.jsonl`),
         conventionNumber,
-        branches
+        mentions: reviewed.mentions,
+        reviewedUrlForms: reviewed.reviewedUrlForms
       });
     }
   }
   if (candidates.length === 0) return result;
   assertGenerationOpen();
   const numberToUrl = /* @__PURE__ */ new Map();
-  const numberToState = /* @__PURE__ */ new Map();
-  const branchToNumber = /* @__PURE__ */ new Map();
-  let resolveNumberUrl;
+  const pageUrlByNumber = /* @__PURE__ */ new Map();
+  const pageStateByNumber = /* @__PURE__ */ new Map();
+  let pageRepoKey;
+  let pageMapTrusted = false;
+  let resolveAoneUrl;
   let isLegacyFabricated;
-  const aoneBackend = options.aoneBackend ?? defaultAoneMrBackend;
-  const aoneRepo = await resolveAoneWorkspaceRepo(
-    runtime.workspaceCwd,
-    runtime.env.effectiveEnv
-  );
   if (aoneRepo) {
     result.platform = "aone";
-    result.aoneAvailable = false;
-    try {
-      const listed = [
-        ...await aoneBackend.list(
-          aoneRepo.repoPath,
-          "opened",
-          AONE_BACKFILL_PAGES_PER_STATE
-        ),
-        ...await aoneBackend.list(
-          aoneRepo.repoPath,
-          "merged",
-          AONE_BACKFILL_PAGES_PER_STATE
-        )
-      ];
-      result.aoneAvailable = true;
-      let defaultBranch;
-      let headBranchMapping = false;
-      if (candidates.some((candidate) => candidate.branches.length > 0)) {
-        const defaultRef = await getDefaultBranch(runtime.workspaceCwd);
-        if (defaultRef) {
-          defaultBranch = defaultRef.slice(defaultRef.indexOf("/") + 1);
-          headBranchMapping = true;
-        }
-      }
-      for (const mr of listed) {
-        numberToState.set(mr.number, mr.state);
-        if (!headBranchMapping) continue;
-        const mapped = branchToNumber.get(mr.headRefName);
-        if (mr.headRefName && mr.headRefName !== defaultBranch && (mapped === void 0 || mr.number > mapped)) {
-          branchToNumber.set(mr.headRefName, mr.number);
-        }
-      }
-    } catch {
-    }
+    const aoneBackend = options.aoneBackend ?? defaultAoneMrBackend;
     const viewCache = /* @__PURE__ */ new Map();
     let viewCalls = 0;
-    resolveNumberUrl = /* @__PURE__ */ __name(async (number) => {
+    resolveAoneUrl = /* @__PURE__ */ __name(async (number) => {
       if (viewCache.has(number)) return viewCache.get(number);
       let url;
       if (viewCalls < AONE_MAX_MR_VIEW_CALLS_PER_RUN) {
@@ -33288,78 +33420,112 @@ async function backfillWorkspaceSessionPrs(runtime, fetchPullRequests = fetchGit
         try {
           const view = await aoneBackend.view(aoneRepo.repoPath, number);
           url = view.url;
-          numberToState.set(number, view.state);
           numberToUrl.set(number, url);
+          pageUrlByNumber.set(number, url);
+          pageStateByNumber.set(number, view.state);
         } catch {
           url = void 0;
         }
       }
       viewCache.set(number, url);
       return url;
-    }, "resolveNumberUrl");
-    let legacyPullRoot;
-    let legacyPullResolved = false;
-    isLegacyFabricated = /* @__PURE__ */ __name((url, number) => {
-      if (!legacyPullResolved) {
-        legacyPullRoot = getRemoteWebUrl(runtime.workspaceCwd);
-        legacyPullResolved = true;
-      }
-      return legacyPullRoot !== void 0 && canonicalSessionPrUrl(url) === canonicalSessionPrUrl(`${legacyPullRoot}/pull/${number}`);
-    }, "isLegacyFabricated");
+    }, "resolveAoneUrl");
+    pageMapTrusted = true;
+    isLegacyFabricated = /* @__PURE__ */ __name((url, number) => remote !== void 0 && canonicalSessionPrUrl(url) === canonicalSessionPrUrl(`${remote}/pull/${number}`), "isLegacyFabricated");
   } else {
     result.platform = "github";
-    const prs = await fetchPullRequests(
-      runtime.workspaceCwd,
-      runtime.env.effectiveEnv,
-      { state: "all", limit: 500, slim: true }
-    );
-    result.ghAvailable = prs.kind === "ok";
-    if (prs.kind === "ok") {
-      let defaultBranch;
-      let headBranchMapping = false;
-      if (candidates.some((candidate) => candidate.branches.length > 0)) {
-        const defaultRef = await getDefaultBranch(runtime.workspaceCwd);
-        if (defaultRef) {
-          defaultBranch = defaultRef.slice(defaultRef.indexOf("/") + 1);
-          headBranchMapping = true;
-        }
-      }
-      for (const pr of prs.pullRequests) {
-        numberToUrl.set(pr.number, pr.url);
-        numberToState.set(pr.number, pr.state === "draft" ? "open" : pr.state);
-        if (!headBranchMapping) continue;
-        const mapped = branchToNumber.get(pr.headRefName);
-        if (pr.headRefName && pr.headRefName !== defaultBranch && (mapped === void 0 || pr.number > mapped)) {
-          branchToNumber.set(pr.headRefName, pr.number);
-        }
+  }
+  const prs = aoneRepo ? void 0 : await fetchPullRequests(runtime.workspaceCwd, runtime.env.effectiveEnv, {
+    state: "all",
+    limit: 500,
+    slim: true
+  });
+  if (prs) result.ghAvailable = prs.kind === "ok";
+  if (prs?.kind === "ok") {
+    for (const pr of prs.pullRequests) {
+      const state = pr.state === "draft" ? "open" : pr.state;
+      pageUrlByNumber.set(pr.number, pr.url);
+      pageStateByNumber.set(pr.number, state);
+      pageRepoKey ??= repoKeyFromWebUrl(pr.url);
+      if (workspaceRepoKey === void 0 || repoKeyFromWebUrl(pr.url) !== workspaceRepoKey) {
+        continue;
       }
+      numberToUrl.set(pr.number, pr.url);
     }
-    let remoteWebUrl;
-    let remoteResolved = false;
-    resolveNumberUrl = /* @__PURE__ */ __name(async (number, isConvention) => {
-      if (!isConvention) return void 0;
-      if (!remoteResolved) {
-        remoteWebUrl = getRemoteWebUrl(runtime.workspaceCwd);
-        remoteResolved = true;
+    if (pageRepoKey !== void 0) {
+      if (workspaceRepoKey !== void 0 && pageRepoKey === workspaceRepoKey) {
+        pageMapTrusted = true;
+      } else {
+        const { resolved, parent } = await fetchRepoKeys(
+          runtime.workspaceCwd,
+          runtime.env.effectiveEnv
+        );
+        pageMapTrusted = workspaceRepoKey !== void 0 && resolved === workspaceRepoKey && parent === pageRepoKey;
       }
-      return remoteWebUrl !== void 0 ? `${remoteWebUrl}/pull/${number}` : void 0;
-    }, "resolveNumberUrl");
+    }
+  }
+  const allowedRepoKeys = /* @__PURE__ */ new Set();
+  if (workspaceRepoKey !== void 0) allowedRepoKeys.add(workspaceRepoKey);
+  if (pageRepoKey !== void 0) allowedRepoKeys.add(pageRepoKey);
+  const sameRepoKeys = /* @__PURE__ */ new Set();
+  if (workspaceRepoKey !== void 0) sameRepoKeys.add(workspaceRepoKey);
+  if (pageMapTrusted && pageRepoKey !== void 0) {
+    sameRepoKeys.add(pageRepoKey);
   }
   for (const candidate of candidates) {
-    let numbers = [];
+    const formUrlByNumber = new Map(
+      candidate.reviewedUrlForms.filter((form) => {
+        if (!isValidSessionPrUrl(form.url)) return false;
+        if (isLegacyFabricated) {
+          return isLegacyFabricated(form.url, form.number);
+        }
+        const repoKey = repoKeyFromWebUrl(form.url);
+        return repoKey !== void 0 && allowedRepoKeys.has(repoKey);
+      }).map((form) => [form.number, form.url])
+    );
+    const numbers = [];
+    for (const mention of candidate.mentions) {
+      if (mention.bare || formUrlByNumber.has(mention.number)) {
+        numbers.push(mention.number);
+      }
+    }
+    const namedAsOwn = new Set(
+      candidate.mentions.filter((mention) => mention.bare).map((mention) => mention.number)
+    );
     if (candidate.conventionNumber !== void 0) {
-      numbers.push(candidate.conventionNumber);
+      namedAsOwn.add(candidate.conventionNumber);
+    }
+    const lendableFormUrl = /* @__PURE__ */ __name((number) => {
+      if (resolveAoneUrl) return void 0;
+      const url = formUrlByNumber.get(number);
+      if (url === void 0 || !namedAsOwn.has(number)) return url;
+      const key = repoKeyFromWebUrl(url);
+      return key !== void 0 && sameRepoKeys.has(key) ? url : void 0;
+    }, "lendableFormUrl");
+    if (candidate.conventionNumber !== void 0) {
+      const conventionNumber = candidate.conventionNumber;
+      const rest = numbers.filter((n) => n !== conventionNumber);
+      numbers.length = 0;
+      numbers.push(...rest, conventionNumber);
     }
-    for (const branch of candidate.branches) {
-      const mapped = branchToNumber.get(branch);
-      if (mapped !== void 0 && !numbers.includes(mapped)) {
-        numbers.push(mapped);
+    if (numbers.length === 0 && !isLegacyFabricated) continue;
+    let archiveState = candidate.archiveState;
+    try {
+      const location = await sessionService.getSessionLocation(
+        candidate.sessionId
+      );
+      if (location === "active" || location === "archived") {
+        archiveState = location;
       }
+    } catch {
     }
-    if (numbers.length === 0 && !isLegacyFabricated) continue;
     const prPath = sessionService.getPrSessionPathForArchiveState(
       candidate.sessionId,
-      candidate.archiveState
+      archiveState
+    );
+    const transcriptPath = path13.join(
+      path13.dirname(prPath),
+      `${candidate.sessionId}.jsonl`
     );
     const snapshotAt = (/* @__PURE__ */ new Date()).toISOString();
     let existing;
@@ -33369,39 +33535,41 @@ async function backfillWorkspaceSessionPrs(runtime, fetchPullRequests = fetchGit
       existing = null;
     }
     const repairs = /* @__PURE__ */ new Map();
-    if (isLegacyFabricated && existing) {
+    if (isLegacyFabricated && resolveAoneUrl && existing) {
       for (const entry of existing) {
         if (!isLegacyFabricated(entry.url, entry.number)) continue;
-        const url = await resolveNumberUrl(entry.number, false);
+        const url = await resolveAoneUrl(entry.number);
         if (url === void 0) continue;
         repairs.set(entry.number, {
           url,
-          state: numberToState.get(entry.number)
+          state: pageStateByNumber.get(entry.number)
         });
       }
     }
     if (numbers.length === 0 && repairs.size === 0) continue;
-    if (candidate.conventionNumber !== void 0) {
-      numbers = [...numbers.slice(1), candidate.conventionNumber];
-    }
     const existingNumbers = new Set((existing ?? []).map((pr) => pr.number));
     const urls = /* @__PURE__ */ new Map();
     const states = /* @__PURE__ */ new Map();
     for (const number of numbers) {
       if (existingNumbers.has(number)) continue;
       let url = numberToUrl.get(number);
-      if (url === void 0) {
-        url = await resolveNumberUrl(
-          number,
-          number === candidate.conventionNumber
-        );
+      if (url === void 0) url = lendableFormUrl(number);
+      if (url === void 0 && pageMapTrusted) {
+        url = pageUrlByNumber.get(number);
       }
       if (url === void 0) {
+        if (resolveAoneUrl) {
+          url = await resolveAoneUrl(number);
+        } else if (remote !== void 0) {
+          url = `${remote}/pull/${number}`;
+        }
+      }
+      if (url === void 0 || !isValidSessionPrUrl(url)) {
         result.unresolved += 1;
         continue;
       }
       urls.set(number, url);
-      const state = numberToState.get(number);
+      const state = pageMapTrusted && pageUrlByNumber.get(number) === url ? pageStateByNumber.get(number) : void 0;
       if (state !== void 0) states.set(number, state);
     }
     const droppable = new Set(
@@ -33415,19 +33583,18 @@ async function backfillWorkspaceSessionPrs(runtime, fetchPullRequests = fetchGit
     const commit = /* @__PURE__ */ __name(async () => {
       const persisted = await replaceSessionPrs(prPath, (fresh) => {
         assertGenerationOpen();
-        if (!existsSync(candidate.transcriptPath)) return null;
+        if (!existsSync(transcriptPath)) return null;
         const base = repairs.size === 0 ? fresh : fresh.map((entry) => {
           const repair = repairs.get(entry.number);
           return repair && isLegacyFabricated?.(entry.url, entry.number) ? {
-            number: entry.number,
+            ...entry,
             url: repair.url,
-            createdAt: entry.createdAt,
             ...repair.state !== void 0 ? { state: repair.state } : {}
           } : entry;
         });
         const freshNumbers = new Set(base.map((entry) => entry.number));
         const plannedFor = /* @__PURE__ */ __name((entry) => {
-          const resolved = numberToUrl.get(entry.number);
+          const resolved = numberToUrl.get(entry.number) ?? urls.get(entry.number);
           const samePr = aoneRepo ? resolved !== void 0 && canonicalSessionPrUrl(entry.url) === canonicalSessionPrUrl(resolved) || isAoneDetailUrlForRepo(aoneRepo.repoPath, entry.number, entry.url) : resolved === void 0 || canonicalSessionPrUrl(entry.url) === canonicalSessionPrUrl(resolved);
           return droppable.has(entry.number) && existingNumbers.has(entry.number) && entry.createdAt < snapshotAt && samePr;
         }, "plannedFor");
@@ -33442,37 +33609,58 @@ async function backfillWorkspaceSessionPrs(runtime, fetchPullRequests = fetchGit
         );
         if (plan.length > slots) {
           result.overLimit += plan.length - slots;
-          const convention = candidate.conventionNumber;
-          if (slots === 0) {
-            plan = [];
-          } else if (convention !== void 0 && plan[plan.length - 1] === convention) {
-            const branchSlots = slots - 1;
-            plan = [
-              ...branchSlots > 0 ? plan.slice(0, -1).slice(-branchSlots) : [],
-              convention
-            ];
-          } else {
-            plan = plan.slice(-slots);
-          }
+          const heldSource = new Map(
+            base.map((entry) => [entry.number, entry.source])
+          );
+          const rank = /* @__PURE__ */ __name((number) => {
+            const stamp = sessionPrSourceAuthority(
+              number === candidate.conventionNumber ? "worktree" : "review"
+            );
+            return heldSource.has(number) ? Math.max(
+              stamp,
+              sessionPrSourceAuthority(heldSource.get(number))
+            ) : stamp;
+          }, "rank");
+          const evicted = new Set(
+            plan.map((_, index) => index).sort((a, b) => rank(plan[a]) - rank(plan[b]) || a - b).slice(0, plan.length - slots)
+          );
+          plan = plan.filter((_, index) => !evicted.has(index));
         }
         const planSet = new Set(plan);
         result.alreadyBound += plan.filter(
           (number) => freshNumbers.has(number)
         ).length;
-        const kept = base.filter(
-          (entry) => planSet.has(entry.number) || !plannedFor(entry)
-        );
+        const attested = /* @__PURE__ */ __name((entry) => {
+          if (aoneRepo) {
+            return isAoneDetailUrlForRepo(
+              aoneRepo.repoPath,
+              entry.number,
+              entry.url
+            );
+          }
+          const canonical = canonicalSessionPrUrl(entry.url);
+          const resolved = numberToUrl.get(entry.number);
+          const pageUrl = pageUrlByNumber.get(entry.number);
+          return resolved !== void 0 && canonical === canonicalSessionPrUrl(resolved) || pageMapTrusted && pageUrl !== void 0 && canonical === canonicalSessionPrUrl(pageUrl) || remote !== void 0 && canonical === canonicalSessionPrUrl(`${remote}/pull/${entry.number}`);
+        }, "attested");
+        const kept = base.filter((entry) => planSet.has(entry.number) || !plannedFor(entry)).map((entry) => {
+          if (!planSet.has(entry.number) || !attested(entry)) return entry;
+          const stamp = entry.number === candidate.conventionNumber ? "worktree" : "review";
+          return sessionPrSourceAuthority(stamp) > sessionPrSourceAuthority(entry.source) ? { ...entry, source: stamp } : entry;
+        });
         const additions = [];
         for (const number of plan) {
           if (freshNumbers.has(number)) continue;
           const url = urls.get(number);
           if (url === void 0) continue;
           const state = states.get(number);
+          const source = number === candidate.conventionNumber ? "worktree" : "review";
           additions.push({
             number,
             url,
             createdAt,
-            ...state !== void 0 ? { state } : {}
+            ...state !== void 0 ? { state } : {},
+            source
           });
         }
         added = additions.length;
@@ -33486,11 +33674,7 @@ async function backfillWorkspaceSessionPrs(runtime, fetchPullRequests = fetchGit
           assertGenerationOpen();
           runtime.bridge.setSessionPrs?.(
             candidate.sessionId,
-            fresh.map(({ number, url, state }) => ({
-              number,
-              url,
-              ...state ? { state } : {}
-            }))
+            fresh.map(toSessionPrInfo)
           );
           return null;
         });
@@ -33531,9 +33715,14 @@ function registerSessionPrBackfillRoutes(app, deps) {
           continue;
         }
         try {
-          const result = await backfillWorkspaceSessionPrs(runtime, void 0, {
-            archiveCoordinator: deps.archiveCoordinator
-          });
+          const result = await backfillWorkspaceSessionPrs(
+            runtime,
+            void 0,
+            void 0,
+            {
+              archiveCoordinator: deps.archiveCoordinator
+            }
+          );
           if (result.written > 0) {
             runtime.generationGuard?.assertOpen();
             invalidateWorkspaceSessionListCache({
@@ -33726,6 +33915,16 @@ function registerStandaloneSessionRoutes(app, deps) {
       });
     }
   }, "handle");
+  app.get(
+    "/standalone/session-options",
+    (req, res) => handle("GET /standalone/session-options", req, res, async () => {
+      if (Object.keys(req.query).length > 0) {
+        sendInvalidRequest(res, "The request query contains unknown fields.");
+        return;
+      }
+      res.status(200).json(await deps.service.getOptions());
+    })
+  );
   app.post(
     "/standalone/sessions",
     deps.mutate({ strict: true }),
@@ -34256,7 +34455,8 @@ async function bindAndNameSessions(bridge, boundWorkspace, tasks, renamed, spawn
       spawnedSessionId = sessionId;
       try {
         bridge.updateSessionMetadata(sessionId, {
-          displayName: scheduledTaskSessionName(task.prompt)
+          displayName: scheduledTaskSessionName(task.prompt),
+          titleSource: "auto"
         });
         renamed.add(sessionId);
       } catch {
@@ -34295,7 +34495,8 @@ async function bindAndNameSessions(bridge, boundWorkspace, tasks, renamed, spawn
     const sessionId = task.sessionId;
     try {
       bridge.updateSessionMetadata(sessionId, {
-        displayName: scheduledTaskSessionName(task.prompt)
+        displayName: scheduledTaskSessionName(task.prompt),
+        titleSource: "auto"
       });
       renamed.add(sessionId);
     } catch (err) {
@@ -35047,6 +35248,8 @@ function createServeFeatures(deps) {
     workspaceRuntimeRemovalAvailable,
     nativeDirectoryPickerAvailable,
     workspaceRuntimeAvailable,
+    localPathOpenAvailable,
+    localTerminalOpenAvailable,
     workspaceTrustHotReloadAvailable
   } = deps;
   const getEnv = deps.getEnv ?? (() => deps.env ?? process.env);
@@ -35093,6 +35296,8 @@ function createServeFeatures(deps) {
         workspaceRuntimeRemovalAvailable,
         nativeDirectoryPickerAvailable,
         workspaceRuntimeAvailable: workspaceRuntimeAvailable(),
+        localPathOpenAvailable,
+        localTerminalOpenAvailable,
         workspaceTrustHotReloadAvailable,
         acpHttpEnabled: currentAcpHttpEnabled,
         realtimeVoiceEnabled: realtimeVoiceEnabled(),
@@ -35616,6 +35821,53 @@ async function withMcpServerMutationLock(workspace, scope, operation) {
   }
 }
 __name(withMcpServerMutationLock, "withMcpServerMutationLock");
+var sessionWorkflowWriteQueues = /* @__PURE__ */ new Map();
+async function withSessionWorkflowWriteLock(workspace, operation) {
+  const previous = sessionWorkflowWriteQueues.get(workspace) ?? Promise.resolve();
+  const run2 = previous.catch(() => void 0).then(operation);
+  const tail = run2.then(
+    () => void 0,
+    () => void 0
+  );
+  sessionWorkflowWriteQueues.set(workspace, tail);
+  try {
+    return await run2;
+  } finally {
+    if (sessionWorkflowWriteQueues.get(workspace) === tail) {
+      sessionWorkflowWriteQueues.delete(workspace);
+    }
+  }
+}
+__name(withSessionWorkflowWriteLock, "withSessionWorkflowWriteLock");
+function readEffectiveSessionWorkflow(boundWorkspace, workspaceTrusted) {
+  const loaded = loadSettings(boundWorkspace, {
+    skipLoadEnvironment: true,
+    skipWorkspaceSettings: !workspaceTrusted,
+    workspaceTrusted
+  });
+  return getNestedProperty(
+    loaded.merged,
+    "experimental.sessionWorkflow"
+  ) === true;
+}
+__name(readEffectiveSessionWorkflow, "readEffectiveSessionWorkflow");
+async function updateLiveSessionWorkflow(update, enabled, workspace, res) {
+  try {
+    await update(enabled);
+    return true;
+  } catch (err) {
+    if (err instanceof SessionNotFoundError) return true;
+    writeStderrLine(
+      `qwen serve: failed to update the live Session Workflow setting for ${workspace}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    res.status(500).json({
+      error: "Failed to update the live Session Workflow setting",
+      code: "runtime_update_error"
+    });
+    return false;
+  }
+}
+__name(updateLiveSessionWorkflow, "updateLiveSessionWorkflow");
 function registerWorkspaceSettingsRoutes(app, deps) {
   const {
     boundWorkspace,
@@ -35741,60 +35993,92 @@ function registerWorkspaceSettingsRoutes(app, deps) {
         return;
       }
       let publicValue = value;
-      try {
-        const persist = /* @__PURE__ */ __name(async () => {
-          const prepared = prepareSettingWrite(
-            boundWorkspace,
-            settingScope,
-            key,
-            value,
-            mcpServerMutation,
-            deps.isWorkspaceTrusted?.() ?? true
-          );
-          publicValue = prepared.publicValue;
-          if (deps.captureGenerationAssertion) {
-            await persistSetting(
+      const persistAndPushSessionWorkflow = /* @__PURE__ */ __name(async () => {
+        try {
+          const persist = /* @__PURE__ */ __name(async () => {
+            const prepared = prepareSettingWrite(
               boundWorkspace,
               settingScope,
               key,
-              prepared.persistedValue,
-              assertGenerationOpen
+              value,
+              mcpServerMutation,
+              deps.isWorkspaceTrusted?.() ?? true
             );
-          } else {
-            await persistSetting(
+            publicValue = prepared.publicValue;
+            if (deps.captureGenerationAssertion) {
+              await persistSetting(
+                boundWorkspace,
+                settingScope,
+                key,
+                prepared.persistedValue,
+                assertGenerationOpen
+              );
+            } else {
+              await persistSetting(
+                boundWorkspace,
+                settingScope,
+                key,
+                prepared.persistedValue
+              );
+            }
+          }, "persist");
+          if (mcpServerMutation) {
+            await withMcpServerMutationLock(
               boundWorkspace,
               settingScope,
-              key,
-              prepared.persistedValue
+              persist
             );
+          } else {
+            await persist();
           }
-        }, "persist");
-        if (mcpServerMutation) {
-          await withMcpServerMutationLock(
+        } catch (err) {
+          if (sendGenerationClosedError(res, err)) return "unchanged_failure";
+          writeStderrLine(
+            `qwen serve: POST /workspace/settings persist error (key=${key}, scope=${scope}, workspace=${boundWorkspace}): ${err instanceof Error ? err.message : String(err)}`
+          );
+          res.status(500).json({
+            error: "Failed to persist setting",
+            code: "persist_error"
+          });
+          return "unchanged_failure";
+        }
+        try {
+          assertGenerationOpen();
+        } catch (err) {
+          if (sendGenerationClosedError(res, err)) return "unchanged_failure";
+          throw err;
+        }
+        if (key === "experimental.sessionWorkflow") {
+          const livePushSucceeded = await updateLiveSessionWorkflow(
+            deps.updateSessionWorkflow,
+            readEffectiveSessionWorkflow(
+              boundWorkspace,
+              deps.isWorkspaceTrusted?.() ?? true
+            ),
             boundWorkspace,
-            settingScope,
-            persist
+            res
           );
-        } else {
-          await persist();
+          if (settingScope === "User" /* User */) {
+            await deps.updateSiblingSessionWorkflows?.();
+          }
+          if (!livePushSucceeded) {
+            return "disk_changed_push_failed";
+          }
+          try {
+            assertGenerationOpen();
+          } catch (err) {
+            if (sendGenerationClosedError(res, err))
+              return "unchanged_failure";
+            throw err;
+          }
         }
-      } catch (err) {
-        if (sendGenerationClosedError(res, err)) return;
-        writeStderrLine(
-          `qwen serve: POST /workspace/settings persist error (key=${key}, scope=${scope}, workspace=${boundWorkspace}): ${err instanceof Error ? err.message : String(err)}`
-        );
-        res.status(500).json({
-          error: "Failed to persist setting",
-          code: "persist_error"
-        });
-        return;
-      }
-      try {
-        assertGenerationOpen();
-      } catch (err) {
-        if (sendGenerationClosedError(res, err)) return;
-        throw err;
-      }
+        return "ok";
+      }, "persistAndPushSessionWorkflow");
+      const writeOutcome = key === "experimental.sessionWorkflow" ? await withSessionWorkflowWriteLock(
+        boundWorkspace,
+        persistAndPushSessionWorkflow
+      ) : await persistAndPushSessionWorkflow();
+      if (writeOutcome === "unchanged_failure") return;
       try {
         broadcastSettingsChanged(key, publicValue, scope, clientId);
       } catch (err) {
@@ -35802,6 +36086,7 @@ function registerWorkspaceSettingsRoutes(app, deps) {
           `qwen serve: POST /workspace/settings broadcast error (key=${key}, scope=${scope}): ${err instanceof Error ? err.message : String(err)}`
         );
       }
+      if (writeOutcome !== "ok") return;
       res.status(200).json({
         key,
         scope,
@@ -35929,57 +36214,90 @@ function registerWorkspaceQualifiedSettingsRoutes(app, deps) {
         return;
       }
       let publicValue = value;
-      try {
-        const persist = /* @__PURE__ */ __name(async () => {
-          const prepared = prepareSettingWrite(
-            runtime.workspaceCwd,
-            settingScope,
-            key,
-            value,
-            mcpServerMutation,
-            true
-          );
-          publicValue = prepared.publicValue;
-          await deps.persistSetting(
-            runtime.workspaceCwd,
-            settingScope,
-            key,
-            prepared.persistedValue,
-            assertGenerationOpen
+      const persistAndPushSessionWorkflow = /* @__PURE__ */ __name(async () => {
+        try {
+          const persist = /* @__PURE__ */ __name(async () => {
+            const prepared = prepareSettingWrite(
+              runtime.workspaceCwd,
+              settingScope,
+              key,
+              value,
+              mcpServerMutation,
+              true
+            );
+            publicValue = prepared.publicValue;
+            await deps.persistSetting(
+              runtime.workspaceCwd,
+              settingScope,
+              key,
+              prepared.persistedValue,
+              assertGenerationOpen
+            );
+          }, "persist");
+          if (mcpServerMutation) {
+            await withMcpServerMutationLock(
+              runtime.workspaceCwd,
+              settingScope,
+              persist
+            );
+          } else {
+            await persist();
+          }
+        } catch (err) {
+          if (sendGenerationClosedError(res, err)) return "unchanged_failure";
+          writeStderrLine(
+            `qwen serve: POST /workspaces/:workspace/settings persist error (key=${key}, scope=${scope}, workspace=${runtime.workspaceCwd}): ${err instanceof Error ? err.message : String(err)}`
           );
-        }, "persist");
-        if (mcpServerMutation) {
-          await withMcpServerMutationLock(
+          res.status(500).json({
+            error: "Failed to persist setting",
+            code: "persist_error"
+          });
+          return "unchanged_failure";
+        }
+        try {
+          assertGenerationOpen();
+        } catch (err) {
+          if (sendGenerationClosedError(res, err)) return "unchanged_failure";
+          throw err;
+        }
+        if (key === "experimental.sessionWorkflow") {
+          if (!await updateLiveSessionWorkflow(
+            (enabled) => runtime.bridge.invokeWorkspaceCommand(
+              SERVE_CONTROL_EXT_METHODS.workspaceSessionWorkflow,
+              { enabled }
+            ),
+            // Push the post-write effective value, not the raw write: a
+            // system-scope (fleet) settings file shadows a workspace write in
+            // mergeSettings, so even on this workspace-only route the written
+            // value is not necessarily the effective one.
+            readEffectiveSessionWorkflow(runtime.workspaceCwd, true),
             runtime.workspaceCwd,
-            settingScope,
-            persist
-          );
-        } else {
-          await persist();
+            res
+          )) {
+            return "disk_changed_push_failed";
+          }
+          try {
+            assertGenerationOpen();
+          } catch (err) {
+            if (sendGenerationClosedError(res, err))
+              return "unchanged_failure";
+            throw err;
+          }
         }
-      } catch (err) {
-        if (sendGenerationClosedError(res, err)) return;
-        writeStderrLine(
-          `qwen serve: POST /workspaces/:workspace/settings persist error (key=${key}, scope=${scope}, workspace=${runtime.workspaceCwd}): ${err instanceof Error ? err.message : String(err)}`
-        );
-        res.status(500).json({
-          error: "Failed to persist setting",
-          code: "persist_error"
-        });
-        return;
-      }
-      try {
-        assertGenerationOpen();
-      } catch (err) {
-        if (sendGenerationClosedError(res, err)) return;
-        throw err;
-      }
+        return "ok";
+      }, "persistAndPushSessionWorkflow");
+      const writeOutcome = key === "experimental.sessionWorkflow" ? await withSessionWorkflowWriteLock(
+        runtime.workspaceCwd,
+        persistAndPushSessionWorkflow
+      ) : await persistAndPushSessionWorkflow();
+      if (writeOutcome === "unchanged_failure") return;
       deps.invalidateServeFeaturesCache();
       runtime.bridge.publishWorkspaceEvent({
         type: "settings_changed",
         data: { key, value: publicValue, scope },
         ...clientId ? { originatorClientId: clientId } : {}
       });
+      if (writeOutcome !== "ok") return;
       res.status(200).json({
         key,
         scope,
@@ -35991,6 +36309,115 @@ function registerWorkspaceQualifiedSettingsRoutes(app, deps) {
 }
 __name(registerWorkspaceQualifiedSettingsRoutes, "registerWorkspaceQualifiedSettingsRoutes");
 
+// packages/cli/src/serve/routes/user-language.ts
+init_esbuild_shims();
+function registerUserLanguageRoutes(app, deps) {
+  app.post("/language", deps.mutate(), async (req, res) => {
+    const body = deps.safeBody(req);
+    const language = body["language"];
+    const syncOutputLanguage = body["syncOutputLanguage"];
+    if (typeof language !== "string" || !deps.languageCodes.includes(language)) {
+      res.status(400).json({
+        error: "`language` is required and must be one of: " + deps.languageCodes.join(", "),
+        code: "invalid_language",
+        allowed: deps.languageCodes
+      });
+      return;
+    }
+    if (syncOutputLanguage !== void 0 && typeof syncOutputLanguage !== "boolean") {
+      res.status(400).json({
+        error: "`syncOutputLanguage` must be a boolean when provided",
+        code: "invalid_sync_flag"
+      });
+      return;
+    }
+    const clientId = deps.parseAndValidateClientId(req, res);
+    if (clientId === null) return;
+    let outputLanguage = null;
+    try {
+      await deps.persistSetting(
+        deps.boundWorkspace,
+        "User" /* User */,
+        "general.language",
+        language
+      );
+      if (syncOutputLanguage === true) {
+        const settingValue = resolveOutputLanguageOrPreserveAuto(language);
+        updateOutputLanguageFile(settingValue);
+        await deps.persistSetting(
+          deps.boundWorkspace,
+          "User" /* User */,
+          "general.outputLanguage",
+          settingValue
+        );
+        outputLanguage = settingValue;
+      }
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: POST /language persist error: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
+        error: "Failed to persist language settings",
+        code: "persist_error"
+      });
+      return;
+    }
+    try {
+      await setLanguageAsync(language);
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: POST /language daemon i18n switch failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    const resolvedLanguage = getCurrentLanguage();
+    const sync = syncOutputLanguage === true;
+    const runtimes = deps.workspaceRegistry.list().filter((r) => r.trusted);
+    const results = await Promise.allSettled(
+      runtimes.map(
+        (runtime) => runtime.bridge.setUserLanguage({
+          language,
+          syncOutputLanguage: sync
+        })
+      )
+    );
+    let refreshedRuntimes = 0;
+    let sessions = 0;
+    let failed = 0;
+    results.forEach((result, index) => {
+      if (result.status === "fulfilled") {
+        refreshedRuntimes += 1;
+        sessions += result.value.sessions;
+        failed += result.value.failed;
+        return;
+      }
+      if (result.reason instanceof SessionNotFoundError) return;
+      failed += 1;
+      writeStderrLine(
+        `qwen serve: POST /language fan-out failed for workspace ${runtimes[index]?.workspaceCwd}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`
+      );
+    });
+    for (const runtime of deps.workspaceRegistry.list()) {
+      try {
+        runtime.bridge.publishWorkspaceEvent({
+          type: "language_changed",
+          data: { language: resolvedLanguage, outputLanguage, userLevel: true },
+          ...clientId ? { originatorClientId: clientId } : {}
+        });
+      } catch (err) {
+        writeStderrLine(
+          `qwen serve: POST /language event publish failed for workspace ${runtime.workspaceCwd}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    res.status(200).json({
+      language: resolvedLanguage,
+      outputLanguage,
+      refresh: { runtimes: refreshedRuntimes, sessions, failed }
+    });
+  });
+}
+__name(registerUserLanguageRoutes, "registerUserLanguageRoutes");
+
 // packages/cli/src/serve/routes/sse-events.ts
 init_esbuild_shims();
 import { randomUUID as randomUUID11 } from "node:crypto";
@@ -36047,7 +36474,7 @@ var SESSION_WRITER_ERROR_MESSAGES = {
 function bridgeErrorExtraContext(ctx) {
   const extra = {};
   for (const [key, value] of Object.entries(ctx ?? {})) {
-    if (key === "route" || key === "sessionId" || value === void 0) {
+    if (key === "route" || key === "sessionId" || key === "initPrecedesMutations" || value === void 0) {
       continue;
     }
     extra[key] = value;
@@ -36115,6 +36542,30 @@ function sendPermissionVoteError(res, err, ctx, daemonLog) {
 }
 __name(sendPermissionVoteError, "sendPermissionVoteError");
 function sendBridgeError(res, err, ctx, daemonLog) {
+  if (err instanceof BridgeTimeoutError && err.label === "initialize") {
+    recordExpectedBridgeError(err, ctx, daemonLog);
+    if (ctx?.initPrecedesMutations === true) {
+      res.set("Retry-After", "5");
+      res.status(504).json({
+        error: err.message,
+        code: "init_timeout",
+        errorKind: "init_timeout",
+        retryable: true,
+        sideEffectPossible: false,
+        phase: "channel.initialize",
+        timeoutMs: err.timeoutMs
+      });
+      return;
+    }
+    res.status(504).json({
+      error: err.message,
+      code: "init_timeout",
+      errorKind: "init_timeout",
+      phase: "channel.initialize",
+      timeoutMs: err.timeoutMs
+    });
+    return;
+  }
   if (err instanceof SessionRestoreTimeoutError) {
     recordExpectedBridgeError(err, ctx, daemonLog);
     res.set("Retry-After", String(restoreRetryAfterSeconds(err.timeoutMs)));
@@ -36301,6 +36752,13 @@ function sendBridgeError(res, err, ctx, daemonLog) {
     });
     return;
   }
+  if (err instanceof McpAuthenticationInProgressError) {
+    res.status(409).json({
+      error: err.message,
+      code: "mcp_authentication_in_progress"
+    });
+    return;
+  }
   if (err instanceof McpServerNotFoundError) {
     res.status(404).json({
       error: err.message,
@@ -38490,6 +38948,7 @@ function registerWorkspaceManagementRoutes(app, deps) {
     });
   }, "isReservedWorkspacePath");
   const inFlight = /* @__PURE__ */ new Map();
+  const internalAdditionsInFlight = /* @__PURE__ */ new Set();
   let sealed = false;
   let activeOperations = 0;
   let pendingScratchCreations = 0;
@@ -38536,10 +38995,12 @@ function registerWorkspaceManagementRoutes(app, deps) {
   }, "restorePersistedDisplayName");
   const projectedWorkspaceCount = /* @__PURE__ */ __name(() => {
     const cwdSet = new Set(
-      workspaceRegistry.listManaged().map((runtime) => runtime.workspaceCwd)
+      workspaceRegistry.listManaged().filter((runtime) => !isInternalWorkspaceRuntime(runtime)).map((runtime) => runtime.workspaceCwd)
     );
     for (const [cwd, operation] of inFlight) {
-      if (operation === "addition") cwdSet.add(cwd);
+      if (operation === "addition" && !internalAdditionsInFlight.has(cwd)) {
+        cwdSet.add(cwd);
+      }
     }
     return cwdSet.size + pendingScratchCreations;
   }, "projectedWorkspaceCount");
@@ -38569,7 +39030,7 @@ function registerWorkspaceManagementRoutes(app, deps) {
     if (nestingConflict) {
       throw new Error("Workspace path nests with an existing workspace");
     }
-    if (projectedWorkspaceCount() >= MAX_REGISTERED_WORKSPACES) {
+    if (provenance !== "live-conversation" && projectedWorkspaceCount() >= MAX_REGISTERED_WORKSPACES) {
       throw new Error("Workspace registration limit reached");
     }
   }, "assertOwnedRuntimeAdmission");
@@ -38579,6 +39040,9 @@ function registerWorkspaceManagementRoutes(app, deps) {
     }
     assertOwnedRuntimeAdmission(canonicalCwd, provenance);
     inFlight.set(canonicalCwd, "addition");
+    if (provenance === "live-conversation") {
+      internalAdditionsInFlight.add(canonicalCwd);
+    }
     operationStarted();
     let runtime;
     let registered = false;
@@ -38601,7 +39065,7 @@ function registerWorkspaceManagementRoutes(app, deps) {
         if (nestingConflict) {
           throw new Error("Workspace path nests with an existing workspace");
         }
-        if (projectedWorkspaceCount() >= MAX_REGISTERED_WORKSPACES) {
+        if (provenance !== "live-conversation" && projectedWorkspaceCount() >= MAX_REGISTERED_WORKSPACES) {
           throw new Error("Workspace registration limit reached");
         }
         workspaceRegistry.add(runtime);
@@ -38633,6 +39097,7 @@ function registerWorkspaceManagementRoutes(app, deps) {
         });
       }
       inFlight.delete(canonicalCwd);
+      internalAdditionsInFlight.delete(canonicalCwd);
       operationFinished();
     }
   }, "publishOwnedRuntime");
@@ -40278,6 +40743,19 @@ __name(registerWorkspaceQualifiedGitLogRoutes, "registerWorkspaceQualifiedGitLog
 // packages/cli/src/serve/routes/workspace-git-branches.ts
 init_esbuild_shims();
 var GIT_ERROR_MESSAGE_MAX = 512;
+function redactGitPaths(detail, cwd) {
+  const gitRoot = findGitRoot(cwd);
+  let message = detail.split(cwd).join("<workspace>");
+  if (gitRoot && gitRoot !== cwd) {
+    message = message.split(gitRoot).join("<workspace>");
+  }
+  return message;
+}
+__name(redactGitPaths, "redactGitPaths");
+function redactGitMessage(detail, cwd) {
+  return redactGitPaths(detail, cwd).slice(0, GIT_ERROR_MESSAGE_MAX);
+}
+__name(redactGitMessage, "redactGitMessage");
 function sendGitError(res, err, route, sendBridgeError2, cwd) {
   let detail;
   if (err && typeof err === "object" && ("stdout" in err || "stderr" in err)) {
@@ -40287,12 +40765,7 @@ ${e.stderr ?? ""}`;
   } else {
     detail = err instanceof Error ? err.message : String(err);
   }
-  const gitRoot = findGitRoot(cwd);
-  let message = detail.split(cwd).join("<workspace>");
-  if (gitRoot && gitRoot !== cwd) {
-    message = message.split(gitRoot).join("<workspace>");
-  }
-  message = message.slice(0, GIT_ERROR_MESSAGE_MAX);
+  const message = redactGitMessage(detail, cwd);
   if (/not a git repository/i.test(message) || /invalid reference/i.test(message)) {
     res.status(404).json({ error: "not_a_git_repository", message });
     return;
@@ -40425,12 +40898,40 @@ async function handlePull(req, res, cwd, sendBridgeError2, route, env) {
     });
     return;
   }
+  if (body["stash"] !== void 0 && typeof body["stash"] !== "boolean") {
+    res.status(400).json({ error: "invalid_stash", message: "stash must be a boolean" });
+    return;
+  }
+  if (body["force"] !== void 0 && typeof body["force"] !== "boolean") {
+    res.status(400).json({ error: "invalid_force", message: "force must be a boolean" });
+    return;
+  }
   const rebase = body["rebase"] === true;
   const fetchOnly = body["fetchOnly"] === true;
+  const stash = body["stash"] === true;
+  const force = body["force"] === true;
+  if (stash && force) {
+    res.status(400).json({
+      error: "invalid_stash_force",
+      message: "stash and force are mutually exclusive"
+    });
+    return;
+  }
+  if (fetchOnly && (stash || force)) {
+    res.status(400).json({
+      error: "invalid_fetch_only_combination",
+      message: "fetchOnly cannot be combined with stash or force"
+    });
+    return;
+  }
   try {
-    const result = await gitPull(cwd, { rebase, fetchOnly }, env);
-    res.status(200).json(result);
+    const result = await gitPull(cwd, { rebase, fetchOnly, stash, force }, env);
+    res.status(200).json({ ...result, output: redactGitPaths(result.output, cwd) });
   } catch (err) {
+    if (err instanceof GitPullFailure) {
+      res.status(409).json({ error: err.code, message: redactGitMessage(err.message, cwd) });
+      return;
+    }
     sendGitError(res, err, route, sendBridgeError2, cwd);
   }
 }
@@ -40968,6 +41469,46 @@ function registerWorkspaceQualifiedGitHubPrsRoutes(app, deps) {
 }
 __name(registerWorkspaceQualifiedGitHubPrsRoutes, "registerWorkspaceQualifiedGitHubPrsRoutes");
 
+// packages/cli/src/serve/routes/workspace-local-open.ts
+init_esbuild_shims();
+function registerWorkspaceLocalOpenRoutes(app, deps) {
+  const openLocally = deps.openPathLocally ?? openPathLocally;
+  const openTerminal = deps.openTerminalLocally ?? openTerminalLocally;
+  app.post(
+    "/workspaces/:workspace/open",
+    deps.mutate(),
+    async (req, res) => {
+      const runtime = resolveTrustedRuntime(deps.workspaceRegistry, req, res);
+      if (!runtime) return;
+      const target = safeBody(req)["target"] === "terminal" ? "terminal" : "folder";
+      try {
+        if (target === "terminal") {
+          await openTerminal(runtime.workspaceCwd);
+        } else {
+          await openLocally(runtime.workspaceCwd);
+        }
+        res.status(200).json({ kind: "workspace-local-open", opened: true, target });
+      } catch (error2) {
+        const detail = error2 instanceof Error ? error2.message : String(error2);
+        if (error2 instanceof LocalPathOpenUnavailableError) {
+          writeStderrLine(`qwen serve: local path open unavailable: ${detail}`);
+          res.status(501).json({
+            error: "Local path open is unavailable",
+            code: "local_path_open_unavailable"
+          });
+          return;
+        }
+        writeStderrLine(`qwen serve: local path open failed: ${detail}`);
+        res.status(500).json({
+          error: "Failed to open workspace locally",
+          code: "local_path_open_failed"
+        });
+      }
+    }
+  );
+}
+__name(registerWorkspaceLocalOpenRoutes, "registerWorkspaceLocalOpenRoutes");
+
 // packages/cli/src/serve/workspace-git-state.ts
 init_esbuild_shims();
 var BACKGROUND_REFRESH_THROTTLE_MS = 2e3;
@@ -41675,6 +42216,583 @@ function registerWorkspaceQualifiedMcpControlRoutes(app, deps) {
 }
 __name(registerWorkspaceQualifiedMcpControlRoutes, "registerWorkspaceQualifiedMcpControlRoutes");
 
+// packages/cli/src/serve/routes/workspace-mcp-config.ts
+init_esbuild_shims();
+function asRecord4(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? redactMcpServersSetting(value) : {};
+}
+__name(asRecord4, "asRecord");
+function buildMcpConfigStatus(workspaceCwd) {
+  const settings = loadSettings(workspaceCwd, {
+    skipLoadEnvironment: true
+  });
+  const effective = asRecord4(settings.merged.mcpServers);
+  const user = asRecord4(settings.user.settings.mcpServers);
+  const workspace = asRecord4(settings.workspace.settings.mcpServers);
+  return {
+    v: 1,
+    effective,
+    user,
+    workspace
+  };
+}
+__name(buildMcpConfigStatus, "buildMcpConfigStatus");
+function affectedRuntimes(registry, target, scope) {
+  return scope === "user" ? registry.listManaged().filter((runtime) => runtime.trusted) : target.runtime ? [target.runtime] : [];
+}
+__name(affectedRuntimes, "affectedRuntimes");
+function scheduleMcpConfiguration(runtimes) {
+  let reconciling = false;
+  for (const runtime of runtimes) {
+    try {
+      if (getWorkspaceRuntimeCoordinator(runtime).reconcileMcpConfiguration() === "reconciling") {
+        reconciling = true;
+      }
+    } catch {
+    }
+  }
+  return reconciling ? "reconciling" : "deferred";
+}
+__name(scheduleMcpConfiguration, "scheduleMcpConfiguration");
+function runManagementOperation(target, operation) {
+  return target.runtime ? getWorkspaceRuntimeCoordinator(target.runtime).runManagementOperation(
+    operation
+  ) : operation();
+}
+__name(runManagementOperation, "runManagementOperation");
+function registerFor2(app, base, scope, resolveReadTarget, resolveMutationTarget, deps) {
+  const settingScope = scope === "user" ? "User" /* User */ : "Workspace" /* Workspace */;
+  app.get(`${base}/config/mcp/servers`, (req, res) => {
+    const target = resolveReadTarget(req, res);
+    if (!target) return;
+    try {
+      res.status(200).json(buildMcpConfigStatus(target.workspaceCwd));
+    } catch (error2) {
+      deps.sendBridgeError(res, error2, {
+        route: `GET ${base}/config/mcp/servers`
+      });
+    }
+  });
+  app.put(
+    `${base}/config/mcp/servers/:name`,
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const target = resolveMutationTarget(req, res);
+      if (!target) return;
+      const name = req.params["name"];
+      if (!validateMcpRuntimeServerName(name, res)) return;
+      const body = deps.safeBody(req);
+      if (body["scope"] !== scope) {
+        res.status(400).json({
+          error: `scope must be ${scope}`,
+          code: "invalid_scope"
+        });
+        return;
+      }
+      const config = body["config"];
+      if (!config || typeof config !== "object" || Array.isArray(config)) {
+        res.status(400).json({
+          error: "config is required and must be an object",
+          code: "invalid_mcp_server_config"
+        });
+        return;
+      }
+      try {
+        const result = await runManagementOperation(target, async () => {
+          let publicValue;
+          await withMcpServerMutationLock(
+            target.workspaceCwd,
+            settingScope,
+            async () => {
+              const prepared = prepareSettingWrite(
+                target.workspaceCwd,
+                settingScope,
+                "mcpServers",
+                config,
+                { operation: "set", name }
+              );
+              const definition = getSettingDefinition("mcpServers");
+              const validationError = definition ? validateSettingValue(definition, prepared.persistedValue) : void 0;
+              if (validationError) {
+                const error2 = new Error(validationError);
+                error2.code = "invalid_mcp_server_config";
+                throw error2;
+              }
+              await deps.persistSetting(
+                target.workspaceCwd,
+                settingScope,
+                "mcpServers",
+                prepared.persistedValue,
+                target.runtime?.generationGuard?.assertOpen
+              );
+              publicValue = prepared.publicValue;
+            }
+          );
+          const servers = asRecord4(publicValue);
+          return {
+            config: servers[name],
+            publicValue,
+            activation: scheduleMcpConfiguration(
+              affectedRuntimes(deps.workspaceRegistry, target, scope)
+            )
+          };
+        });
+        publishConfiguration(
+          target,
+          scope,
+          "mcpServers",
+          result.publicValue,
+          deps
+        );
+        res.status(200).json({
+          name,
+          scope,
+          config: result.config,
+          activation: result.activation
+        });
+      } catch (error2) {
+        if (error2 instanceof Error && error2.code === "invalid_mcp_server_config") {
+          res.status(400).json({
+            error: error2.message,
+            code: "invalid_mcp_server_config"
+          });
+          return;
+        }
+        deps.sendBridgeError(res, error2, {
+          route: `PUT ${base}/config/mcp/servers/:name`
+        });
+      }
+    }
+  );
+  app.delete(
+    `${base}/config/mcp/servers/:name`,
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const target = resolveMutationTarget(req, res);
+      if (!target) return;
+      const name = req.params["name"];
+      if (!validateMcpRuntimeServerName(name, res)) return;
+      if (req.query["scope"] !== scope) {
+        res.status(400).json({
+          error: `scope must be ${scope}`,
+          code: "invalid_scope"
+        });
+        return;
+      }
+      try {
+        const result = await runManagementOperation(target, async () => {
+          let publicValue;
+          await withMcpServerMutationLock(
+            target.workspaceCwd,
+            settingScope,
+            async () => {
+              const prepared = prepareSettingWrite(
+                target.workspaceCwd,
+                settingScope,
+                "mcpServers",
+                {},
+                { operation: "remove", name }
+              );
+              await deps.persistSetting(
+                target.workspaceCwd,
+                settingScope,
+                "mcpServers",
+                prepared.persistedValue,
+                target.runtime?.generationGuard?.assertOpen
+              );
+              publicValue = prepared.publicValue;
+            }
+          );
+          return {
+            publicValue,
+            activation: scheduleMcpConfiguration(
+              affectedRuntimes(deps.workspaceRegistry, target, scope)
+            )
+          };
+        });
+        publishConfiguration(
+          target,
+          scope,
+          "mcpServers",
+          result.publicValue,
+          deps
+        );
+        res.status(200).json({ name, scope, activation: result.activation });
+      } catch (error2) {
+        deps.sendBridgeError(res, error2, {
+          route: `DELETE ${base}/config/mcp/servers/:name`
+        });
+      }
+    }
+  );
+  for (const action of ["enable", "disable"]) {
+    app.post(
+      `${base}/config/mcp/:server/${action}`,
+      deps.mutate({ strict: true }),
+      async (req, res) => {
+        const target = resolveMutationTarget(req, res);
+        if (!target) return;
+        const serverName = req.params["server"];
+        if (!validateMcpRuntimeServerName(serverName, res)) return;
+        try {
+          const result = await runManagementOperation(target, async () => {
+            let changed = false;
+            let next = [];
+            let blocking = [];
+            await withMcpServerMutationLock(
+              target.workspaceCwd,
+              settingScope,
+              async () => {
+                const settings = loadSettings(target.workspaceCwd, {
+                  skipLoadEnvironment: true
+                });
+                const existing = settings.forScope(settingScope).settings.mcp?.excluded ?? [];
+                if (action === "enable") {
+                  const blockingScopes = [
+                    "SystemDefaults" /* SystemDefaults */,
+                    "System" /* System */,
+                    "User" /* User */,
+                    ...settingScope === "Workspace" /* Workspace */ ? ["Workspace" /* Workspace */] : []
+                  ];
+                  blocking = blockingScopes.flatMap(
+                    (candidateScope) => (settings.forScope(candidateScope).settings.mcp?.excluded ?? []).filter(
+                      (pattern) => matchesAnyServerPattern(serverName, [pattern]) && (candidateScope !== settingScope || pattern !== serverName)
+                    )
+                  );
+                  if (blocking.length > 0) return;
+                }
+                next = action === "enable" ? existing.filter((pattern) => pattern !== serverName) : existing.includes(serverName) ? existing : [...existing, serverName];
+                changed = next.length !== existing.length;
+                if (changed) {
+                  await deps.persistSetting(
+                    target.workspaceCwd,
+                    settingScope,
+                    "mcp.excluded",
+                    next,
+                    target.runtime?.generationGuard?.assertOpen
+                  );
+                }
+              }
+            );
+            if (blocking.length > 0) {
+              res.status(409).json({
+                error: `MCP server is excluded by pattern: ${blocking.join(", ")}`,
+                code: "mcp_excluded_by_pattern",
+                patterns: blocking
+              });
+              return null;
+            }
+            return {
+              changed,
+              value: next,
+              activation: changed ? scheduleMcpConfiguration(
+                affectedRuntimes(deps.workspaceRegistry, target, scope)
+              ) : "applied"
+            };
+          });
+          if (!result) return;
+          if (result.changed) {
+            publishConfiguration(
+              target,
+              scope,
+              "mcp.excluded",
+              result.value,
+              deps
+            );
+          }
+          res.status(200).json({
+            serverName,
+            action,
+            ok: true,
+            changed: result.changed,
+            activation: result.activation
+          });
+        } catch (error2) {
+          deps.sendBridgeError(res, error2, {
+            route: `POST ${base}/config/mcp/:server/${action}`
+          });
+        }
+      }
+    );
+  }
+}
+__name(registerFor2, "registerFor");
+function publishConfiguration(target, scope, key, value, deps) {
+  deps.invalidateServeFeaturesCache();
+  if (scope === "user") {
+    try {
+      deps.broadcastSettingsChanged(key, value, scope, void 0);
+    } catch {
+    }
+    for (const candidate of deps.workspaceRegistry.listManaged()) {
+      if (candidate.workspaceCwd === target.workspaceCwd) continue;
+      try {
+        candidate.bridge.publishWorkspaceEvent({
+          type: "settings_changed",
+          data: { key, value, scope }
+        });
+      } catch {
+      }
+    }
+    return;
+  }
+  try {
+    target.runtime?.bridge.publishWorkspaceEvent({
+      type: "settings_changed",
+      data: { key, value, scope }
+    });
+  } catch {
+  }
+}
+__name(publishConfiguration, "publishConfiguration");
+function registerWorkspaceMcpConfigRoutes(app, deps) {
+  registerFor2(
+    app,
+    "/workspace",
+    "user",
+    () => ({ workspaceCwd: deps.workspaceRegistry.primaryEntry.workspaceCwd }),
+    () => ({ workspaceCwd: deps.workspaceRegistry.primaryEntry.workspaceCwd }),
+    deps
+  );
+  registerFor2(
+    app,
+    "/workspaces/:workspace",
+    "workspace",
+    (req, res) => {
+      const entry = resolveWorkspaceEntryFromParam(
+        deps.workspaceRegistry,
+        req,
+        res
+      );
+      return entry ? { workspaceCwd: entry.workspaceCwd } : null;
+    },
+    (req, res) => {
+      const runtime = resolveWorkspaceRuntimeFromParam(
+        deps.workspaceRegistry,
+        req,
+        res
+      );
+      return runtime && requireTrustedWorkspaceRuntime(runtime, res) ? { workspaceCwd: runtime.workspaceCwd, runtime } : null;
+    },
+    deps
+  );
+}
+__name(registerWorkspaceMcpConfigRoutes, "registerWorkspaceMcpConfigRoutes");
+
+// packages/cli/src/serve/routes/workspace-runtime-mcp.ts
+init_esbuild_shims();
+function validateRuntimeServerName(name, res) {
+  if (typeof name === "string" && name.length > 0 && name.length <= MAX_SERVER_NAME_LENGTH && name !== "__proto__" && name !== "constructor" && name !== "prototype")
+    return true;
+  res.status(400).json({
+    error: name === "__proto__" || name === "constructor" || name === "prototype" ? "Server name must not be a reserved JS property name" : typeof name === "string" && name.length > 0 ? `Server name exceeds ${MAX_SERVER_NAME_LENGTH}-character limit` : "Server name is required and must be a non-empty string",
+    code: "invalid_server_name"
+  });
+  return false;
+}
+__name(validateRuntimeServerName, "validateRuntimeServerName");
+function requireRuntimeCoordinator2(runtime, res) {
+  const coordinator = getWorkspaceRuntimeCoordinatorIfSupported(runtime);
+  if (coordinator) return coordinator;
+  res.status(501).json({
+    error: "Workspace runtime lifecycle is not supported",
+    code: "workspace_runtime_not_supported"
+  });
+  return void 0;
+}
+__name(requireRuntimeCoordinator2, "requireRuntimeCoordinator");
+function parseReloadOptions(body, res) {
+  const forceReconnectAll = body["forceReconnectAll"];
+  const forceReconnectWhich = body["forceReconnectWhich"];
+  if (forceReconnectAll !== void 0 && typeof forceReconnectAll !== "boolean") {
+    res.status(400).json({
+      error: "`forceReconnectAll` must be a boolean",
+      code: "invalid_force_reconnect_all_flag"
+    });
+    return null;
+  }
+  if (forceReconnectWhich !== void 0 && (!Array.isArray(forceReconnectWhich) || forceReconnectWhich.some(
+    (name) => typeof name !== "string" || name.length === 0
+  ))) {
+    res.status(400).json({
+      error: "`forceReconnectWhich` must be an array of server names",
+      code: "invalid_force_reconnect_which"
+    });
+    return null;
+  }
+  if (forceReconnectAll === true && forceReconnectWhich !== void 0) {
+    res.status(400).json({
+      error: "Reconnect options cannot be combined",
+      code: "conflicting_force_reconnect_options"
+    });
+    return null;
+  }
+  return {
+    ...forceReconnectAll === void 0 ? {} : { forceReconnectAll },
+    ...forceReconnectWhich === void 0 ? {} : { forceReconnectWhich }
+  };
+}
+__name(parseReloadOptions, "parseReloadOptions");
+function parseEntryIndex(req, res) {
+  const raw = req.query["entryIndex"];
+  if (raw === void 0 || raw === "*") return void 0;
+  const value = typeof raw === "string" ? Number.parseInt(raw, 10) : NaN;
+  if (!Number.isInteger(value) || value < 0 || String(value) !== raw) {
+    res.status(400).json({
+      error: '`entryIndex` must be a non-negative integer or "*"',
+      code: "invalid_entry_index"
+    });
+    return null;
+  }
+  return value;
+}
+__name(parseEntryIndex, "parseEntryIndex");
+function registerFor3(app, base, resolveRuntime, deps) {
+  app.get(`${base}/runtime/mcp`, async (req, res) => {
+    const runtime = resolveRuntime(req, res);
+    if (!runtime) return;
+    const route = `GET ${base}/runtime/mcp`;
+    try {
+      res.status(200).json(
+        await runtime.workspaceService.getWorkspaceMcpStatus(
+          createBuildWorkspaceCtx(runtime.workspaceCwd)(route)
+        )
+      );
+    } catch (error2) {
+      deps.sendBridgeError(res, error2, { route });
+    }
+  });
+  app.get(`${base}/runtime/mcp/:server/tools`, async (req, res) => {
+    const runtime = resolveRuntime(req, res);
+    if (!runtime) return;
+    const serverName = req.params["server"];
+    if (!validateRuntimeServerName(serverName, res)) return;
+    const route = `GET ${base}/runtime/mcp/:server/tools`;
+    try {
+      res.status(200).json(await runtime.bridge.getWorkspaceMcpToolsStatus(serverName));
+    } catch (error2) {
+      deps.sendBridgeError(res, error2, { route });
+    }
+  });
+  app.get(`${base}/runtime/mcp/:server/resources`, async (req, res) => {
+    const runtime = resolveRuntime(req, res);
+    if (!runtime) return;
+    const serverName = req.params["server"];
+    if (!validateRuntimeServerName(serverName, res)) return;
+    const route = `GET ${base}/runtime/mcp/:server/resources`;
+    try {
+      res.status(200).json(await runtime.bridge.getWorkspaceMcpResourcesStatus(serverName));
+    } catch (error2) {
+      deps.sendBridgeError(res, error2, { route });
+    }
+  });
+  app.post(
+    `${base}/runtime/mcp/reload`,
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const runtime = resolveRuntime(req, res);
+      if (!runtime) return;
+      const coordinator = requireRuntimeCoordinator2(runtime, res);
+      if (!coordinator) return;
+      const options = parseReloadOptions(deps.safeBody(req), res);
+      if (!options) return;
+      const route = `POST ${base}/runtime/mcp/reload`;
+      try {
+        const result = await coordinator.runMcpRuntimeMutation(
+          () => runtime.bridge.reloadWorkspaceMcp(options)
+        );
+        runtime.generationGuard?.assertOpen();
+        res.status(200).json(result);
+      } catch (error2) {
+        deps.sendBridgeError(res, error2, { route });
+      }
+    }
+  );
+  app.post(
+    `${base}/runtime/mcp/:server/restart`,
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const runtime = resolveRuntime(req, res);
+      if (!runtime) return;
+      const coordinator = requireRuntimeCoordinator2(runtime, res);
+      if (!coordinator) return;
+      const serverName = req.params["server"];
+      if (!validateRuntimeServerName(serverName, res)) return;
+      const entryIndex = parseEntryIndex(req, res);
+      if (entryIndex === null) return;
+      const route = `POST ${base}/runtime/mcp/:server/restart`;
+      try {
+        const result = await coordinator.runMcpRuntimeMutation(
+          () => runtime.workspaceService.restartMcpServer(
+            createBuildWorkspaceCtx(runtime.workspaceCwd)(route),
+            serverName,
+            entryIndex === void 0 ? void 0 : { entryIndex }
+          )
+        );
+        runtime.generationGuard?.assertOpen();
+        res.status(200).json(result);
+      } catch (error2) {
+        deps.sendBridgeError(res, error2, { route });
+      }
+    }
+  );
+  for (const action of ["approve", "authenticate", "clear-auth"]) {
+    app.post(
+      `${base}/runtime/mcp/:server/${action}`,
+      deps.mutate({ strict: true }),
+      async (req, res) => {
+        const runtime = resolveRuntime(req, res);
+        if (!runtime) return;
+        const coordinator = requireRuntimeCoordinator2(runtime, res);
+        if (!coordinator) return;
+        const serverName = req.params["server"];
+        if (!validateRuntimeServerName(serverName, res)) return;
+        const route = `POST ${base}/runtime/mcp/:server/${action}`;
+        try {
+          const result = await coordinator.runMcpRuntimeMutation(
+            () => runtime.bridge.manageMcpServer(serverName, action, void 0)
+          );
+          runtime.generationGuard?.assertOpen();
+          res.status(200).json(result);
+        } catch (error2) {
+          deps.sendBridgeError(res, error2, { route });
+        }
+      }
+    );
+  }
+}
+__name(registerFor3, "registerFor");
+function registerWorkspaceRuntimeMcpRoutes(app, deps) {
+  registerFor3(
+    app,
+    "/workspace",
+    (_req, res) => {
+      const entry = deps.workspaceRegistry.primaryEntry;
+      const runtime = entry.state === "active" ? entry.current?.runtime : void 0;
+      if (!runtime) {
+        sendWorkspaceRuntimeUnavailable(res, entry);
+        return null;
+      }
+      return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
+    },
+    deps
+  );
+  registerFor3(
+    app,
+    "/workspaces/:workspace",
+    (req, res) => {
+      const runtime = resolveWorkspaceRuntimeFromParam(
+        deps.workspaceRegistry,
+        req,
+        res
+      );
+      return runtime && requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
+    },
+    deps
+  );
+}
+__name(registerWorkspaceRuntimeMcpRoutes, "registerWorkspaceRuntimeMcpRoutes");
+
 // packages/cli/src/serve/routes/workspace-channel-control.ts
 init_esbuild_shims();
 function parseSelection(body, res) {
@@ -43412,6 +44530,12 @@ function parseHostMessage(text) {
       };
     }
   }
+  if (value["type"] === "host.playback_started" && typeof value["epoch"] === "number") {
+    return { type: "host.playback_started", epoch: value["epoch"] };
+  }
+  if (value["type"] === "host.playback_completed" && typeof value["epoch"] === "number") {
+    return { type: "host.playback_completed", epoch: value["epoch"] };
+  }
   return void 0;
 }
 __name(parseHostMessage, "parseHostMessage");
@@ -43961,6 +45085,9 @@ var LiveHostCoordinator = class {
       this.handleShortcutResult(message);
       return;
     }
+    if (message.type === "host.playback_started" || message.type === "host.playback_completed") {
+      return;
+    }
     this.handleAction(message);
   }
   handleShortcutResult(message) {
@@ -46915,6 +48042,9 @@ var LiveHostInstaller = class {
     return operation;
   }
   async launch() {
+    if (this.platform !== "darwin") {
+      return this.setError("Qwen Live Host is available only on macOS.", false);
+    }
     if (this.operation) return await this.operation;
     try {
       const installed = await this.inspectInstalled();
@@ -47581,7 +48711,7 @@ var LiveSessionCoordinator = class {
         try {
           context.runtime?.bridge.updateSessionMetadata(
             context.coordinator.sessionId,
-            { displayName: "Voice chat" }
+            { displayName: "Voice chat", titleSource: "auto" }
           );
         } catch {
         }
@@ -50132,6 +51262,8 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
         (runtime) => supportsWorkspaceRuntimeLifecycle(runtime.bridge)
       );
     }, "workspaceRuntimeAvailable"),
+    localPathOpenAvailable: deps.localPathOpenAvailable ?? isLocalPathOpenAvailable(),
+    localTerminalOpenAvailable: deps.localTerminalOpenAvailable ?? isLocalTerminalAvailable(),
     workspaceTrustHotReloadAvailable: deps.workspaceTrustHotReloadAvailable === true,
     isPrimaryWorkspaceTrusted: /* @__PURE__ */ __name(() => isPrimaryWorkspaceTrusted(), "isPrimaryWorkspaceTrusted"),
     ...deps.workspaceTrustHotReloadAvailable === true ? {
@@ -50153,11 +51285,13 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   }) : void 0;
   const defaultSessionOwnerIndex = !injectedWorkspaceRegistry ? createWorkspaceSessionOwnerIndex() : void 0;
   const acpChildArgs = acpChildExtraArgs(opts);
+  const attachmentsRoots = sessionAttachmentsRoots(
+    boundWorkspace,
+    Storage.getRuntimeBaseDir()
+  );
   const bridge = injectedWorkspaceRegistry?.primary.bridge ?? deps.bridge ?? createAcpSessionBridge({
-    sessionAttachmentsRoot: path18.join(
-      new Storage(boundWorkspace).getProjectTempDir(),
-      "attachments"
-    ),
+    sessionAttachmentsRoot: attachmentsRoots.root,
+    sessionAttachmentsFallbackRoot: attachmentsRoots.fallback,
     maxSessions: opts.maxSessions,
     ...totalSessionAdmission ? { freshSessionAdmission: totalSessionAdmission.admit } : {},
     ...defaultSessionOwnerIndex ? {
@@ -50443,6 +51577,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   let liveBindingPromise;
   let liveRuntimeBootPromise;
   let liveRuntimeBootResult;
+  let liveRuntimeBootWarned = false;
   let liveAppshotChannelPromise;
   let liveCoordinatorSealed = false;
   const clearLiveRuntimeHandlers = /* @__PURE__ */ __name((runtime) => {
@@ -50520,10 +51655,30 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     liveBindingPromise = pending;
     return pending;
   }, "ensureLiveConversationRuntime");
+  const describeConversationBootError = /* @__PURE__ */ __name((error2) => {
+    const messages = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = error2;
+    while (current instanceof Error && !seen.has(current) && messages.length < 8) {
+      seen.add(current);
+      messages.push(current.message);
+      current = current.cause;
+    }
+    return messages.length > 0 ? messages.join(" <- ") : String(error2);
+  }, "describeConversationBootError");
   const startConversationRuntimeBoot = /* @__PURE__ */ __name(() => {
     if (liveRuntimeBootPromise) return liveRuntimeBootPromise;
     const pending = ensureLiveConversationRuntime().then((runtime) => {
       liveRuntimeBootResult = runtime;
+      liveRuntimeBootWarned = false;
+    }).catch((error2) => {
+      if (!liveRuntimeBootWarned) {
+        liveRuntimeBootWarned = true;
+        writeStderrLineSafe(
+          `qwen serve: Conversations runtime boot failed: ${describeConversationBootError(error2)}`
+        );
+      }
+      throw error2;
     }).finally(() => {
       if (liveRuntimeBootPromise === pending) {
         liveRuntimeBootPromise = void 0;
@@ -51047,6 +52202,10 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     gitState: workspaceGitState,
     sendBridgeError: sendBridgeError2
   });
+  registerWorkspaceLocalOpenRoutes(app, {
+    workspaceRegistry,
+    mutate
+  });
   registerWorkspaceGitDiffRoutes(app, {
     boundWorkspace: primaryBoundWorkspace,
     sendBridgeError: sendBridgeError2,
@@ -51286,11 +52445,28 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   app.locals.workspaceRuntimeRemoval = deps.workspaceRuntimeRemoval;
   const broadcastSettingsChanged = /* @__PURE__ */ __name((key, value, scope, clientId) => {
     invalidateServeFeaturesCache();
-    primaryBridge.publishWorkspaceEvent({
+    const event = {
       type: "settings_changed",
-      data: { key, value, scope },
-      ...clientId ? { originatorClientId: clientId } : {}
-    });
+      data: { key, value, scope }
+    };
+    const publish = /* @__PURE__ */ __name((bridge2, workspace2, originatorClientId) => {
+      try {
+        bridge2.publishWorkspaceEvent({
+          ...event,
+          ...originatorClientId ? { originatorClientId } : {}
+        });
+      } catch (err) {
+        writeStderrLine(
+          `qwen serve: settings_changed broadcast to workspace ${workspace2} failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }, "publish");
+    publish(primaryBridge, primaryBoundWorkspace, clientId);
+    if (scope !== "user") return;
+    for (const runtime of workspaceRegistry.listAll()) {
+      if (runtime.primary) continue;
+      publish(runtime.bridge, runtime.workspaceCwd);
+    }
   }, "broadcastSettingsChanged");
   if (deps.persistSetting) {
     const persistSetting = deps.persistSetting;
@@ -51303,6 +52479,33 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       persistSetting: /* @__PURE__ */ __name(async (...args) => {
         await persistSetting(...args);
       }, "persistSetting"),
+      updateSessionWorkflow: /* @__PURE__ */ __name((enabled) => primaryBridge.invokeWorkspaceCommand(
+        SERVE_CONTROL_EXT_METHODS.workspaceSessionWorkflow,
+        { enabled }
+      ), "updateSessionWorkflow"),
+      updateSiblingSessionWorkflows: /* @__PURE__ */ __name(async () => {
+        for (const runtime of workspaceRegistry.listAll()) {
+          if (runtime.primary) continue;
+          try {
+            await withSessionWorkflowWriteLock(
+              runtime.workspaceCwd,
+              () => runtime.bridge.invokeWorkspaceCommand(
+                SERVE_CONTROL_EXT_METHODS.workspaceSessionWorkflow,
+                {
+                  enabled: readEffectiveSessionWorkflow(
+                    runtime.workspaceCwd,
+                    runtime.trusted
+                  )
+                }
+              )
+            );
+          } catch (err) {
+            writeStderrLine(
+              `qwen serve: Session Workflow push to sibling workspace ${runtime.workspaceCwd} failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      }, "updateSiblingSessionWorkflows"),
       broadcastSettingsChanged,
       parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId"),
       includeLiveVoice: liveVoiceSurfaceAvailable
@@ -51316,6 +52519,31 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       }, "persistSetting"),
       invalidateServeFeaturesCache
     });
+    registerUserLanguageRoutes(app, {
+      boundWorkspace: primaryBoundWorkspace,
+      mutate,
+      safeBody,
+      languageCodes,
+      persistSetting: /* @__PURE__ */ __name(async (...args) => {
+        await persistSetting(...args);
+      }, "persistSetting"),
+      workspaceRegistry,
+      parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, [
+        primaryBridge,
+        ...workspaceRegistry.list().map((runtime) => runtime.bridge)
+      ]), "parseAndValidateClientId")
+    });
+    registerWorkspaceMcpConfigRoutes(app, {
+      workspaceRegistry,
+      mutate,
+      safeBody,
+      persistSetting: /* @__PURE__ */ __name(async (...args) => {
+        await persistSetting(...args);
+      }, "persistSetting"),
+      sendBridgeError: sendBridgeError2,
+      invalidateServeFeaturesCache,
+      broadcastSettingsChanged
+    });
   }
   registerWorkspacePermissionsRoutes(app, {
     boundWorkspace: primaryBoundWorkspace,
@@ -51448,6 +52676,12 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     safeBody,
     sendBridgeError: sendBridgeError2
   });
+  registerWorkspaceRuntimeMcpRoutes(app, {
+    workspaceRegistry,
+    mutate,
+    safeBody,
+    sendBridgeError: sendBridgeError2
+  });
   const channelWorkerControl = deps.getChannelWorkerControl ?? (deps.getChannelWorkerSnapshot ? () => {
     const workers = deps.getChannelWorkerSnapshots?.() ?? [];
     const primary = deps.getChannelWorkerSnapshot();