@qwen-code/qwen-code 0.19.11 → 0.19.12-preview.0

package/chunks/{server-5ECMV4TM.js → server-AA24QLPA.js}

@@ -14,12 +14,12 @@ import {
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-QOTQH4CB.js";
+} from "./chunk-4AGBO6RB.js";
 import {
   openQwenAsrRealtimeStream,
   openVoiceStream,
   openVoiceStreamWithRetry
-} from "./chunk-5VWYKIMW.js";
+} from "./chunk-KANTXY7B.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -30,11 +30,21 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-6Y6ORE2G.js";
-import "./chunk-CF5VJRGC.js";
-import "./chunk-SUARMD4Q.js";
+} from "./chunk-WACI4VES.js";
+import {
+  OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS,
+  ObservedChannelContactStore
+} from "./chunk-QSG4ZFG4.js";
+import "./chunk-7LMAKIWE.js";
+import "./chunk-J6NT5YTN.js";
 import "./chunk-QHTIBUWB.js";
+import "./chunk-76BFY7AF.js";
+import "./chunk-HTHUX2T5.js";
 import "./chunk-L573Z2QZ.js";
+import {
+  createSingleWorkspaceRegistry,
+  createWorkspaceSessionOwnerIndex
+} from "./chunk-W7H223ZZ.js";
 import {
   CAPABILITIES_SCHEMA_VERSION,
   CLIENT_ID_HEADER,
@@ -44,7 +54,6 @@ import {
   MAX_CLIENT_ID_LENGTH,
   MAX_CONCURRENT_VOICE_SESSIONS,
   MAX_SERVER_NAME_LENGTH,
-  MAX_SKILL_NAME_LENGTH,
   MAX_TOOL_NAME_LENGTH,
   PathMutexRegistry,
   QWEN_CDP_MCP_COMMAND_ENV,
@@ -65,6 +74,7 @@ import {
   denyBrowserOriginCors,
   detectFromLoopback,
   getAdvertisedServeFeatures,
+  getDeferredRuntimeRequestTiming,
   getServeProtocolVersions,
   hostAllowlist,
   isBrowserAutomationMcpAvailable,
@@ -89,48 +99,51 @@ import {
   setRateLimiter,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-KXYJPRT5.js";
+} from "./chunk-BEZPRKD3.js";
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-6EDDYPI3.js";
+} from "./chunk-JUNVFQVY.js";
 import "./chunk-LXXMOYPL.js";
-import "./chunk-S63Z5V42.js";
+import "./chunk-F2YCCUXI.js";
 import "./chunk-E5Z2AVNV.js";
 import {
   createWorkspaceProvidersStatusProvider
-} from "./chunk-7ZYHLN67.js";
+} from "./chunk-7OZGMFHC.js";
 import {
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-ZIXOTAPZ.js";
+} from "./chunk-2DZ7E27L.js";
 import {
   snapshotProcessEnv
-} from "./chunk-SY7NEYX4.js";
+} from "./chunk-ZFHHBRRA.js";
 import {
   createWorkspaceSkillsStatusProvider
-} from "./chunk-JD44PNGJ.js";
+} from "./chunk-AWOU24F6.js";
 import "./chunk-2W3OOD4W.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
+  MAX_WORKSPACE_SKILL_NAME_LENGTH,
+  WorkspaceSkillManagementError,
   WorkspaceVoiceError,
   buildWorkspaceVoiceSettingsWrites,
   buildWorkspaceVoiceStatus,
   createDaemonWorkspaceService,
   hasConfiguredBatchVoiceTranscriptionModel,
   transcribeWorkspaceVoiceAudio,
+  validateWorkspaceSkillName,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-4IJMTYCB.js";
+} from "./chunk-SNONG66P.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-K7VD4XLT.js";
+} from "./chunk-LHEQDKAR.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -138,13 +151,13 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-BUAXJVNP.js";
+} from "./chunk-XACBIZJB.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-3M75MSVA.js";
-import "./chunk-FSA7ERJ2.js";
+} from "./chunk-SMASS3CY.js";
+import "./chunk-F2RR4HO2.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError,
@@ -153,24 +166,21 @@ import {
 } from "./chunk-OA4JVLSA.js";
 import {
   createTotalSessionAdmissionController
-} from "./chunk-AVEOWVOM.js";
-import {
-  createSingleWorkspaceRegistry,
-  createWorkspaceSessionOwnerIndex
-} from "./chunk-STZQCNN3.js";
+} from "./chunk-R3VWUU2E.js";
 import "./chunk-GRC5HGPI.js";
 import {
   SessionArtifactAuthorizationError,
   SessionArtifactValidationError,
   createAcpSessionBridge,
   parseSessionSource
-} from "./chunk-574PTLMU.js";
-import "./chunk-PZL23GTM.js";
+} from "./chunk-4OVECYBM.js";
 import {
   EVENT_SCHEMA_VERSION,
   SubscriberLimitExceededError
 } from "./chunk-6RLROE6G.js";
 import "./chunk-COH43MRJ.js";
+import "./chunk-QR6U5QPP.js";
+import "./chunk-FEZXQXW2.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -202,30 +212,30 @@ import {
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
-} from "./chunk-L4Y55KIS.js";
+} from "./chunk-X6YQWCIJ.js";
+import {
+  STATUS_SCHEMA_VERSION,
+  createIdleWorkspaceMemoryStatus,
+  mapDomainErrorToErrorKind
+} from "./chunk-TFV3XVAZ.js";
 import "./chunk-WBL3FJEU.js";
 import {
+  daemonObservedContactsPath,
   loadChannelsConfig
-} from "./chunk-7NMU22Q3.js";
-import "./chunk-YFVO2HOR.js";
+} from "./chunk-HQ7MDVBO.js";
+import "./chunk-HZXU6YZW.js";
 import "./chunk-57OAHC2Y.js";
 import {
   parseChannelWebhookConfigLenient
-} from "./chunk-5CNYZ7TN.js";
-import "./chunk-FNX3LGAK.js";
+} from "./chunk-NJQPQ4IO.js";
+import "./chunk-E655RDRL.js";
 import "./chunk-V6WHFGST.js";
-import "./chunk-3AYLDB6B.js";
-import {
-  STATUS_SCHEMA_VERSION,
-  createIdleWorkspaceMemoryStatus,
-  mapDomainErrorToErrorKind
-} from "./chunk-VFX7EZIR.js";
 import {
   MAX_REGISTERED_WORKSPACES,
   WorkspaceRegistrationStoreCommittedError,
   WorkspaceRegistrationStoreLimitError,
   workspaceRegistrationId
-} from "./chunk-N5VIZTND.js";
+} from "./chunk-EWPLL4OT.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace,
@@ -239,7 +249,7 @@ import {
   QWEN_SERVER_TOKEN_ENV,
   isChannelWebhookEnqueueError,
   normalizeWorkerDiagnostic
-} from "./chunk-KSZKSE23.js";
+} from "./chunk-HVWPSGDY.js";
 import {
   normalizeServeChannelSelection
 } from "./chunk-TJTKSVIV.js";
@@ -250,7 +260,7 @@ import "./chunk-5HBA2Z7V.js";
 import "./chunk-T2NCM2ET.js";
 import {
   sanitizeLogText
-} from "./chunk-ZQIYGQCG.js";
+} from "./chunk-MHEZV3OY.js";
 import "./chunk-UDXSXLER.js";
 import {
   getDialogSettingKeys,
@@ -261,27 +271,27 @@ import {
   getWritableScopes,
   loadSettings,
   validateSettingValue
-} from "./chunk-GNBBAQ6J.js";
+} from "./chunk-ILQ42UG6.js";
 import "./chunk-RKUWKYED.js";
-import {
-  SUPPORTED_LANGUAGES
-} from "./chunk-4AGTGMCQ.js";
-import "./chunk-JWICTOXS.js";
 import "./chunk-GOXKNSDZ.js";
 import "./chunk-IDS7MSUP.js";
+import {
+  SUPPORTED_LANGUAGES
+} from "./chunk-3PE7OY2G.js";
+import "./chunk-NGTQA57Y.js";
 import "./chunk-QRUIS3DN.js";
+import "./chunk-W4DFAUAO.js";
+import "./chunk-VJNBRRZG.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-2OG646IN.js";
+} from "./chunk-XFJU7SVP.js";
 import "./chunk-ALGGS7UH.js";
 import {
   isWithinRoot as isWithinRoot2
 } from "./chunk-MR3PXB6E.js";
 import {
   writeStderrLine
-} from "./chunk-YUZI3WAC.js";
-import "./chunk-GLNHPRZT.js";
-import "./chunk-VJNBRRZG.js";
+} from "./chunk-OWAK7LMW.js";
 import {
   ALL_PROVIDERS,
   BTW_MAX_INPUT_LENGTH,
@@ -296,6 +306,7 @@ import {
   RUNTIME_MCP_IF_ABSENT_CONFIG_FLAG,
   SESSION_TRANSCRIPT_MAX_INDEX_BYTES,
   SESSION_TRANSCRIPT_MAX_LIMIT,
+  SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
   SessionOrganizationError,
   SessionOrganizationService,
   SessionService,
@@ -314,6 +325,9 @@ import {
   buildUsageDashboard,
   detectLineEnding,
   encodeTextFileContent,
+  fetchGitDiff,
+  fetchGitDiffHunksForFile,
+  getGitWorkingTreeStatus,
   glob,
   loadIgnoreRules,
   loadUsageHistoryWithLive,
@@ -326,17 +340,17 @@ import {
   stripTerminalControlSequences,
   watchRepoBranch,
   writeWorkspaceContextFile
-} from "./chunk-NJOFRXTM.js";
+} from "./chunk-6TDA4EVC.js";
+import "./chunk-5M6IDOMF.js";
 import "./chunk-T4TZQJ7W.js";
 import "./chunk-H6XPXXMH.js";
-import "./chunk-5M6IDOMF.js";
 import {
   MAX_JOBS,
   nextDurableFireMs
-} from "./chunk-A2HWMJVO.js";
-import "./chunk-RCEEXIOO.js";
-import "./chunk-KKRTYONM.js";
-import "./chunk-TV6K2FB4.js";
+} from "./chunk-LKR7QQ63.js";
+import "./chunk-4XCVGEEX.js";
+import "./chunk-XSPFQQRE.js";
+import "./chunk-4RPARQ5D.js";
 import "./chunk-E2UVIFI2.js";
 import {
   nextFireTime,
@@ -350,7 +364,7 @@ import {
   readCronTasks,
   taskHasLegacyCondition,
   updateCronTasks
-} from "./chunk-SPJQO2CE.js";
+} from "./chunk-J2MKYJKZ.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
@@ -358,12 +372,23 @@ import {
   APPROVAL_MODES,
   SubagentError,
   SubagentErrorCode
-} from "./chunk-F333XEAU.js";
+} from "./chunk-UOA2IHRI.js";
 import "./chunk-6AM5D4ME.js";
-import "./chunk-2Z5UX4KI.js";
-import "./chunk-ARKANCNX.js";
-import "./chunk-L5U3ELZX.js";
-import "./chunk-TYLOFD2U.js";
+import "./chunk-OSSDHJDU.js";
+import "./chunk-SGPFJMRP.js";
+import "./chunk-335ECZTA.js";
+import "./chunk-JCJPZMJV.js";
+import {
+  QwenOAuth2Client,
+  QwenOAuthPollError,
+  cacheQwenCredentials,
+  generatePKCEPair,
+  isDeviceAuthorizationSuccess,
+  isDeviceTokenPending,
+  isDeviceTokenSuccess
+} from "./chunk-QGONRHUS.js";
+import "./chunk-7KS72E2N.js";
+import "./chunk-JESCGQM3.js";
 import {
   addDaemonRequestAttribute,
   decodeBufferWithEncodingInfo,
@@ -377,45 +402,33 @@ import {
   recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   withDaemonRequestSpan
-} from "./chunk-MQOVXZAF.js";
+} from "./chunk-YN2I5I42.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
-import "./chunk-RTV5TUYB.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-FBU7WRZI.js";
-import "./chunk-Y66VOBRP.js";
-import "./chunk-WTNZ6DXB.js";
-import "./chunk-JGUT3LWZ.js";
-import {
-  QwenOAuth2Client,
-  QwenOAuthPollError,
-  cacheQwenCredentials,
-  generatePKCEPair,
-  isDeviceAuthorizationSuccess,
-  isDeviceTokenPending,
-  isDeviceTokenSuccess
-} from "./chunk-OKAIGAYW.js";
-import "./chunk-ZPAHLFZU.js";
-import "./chunk-JESCGQM3.js";
-import "./chunk-WIEO4CWB.js";
+import "./chunk-LPHGXXZX.js";
+import "./chunk-4CA4WUMS.js";
+import "./chunk-VAJS2E2D.js";
+import "./chunk-WEPXQKGP.js";
+import "./chunk-ANRANWVE.js";
 import "./chunk-XVNQMZ2I.js";
 import "./chunk-FEOZBUMT.js";
-import "./chunk-VRR65QYW.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-4CHDYDG3.js";
+import "./chunk-V4PCIS25.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
-import "./chunk-4LD5APFL.js";
+import "./chunk-TYQMGACW.js";
 import {
   import_websocket_server
 } from "./chunk-TYAMGABM.js";
 import "./chunk-FCMNKVXT.js";
-import "./chunk-DJ2GSRLV.js";
-import "./chunk-LQIDP6K5.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger,
   runWithoutDebugLogSession
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -2911,7 +2924,7 @@ async function handleSetupGithub(req, res, deps) {
     const result = await setupGithub({
       cwd: deps.boundWorkspace,
       workspaceRoot: deps.boundWorkspace,
-      proxy: resolveSetupGithubProxy(deps.boundWorkspace),
+      proxy: resolveSetupGithubProxy(deps.boundWorkspace, deps.env),
       abortSignal: requestAbortSignal(req, res),
       fileOps: createSetupGithubFileOps(factory, ROUTE, originatorClientId)
     });
@@ -3129,14 +3142,14 @@ function setupGithubEventData(result) {
   };
 }
 __name(setupGithubEventData, "setupGithubEventData");
-function resolveSetupGithubProxy(boundWorkspace) {
+function resolveSetupGithubProxy(boundWorkspace, env) {
   const settings = loadSettings(boundWorkspace, { skipLoadEnvironment: true });
   const trustState = getWorkspaceTrustStatus(
     settingsForSetupGithubTrust(settings),
     boundWorkspace
   ).effective.state;
   const settingsProxy = trustState === "trusted" ? settings.merged.proxy : settings.user.settings.proxy || settings.system.settings.proxy || settings.systemDefaults.settings.proxy;
-  return settingsProxy || process.env["HTTPS_PROXY"] || process.env["https_proxy"] || process.env["HTTP_PROXY"] || process.env["http_proxy"];
+  return settingsProxy || env["HTTPS_PROXY"] || env["https_proxy"] || env["HTTP_PROXY"] || env["http_proxy"];
 }
 __name(resolveSetupGithubProxy, "resolveSetupGithubProxy");
 function settingsForSetupGithubTrust(settings) {
@@ -6954,9 +6967,10 @@ function rpcErrorFrame(id, err) {
 __name(rpcErrorFrame, "rpcErrorFrame");
 var ACP_PROTOCOL_VERSION = 1;
 var AcpDispatcher = class {
-  constructor(bridge, boundWorkspace, workspace, workspaceRememberLane, fsFactory, deviceFlowRegistry, sessionShellCommandEnabled = false, registry, archiveCoordinator = new SessionArchiveCoordinator()) {
+  constructor(bridge, boundWorkspace, env, workspace, workspaceRememberLane, fsFactory, deviceFlowRegistry, sessionShellCommandEnabled = false, registry, archiveCoordinator = new SessionArchiveCoordinator()) {
     this.bridge = bridge;
     this.boundWorkspace = boundWorkspace;
+    this.env = env;
     this.workspace = workspace;
     this.workspaceRememberLane = workspaceRememberLane;
     this.fsFactory = fsFactory;
@@ -8333,7 +8347,7 @@ var AcpDispatcher = class {
             const result = await setupGithub({
               cwd: this.boundWorkspace,
               workspaceRoot: this.boundWorkspace,
-              proxy: resolveSetupGithubProxy(this.boundWorkspace),
+              proxy: resolveSetupGithubProxy(this.boundWorkspace, this.env),
               abortSignal: conn.abortSignal,
               fileOps: createSetupGithubFileOps(
                 this.fsFactory,
@@ -11804,11 +11818,11 @@ function delay(ms) {
   return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 __name(delay, "delay");
-function buildChromeDevToolsMcpRuntimeConfig(localPort, hostname) {
+function buildChromeDevToolsMcpRuntimeConfig(localPort, hostname, env) {
   if (localPort === void 0 || !Number.isInteger(localPort) || localPort <= 0) {
     return void 0;
   }
-  const command = resolveCdpMcpCommand(process.env);
+  const command = resolveCdpMcpCommand(env);
   if (!command) {
     writeStderrLine(
       `qwen serve: set ${QWEN_CDP_MCP_COMMAND_ENV} to enable browser automation MCP (no adapter is bundled)`
@@ -11914,9 +11928,18 @@ function workspaceRateLimitKey(mount, clientKey) {
   return JSON.stringify([clientKey, mount.rateLimitScope]);
 }
 __name(workspaceRateLimitKey, "workspaceRateLimitKey");
+function runtimeEffectiveEnv(runtime, daemonEnv) {
+  if (runtime.env.mode === "runtime-overlay") {
+    return runtime.env.effectiveEnv ?? {};
+  }
+  return runtime.env.effectiveEnv ?? daemonEnv;
+}
+__name(runtimeEffectiveEnv, "runtimeEffectiveEnv");
 function mountAcpHttp(app, bridge, opts) {
   const enabled = opts.enabled ?? resolveAcpHttpEnabled();
   if (!enabled) return void 0;
+  const daemonEnv = opts.daemonEnv ?? process.env;
+  const primaryEnv = opts.workspaceRegistry ? runtimeEffectiveEnv(opts.workspaceRegistry.primary, daemonEnv) : daemonEnv;
   const path15 = opts.path ?? "/acp";
   const dispatcherRef = {};
   let disposed = false;
@@ -12006,7 +12029,8 @@ function mountAcpHttp(app, bridge, opts) {
     }
     const runtimeConfig = buildChromeDevToolsMcpRuntimeConfig(
       localPort,
-      opts.hostname
+      opts.hostname,
+      daemonEnv
     );
     if (!runtimeConfig) {
       cdpMcpTerminalSkipLogged = true;
@@ -12065,6 +12089,7 @@ function mountAcpHttp(app, bridge, opts) {
   const dispatcher = new AcpDispatcher(
     bridge,
     opts.boundWorkspace,
+    primaryEnv,
     opts.workspace,
     opts.workspaceRememberLane,
     opts.fsFactory,
@@ -12353,6 +12378,7 @@ function mountAcpHttp(app, bridge, opts) {
     const secondaryDispatcher = new AcpDispatcher(
       rt.bridge,
       rt.workspaceCwd,
+      runtimeEffectiveEnv(rt, daemonEnv),
       rt.workspaceService,
       workspaceRememberLane,
       rt.routeFileSystemFactory,
@@ -17714,157 +17740,772 @@ init_esbuild_shims();
 
 // packages/cli/src/serve/routes/session-runtime.ts
 init_esbuild_shims();
-function requireSessionRuntime(opts) {
-  const {
-    sessionId,
-    route,
-    res,
-    workspaceRegistry,
-    daemonLog,
-    details = {}
-  } = opts;
-  if (workspaceRegistry.list().length === 1) {
-    return workspaceRegistry.primary;
+
+// packages/cli/src/serve/server/telemetry.ts
+init_esbuild_shims();
+var legacySessionTelemetryRoutes = [
+  {
+    method: "POST",
+    path: "/session",
+    attribution: "handler_resolved",
+    route: "POST /session"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/load",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/load"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/resume",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/resume"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/branch",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/branch"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/fork",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/fork"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/cd",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/cd"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/status",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/status"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/export",
+    attribution: "pre_resolved",
+    route: "GET /session/:id/export"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/transcript",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/transcript"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/context",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/context"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/context-usage",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/context-usage"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/stats",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/stats"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/supported-commands",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/supported-commands"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/tasks",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/tasks"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/lsp",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/lsp"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/hooks",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/hooks"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/artifacts",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/artifacts"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/artifacts",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/artifacts"
+  },
+  {
+    method: "DELETE",
+    path: "/session/:id/artifacts/:artifactId",
+    attribution: "handler_resolved",
+    route: "DELETE /session/:id/artifacts/:artifactId"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/tasks/:taskId/cancel",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/tasks/:taskId/cancel"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/goal/clear",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/goal/clear"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/continue",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/continue"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/prompt",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/prompt"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/generate",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/generate"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/heartbeat",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/heartbeat"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/detach",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/detach"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/cancel",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/cancel"
+  },
+  {
+    method: "DELETE",
+    path: "/session/:id",
+    attribution: "handler_resolved",
+    route: "DELETE /session/:id"
+  },
+  {
+    method: "POST",
+    path: "/sessions/delete",
+    attribution: "pre_resolved",
+    route: "POST /sessions/delete"
+  },
+  {
+    method: "POST",
+    path: "/sessions/archive",
+    attribution: "pre_resolved",
+    route: "POST /sessions/archive"
+  },
+  {
+    method: "POST",
+    path: "/sessions/unarchive",
+    attribution: "pre_resolved",
+    route: "POST /sessions/unarchive"
+  },
+  {
+    method: "PATCH",
+    path: "/session/:id/metadata",
+    attribution: "handler_resolved",
+    route: "PATCH /session/:id/metadata"
+  },
+  {
+    method: "PATCH",
+    path: "/session/:id/organization",
+    attribution: "pre_resolved",
+    route: "PATCH /session/:id/organization"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/model",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/model"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/recap",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/recap"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/btw",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/btw"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/mid-turn-message",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/mid-turn-message"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/pending-prompts",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/pending-prompts"
+  },
+  {
+    method: "DELETE",
+    path: "/session/:id/pending-prompts/:promptId",
+    attribution: "handler_resolved",
+    route: "DELETE /session/:id/pending-prompts/:promptId"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/shell",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/shell"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/rewind/snapshots",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/rewind/snapshots"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/rewind",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/rewind"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/approval-mode",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/approval-mode"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/language",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/language"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/permission/:requestId",
+    attribution: "handler_resolved",
+    route: "POST /session/:id/permission/:requestId"
+  },
+  {
+    method: "POST",
+    path: "/permission/:requestId",
+    attribution: "pre_resolved",
+    route: "POST /permission/:requestId"
+  },
+  {
+    method: "GET",
+    path: "/session/:id/events",
+    attribution: "handler_resolved",
+    route: "GET /session/:id/events"
+  },
+  {
+    method: "POST",
+    path: "/session/:id/a2ui-action",
+    attribution: "pre_resolved",
+    route: "POST /session/:id/a2ui-action"
   }
-  const resolution = workspaceRegistry.resolveLiveSessionOwner(sessionId);
-  if (resolution.kind === "found") {
-    const runtime = resolution.runtime;
-    if (!runtime.primary && !runtime.trusted) {
-      daemonLog?.warn("session routing failed", {
-        route,
-        resolutionKind: "untrusted_workspace",
-        sessionId,
-        workspaceId: runtime.workspaceId,
-        workspaceCwd: runtime.workspaceCwd,
-        ...details
-      });
-      sendUntrustedWorkspaceResponse(res, {
-        sessionId,
-        workspaceCwd: runtime.workspaceCwd,
-        workspaceId: runtime.workspaceId
-      });
-      return void 0;
-    }
-    return runtime;
+];
+var daemonTelemetryResponseContext = Symbol("daemonTelemetryResponseContext");
+function decodePathSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
   }
-  if (resolution.kind === "not_found") {
-    daemonLog?.warn("session routing failed", {
-      route,
-      resolutionKind: "not_found",
-      sessionId,
-      ...details
-    });
-    res.status(404).json({
-      error: `No session with id "${sessionId}"`,
-      code: "session_not_found",
-      sessionId
-    });
+}
+__name(decodePathSegment, "decodePathSegment");
+function matchLegacySessionTelemetryRoute(method, requestPath) {
+  const path15 = requestPath.length > 1 && requestPath.endsWith("/") ? requestPath.slice(0, -1) : requestPath;
+  const requestSegments = path15.split("/").slice(1);
+  const prefix = requestSegments[0]?.toLowerCase();
+  if (prefix !== "session" && prefix !== "sessions" && prefix !== "permission") {
     return void 0;
   }
-  const workspaceIds = resolution.runtimes.map(
-    (runtime) => runtime.workspaceId
-  );
-  daemonLog?.warn("session routing failed", {
-    route,
-    resolutionKind: "ambiguous",
-    sessionId,
-    workspaceIds,
-    ...details
-  });
-  res.status(500).json({
-    error: `Session owner is ambiguous for "${sessionId}"`,
-    code: "ambiguous_session_owner",
-    sessionId,
-    route,
-    workspaceIds
-  });
-  return void 0;
-}
-__name(requireSessionRuntime, "requireSessionRuntime");
-
-// packages/cli/src/serve/routes/permission.ts
-function registerPermissionRoutes(app, deps) {
-  const {
-    bridge,
-    workspaceRegistry,
-    daemonLog,
-    mutate,
-    sendPermissionVoteError: sendPermissionVoteError2
-  } = deps;
-  app.post("/session/:id/permission/:requestId", mutate(), (req, res) => {
-    const sessionId = req.params["id"];
-    const requestId = req.params["requestId"];
-    const response = parsePermissionVoteBody(req, res);
-    if (response === void 0) return;
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    const fromLoopback = detectFromLoopback(req);
-    const context = {
-      ...clientId !== void 0 ? { clientId } : {},
-      fromLoopback
-    };
-    let accepted;
-    try {
-      const runtime = requireSessionRuntime({
-        sessionId,
-        route: "POST /session/:id/permission/:requestId",
-        res,
-        workspaceRegistry,
-        daemonLog,
-        details: { requestId }
-      });
-      if (!runtime) return;
-      accepted = runtime.bridge.respondToSessionPermission(
-        sessionId,
-        requestId,
-        response,
-        context
-      );
-    } catch (err) {
-      sendPermissionVoteError2(res, err, {
-        route: "POST /session/:id/permission/:requestId",
-        sessionId
-      });
-      return;
-    }
-    if (!accepted) {
-      res.status(404).json({
-        error: "No pending permission request for session",
-        sessionId,
-        requestId
-      });
-      return;
+  for (const entry of legacySessionTelemetryRoutes) {
+    if (entry.method !== method) continue;
+    const templateSegments = entry.path.split("/").slice(1);
+    if (templateSegments.length !== requestSegments.length) continue;
+    const params = /* @__PURE__ */ new Map();
+    let matched = true;
+    for (let index = 0; index < templateSegments.length; index += 1) {
+      const templateSegment = templateSegments[index];
+      const requestSegment = requestSegments[index];
+      if (templateSegment.startsWith(":")) {
+        if (requestSegment === "") {
+          matched = false;
+          break;
+        }
+        params.set(templateSegment.slice(1), requestSegment);
+      } else if (templateSegment.toLowerCase() !== requestSegment.toLowerCase()) {
+        matched = false;
+        break;
+      }
     }
-    res.status(200).json({});
-  });
-  app.post("/permission/:requestId", mutate(), (req, res) => {
-    const requestId = req.params["requestId"];
-    const response = parsePermissionVoteBody(req, res);
-    if (response === void 0) return;
-    const clientId = parseClientIdHeader(req, res);
-    if (clientId === null) return;
-    const fromLoopback = detectFromLoopback(req);
-    const context = {
-      ...clientId !== void 0 ? { clientId } : {},
-      fromLoopback
+    if (!matched) continue;
+    const rawSessionId = params.get("id");
+    const rawRequestId = params.get("requestId");
+    const requestId = rawRequestId !== void 0 ? decodePathSegment(rawRequestId) : void 0;
+    return {
+      route: entry.route,
+      attribution: entry.attribution,
+      ...rawSessionId ? { sessionId: decodePathSegment(rawSessionId) } : {},
+      ...requestId !== void 0 && requestId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(requestId) ? { permissionRequestId: requestId } : {}
     };
-    let accepted;
-    try {
-      accepted = bridge.respondToPermission(requestId, response, context);
-    } catch (err) {
-      sendPermissionVoteError2(res, err, {
-        route: "POST /permission/:requestId"
-      });
-      return;
-    }
-    if (!accepted) {
-      res.status(404).json({ error: "No pending permission request", requestId });
-      return;
+  }
+  return void 0;
+}
+__name(matchLegacySessionTelemetryRoute, "matchLegacySessionTelemetryRoute");
+function setDaemonTelemetryWorkspace(res, workspaceCwd) {
+  try {
+    const context = res[daemonTelemetryResponseContext];
+    if (context && context.workspaceCwd === void 0) {
+      context.workspaceCwd = workspaceCwd;
     }
-    res.status(200).json({});
-  });
+  } catch {
+  }
 }
-__name(registerPermissionRoutes, "registerPermissionRoutes");
+__name(setDaemonTelemetryWorkspace, "setDaemonTelemetryWorkspace");
+function resolveDaemonTelemetryRoute(req) {
+  const legacyRoute = matchLegacySessionTelemetryRoute(req.method, req.path);
+  if (legacyRoute) return legacyRoute;
+  const path15 = req.path.replace(/\/$/, "") || "/";
+  if (req.method === "GET" && path15 === "/daemon/status") {
+    return { route: "GET /daemon/status" };
+  }
+  if (req.method === "GET" && /^\/workspace\/[^/]+\/sessions$/.test(path15)) {
+    return { route: "GET /workspace/:id/sessions" };
+  }
+  if (req.method === "GET" && /^\/workspaces\/[^/]+\/sessions$/.test(path15)) {
+    return { route: "GET /workspace/:id/sessions" };
+  }
+  if (req.method === "GET" && /^\/workspace\/[^/]+\/session-info$/.test(path15)) {
+    return { route: "GET /workspace/:id/session-info" };
+  }
+  if (req.method === "GET" && /^\/workspaces\/[^/]+\/session-info$/.test(path15)) {
+    return { route: "GET /workspace/:id/session-info" };
+  }
+  const workspaceTranscript = path15.match(
+    /^\/workspaces\/[^/]+\/session\/([^/]+)\/transcript$/
+  );
+  if (workspaceTranscript?.[1] && req.method === "GET") {
+    return {
+      route: "GET /workspaces/:workspace/session/:id/transcript",
+      sessionId: decodePathSegment(workspaceTranscript[1])
+    };
+  }
+  const workspaceExport = path15.match(
+    /^\/workspaces\/[^/]+\/session\/([^/]+)\/export$/
+  );
+  if (workspaceExport?.[1] && req.method === "GET") {
+    return {
+      route: "GET /workspaces/:workspace/session/:id/export",
+      sessionId: decodePathSegment(workspaceExport[1])
+    };
+  }
+  const workspaceArchivedExport = path15.match(
+    /^\/workspaces\/[^/]+\/session\/([^/]+)\/archive\/export$/
+  );
+  if (workspaceArchivedExport?.[1] && req.method === "GET") {
+    return {
+      route: "GET /workspaces/:workspace/session/:id/archive/export",
+      sessionId: decodePathSegment(workspaceArchivedExport[1])
+    };
+  }
+  const pluralWorkspacePrefix = /^\/workspaces\/[^/]+/;
+  if (pluralWorkspacePrefix.test(path15)) {
+    const suffix = path15.replace(pluralWorkspacePrefix, "/workspace");
+    if (req.method === "GET") {
+      if (suffix === "/workspace/mcp" || suffix === "/workspace/skills" || suffix === "/workspace/tools" || suffix === "/workspace/providers" || suffix === "/workspace/env" || suffix === "/workspace/preflight" || suffix === "/workspace/hooks" || suffix === "/workspace/settings" || suffix === "/workspace/voice" || suffix === "/workspace/permissions" || suffix === "/workspace/trust" || suffix === "/workspace/memory" || suffix === "/workspace/agents") {
+        return { route: `GET ${suffix}` };
+      }
+      if (/^\/workspace\/agents\/[^/]+$/.test(suffix)) {
+        return { route: "GET /workspace/agents/:agentType" };
+      }
+      if (suffix === "/workspace/file") return { route: "GET /file" };
+      if (suffix === "/workspace/file/bytes") {
+        return { route: "GET /file/bytes" };
+      }
+      if (suffix === "/workspace/stat") return { route: "GET /stat" };
+      if (suffix === "/workspace/list") return { route: "GET /list" };
+      if (suffix === "/workspace/glob") return { route: "GET /glob" };
+      if (/^\/workspace\/mcp\/[^/]+\/tools$/.test(suffix)) {
+        return { route: "GET /workspace/mcp/:server/tools" };
+      }
+      if (/^\/workspace\/mcp\/[^/]+\/resources$/.test(suffix)) {
+        return { route: "GET /workspace/mcp/:server/resources" };
+      }
+    }
+    if (req.method === "POST") {
+      if (suffix === "/workspace/settings" || suffix === "/workspace/voice" || suffix === "/workspace/voice/transcribe" || suffix === "/workspace/permissions" || suffix === "/workspace/trust/request" || suffix === "/workspace/init" || suffix === "/workspace/reload" || suffix === "/workspace/file/write" || suffix === "/workspace/file/edit" || suffix === "/workspace/mcp/servers" || suffix === "/workspace/memory" || suffix === "/workspace/agents" || suffix === "/workspace/sessions/delete" || suffix === "/workspace/sessions/archive" || suffix === "/workspace/sessions/unarchive" || suffix === "/workspace/session-groups") {
+        return { route: `POST ${suffix}` };
+      }
+      if (/^\/workspace\/tools\/[^/]+\/enable$/.test(suffix)) {
+        return { route: "POST /workspace/tools/:name/enable" };
+      }
+      if (/^\/workspace\/mcp\/[^/]+\/restart$/.test(suffix)) {
+        return { route: "POST /workspace/mcp/:server/restart" };
+      }
+      if (/^\/workspace\/agents\/[^/]+$/.test(suffix)) {
+        return { route: "POST /workspace/agents/:agentType" };
+      }
+      if (/^\/workspace\/mcp\/[^/]+\/(approve|enable|disable|authenticate|clear-auth)$/.test(
+        suffix
+      )) {
+        return {
+          route: `POST /workspace/mcp/:server/${suffix.split("/").at(-1)}`
+        };
+      }
+    }
+    if (req.method === "DELETE" && /^\/workspace\/mcp\/servers\/[^/]+$/.test(suffix)) {
+      return { route: "DELETE /workspace/mcp/servers/:name" };
+    }
+    if (req.method === "DELETE" && /^\/workspace\/agents\/[^/]+$/.test(suffix)) {
+      return { route: "DELETE /workspace/agents/:agentType" };
+    }
+    if (suffix === "/workspace/session-groups" && req.method === "GET") {
+      return { route: "GET /workspace/session-groups" };
+    }
+    if (/^\/workspace\/session-groups\/[^/]+$/.test(suffix) && req.method === "PATCH") {
+      return { route: "PATCH /workspace/session-groups/:groupId" };
+    }
+    if (/^\/workspace\/session-groups\/[^/]+$/.test(suffix) && req.method === "DELETE") {
+      return { route: "DELETE /workspace/session-groups/:groupId" };
+    }
+  }
+  if (req.method === "POST" && path15 === "/workspace/init") {
+    return { route: "POST /workspace/init" };
+  }
+  if (req.method === "POST" && path15 === "/workspace/setup-github") {
+    return { route: "POST /workspace/setup-github" };
+  }
+  if (req.method === "POST" && path15 === "/workspace/reload") {
+    return { route: "POST /workspace/reload" };
+  }
+  const mcpRestart = path15.match(/^\/workspace\/mcp\/([^/]+)\/restart$/);
+  if (mcpRestart?.[1] && req.method === "POST") {
+    return { route: "POST /workspace/mcp/:server/restart" };
+  }
+  if (req.method === "POST" && path15 === "/workspace/mcp/servers") {
+    return { route: "POST /workspace/mcp/servers" };
+  }
+  const mcpDelete = path15.match(/^\/workspace\/mcp\/servers\/([^/]+)$/);
+  if (mcpDelete?.[1] && req.method === "DELETE") {
+    return { route: "DELETE /workspace/mcp/servers/:name" };
+  }
+  if (req.method === "POST" && path15 === "/workspace/auth/device-flow") {
+    return { route: "POST /workspace/auth/device-flow" };
+  }
+  const deviceFlowDelete = path15.match(
+    /^\/workspace\/auth\/device-flow\/([^/]+)$/
+  );
+  if (deviceFlowDelete?.[1] && req.method === "DELETE") {
+    return { route: "DELETE /workspace/auth/device-flow/:id" };
+  }
+  const toolEnable = path15.match(/^\/workspace\/tools\/([^/]+)\/enable$/);
+  if (toolEnable?.[1] && req.method === "POST") {
+    return { route: "POST /workspace/tools/:name/enable" };
+  }
+  if (path15 === "/workspace/settings") {
+    if (req.method === "GET") return { route: "GET /workspace/settings" };
+    if (req.method === "POST") return { route: "POST /workspace/settings" };
+  }
+  if (path15 === "/workspace/permissions") {
+    if (req.method === "GET") return { route: "GET /workspace/permissions" };
+    if (req.method === "POST") return { route: "POST /workspace/permissions" };
+  }
+  if (path15 === "/workspace/trust") {
+    if (req.method === "GET") return { route: "GET /workspace/trust" };
+  }
+  if (req.method === "POST" && path15 === "/workspace/trust/request") {
+    return { route: "POST /workspace/trust/request" };
+  }
+  if (path15 === "/workspace/voice") {
+    if (req.method === "GET") return { route: "GET /workspace/voice" };
+    if (req.method === "POST") return { route: "POST /workspace/voice" };
+  }
+  if (req.method === "POST" && path15 === "/workspace/voice/transcribe") {
+    return { route: "POST /workspace/voice/transcribe" };
+  }
+  return void 0;
+}
+__name(resolveDaemonTelemetryRoute, "resolveDaemonTelemetryRoute");
+function daemonTelemetryMiddleware(resolveWorkspaceCwd, recordRequest) {
+  const workspaceHashByCwd = /* @__PURE__ */ new Map();
+  const resolveWorkspaceHash = /* @__PURE__ */ __name((workspaceCwd) => {
+    const existing = workspaceHashByCwd.get(workspaceCwd);
+    if (existing !== void 0) return existing;
+    const workspaceHash = hashDaemonWorkspace(workspaceCwd);
+    workspaceHashByCwd.set(workspaceCwd, workspaceHash);
+    return workspaceHash;
+  }, "resolveWorkspaceHash");
+  return (req, res, next) => {
+    const route = resolveDaemonTelemetryRoute(req);
+    if (!route) {
+      next();
+      return;
+    }
+    const sessionId = route.sessionId;
+    let workspaceHash;
+    if (route.attribution !== "handler_resolved") {
+      try {
+        workspaceHash = resolveWorkspaceHash(resolveWorkspaceCwd(req));
+      } catch {
+      }
+    }
+    const rawClientId = req.get(CLIENT_ID_HEADER);
+    const clientId = rawClientId !== void 0 && rawClientId !== "" && rawClientId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawClientId) ? rawClientId : void 0;
+    const deferredRuntime = getDeferredRuntimeRequestTiming(req);
+    const startMs = deferredRuntime?.startedAt.getTime() ?? Date.now();
+    const telemetryRes = res;
+    if (route.attribution === "handler_resolved") {
+      try {
+        telemetryRes[daemonTelemetryResponseContext] = {};
+      } catch {
+      }
+    }
+    void withDaemonRequestSpan(
+      {
+        method: req.method,
+        route: route.route,
+        ...workspaceHash !== void 0 ? { workspaceHash } : {},
+        ...sessionId ? { sessionId } : {},
+        ...route.permissionRequestId ? { permissionRequestId: route.permissionRequestId } : {},
+        ...clientId ? { clientId } : {},
+        ...deferredRuntime?.waitMs !== void 0 ? {
+          startTime: deferredRuntime.startedAt,
+          deferredRuntimeWaitMs: deferredRuntime.waitMs,
+          deferredRuntimePath: deferredRuntime.path
+        } : {}
+      },
+      async (span) => await new Promise((resolve5, reject) => {
+        let done = false;
+        const finish = /* @__PURE__ */ __name(() => {
+          if (done) return;
+          done = true;
+          try {
+            const context = telemetryRes[daemonTelemetryResponseContext];
+            delete telemetryRes[daemonTelemetryResponseContext];
+            if (context?.workspaceCwd !== void 0) {
+              span?.setAttribute(
+                "qwen-code.workspace.hash",
+                resolveWorkspaceHash(context.workspaceCwd)
+              );
+            }
+          } catch {
+          }
+          recordDaemonHttpResponse(span, res.statusCode);
+          const durationMs = Date.now() - startMs;
+          const successfulSse = route.route === "GET /session/:id/events" && res.statusCode === 200 && res.headersSent;
+          if (!successfulSse) {
+            recordDaemonHttpRequest(
+              durationMs,
+              route.route,
+              res.statusCode,
+              deferredRuntime?.path
+            );
+          }
+          if (!successfulSse && route.route !== "GET /daemon/status" && route.route !== "POST /session/:id/heartbeat") {
+            recordRequest?.(durationMs, res.statusCode);
+          }
+          resolve5();
+        }, "finish");
+        res.once("finish", finish);
+        res.once("close", finish);
+        try {
+          next();
+        } catch (error2) {
+          recordDaemonError(span, error2);
+          reject(error2);
+        }
+      })
+    ).catch(next);
+  };
+}
+__name(daemonTelemetryMiddleware, "daemonTelemetryMiddleware");
+
+// packages/cli/src/serve/routes/session-runtime.ts
+function requireSessionRuntime(opts) {
+  const {
+    sessionId,
+    route,
+    res,
+    workspaceRegistry,
+    daemonLog,
+    details = {}
+  } = opts;
+  if (workspaceRegistry.list().length === 1) {
+    const runtime = workspaceRegistry.primary;
+    setDaemonTelemetryWorkspace(res, runtime.workspaceCwd);
+    return runtime;
+  }
+  const resolution = workspaceRegistry.resolveLiveSessionOwner(sessionId);
+  if (resolution.kind === "found") {
+    const runtime = resolution.runtime;
+    setDaemonTelemetryWorkspace(res, runtime.workspaceCwd);
+    if (!runtime.primary && !runtime.trusted) {
+      daemonLog?.warn("session routing failed", {
+        route,
+        resolutionKind: "untrusted_workspace",
+        sessionId,
+        workspaceId: runtime.workspaceId,
+        workspaceCwd: runtime.workspaceCwd,
+        ...details
+      });
+      sendUntrustedWorkspaceResponse(res, {
+        sessionId,
+        workspaceCwd: runtime.workspaceCwd,
+        workspaceId: runtime.workspaceId
+      });
+      return void 0;
+    }
+    return runtime;
+  }
+  if (resolution.kind === "not_found") {
+    daemonLog?.warn("session routing failed", {
+      route,
+      resolutionKind: "not_found",
+      sessionId,
+      ...details
+    });
+    res.status(404).json({
+      error: `No session with id "${sessionId}"`,
+      code: "session_not_found",
+      sessionId
+    });
+    return void 0;
+  }
+  const workspaceIds = resolution.runtimes.map(
+    (runtime) => runtime.workspaceId
+  );
+  daemonLog?.warn("session routing failed", {
+    route,
+    resolutionKind: "ambiguous",
+    sessionId,
+    workspaceIds,
+    ...details
+  });
+  res.status(500).json({
+    error: `Session owner is ambiguous for "${sessionId}"`,
+    code: "ambiguous_session_owner",
+    sessionId,
+    route,
+    workspaceIds
+  });
+  return void 0;
+}
+__name(requireSessionRuntime, "requireSessionRuntime");
+
+// packages/cli/src/serve/routes/permission.ts
+function registerPermissionRoutes(app, deps) {
+  const {
+    bridge,
+    workspaceRegistry,
+    daemonLog,
+    mutate,
+    sendPermissionVoteError: sendPermissionVoteError2
+  } = deps;
+  app.post("/session/:id/permission/:requestId", mutate(), (req, res) => {
+    const sessionId = req.params["id"];
+    const requestId = req.params["requestId"];
+    const response = parsePermissionVoteBody(req, res);
+    if (response === void 0) return;
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    const fromLoopback = detectFromLoopback(req);
+    const context = {
+      ...clientId !== void 0 ? { clientId } : {},
+      fromLoopback
+    };
+    let accepted;
+    try {
+      const runtime = requireSessionRuntime({
+        sessionId,
+        route: "POST /session/:id/permission/:requestId",
+        res,
+        workspaceRegistry,
+        daemonLog,
+        details: { requestId }
+      });
+      if (!runtime) return;
+      accepted = runtime.bridge.respondToSessionPermission(
+        sessionId,
+        requestId,
+        response,
+        context
+      );
+    } catch (err) {
+      sendPermissionVoteError2(res, err, {
+        route: "POST /session/:id/permission/:requestId",
+        sessionId
+      });
+      return;
+    }
+    if (!accepted) {
+      res.status(404).json({
+        error: "No pending permission request for session",
+        sessionId,
+        requestId
+      });
+      return;
+    }
+    res.status(200).json({});
+  });
+  app.post("/permission/:requestId", mutate(), (req, res) => {
+    const requestId = req.params["requestId"];
+    const response = parsePermissionVoteBody(req, res);
+    if (response === void 0) return;
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    const fromLoopback = detectFromLoopback(req);
+    const context = {
+      ...clientId !== void 0 ? { clientId } : {},
+      fromLoopback
+    };
+    let accepted;
+    try {
+      accepted = bridge.respondToPermission(requestId, response, context);
+    } catch (err) {
+      sendPermissionVoteError2(res, err, {
+        route: "POST /permission/:requestId"
+      });
+      return;
+    }
+    if (!accepted) {
+      res.status(404).json({ error: "No pending permission request", requestId });
+      return;
+    }
+    res.status(200).json({});
+  });
+}
+__name(registerPermissionRoutes, "registerPermissionRoutes");
 
 // packages/cli/src/serve/routes/session.ts
 init_esbuild_shims();
@@ -18379,6 +19020,19 @@ function listLiveWorkspaceSessionsForResponse(bridge, workspaceCwd, options) {
   };
 }
 __name(listLiveWorkspaceSessionsForResponse, "listLiveWorkspaceSessionsForResponse");
+async function getWorkspaceSessionInfoForResponse(bridge, workspaceCwd, options = {}) {
+  const counts = await new SessionService(workspaceCwd).getSessionInfoCounts();
+  return {
+    active: counts.active,
+    archived: counts.archived,
+    total: counts.total,
+    ...options.includeLive === false ? {} : { live: bridge.listWorkspaceSessions(workspaceCwd).length },
+    expensive: true,
+    cost: "disk_scan",
+    ...counts.truncated ? { truncated: true } : {}
+  };
+}
+__name(getWorkspaceSessionInfoForResponse, "getWorkspaceSessionInfoForResponse");
 function parseSessionPageSizeQuery(raw) {
   if (typeof raw !== "string") return void 0;
   const trimmed = raw.trim();
@@ -18451,11 +19105,21 @@ async function exportSessionTranscript(params) {
 __name(exportSessionTranscript, "exportSessionTranscript");
 
 // packages/cli/src/serve/routes/session.ts
-var WORKSPACE_TRANSCRIPT_PAGE_SOURCE_MAX_BYTES = 4 * 1024 * 1024;
 var WORKSPACE_TRANSCRIPT_RESPONSE_MAX_BYTES = 32 * 1024 * 1024;
 var WORKSPACE_TRANSCRIPT_CURSOR_MAX_BYTES = 64 * 1024;
 var TRANSCRIPT_CURSOR_TOO_LARGE_REPLAY_ERROR = "Transcript pagination state exceeds the safe limit";
 var GENERATION_HEARTBEAT_MS = 15e3;
+var PRIMARY_ONLY_LIVE_SESSION_ROUTES = [
+  "POST /session/:id/branch",
+  "POST /session/:id/fork",
+  "POST /session/:id/cd"
+];
+function isPrimaryOnlyLiveSessionRoute(route) {
+  return PRIMARY_ONLY_LIVE_SESSION_ROUTES.includes(
+    route
+  );
+}
+__name(isPrimaryOnlyLiveSessionRoute, "isPrimaryOnlyLiveSessionRoute");
 function formatGenerationSse(event, data) {
   return `event: ${event}
 data: ${JSON.stringify({ v: 1, ...data })}
@@ -18584,6 +19248,32 @@ function parseTranscriptCursorQuery(rawCursor, res) {
   return rawCursor;
 }
 __name(parseTranscriptCursorQuery, "parseTranscriptCursorQuery");
+function parseTranscriptRecordBoundaryQuery(rawBoundary, res) {
+  if (rawBoundary === void 0) return void 0;
+  if (typeof rawBoundary !== "string" || rawBoundary.trim() === "" || rawBoundary.length > 200) {
+    res.status(400).json({
+      error: "`beforeRecordId` must be a non-empty record id",
+      code: "invalid_transcript_cursor"
+    });
+    return null;
+  }
+  return rawBoundary;
+}
+__name(parseTranscriptRecordBoundaryQuery, "parseTranscriptRecordBoundaryQuery");
+function parseHistoryPageSize(body, res) {
+  const value = body["historyPageSize"];
+  if (value === void 0) return void 0;
+  if (!Number.isSafeInteger(value) || value < 1 || value > SESSION_TRANSCRIPT_MAX_LIMIT) {
+    res.status(400).json({
+      error: `\`historyPageSize\` must be between 1 and ${SESSION_TRANSCRIPT_MAX_LIMIT}`,
+      code: "invalid_transcript_limit",
+      maxLimit: SESSION_TRANSCRIPT_MAX_LIMIT
+    });
+    return null;
+  }
+  return value;
+}
+__name(parseHistoryPageSize, "parseHistoryPageSize");
 function workspaceTranscriptCursorExceedsLimit(cursor, maxBytes = WORKSPACE_TRANSCRIPT_CURSOR_MAX_BYTES) {
   return Buffer.byteLength(cursor) > maxBytes;
 }
@@ -18705,6 +19395,7 @@ function registerSessionRoutes(app, deps) {
       return void 0;
     }
     if (workspaceRegistry.list().length === 1) {
+      setDaemonTelemetryWorkspace(res, workspaceRegistry.primary.workspaceCwd);
       return {
         runtime: workspaceRegistry.primary,
         workspaceCwd: "cwd" in body ? key : workspaceRegistry.primary.workspaceCwd
@@ -18720,6 +19411,7 @@ function registerSessionRoutes(app, deps) {
       sendWorkspaceMismatch2(res, key);
       return void 0;
     }
+    setDaemonTelemetryWorkspace(res, runtime.workspaceCwd);
     if (!runtime.primary && !runtime.trusted) {
       logSessionRoutingFailure("POST /session", "untrusted_workspace", {
         workspaceId: runtime.workspaceId,
@@ -18972,6 +19664,7 @@ function registerSessionRoutes(app, deps) {
       sendWorkspaceMismatch2(res, key);
       return void 0;
     }
+    setDaemonTelemetryWorkspace(res, runtime.workspaceCwd);
     if (!runtime.primary && !runtime.trusted) {
       logSessionRoutingFailure(route, "untrusted_workspace", {
         workspaceId: runtime.workspaceId,
@@ -19009,7 +19702,7 @@ function registerSessionRoutes(app, deps) {
   }), "resolveLiveSessionRuntime");
   const sendNonPrimarySessionRouteUnsupported = /* @__PURE__ */ __name((res, route, sessionId, runtime) => {
     res.status(400).json({
-      error: `Route "${route}" is primary-only for non-primary workspace sessions in Phase 2a.`,
+      error: `Route "${route}" is only available for primary workspace sessions.`,
       code: "non_primary_session_route_not_supported",
       sessionId,
       workspaceId: runtime.workspaceId,
@@ -19057,6 +19750,7 @@ function registerSessionRoutes(app, deps) {
     }, "throwMissingActiveTranscript");
     if (workspaceRegistry.list().length === 1) {
       const runtime = workspaceRegistry.primary;
+      setDaemonTelemetryWorkspace(res, runtime.workspaceCwd);
       if (await activeInRuntime(runtime)) {
         return runtime;
       }
@@ -19068,6 +19762,7 @@ function registerSessionRoutes(app, deps) {
       return void 0;
     }
     if (liveOwner.kind === "found") {
+      setDaemonTelemetryWorkspace(res, liveOwner.runtime.workspaceCwd);
       if (!assertTrustedSessionOwner(res, route, sessionId, liveOwner.runtime)) {
         return void 0;
       }
@@ -19102,6 +19797,7 @@ function registerSessionRoutes(app, deps) {
     }
     if (activeRuntimes.length === 1) {
       const runtime = activeRuntimes[0];
+      setDaemonTelemetryWorkspace(res, runtime.workspaceCwd);
       if (!assertTrustedSessionOwner(res, route, sessionId, runtime)) {
         return void 0;
       }
@@ -19158,23 +19854,37 @@ function registerSessionRoutes(app, deps) {
     }
     return key;
   }, "resolveWorkspaceParam");
-  const withMutableSession = /* @__PURE__ */ __name((route, handler) => async (req, res) => {
-    const sessionId = requireSessionId(req, res);
-    if (sessionId === null) return;
-    const runtime = resolveLiveSessionRuntime(sessionId, res, route);
-    if (!runtime) return;
-    if (!runtime.primary) {
-      sendNonPrimarySessionRouteUnsupported(res, route, sessionId, runtime);
-      return;
-    }
-    try {
-      await archiveCoordinator.runSharedMany([sessionId], async () => {
-        await handler(req, res, sessionId);
-      });
-    } catch (err) {
-      sendBridgeError2(res, err, { route, sessionId });
+  const withPrimaryOnlyMutableSession = /* @__PURE__ */ __name((route, handler) => {
+    if (!isPrimaryOnlyLiveSessionRoute(route)) {
+      throw new Error(`Unregistered primary-only session route: ${route}`);
     }
-  }, "withMutableSession");
+    return async (req, res) => {
+      const sessionId = requireSessionId(req, res);
+      if (sessionId === null) return;
+      const runtime = resolveLiveSessionRuntime(sessionId, res, route);
+      if (!runtime) return;
+      if (!runtime.primary) {
+        logSessionRoutingFailure(
+          route,
+          "non_primary_session_route_not_supported",
+          {
+            sessionId,
+            workspaceId: runtime.workspaceId,
+            workspaceCwd: runtime.workspaceCwd
+          }
+        );
+        sendNonPrimarySessionRouteUnsupported(res, route, sessionId, runtime);
+        return;
+      }
+      try {
+        await archiveCoordinator.runSharedMany([sessionId], async () => {
+          await handler(req, res, sessionId);
+        });
+      } catch (err) {
+        sendBridgeError2(res, err, { route, sessionId });
+      }
+    };
+  }, "withPrimaryOnlyMutableSession");
   app.post("/session", mutate(), async (req, res) => {
     const body = safeBody(req);
     const resolvedRuntime = resolveRuntimeForSessionCreation(body, res);
@@ -19285,6 +19995,11 @@ function registerSessionRoutes(app, deps) {
       releaseRestoreOwner();
       return;
     }
+    const historyPageSize = action === "load" ? parseHistoryPageSize(body ?? {}, res) : void 0;
+    if (historyPageSize === null) {
+      releaseRestoreOwner();
+      return;
+    }
     const clientId = parseClientIdHeader(req, res);
     if (clientId === null) {
       releaseRestoreOwner();
@@ -19302,6 +20017,7 @@ function registerSessionRoutes(app, deps) {
             sessionId,
             workspaceCwd,
             historyReplay: "response",
+            ...historyPageSize !== void 0 ? { historyPageSize } : {},
             ...clientId !== void 0 ? { clientId } : {},
             ...approvalMode !== void 0 ? { approvalMode } : {},
             ...metadata
@@ -19345,7 +20061,7 @@ function registerSessionRoutes(app, deps) {
   app.post(
     "/session/:id/branch",
     mutate(),
-    withMutableSession(
+    withPrimaryOnlyMutableSession(
       "POST /session/:id/branch",
       async (req, res, sessionId) => {
         const body = safeBody(req);
@@ -19380,7 +20096,7 @@ function registerSessionRoutes(app, deps) {
   app.post(
     "/session/:id/fork",
     mutate(),
-    withMutableSession(
+    withPrimaryOnlyMutableSession(
       "POST /session/:id/fork",
       async (req, res, sessionId) => {
         const body = safeBody(req);
@@ -19406,25 +20122,28 @@ function registerSessionRoutes(app, deps) {
   app.post(
     "/session/:id/cd",
     mutate(),
-    withMutableSession("POST /session/:id/cd", async (req, res, sessionId) => {
-      const body = safeBody(req);
-      const targetPath = body["path"];
-      if (typeof targetPath !== "string" || targetPath.length === 0 || !path11.isAbsolute(targetPath)) {
-        res.status(400).json({
-          error: "`path` is required and must be an absolute path",
-          code: "invalid_path"
-        });
-        return;
+    withPrimaryOnlyMutableSession(
+      "POST /session/:id/cd",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        const targetPath = body["path"];
+        if (typeof targetPath !== "string" || targetPath.length === 0 || !path11.isAbsolute(targetPath)) {
+          res.status(400).json({
+            error: "`path` is required and must be an absolute path",
+            code: "invalid_path"
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const result = await bridge.changeSessionCwd(
+          sessionId,
+          { path: targetPath },
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(200).json(result);
       }
-      const clientId = parseClientIdHeader(req, res);
-      if (clientId === null) return;
-      const result = await bridge.changeSessionCwd(
-        sessionId,
-        { path: targetPath },
-        clientId !== void 0 ? { clientId } : void 0
-      );
-      res.status(200).json(result);
-    })
+    )
   );
   app.get("/session/:id/status", (req, res) => {
     const sessionId = requireSessionId(req, res);
@@ -19482,6 +20201,18 @@ function registerSessionRoutes(app, deps) {
     if (limit === null) return;
     const cursor = parseTranscriptCursorQuery(req.query["cursor"], res);
     if (cursor === null) return;
+    const beforeRecordId = parseTranscriptRecordBoundaryQuery(
+      req.query["beforeRecordId"],
+      res
+    );
+    if (beforeRecordId === null) return;
+    if (cursor !== void 0 && beforeRecordId !== void 0) {
+      res.status(400).json({
+        error: "`cursor` and `beforeRecordId` are mutually exclusive",
+        code: "invalid_transcript_cursor"
+      });
+      return;
+    }
     try {
       const result = await archiveCoordinator.runSharedMany(
         [sessionId],
@@ -19496,7 +20227,8 @@ function registerSessionRoutes(app, deps) {
           return runtime.bridge.getSessionTranscriptPage({
             sessionId,
             ...limit !== void 0 ? { limit } : {},
-            ...cursor !== void 0 ? { cursor } : {}
+            ...cursor !== void 0 ? { cursor } : {},
+            ...beforeRecordId !== void 0 ? { beforeRecordId } : {}
           });
         }
       );
@@ -19531,6 +20263,18 @@ function registerSessionRoutes(app, deps) {
     if (limit === null) return;
     const cursor = parseTranscriptCursorQuery(req.query["cursor"], res);
     if (cursor === null) return;
+    const beforeRecordId = parseTranscriptRecordBoundaryQuery(
+      req.query["beforeRecordId"],
+      res
+    );
+    if (beforeRecordId === null) return;
+    if (cursor !== void 0 && beforeRecordId !== void 0) {
+      res.status(400).json({
+        error: "`cursor` and `beforeRecordId` are mutually exclusive",
+        code: "invalid_transcript_cursor"
+      });
+      return;
+    }
     if (cursor !== void 0 && workspaceTranscriptCursorExceedsLimit(cursor)) {
       res.status(400).json({
         error: "`cursor` exceeds the maximum size",
@@ -19555,7 +20299,8 @@ function registerSessionRoutes(app, deps) {
             page = await reader.readPage(sessionId, {
               ...limit !== void 0 ? { limit } : {},
               ...cursor !== void 0 ? { cursor } : {},
-              maxBytes: WORKSPACE_TRANSCRIPT_PAGE_SOURCE_MAX_BYTES
+              ...beforeRecordId !== void 0 ? { beforeRecordId } : {},
+              maxBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES
             });
           } catch (error2) {
             if (error2.code !== "ENOENT") {
@@ -20686,6 +21431,36 @@ function registerSessionRoutes(app, deps) {
     "/workspaces/:workspace/sessions",
     listWorkspaceSessionsHandler("workspace")
   );
+  const workspaceSessionInfoHandler = /* @__PURE__ */ __name((paramName) => async (req, res) => {
+    const route = paramName === "workspace" ? "GET /workspaces/:workspace/session-info" : "GET /workspace/:id/session-info";
+    const runtime = resolveRuntimeForCatalogRoute(req, res, paramName, route);
+    if (runtime === null) return;
+    const key = runtime.workspaceCwd;
+    try {
+      const info = await runWorkspaceInspectionWithLogPolicy(
+        runtime,
+        () => getWorkspaceSessionInfoForResponse(runtime.bridge, key, {
+          includeLive: !isReadOnlyWorkspaceInspection(runtime)
+        })
+      );
+      res.status(200).json(info);
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: failed to read session-info for workspace ${safeLogValue(
+          key
+        )}: ${safeLogValue(err instanceof Error ? err.message : String(err))}`
+      );
+      res.status(500).json({
+        error: "Failed to read session info",
+        code: "session_info_failed"
+      });
+    }
+  }, "workspaceSessionInfoHandler");
+  app.get("/workspace/:id/session-info", workspaceSessionInfoHandler("id"));
+  app.get(
+    "/workspaces/:workspace/session-info",
+    workspaceSessionInfoHandler("workspace")
+  );
   app.post(
     "/session/:id/model",
     mutate(),
@@ -21663,6 +22438,81 @@ function parseNameField(raw) {
 }
 __name(parseNameField, "parseNameField");
 
+// packages/cli/src/serve/routes/goals.ts
+init_esbuild_shims();
+var PROBE_CONCURRENCY = 10;
+async function allSettledWithLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = /* @__PURE__ */ __name(async () => {
+    while (next < items.length) {
+      const index = next++;
+      try {
+        results[index] = { status: "fulfilled", value: await fn(items[index]) };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  }, "worker");
+  const workers = Math.min(Math.max(1, limit), items.length);
+  await Promise.all(Array.from({ length: workers }, worker));
+  return results;
+}
+__name(allSettledWithLimit, "allSettledWithLimit");
+function registerGoalsRoutes(app, deps) {
+  const { boundWorkspace, bridge } = deps;
+  app.get("/goals", async (_req, res) => {
+    try {
+      const sessions = bridge.listWorkspaceSessions(boundWorkspace);
+      const settled = await allSettledWithLimit(
+        sessions,
+        PROBE_CONCURRENCY,
+        async (session) => ({
+          session,
+          goal: await bridge.getSessionGoal(session.sessionId)
+        })
+      );
+      const goals = [];
+      const dropped = [];
+      for (const [index, outcome] of settled.entries()) {
+        if (outcome.status !== "fulfilled") {
+          const sessionId = sessions[index]?.sessionId ?? "(unknown)";
+          const reason = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+          dropped.push(`${sessionId}: ${reason}`);
+          continue;
+        }
+        const { session, goal } = outcome.value;
+        if (!goal.active) continue;
+        goals.push({
+          sessionId: session.sessionId,
+          displayName: session.displayName ?? null,
+          condition: goal.active.condition,
+          iterations: goal.active.iterations,
+          setAt: goal.active.setAt,
+          ...goal.active.lastReason !== void 0 ? { lastReason: goal.active.lastReason } : {},
+          hasActivePrompt: session.hasActivePrompt
+        });
+      }
+      if (dropped.length > 0) {
+        writeStderrLine(
+          `qwen serve: GET /goals could not probe ${dropped.length} of ${sessions.length} session(s): ${dropped.join("; ")}`
+        );
+      }
+      goals.sort((a, b) => b.setAt - a.setAt);
+      res.status(200).json({ v: 1, goals, droppedCount: dropped.length });
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: GET /goals failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
+        error: "Failed to list active goals",
+        code: "goals_read_failed"
+      });
+    }
+  });
+}
+__name(registerGoalsRoutes, "registerGoalsRoutes");
+
 // packages/cli/src/serve/routes/usage-stats.ts
 init_esbuild_shims();
 var DEFAULT_HEATMAP_DAYS = 183;
@@ -23188,7 +24038,7 @@ function sendBridgeError(res, err, ctx, daemonLog) {
   if (err instanceof WorkspaceSkillNotToggleableError) {
     res.status(409).json({
       error: err.message,
-      code: "skill_not_toggleable",
+      code: err.reason === "inactive_extension" ? "skill_inactive_extension" : "skill_not_toggleable",
       skillName: err.skillName,
       reason: err.reason,
       ...err.lockedScope ? { lockedScope: err.lockedScope } : {}
@@ -23391,7 +24241,7 @@ function sendBridgeError(res, err, ctx, daemonLog) {
   }
   if (err instanceof WorkspaceMismatchError) {
     writeStderrLine(
-      `qwen serve: workspace_mismatch (POST /session): daemon bound to ${JSON.stringify(err.bound)}, rejected ${JSON.stringify(err.requested)}`
+      `qwen serve: workspace_mismatch (POST /session): runtime bound to ${JSON.stringify(err.bound)}, rejected ${JSON.stringify(err.requested)}`
     );
     res.status(400).json({
       error: err.message,
@@ -23575,13 +24425,24 @@ function sendBridgeError(res, err, ctx, daemonLog) {
         });
         return;
       }
-      if (kind === "transcript_too_large") {
+      if (kind === "transcript_too_large") {
+        const d = data;
+        res.status(413).json({
+          error: errorMessage2(err),
+          code: "transcript_too_large",
+          ...d.sessionId ? { sessionId: d.sessionId } : {},
+          ...typeof d.snapshotSize === "number" ? { snapshotSize: d.snapshotSize } : {},
+          ...typeof d.maxBytes === "number" ? { maxBytes: d.maxBytes } : {}
+        });
+        return;
+      }
+      if (kind === "transcript_page_too_large") {
         const d = data;
         res.status(413).json({
           error: errorMessage2(err),
-          code: "transcript_too_large",
+          code: "transcript_page_too_large",
           ...d.sessionId ? { sessionId: d.sessionId } : {},
-          ...typeof d.snapshotSize === "number" ? { snapshotSize: d.snapshotSize } : {},
+          ...typeof d.pageBytes === "number" ? { pageBytes: d.pageBytes } : {},
           ...typeof d.maxBytes === "number" ? { maxBytes: d.maxBytes } : {}
         });
         return;
@@ -24373,309 +25234,6 @@ function dropNestedWorkspacesPreservingPrimary(workspaces) {
 }
 __name(dropNestedWorkspacesPreservingPrimary, "dropNestedWorkspacesPreservingPrimary");
 
-// packages/cli/src/serve/server/telemetry.ts
-init_esbuild_shims();
-function decodePathSegment(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-__name(decodePathSegment, "decodePathSegment");
-function resolveDaemonTelemetryRoute(req) {
-  const path15 = req.path.replace(/\/$/, "") || "/";
-  if (req.method === "POST" && path15 === "/session") {
-    return { route: "POST /session" };
-  }
-  if (req.method === "POST" && path15 === "/sessions/delete") {
-    return { route: "POST /sessions/delete" };
-  }
-  if (req.method === "GET" && path15 === "/daemon/status") {
-    return { route: "GET /daemon/status" };
-  }
-  const rewindSnapshots = path15.match(/^\/session\/([^/]+)\/rewind\/snapshots$/);
-  if (rewindSnapshots?.[1] && req.method === "GET") {
-    return {
-      route: "GET /session/:id/rewind/snapshots",
-      sessionId: rewindSnapshots[1]
-    };
-  }
-  const sessionAction = path15.match(
-    /^\/session\/([^/]+)\/(load|resume|prompt|cancel|recap|btw|mid-turn-message|model|shell|detach|rewind|approval-mode|language|a2ui-action)$/
-  );
-  const sessionActionId = sessionAction?.[1];
-  const sessionActionName = sessionAction?.[2];
-  if (sessionActionId && sessionActionName && req.method === "POST") {
-    return {
-      route: `POST /session/:id/${sessionActionName}`,
-      sessionId: sessionActionId
-    };
-  }
-  const sessionMetadata = path15.match(/^\/session\/([^/]+)\/metadata$/);
-  if (sessionMetadata?.[1] && req.method === "PATCH") {
-    return {
-      route: "PATCH /session/:id/metadata",
-      sessionId: sessionMetadata[1]
-    };
-  }
-  const sessionArtifacts = path15.match(/^\/session\/([^/]+)\/artifacts$/);
-  if (sessionArtifacts?.[1]) {
-    if (req.method === "GET") {
-      return {
-        route: "GET /session/:id/artifacts",
-        sessionId: sessionArtifacts[1]
-      };
-    }
-    if (req.method === "POST") {
-      return {
-        route: "POST /session/:id/artifacts",
-        sessionId: sessionArtifacts[1]
-      };
-    }
-  }
-  const sessionArtifact = path15.match(
-    /^\/session\/([^/]+)\/artifacts\/([^/]+)$/
-  );
-  if (sessionArtifact?.[1] && req.method === "DELETE") {
-    return {
-      route: "DELETE /session/:id/artifacts/:artifactId",
-      sessionId: sessionArtifact[1]
-    };
-  }
-  const sessionPermission = path15.match(
-    /^\/session\/([^/]+)\/permission\/([^/]+)$/
-  );
-  if (sessionPermission?.[1] && sessionPermission?.[2] && req.method === "POST") {
-    const rawRequestId = sessionPermission[2];
-    return {
-      route: "POST /session/:id/permission/:requestId",
-      sessionId: sessionPermission[1],
-      ...rawRequestId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawRequestId) ? { permissionRequestId: rawRequestId } : {}
-    };
-  }
-  const globalPermission = path15.match(/^\/permission\/([^/]+)$/);
-  if (globalPermission?.[1] && req.method === "POST") {
-    const rawRequestId = globalPermission[1];
-    return {
-      route: "POST /permission/:requestId",
-      ...rawRequestId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawRequestId) ? { permissionRequestId: rawRequestId } : {}
-    };
-  }
-  const deleteSession = path15.match(/^\/session\/([^/]+)$/);
-  const deleteSessionId = deleteSession?.[1];
-  if (deleteSessionId && req.method === "DELETE") {
-    return { route: "DELETE /session/:id", sessionId: deleteSessionId };
-  }
-  if (req.method === "GET" && /^\/workspace\/[^/]+\/sessions$/.test(path15)) {
-    return { route: "GET /workspace/:id/sessions" };
-  }
-  if (req.method === "GET" && /^\/workspaces\/[^/]+\/sessions$/.test(path15)) {
-    return { route: "GET /workspace/:id/sessions" };
-  }
-  const workspaceTranscript = path15.match(
-    /^\/workspaces\/[^/]+\/session\/([^/]+)\/transcript$/
-  );
-  if (workspaceTranscript?.[1] && req.method === "GET") {
-    return {
-      route: "GET /workspaces/:workspace/session/:id/transcript",
-      sessionId: workspaceTranscript[1]
-    };
-  }
-  const workspaceExport = path15.match(
-    /^\/workspaces\/[^/]+\/session\/([^/]+)\/export$/
-  );
-  if (workspaceExport?.[1] && req.method === "GET") {
-    return {
-      route: "GET /workspaces/:workspace/session/:id/export",
-      sessionId: workspaceExport[1]
-    };
-  }
-  const workspaceArchivedExport = path15.match(
-    /^\/workspaces\/[^/]+\/session\/([^/]+)\/archive\/export$/
-  );
-  if (workspaceArchivedExport?.[1] && req.method === "GET") {
-    return {
-      route: "GET /workspaces/:workspace/session/:id/archive/export",
-      sessionId: workspaceArchivedExport[1]
-    };
-  }
-  const pluralWorkspacePrefix = /^\/workspaces\/[^/]+/;
-  if (pluralWorkspacePrefix.test(path15)) {
-    const suffix = path15.replace(pluralWorkspacePrefix, "/workspace");
-    if (req.method === "GET") {
-      if (suffix === "/workspace/mcp" || suffix === "/workspace/skills" || suffix === "/workspace/tools" || suffix === "/workspace/providers" || suffix === "/workspace/env" || suffix === "/workspace/preflight" || suffix === "/workspace/hooks" || suffix === "/workspace/settings" || suffix === "/workspace/voice" || suffix === "/workspace/permissions" || suffix === "/workspace/trust" || suffix === "/workspace/memory" || suffix === "/workspace/agents") {
-        return { route: `GET ${suffix}` };
-      }
-      if (/^\/workspace\/agents\/[^/]+$/.test(suffix)) {
-        return { route: "GET /workspace/agents/:agentType" };
-      }
-      if (suffix === "/workspace/file") return { route: "GET /file" };
-      if (suffix === "/workspace/file/bytes") {
-        return { route: "GET /file/bytes" };
-      }
-      if (suffix === "/workspace/stat") return { route: "GET /stat" };
-      if (suffix === "/workspace/list") return { route: "GET /list" };
-      if (suffix === "/workspace/glob") return { route: "GET /glob" };
-      if (/^\/workspace\/mcp\/[^/]+\/tools$/.test(suffix)) {
-        return { route: "GET /workspace/mcp/:server/tools" };
-      }
-      if (/^\/workspace\/mcp\/[^/]+\/resources$/.test(suffix)) {
-        return { route: "GET /workspace/mcp/:server/resources" };
-      }
-    }
-    if (req.method === "POST") {
-      if (suffix === "/workspace/settings" || suffix === "/workspace/voice" || suffix === "/workspace/voice/transcribe" || suffix === "/workspace/permissions" || suffix === "/workspace/trust/request" || suffix === "/workspace/init" || suffix === "/workspace/reload" || suffix === "/workspace/file/write" || suffix === "/workspace/file/edit" || suffix === "/workspace/mcp/servers" || suffix === "/workspace/memory" || suffix === "/workspace/agents" || suffix === "/workspace/sessions/delete" || suffix === "/workspace/sessions/archive" || suffix === "/workspace/sessions/unarchive" || suffix === "/workspace/session-groups") {
-        return { route: `POST ${suffix}` };
-      }
-      if (/^\/workspace\/tools\/[^/]+\/enable$/.test(suffix)) {
-        return { route: "POST /workspace/tools/:name/enable" };
-      }
-      if (/^\/workspace\/mcp\/[^/]+\/restart$/.test(suffix)) {
-        return { route: "POST /workspace/mcp/:server/restart" };
-      }
-      if (/^\/workspace\/agents\/[^/]+$/.test(suffix)) {
-        return { route: "POST /workspace/agents/:agentType" };
-      }
-      if (/^\/workspace\/mcp\/[^/]+\/(approve|enable|disable|authenticate|clear-auth)$/.test(
-        suffix
-      )) {
-        return {
-          route: `POST /workspace/mcp/:server/${suffix.split("/").at(-1)}`
-        };
-      }
-    }
-    if (req.method === "DELETE" && /^\/workspace\/mcp\/servers\/[^/]+$/.test(suffix)) {
-      return { route: "DELETE /workspace/mcp/servers/:name" };
-    }
-    if (req.method === "DELETE" && /^\/workspace\/agents\/[^/]+$/.test(suffix)) {
-      return { route: "DELETE /workspace/agents/:agentType" };
-    }
-    if (suffix === "/workspace/session-groups" && req.method === "GET") {
-      return { route: "GET /workspace/session-groups" };
-    }
-    if (/^\/workspace\/session-groups\/[^/]+$/.test(suffix) && req.method === "PATCH") {
-      return { route: "PATCH /workspace/session-groups/:groupId" };
-    }
-    if (/^\/workspace\/session-groups\/[^/]+$/.test(suffix) && req.method === "DELETE") {
-      return { route: "DELETE /workspace/session-groups/:groupId" };
-    }
-  }
-  if (req.method === "POST" && path15 === "/workspace/init") {
-    return { route: "POST /workspace/init" };
-  }
-  if (req.method === "POST" && path15 === "/workspace/setup-github") {
-    return { route: "POST /workspace/setup-github" };
-  }
-  if (req.method === "POST" && path15 === "/workspace/reload") {
-    return { route: "POST /workspace/reload" };
-  }
-  const mcpRestart = path15.match(/^\/workspace\/mcp\/([^/]+)\/restart$/);
-  if (mcpRestart?.[1] && req.method === "POST") {
-    return { route: "POST /workspace/mcp/:server/restart" };
-  }
-  if (req.method === "POST" && path15 === "/workspace/mcp/servers") {
-    return { route: "POST /workspace/mcp/servers" };
-  }
-  const mcpDelete = path15.match(/^\/workspace\/mcp\/servers\/([^/]+)$/);
-  if (mcpDelete?.[1] && req.method === "DELETE") {
-    return { route: "DELETE /workspace/mcp/servers/:name" };
-  }
-  if (req.method === "POST" && path15 === "/workspace/auth/device-flow") {
-    return { route: "POST /workspace/auth/device-flow" };
-  }
-  const deviceFlowDelete = path15.match(
-    /^\/workspace\/auth\/device-flow\/([^/]+)$/
-  );
-  if (deviceFlowDelete?.[1] && req.method === "DELETE") {
-    return { route: "DELETE /workspace/auth/device-flow/:id" };
-  }
-  const toolEnable = path15.match(/^\/workspace\/tools\/([^/]+)\/enable$/);
-  if (toolEnable?.[1] && req.method === "POST") {
-    return { route: "POST /workspace/tools/:name/enable" };
-  }
-  if (path15 === "/workspace/settings") {
-    if (req.method === "GET") return { route: "GET /workspace/settings" };
-    if (req.method === "POST") return { route: "POST /workspace/settings" };
-  }
-  if (path15 === "/workspace/permissions") {
-    if (req.method === "GET") return { route: "GET /workspace/permissions" };
-    if (req.method === "POST") return { route: "POST /workspace/permissions" };
-  }
-  if (path15 === "/workspace/trust") {
-    if (req.method === "GET") return { route: "GET /workspace/trust" };
-  }
-  if (req.method === "POST" && path15 === "/workspace/trust/request") {
-    return { route: "POST /workspace/trust/request" };
-  }
-  if (path15 === "/workspace/voice") {
-    if (req.method === "GET") return { route: "GET /workspace/voice" };
-    if (req.method === "POST") return { route: "POST /workspace/voice" };
-  }
-  if (req.method === "POST" && path15 === "/workspace/voice/transcribe") {
-    return { route: "POST /workspace/voice/transcribe" };
-  }
-  return void 0;
-}
-__name(resolveDaemonTelemetryRoute, "resolveDaemonTelemetryRoute");
-function daemonTelemetryMiddleware(resolveWorkspaceCwd, recordRequest, resolveSessionWorkspaceCwd) {
-  const workspaceHashByCwd = /* @__PURE__ */ new Map();
-  const resolveWorkspaceHash = /* @__PURE__ */ __name((workspaceCwd) => {
-    const existing = workspaceHashByCwd.get(workspaceCwd);
-    if (existing !== void 0) return existing;
-    const workspaceHash = hashDaemonWorkspace(workspaceCwd);
-    workspaceHashByCwd.set(workspaceCwd, workspaceHash);
-    return workspaceHash;
-  }, "resolveWorkspaceHash");
-  return (req, res, next) => {
-    const route = resolveDaemonTelemetryRoute(req);
-    if (!route) {
-      next();
-      return;
-    }
-    const resolveOwnerWorkspace = route.route === "GET /session/:id/rewind/snapshots" || route.route === "POST /session/:id/rewind" || route.route === "POST /session/:id/shell";
-    const sessionId = route.sessionId ? decodePathSegment(route.sessionId) : void 0;
-    const workspaceCwd = (resolveOwnerWorkspace && sessionId ? resolveSessionWorkspaceCwd?.(sessionId) : void 0) ?? resolveWorkspaceCwd(req);
-    const workspaceHash = resolveWorkspaceHash(workspaceCwd);
-    const rawClientId = req.get(CLIENT_ID_HEADER);
-    const clientId = rawClientId !== void 0 && rawClientId !== "" && rawClientId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawClientId) ? rawClientId : void 0;
-    const startMs = Date.now();
-    void withDaemonRequestSpan(
-      {
-        method: req.method,
-        route: route.route,
-        workspaceHash,
-        ...sessionId ? { sessionId } : {},
-        ...route.permissionRequestId ? { permissionRequestId: route.permissionRequestId } : {},
-        ...clientId ? { clientId } : {}
-      },
-      async (span) => await new Promise((resolve5, reject) => {
-        let done = false;
-        const finish = /* @__PURE__ */ __name(() => {
-          if (done) return;
-          done = true;
-          recordDaemonHttpResponse(span, res.statusCode);
-          const durationMs = Date.now() - startMs;
-          recordDaemonHttpRequest(durationMs, route.route, res.statusCode);
-          if (route.route !== "GET /daemon/status") {
-            recordRequest?.(durationMs, res.statusCode);
-          }
-          resolve5();
-        }, "finish");
-        res.once("finish", finish);
-        res.once("close", finish);
-        try {
-          next();
-        } catch (error2) {
-          recordDaemonError(span, error2);
-          reject(error2);
-        }
-      })
-    ).catch(next);
-  };
-}
-__name(daemonTelemetryMiddleware, "daemonTelemetryMiddleware");
-
 // packages/cli/src/serve/server/access-log.ts
 init_esbuild_shims();
 var SESSION_ID_RE = /\/session\/([^/]+)/;
@@ -25199,9 +25757,10 @@ __name(registerWorkspaceQualifiedLifecycleRoutes, "registerWorkspaceQualifiedLif
 
 // packages/cli/src/serve/routes/workspace-management.ts
 init_esbuild_shims();
-import { stat } from "node:fs/promises";
+import { readdir, stat } from "node:fs/promises";
 import { realpathSync } from "node:fs";
-import { isAbsolute as isAbsolute7, resolve as resolve4 } from "node:path";
+import { basename as basename4, dirname as dirname4, isAbsolute as isAbsolute7, join as join7, resolve as resolve4, sep as sep3 } from "node:path";
+var MAX_PATH_SUGGESTIONS = 50;
 function registerWorkspaceManagementRoutes(app, deps) {
   const {
     workspaceRegistry,
@@ -25231,6 +25790,72 @@ function registerWorkspaceManagementRoutes(app, deps) {
       code: "daemon_shutting_down"
     });
   }, "sendSealed");
+  app.get(
+    "/workspace-path-suggestions",
+    async (req, res) => {
+      const prefixRaw = req.query["prefix"];
+      if (typeof prefixRaw !== "string" || prefixRaw.trim().length === 0) {
+        res.status(400).json({
+          error: "`prefix` must be a non-empty string",
+          code: "invalid_prefix"
+        });
+        return;
+      }
+      const prefix = prefixRaw;
+      if (prefix.length > MAX_WORKSPACE_PATH_LENGTH) {
+        res.status(400).json({
+          error: `\`prefix\` exceeds the ${MAX_WORKSPACE_PATH_LENGTH}-character limit`,
+          code: "invalid_prefix"
+        });
+        return;
+      }
+      if (!isAbsolute7(prefix)) {
+        res.status(400).json({
+          error: "`prefix` must be an absolute path",
+          code: "invalid_prefix"
+        });
+        return;
+      }
+      const endsWithSep = prefix.endsWith("/") || process.platform === "win32" && prefix.endsWith("\\");
+      const dir = endsWithSep ? join7(prefix, ".") : dirname4(prefix);
+      const filter = endsWithSep ? "" : basename4(prefix);
+      const filterLower = filter.toLowerCase();
+      const suggestions = [];
+      let truncated = false;
+      try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+          if (entry.name.startsWith(".") && !filter.startsWith(".")) continue;
+          if (filter && !entry.name.toLowerCase().startsWith(filterLower)) {
+            continue;
+          }
+          let isDir = entry.isDirectory();
+          if (!isDir && entry.isSymbolicLink()) {
+            try {
+              isDir = (await stat(join7(dir, entry.name))).isDirectory();
+            } catch {
+              continue;
+            }
+          }
+          if (!isDir) continue;
+          if (suggestions.length >= MAX_PATH_SUGGESTIONS) {
+            truncated = true;
+            break;
+          }
+          suggestions.push({ name: entry.name, path: join7(dir, entry.name) });
+        }
+      } catch {
+      }
+      res.status(200).json({
+        kind: "workspace-path-suggestions",
+        dir,
+        sep: sep3,
+        suggestions,
+        truncated
+      });
+    }
+  );
   app.post(
     "/workspaces",
     mutate({ strict: true }),
@@ -25983,6 +26608,151 @@ function registerWorkspaceQualifiedGitRoutes(app, deps) {
 }
 __name(registerWorkspaceQualifiedGitRoutes, "registerWorkspaceQualifiedGitRoutes");
 
+// packages/cli/src/serve/routes/workspace-git-diff.ts
+init_esbuild_shims();
+function buildDiffList(workspaceCwd, result) {
+  if (!result) {
+    return {
+      v: 1,
+      workspaceCwd,
+      available: false,
+      filesCount: 0,
+      linesAdded: 0,
+      linesRemoved: 0,
+      files: [],
+      hiddenCount: 0
+    };
+  }
+  const files = [...result.perFileStats.entries()].map(([path15, s]) => ({
+    path: path15,
+    oldPath: s.oldPath,
+    added: s.added,
+    removed: s.removed,
+    isBinary: s.isBinary,
+    isUntracked: s.isUntracked ?? false,
+    isDeleted: s.isDeleted ?? false,
+    truncated: s.truncated ?? false
+  }));
+  return {
+    v: 1,
+    workspaceCwd,
+    available: true,
+    filesCount: result.stats.filesCount,
+    linesAdded: result.stats.linesAdded,
+    linesRemoved: result.stats.linesRemoved,
+    files,
+    hiddenCount: Math.max(
+      0,
+      result.stats.filesCount - result.perFileStats.size
+    )
+  };
+}
+__name(buildDiffList, "buildDiffList");
+function buildFileHunks(workspaceCwd, queryPath, result) {
+  return {
+    v: 1,
+    workspaceCwd,
+    path: queryPath,
+    available: result !== null && result.hunks.length > 0,
+    hunks: (result?.hunks ?? []).map((h) => ({
+      oldStart: h.oldStart,
+      oldLines: h.oldLines,
+      newStart: h.newStart,
+      newLines: h.newLines,
+      lines: h.lines
+    })),
+    // Only present when the per-file caps actually cut content, so the client
+    // can label the diff incomplete; absent otherwise (additive to v=1).
+    ...result?.truncated ? { truncated: true } : {}
+  };
+}
+__name(buildFileHunks, "buildFileHunks");
+async function handleDiffList(res, workspaceCwd, sendBridgeError2, route) {
+  try {
+    applyReadHeaders(res);
+    res.status(200).json(buildDiffList(workspaceCwd, await fetchGitDiff(workspaceCwd)));
+  } catch (err) {
+    sendBridgeError2(res, err, { route });
+  }
+}
+__name(handleDiffList, "handleDiffList");
+async function handleDiffFile(req, res, workspaceCwd, sendBridgeError2, route) {
+  const queryPath = req.query["path"];
+  if (typeof queryPath !== "string" || queryPath.length === 0) {
+    applyReadHeaders(res);
+    res.status(400).json({
+      errorKind: "parse_error",
+      error: "path query parameter is required",
+      status: 400
+    });
+    return;
+  }
+  const queryOldPath = req.query["oldPath"];
+  const oldPath = typeof queryOldPath === "string" && queryOldPath.length > 0 ? queryOldPath : void 0;
+  try {
+    applyReadHeaders(res);
+    const result = await fetchGitDiffHunksForFile(
+      workspaceCwd,
+      queryPath,
+      oldPath
+    );
+    res.status(200).json(buildFileHunks(workspaceCwd, queryPath, result));
+  } catch (err) {
+    sendBridgeError2(res, err, { route });
+  }
+}
+__name(handleDiffFile, "handleDiffFile");
+function registerWorkspaceGitDiffRoutes(app, deps) {
+  app.get("/workspace/git/diff", (_req, res) => {
+    void handleDiffList(
+      res,
+      deps.boundWorkspace,
+      deps.sendBridgeError,
+      "GET /workspace/git/diff"
+    );
+  });
+  app.get("/workspace/git/diff/file", (req, res) => {
+    void handleDiffFile(
+      req,
+      res,
+      deps.boundWorkspace,
+      deps.sendBridgeError,
+      "GET /workspace/git/diff/file"
+    );
+  });
+}
+__name(registerWorkspaceGitDiffRoutes, "registerWorkspaceGitDiffRoutes");
+function resolveTrustedRuntime3(registry, req, res) {
+  const runtime = resolveWorkspaceRuntimeFromParam(registry, req, res);
+  if (!runtime) return null;
+  return requireTrustedWorkspaceRuntime(runtime, res) ? runtime : null;
+}
+__name(resolveTrustedRuntime3, "resolveTrustedRuntime");
+function registerWorkspaceQualifiedGitDiffRoutes(app, deps) {
+  app.get("/workspaces/:workspace/git/diff", (req, res) => {
+    const runtime = resolveTrustedRuntime3(deps.workspaceRegistry, req, res);
+    if (!runtime) return;
+    void handleDiffList(
+      res,
+      runtime.workspaceCwd,
+      deps.sendBridgeError,
+      "GET /workspaces/:workspace/git/diff"
+    );
+  });
+  app.get("/workspaces/:workspace/git/diff/file", (req, res) => {
+    const runtime = resolveTrustedRuntime3(deps.workspaceRegistry, req, res);
+    if (!runtime) return;
+    void handleDiffFile(
+      req,
+      res,
+      runtime.workspaceCwd,
+      deps.sendBridgeError,
+      "GET /workspaces/:workspace/git/diff/file"
+    );
+  });
+}
+__name(registerWorkspaceQualifiedGitDiffRoutes, "registerWorkspaceQualifiedGitDiffRoutes");
+
 // packages/cli/src/serve/workspace-git-state.ts
 init_esbuild_shims();
 var WorkspaceGitState = class {
@@ -25992,7 +26762,28 @@ var WorkspaceGitState = class {
   entries = /* @__PURE__ */ new Map();
   async getStatus(workspaceCwd, bridge) {
     const entry = await this.getOrCreateEntry(workspaceCwd, bridge);
-    return { v: 1, workspaceCwd, branch: entry.branch ?? null };
+    const status = await getGitWorkingTreeStatus(workspaceCwd).catch(
+      () => null
+    );
+    if (!status) {
+      return { v: 2, workspaceCwd, branch: entry.branch ?? null };
+    }
+    return {
+      v: 2,
+      workspaceCwd,
+      branch: entry.branch ?? status.branch ?? null,
+      detached: status.detached,
+      staged: status.staged,
+      unstaged: status.unstaged,
+      untracked: status.untracked,
+      conflicted: status.conflicted,
+      hasUpstream: status.hasUpstream,
+      ahead: status.ahead,
+      behind: status.behind,
+      stashCount: status.stashCount,
+      ...status.operation ? { operation: status.operation } : {},
+      computedAt: Date.now()
+    };
   }
   dispose() {
     for (const pending of this.entries.values()) {
@@ -26764,6 +27555,63 @@ function registerWorkspaceChannelControlRoutes(app, deps) {
 }
 __name(registerWorkspaceChannelControlRoutes, "registerWorkspaceChannelControlRoutes");
 
+// packages/cli/src/serve/routes/workspace-channel-observed-contacts.ts
+init_esbuild_shims();
+var DEFAULT_FRESH_WITHIN_SECONDS = 7 * 24 * 60 * 60;
+function parseFreshWithinSeconds(req) {
+  const raw = req.query["freshWithinSeconds"];
+  if (raw === void 0) return DEFAULT_FRESH_WITHIN_SECONDS;
+  if (typeof raw !== "string" || !/^\d+$/u.test(raw)) return void 0;
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < 1 || value > OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS) {
+    return void 0;
+  }
+  return value;
+}
+__name(parseFreshWithinSeconds, "parseFreshWithinSeconds");
+function sendContacts(req, res, workspaceCwd) {
+  res.setHeader("Cache-Control", "no-store");
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  const freshWithinSeconds = parseFreshWithinSeconds(req);
+  if (freshWithinSeconds === void 0) {
+    res.status(400).json({
+      error: `freshWithinSeconds must be an integer from 1 to ${OBSERVED_CONTACT_MAX_FRESH_WITHIN_SECONDS}.`,
+      code: "invalid_freshness"
+    });
+    return;
+  }
+  try {
+    const store = new ObservedChannelContactStore(
+      daemonObservedContactsPath(workspaceCwd)
+    );
+    res.status(200).json(store.list({ freshWithinSeconds }));
+  } catch {
+    process.stderr.write(
+      "qwen serve: observed channel contacts unavailable.\n"
+    );
+    res.status(500).json({
+      error: "Observed channel contacts are unavailable.",
+      code: "channel_observed_contacts_unavailable"
+    });
+  }
+}
+__name(sendContacts, "sendContacts");
+function registerWorkspaceChannelObservedContactRoutes(app, deps) {
+  app.get("/workspace/channel/observed-contacts", (req, res) => {
+    sendContacts(req, res, deps.primaryWorkspace);
+  });
+  app.get("/workspaces/:workspace/channel/observed-contacts", (req, res) => {
+    const runtime = resolveWorkspaceRuntimeFromParam(
+      deps.workspaceRegistry,
+      req,
+      res
+    );
+    if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+    sendContacts(req, res, runtime.workspaceCwd);
+  });
+}
+__name(registerWorkspaceChannelObservedContactRoutes, "registerWorkspaceChannelObservedContactRoutes");
+
 // packages/cli/src/serve/routes/workspace-tools.ts
 init_esbuild_shims();
 function registerWorkspaceToolsRoutes(app, deps) {
@@ -26922,9 +27770,9 @@ function parseSkillToggleRequest(req, res, safeBody2) {
     });
     return void 0;
   }
-  if (skillName.length > MAX_SKILL_NAME_LENGTH) {
+  if (skillName.length > MAX_WORKSPACE_SKILL_NAME_LENGTH) {
     res.status(400).json({
-      error: `Skill name exceeds ${MAX_SKILL_NAME_LENGTH}-character limit`,
+      error: `Skill name exceeds ${MAX_WORKSPACE_SKILL_NAME_LENGTH}-character limit`,
       code: "invalid_skill_name"
     });
     return void 0;
@@ -26940,11 +27788,138 @@ function parseSkillToggleRequest(req, res, safeBody2) {
   return { skillName, enabled };
 }
 __name(parseSkillToggleRequest, "parseSkillToggleRequest");
+function parseSkillScope(value, res) {
+  if (value === "workspace" || value === "global") return value;
+  res.status(400).json({
+    error: '`scope` must be "workspace" or "global"',
+    code: "invalid_skill_scope"
+  });
+  return void 0;
+}
+__name(parseSkillScope, "parseSkillScope");
+function parseSkillInstallRequest(req, res, safeBody2) {
+  const body = safeBody2(req);
+  const name = body["name"];
+  if (typeof name !== "string" || !name.trim()) {
+    res.status(400).json({
+      error: "`name` is required and must be a string",
+      code: "invalid_skill_name"
+    });
+    return void 0;
+  }
+  if (name.trim().length > MAX_WORKSPACE_SKILL_NAME_LENGTH) {
+    res.status(400).json({
+      error: `Skill name exceeds ${MAX_WORKSPACE_SKILL_NAME_LENGTH}-character limit`,
+      code: "invalid_skill_name"
+    });
+    return void 0;
+  }
+  const scope = parseSkillScope(body["scope"], res);
+  if (!scope) return void 0;
+  const rawSource = body["source"];
+  if (!rawSource || typeof rawSource !== "object" || Array.isArray(rawSource)) {
+    res.status(400).json({
+      error: "`source` is required",
+      code: "invalid_skill_source"
+    });
+    return void 0;
+  }
+  const source = rawSource;
+  if (source["type"] === "github" && typeof source["url"] === "string") {
+    return { name, scope, source: { type: "github", url: source["url"] } };
+  }
+  if (source["type"] === "zip" && typeof source["contentBase64"] === "string") {
+    return {
+      name,
+      scope,
+      source: { type: "zip", contentBase64: source["contentBase64"] }
+    };
+  }
+  if (source["type"] === "folder" && typeof source["path"] === "string") {
+    return {
+      name,
+      scope,
+      source: { type: "folder", path: source["path"] }
+    };
+  }
+  res.status(400).json({
+    error: "Invalid Skill install source",
+    code: "invalid_skill_source"
+  });
+  return void 0;
+}
+__name(parseSkillInstallRequest, "parseSkillInstallRequest");
+function parseDeleteScope(req, res) {
+  return parseSkillScope(req.query["scope"], res);
+}
+__name(parseDeleteScope, "parseDeleteScope");
+function sendSkillManagementError(res, error2) {
+  if (!(error2 instanceof WorkspaceSkillManagementError)) return false;
+  res.status(error2.statusCode).json({
+    error: error2.message,
+    code: error2.code
+  });
+  return true;
+}
+__name(sendSkillManagementError, "sendSkillManagementError");
 function registerWorkspaceSkillsRoutes(app, deps) {
   const buildWorkspaceCtx = createBuildWorkspaceCtx(
     deps.workspaceRuntime.workspaceCwd
   );
   const route = "POST /workspace/skills/:name/enable";
+  app.post(
+    "/workspace/skills/install",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      if (!requireTrustedWorkspaceRuntime(deps.workspaceRuntime, res)) return;
+      const input = parseSkillInstallRequest(req, res, deps.safeBody);
+      if (!input) return;
+      const clientId = deps.parseAndValidateClientId(req, res);
+      if (clientId === null) return;
+      const installRoute = "POST /workspace/skills/install";
+      try {
+        const result = await deps.workspaceRuntime.workspaceService.installWorkspaceSkill(
+          buildWorkspaceCtx(installRoute, clientId),
+          input
+        );
+        res.status(200).json(result);
+      } catch (err) {
+        if (!sendSkillManagementError(res, err))
+          deps.sendBridgeError(res, err, { route: installRoute });
+      }
+    }
+  );
+  app.delete(
+    "/workspace/skills/:name",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      if (!requireTrustedWorkspaceRuntime(deps.workspaceRuntime, res)) return;
+      const rawSkillName = req.params["name"];
+      const scope = parseDeleteScope(req, res);
+      if (!rawSkillName || !scope) return;
+      let skillName;
+      try {
+        skillName = validateWorkspaceSkillName(rawSkillName);
+      } catch (error2) {
+        sendSkillManagementError(res, error2);
+        return;
+      }
+      const clientId = deps.parseAndValidateClientId(req, res);
+      if (clientId === null) return;
+      const deleteRoute = "DELETE /workspace/skills/:name";
+      try {
+        const result = await deps.workspaceRuntime.workspaceService.deleteWorkspaceSkill(
+          buildWorkspaceCtx(deleteRoute, clientId),
+          skillName,
+          scope
+        );
+        res.status(200).json(result);
+      } catch (err) {
+        if (!sendSkillManagementError(res, err))
+          deps.sendBridgeError(res, err, { route: deleteRoute });
+      }
+    }
+  );
   app.post(
     "/workspace/skills/:name/enable",
     deps.mutate({ strict: true }),
@@ -26970,6 +27945,77 @@ function registerWorkspaceSkillsRoutes(app, deps) {
 __name(registerWorkspaceSkillsRoutes, "registerWorkspaceSkillsRoutes");
 function registerWorkspaceQualifiedSkillsRoutes(app, deps) {
   const route = "POST /workspaces/:workspace/skills/:name/enable";
+  app.post(
+    "/workspaces/:workspace/skills/install",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const runtime = resolveWorkspaceRuntimeFromParam(
+        deps.workspaceRegistry,
+        req,
+        res
+      );
+      if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+      const input = parseSkillInstallRequest(req, res, deps.safeBody);
+      if (!input) return;
+      const clientId = parseAndValidateWorkspaceClientId(
+        req,
+        res,
+        runtime.bridge
+      );
+      if (clientId === null) return;
+      const installRoute = "POST /workspaces/:workspace/skills/install";
+      try {
+        const result = await runtime.workspaceService.installWorkspaceSkill(
+          createBuildWorkspaceCtx(runtime.workspaceCwd)(installRoute, clientId),
+          input
+        );
+        res.status(200).json(result);
+      } catch (err) {
+        if (!sendSkillManagementError(res, err))
+          deps.sendBridgeError(res, err, { route: installRoute });
+      }
+    }
+  );
+  app.delete(
+    "/workspaces/:workspace/skills/:name",
+    deps.mutate({ strict: true }),
+    async (req, res) => {
+      const runtime = resolveWorkspaceRuntimeFromParam(
+        deps.workspaceRegistry,
+        req,
+        res
+      );
+      if (!runtime || !requireTrustedWorkspaceRuntime(runtime, res)) return;
+      const rawSkillName = req.params["name"];
+      const scope = parseDeleteScope(req, res);
+      if (!rawSkillName || !scope) return;
+      let skillName;
+      try {
+        skillName = validateWorkspaceSkillName(rawSkillName);
+      } catch (error2) {
+        sendSkillManagementError(res, error2);
+        return;
+      }
+      const clientId = parseAndValidateWorkspaceClientId(
+        req,
+        res,
+        runtime.bridge
+      );
+      if (clientId === null) return;
+      const deleteRoute = "DELETE /workspaces/:workspace/skills/:name";
+      try {
+        const result = await runtime.workspaceService.deleteWorkspaceSkill(
+          createBuildWorkspaceCtx(runtime.workspaceCwd)(deleteRoute, clientId),
+          skillName,
+          scope
+        );
+        res.status(200).json(result);
+      } catch (err) {
+        if (!sendSkillManagementError(res, err))
+          deps.sendBridgeError(res, err, { route: deleteRoute });
+      }
+    }
+  );
   app.post(
     "/workspaces/:workspace/skills/:name/enable",
     deps.mutate({ strict: true }),
@@ -27484,6 +28530,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       primaryEffectiveEnv ? { env: primaryEffectiveEnv } : {}
     ),
     workspaceSkillsStatusProvider: createWorkspaceSkillsStatusProvider(),
+    ...primaryEffectiveEnv ? { skillInstallEnv: primaryEffectiveEnv } : {},
     ...primaryEffectiveEnv ? { voiceEnv: primaryEffectiveEnv } : {},
     isChannelLive: /* @__PURE__ */ __name(() => bridge.isChannelLive(), "isChannelLive"),
     persistDisabledTools: deps.persistDisabledTools ?? (async () => {
@@ -27528,6 +28575,8 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   );
   app.locals.workspaceRegistry = workspaceRegistry;
   const primaryRuntime = workspaceRegistry.primary;
+  const daemonEnv = deps.daemonEnv ?? process.env;
+  const primaryRuntimeEffectiveEnv = getRuntimeEffectiveEnv(primaryRuntime.env) ?? daemonEnv;
   const voiceCoordinator = deps.voiceCoordinator ?? new WorkspaceVoiceCoordinator();
   const primaryBoundWorkspace = primaryRuntime.workspaceCwd;
   const primaryBridge = primaryRuntime.bridge;
@@ -27617,38 +28666,27 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     requireAuth: opts.requireAuth === true
   });
   app.use(
-    daemonTelemetryMiddleware(
-      (req) => {
-        const match = req.path.match(/^\/workspaces\/([^/]+)/);
-        const rawSelector = match?.[1];
-        if (rawSelector) {
-          try {
-            const selector = decodeURIComponent(rawSelector);
-            const byId = workspaceRegistry.getByWorkspaceId(selector);
-            if (byId) return byId.workspaceCwd;
-            if (isPortableAbsolutePath(selector)) {
-              const runtime = resolveRegisteredWorkspaceRuntimeByPathSelector(
-                workspaceRegistry,
-                selector
-              );
-              if (runtime) return runtime.workspaceCwd;
-            }
-          } catch {
-            return primaryBoundWorkspace;
-          }
-        }
-        return primaryBoundWorkspace;
-      },
-      deps.recordDaemonRequest,
-      (sessionId) => {
+    daemonTelemetryMiddleware((req) => {
+      const match = req.path.match(/^\/workspaces\/([^/]+)/);
+      const rawSelector = match?.[1];
+      if (rawSelector) {
         try {
-          const owner = workspaceRegistry.resolveLiveSessionOwner(sessionId);
-          return owner.kind === "found" ? owner.runtime.workspaceCwd : void 0;
+          const selector = decodeURIComponent(rawSelector);
+          const byId = workspaceRegistry.getByWorkspaceId(selector);
+          if (byId) return byId.workspaceCwd;
+          if (isPortableAbsolutePath(selector)) {
+            const runtime = resolveRegisteredWorkspaceRuntimeByPathSelector(
+              workspaceRegistry,
+              selector
+            );
+            if (runtime) return runtime.workspaceCwd;
+          }
         } catch {
-          return void 0;
+          return primaryBoundWorkspace;
         }
       }
-    )
+      return primaryBoundWorkspace;
+    }, deps.recordDaemonRequest)
   );
   const buildWorkspaceCtx = createBuildWorkspaceCtx(primaryBoundWorkspace);
   const acpHandleRef = {};
@@ -27713,6 +28751,14 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     gitState: workspaceGitState,
     sendBridgeError: sendBridgeError2
   });
+  registerWorkspaceGitDiffRoutes(app, {
+    boundWorkspace: primaryBoundWorkspace,
+    sendBridgeError: sendBridgeError2
+  });
+  registerWorkspaceQualifiedGitDiffRoutes(app, {
+    workspaceRegistry,
+    sendBridgeError: sendBridgeError2
+  });
   mountWorkspaceMemoryRoutes(app, {
     bridge: primaryBridge,
     boundWorkspace: primaryBoundWorkspace,
@@ -27790,6 +28836,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   registerWorkspaceSetupGithubRoutes(app, {
     boundWorkspace: primaryBoundWorkspace,
     bridge: primaryBridge,
+    env: primaryRuntimeEffectiveEnv,
     mutate,
     parseClientId: parseClientIdHeader,
     safeBody
@@ -27965,6 +29012,10 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
     });
   }
+  registerWorkspaceChannelObservedContactRoutes(app, {
+    primaryWorkspace: primaryBoundWorkspace,
+    workspaceRegistry
+  });
   registerWorkspaceLifecycleRoutes(app, {
     boundWorkspace: primaryBoundWorkspace,
     workspace: primaryWorkspace,
@@ -28014,6 +29065,10 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     safeBody,
     bridge: deps.manageScheduledTaskSessions ? bridge : void 0
   });
+  registerGoalsRoutes(app, {
+    boundWorkspace: primaryBoundWorkspace,
+    bridge: primaryBridge
+  });
   registerWorkspaceQualifiedScheduledTasksRoutes(app, {
     workspaceRegistry,
     mutate,
@@ -28086,6 +29141,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   });
   acpHandleRef.current = mountAcpHttp(app, primaryBridge, {
     boundWorkspace: primaryBoundWorkspace,
+    daemonEnv,
     // Phase 4 (issue #6378): pass the registry so `/workspaces/:workspace/acp`
     // mounts a per-runtime ACP dispatcher for each registered workspace.
     workspaceRegistry,
@@ -28157,6 +29213,7 @@ export {
   createServeApp,
   detectFromLoopback,
   getActiveSseCount,
+  getWorkspaceSessionInfoForResponse,
   listWorkspaceSessionsForResponse,
   resolveBoundWorkspacesFromIdeEnv,
   resolveBridgeFsFactory,