@qwen-code/qwen-code 0.19.6 → 0.19.7-nightly.20260708.394c1a289

package/chunks/{server-WKDQA6XR.js → server-GEOYEPYT.js}

@@ -11,28 +11,36 @@ import {
   openQwenAsrRealtimeStream,
   openVoiceStream,
   openVoiceStreamWithRetry
-} from "./chunk-OBVBTAX5.js";
+} from "./chunk-2YELHTUE.js";
 import {
   SetupGithubError,
-  setupGithub
-} from "./chunk-L7QPM2YD.js";
+  collectSessionData,
+  generateExportFilename,
+  normalizeSessionData,
+  setupGithub,
+  toHtml,
+  toJson,
+  toJsonl,
+  toMarkdown
+} from "./chunk-FK77ILF5.js";
+import "./chunk-ZK5EI6NR.js";
+import "./chunk-LGFAYIKX.js";
 import "./chunk-54YZOP7P.js";
-import "./chunk-XH7H6YG4.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-DBF3HTLT.js";
-import "./chunk-OAYOHSGP.js";
+} from "./chunk-FB2ULV4M.js";
+import "./chunk-BHRU4SDF.js";
 import "./chunk-KHDZHZMH.js";
 import {
   createWorkspaceProvidersStatusProvider
-} from "./chunk-3UC7ZC43.js";
+} from "./chunk-B6WUEODT.js";
 import {
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-SOT7OMGL.js";
+} from "./chunk-KT3SI3CQ.js";
 import {
   createWorkspaceSkillsStatusProvider
-} from "./chunk-C2QKQZEQ.js";
+} from "./chunk-VTCPREC7.js";
 import "./chunk-6IAWPIQ6.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
@@ -44,14 +52,14 @@ import {
   transcribeWorkspaceVoiceAudio,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-MX7CTJHR.js";
+} from "./chunk-UZCT5OLN.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-YTWX5TT2.js";
+} from "./chunk-5FL2K3ZB.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -59,13 +67,13 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-FZ5NVRVK.js";
+} from "./chunk-B5FOCTEZ.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-HCFSKO6K.js";
-import "./chunk-NIOPRZNN.js";
+} from "./chunk-3QDZDAJG.js";
+import "./chunk-E7KNELIZ.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError
@@ -79,6 +87,7 @@ import {
   MAX_CLIENT_ID_LENGTH,
   MAX_SERVER_NAME_LENGTH,
   MAX_TOOL_NAME_LENGTH,
+  PathMutexRegistry,
   TooManyActiveDeviceFlowsError,
   UnsupportedDeviceFlowProviderError,
   UpstreamDeviceFlowError,
@@ -114,7 +123,7 @@ import {
   setRateLimiter,
   unsafeRevealSecret,
   validateMcpRuntimeServerName
-} from "./chunk-N4YJQTRL.js";
+} from "./chunk-RFIL6REB.js";
 import {
   isLoopbackBind
 } from "./chunk-RNBYOUGV.js";
@@ -126,16 +135,16 @@ import {
   getSettingDefinition,
   loadSettings,
   validateSettingValue
-} from "./chunk-CEYA7K7C.js";
+} from "./chunk-QHT5USLK.js";
 import {
   SUPPORTED_LANGUAGES
-} from "./chunk-6QVRLKTZ.js";
+} from "./chunk-TBLJNMI7.js";
 import "./chunk-TLRYABYP.js";
 import "./chunk-4RQIB5UZ.js";
 import {
   SessionArtifactValidationError,
   createAcpSessionBridge
-} from "./chunk-LXFCHX4X.js";
+} from "./chunk-OU6FPTJZ.js";
 import "./chunk-P7M4GA57.js";
 import {
   BranchWhilePromptActiveError,
@@ -165,33 +174,37 @@ import {
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError,
   WorkspaceMismatchError
-} from "./chunk-T22H4V4R.js";
-import "./chunk-EWALXUAD.js";
+} from "./chunk-B34OV7K2.js";
+import "./chunk-AGHU5VRK.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
-  canonicalizeWorkspace
-} from "./chunk-SEZC2725.js";
+  canonicalizeWorkspace,
+  canonicalizeWorkspaces
+} from "./chunk-ER3BKOLB.js";
 import {
   EVENT_SCHEMA_VERSION,
   SubscriberLimitExceededError
-} from "./chunk-ALX6BUYW.js";
+} from "./chunk-G7ZG7CA6.js";
 import "./chunk-VRDMOSQS.js";
-import "./chunk-57NRQM3P.js";
-import "./chunk-3VJ7MT3N.js";
+import "./chunk-K34DD7FH.js";
+import "./chunk-EXPMGZZV.js";
 import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceMemoryStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-7Z6UEJA4.js";
+} from "./chunk-ME344634.js";
 import "./chunk-HLKG6CZN.js";
-import "./chunk-SL2P3JUA.js";
+import "./chunk-XUSONNJ4.js";
+import "./chunk-43W4YSO6.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-V6NH3CUC.js";
+} from "./chunk-MOQOAH7N.js";
 import {
   writeStderrLine
 } from "./chunk-Y6Z2O3WR.js";
-import "./chunk-QYUE6W3T.js";
+import {
+  isWithinRoot as isWithinRoot2
+} from "./chunk-QYUE6W3T.js";
 import {
   ALL_PROVIDERS,
   BTW_MAX_INPUT_LENGTH,
@@ -199,8 +212,12 @@ import {
   Client,
   ClientMcpRegistrar,
   ExtensionManager,
+  GROUP_COLOR_OPTIONS,
+  IMAGE_CAPABILITY,
   ModelsConfig,
   RUNTIME_MCP_IF_ABSENT_CONFIG_FLAG,
+  SessionOrganizationError,
+  SessionOrganizationService,
   SessionService,
   StandardFileSystemService,
   StdioClientTransport,
@@ -209,27 +226,42 @@ import {
   TrustGateError,
   WorkspaceMemoryFileTooLargeError,
   WorkspaceMemoryWriteTimeoutError,
+  buildUsageDashboard,
   checkForExtensionUpdate,
   detectLineEnding,
   encodeTextFileContent,
   glob,
   loadIgnoreRules,
+  loadUsageHistory,
   parseInstallSource,
   redactUrlCredentials,
   shouldShowStep,
+  stripTerminalControlSequences,
   writeWorkspaceContextFile
-} from "./chunk-AGZF43UV.js";
+} from "./chunk-E7HM76PR.js";
 import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
 import "./chunk-K5PGHDBN.js";
-import "./chunk-CLQPBI4H.js";
-import "./chunk-QOMAHFYI.js";
-import "./chunk-G7OQ3RFJ.js";
-import "./chunk-LKWAVAB5.js";
-import "./chunk-5ES5YPED.js";
-import "./chunk-2MPVVENX.js";
+import {
+  MAX_JOBS,
+  nextDurableFireMs
+} from "./chunk-3B26UVCX.js";
+import "./chunk-W7EEOR7D.js";
+import "./chunk-42XGFRJS.js";
+import "./chunk-X2XNQQJI.js";
+import "./chunk-VZ7HY3YU.js";
+import {
+  nextFireTime,
+  parseCron
+} from "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-DMSNJDWG.js";
+import {
+  appendCronRun,
+  generateCronTaskId,
+  getCronFilePath,
+  readCronTasks,
+  updateCronTasks
+} from "./chunk-FV7425LN.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-E5A7LHNN.js";
@@ -237,12 +269,12 @@ import {
   APPROVAL_MODES,
   SubagentError,
   SubagentErrorCode
-} from "./chunk-LM3YCCZJ.js";
+} from "./chunk-VEB3NYSO.js";
 import "./chunk-GO6LNQXT.js";
-import "./chunk-B236XPGF.js";
-import "./chunk-NVFJSIAX.js";
-import "./chunk-TOAUDIS7.js";
-import "./chunk-NPQWQYU6.js";
+import "./chunk-NQKLOAVJ.js";
+import "./chunk-WMPVYQ4P.js";
+import "./chunk-TLWA7TPR.js";
+import "./chunk-QYNNN7BK.js";
 import {
   addDaemonRequestAttribute,
   decodeBufferWithEncodingInfo,
@@ -256,15 +288,15 @@ import {
   recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   withDaemonRequestSpan
-} from "./chunk-JN2VJ33O.js";
+} from "./chunk-7I4MGFBN.js";
 import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
-import "./chunk-MOUXUCXQ.js";
-import "./chunk-BZHLWC6T.js";
-import "./chunk-RZORUN6X.js";
-import "./chunk-MJKMIQMK.js";
+import "./chunk-4KJ2BPIT.js";
+import "./chunk-SUAKHHK7.js";
+import "./chunk-FEJ2FZ3U.js";
+import "./chunk-X3YGAX7V.js";
 import {
   QwenOAuth2Client,
   QwenOAuthPollError,
@@ -273,13 +305,13 @@ import {
   isDeviceAuthorizationSuccess,
   isDeviceTokenPending,
   isDeviceTokenSuccess
-} from "./chunk-TENOUWY2.js";
-import "./chunk-GLPV75ES.js";
+} from "./chunk-IJRL2S3D.js";
+import "./chunk-AHNJGLFV.js";
 import "./chunk-22IFUCVR.js";
-import "./chunk-T42ACHFI.js";
+import "./chunk-7LTB54MK.js";
 import "./chunk-SIUQ3YYX.js";
-import "./chunk-KYTQOCDE.js";
-import "./chunk-YPCPZSZB.js";
+import "./chunk-HW4N45EE.js";
+import "./chunk-CCGOFQV3.js";
 import "./chunk-IRJWHZWU.js";
 import "./chunk-SYCJMSIJ.js";
 import "./chunk-55ZMG67I.js";
@@ -288,12 +320,12 @@ import {
 } from "./chunk-H6BD2ELD.js";
 import "./chunk-5IFG2VC4.js";
 import "./chunk-64WXLC72.js";
-import "./chunk-D5KISTLW.js";
+import "./chunk-H6EMK6QK.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
@@ -460,6 +492,35 @@ function canonicalizeBoundWorkspaceCached(boundWorkspace) {
   return canonical;
 }
 __name(canonicalizeBoundWorkspaceCached, "canonicalizeBoundWorkspaceCached");
+function canonicalizeBoundWorkspacesCached(boundWorkspaces) {
+  const inputs = typeof boundWorkspaces === "string" ? [boundWorkspaces] : boundWorkspaces;
+  if (inputs.length === 0) {
+    throw new FsError(
+      "parse_error",
+      "boundWorkspaces must include at least one workspace root"
+    );
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const workspace of inputs) {
+    const canonical = canonicalizeBoundWorkspaceCached(workspace);
+    if (seen.has(canonical)) continue;
+    seen.add(canonical);
+    out.push(canonical);
+  }
+  return out;
+}
+__name(canonicalizeBoundWorkspacesCached, "canonicalizeBoundWorkspacesCached");
+function findContainingWorkspace(absolute, boundWorkspaces) {
+  let match;
+  for (const workspace of boundWorkspaces) {
+    if (isWithinRoot(absolute, workspace) && (match === void 0 || workspace.length > match.length)) {
+      match = workspace;
+    }
+  }
+  return match;
+}
+__name(findContainingWorkspace, "findContainingWorkspace");
 async function findExistingAncestor(absolute) {
   let current = absolute;
   const tailParts = [];
@@ -505,7 +566,7 @@ async function findExistingAncestor(absolute) {
   );
 }
 __name(findExistingAncestor, "findExistingAncestor");
-async function resolveWithinWorkspace(input, boundWorkspace, intent) {
+async function resolveWithinWorkspace(input, boundWorkspaces, intent) {
   if (typeof input !== "string" || input.length === 0) {
     throw new FsError("parse_error", "path must be a non-empty string");
   }
@@ -518,9 +579,58 @@ async function resolveWithinWorkspace(input, boundWorkspace, intent) {
       }
     );
   }
-  const boundCanonical = canonicalizeBoundWorkspaceCached(boundWorkspace);
-  const absolute = path.resolve(boundCanonical, input);
-  if (!isWithinRoot(absolute, boundCanonical)) {
+  const boundCanonicals = canonicalizeBoundWorkspacesCached(boundWorkspaces);
+  const primary = boundCanonicals[0];
+  if (primary === void 0) {
+    throw new FsError(
+      "parse_error",
+      "boundWorkspaces must include at least one workspace root"
+    );
+  }
+  const absolute = path.resolve(primary, input);
+  let boundCanonical = findContainingWorkspace(absolute, boundCanonicals);
+  let preResolvedCanonical;
+  if (boundCanonical === void 0 && path.isAbsolute(input)) {
+    try {
+      preResolvedCanonical = await fsp.realpath(absolute);
+      boundCanonical = findContainingWorkspace(
+        preResolvedCanonical,
+        boundCanonicals
+      );
+    } catch (err) {
+      const code = err?.code;
+      if (code === "ENOENT" || code === "ENOTDIR") {
+        try {
+          const { ancestor, tail } = await findExistingAncestor(absolute);
+          const ancestorReal = await fsp.realpath(ancestor);
+          const canonicalCandidate = tail ? path.join(ancestorReal, tail) : ancestorReal;
+          boundCanonical = findContainingWorkspace(
+            canonicalCandidate,
+            boundCanonicals
+          );
+          if (boundCanonical !== void 0) {
+            const finalPathIsSymlink = await fsp.lstat(absolute).then((stat) => stat.isSymbolicLink()).catch((lstatErr) => {
+              if (lstatErr.code === "ENOENT" || lstatErr.code === "ENOTDIR") {
+                return false;
+              }
+              throw lstatErr;
+            });
+            if (!finalPathIsSymlink && ENOENT_TOLERATING_INTENTS.has(intent)) {
+              preResolvedCanonical = canonicalCandidate;
+            }
+          }
+        } catch (innerErr) {
+          const innerCode = innerErr?.code;
+          if (innerCode !== "ENOENT" && innerCode !== "ENOTDIR") {
+            throw innerErr;
+          }
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (boundCanonical === void 0) {
     throw new FsError(
       "path_outside_workspace",
       `path escapes workspace: ${input}`
@@ -528,7 +638,7 @@ async function resolveWithinWorkspace(input, boundWorkspace, intent) {
   }
   let canonical;
   try {
-    canonical = await fsp.realpath(absolute);
+    canonical = preResolvedCanonical ?? await fsp.realpath(absolute);
   } catch (err) {
     const code = err?.code;
     if (code === "ENOENT" && ENOENT_TOLERATING_INTENTS.has(intent)) {
@@ -579,7 +689,7 @@ async function resolveWithinWorkspace(input, boundWorkspace, intent) {
           const { ancestor: targetAncestor, tail: targetTail } = await findExistingAncestor(cursor);
           const targetAncestorReal = await fsp.realpath(targetAncestor);
           const canonicalTarget = targetTail ? path.join(targetAncestorReal, targetTail) : targetAncestorReal;
-          if (!isWithinRoot(canonicalTarget, boundCanonical)) {
+          if (!boundCanonicals.some((root) => isWithinRoot(canonicalTarget, root))) {
             throw new FsError(
               "symlink_escape",
               `dangling symlink target escapes workspace: ${input}`,
@@ -632,7 +742,7 @@ async function resolveWithinWorkspace(input, boundWorkspace, intent) {
       throw err;
     }
   }
-  if (!isWithinRoot(canonical, boundCanonical)) {
+  if (!boundCanonicals.some((root) => isWithinRoot(canonical, root))) {
     const kind = canonical !== absolute ? "symlink_escape" : "path_outside_workspace";
     throw new FsError(
       kind,
@@ -805,34 +915,42 @@ __name(createAuditPublisher, "createAuditPublisher");
 // packages/cli/src/serve/fs/workspace-file-system.ts
 init_esbuild_shims();
 import { createHash as createHash2, randomBytes } from "node:crypto";
-import { promises as fsp2 } from "node:fs";
+import { constants as fsConstants, promises as fsp2 } from "node:fs";
 import * as path4 from "node:path";
 function createWorkspaceFileSystemFactory(deps) {
-  const boundWorkspace = canonicalizeWorkspace(deps.boundWorkspace);
-  const ignore = deps.ignore ?? loadIgnoreRules({
-    projectRoot: boundWorkspace,
-    useGitignore: true,
-    useQwenignore: true,
-    ...deps.customIgnoreFiles !== void 0 ? { customIgnoreFiles: deps.customIgnoreFiles } : {},
-    ignoreDirs: []
+  const boundWorkspaces = canonicalizeWorkspaces(deps.boundWorkspaces);
+  if (boundWorkspaces.length === 0) {
+    throw new Error("WorkspaceFileSystem requires at least one workspace root");
+  }
+  assertNoNestedWorkspaces(boundWorkspaces);
+  const primaryWorkspace = boundWorkspaces[0];
+  const workspaces = boundWorkspaces.map((workspace) => {
+    const ignore = deps.ignore ?? loadIgnoreRules({
+      projectRoot: workspace,
+      useGitignore: true,
+      useQwenignore: true,
+      ...deps.customIgnoreFiles !== void 0 ? { customIgnoreFiles: deps.customIgnoreFiles } : {},
+      ignoreDirs: []
+    });
+    Object.freeze(ignore);
+    return { path: workspace, ignore };
   });
-  Object.freeze(ignore);
   const audit = createAuditPublisher({
     emit: deps.emit,
-    boundWorkspace,
+    boundWorkspace: primaryWorkspace,
     includeRawPaths: deps.includeRawPaths
   });
   const lowFs = new StandardFileSystemService();
-  const pathLocks = new PathMutexRegistry();
+  const pathLocks = deps.pathLocks ?? new PathMutexRegistry();
   return {
     assertCanWrite() {
       assertTrustedForIntent(deps.trusted, "write");
     },
     forRequest(ctx) {
       return new WorkspaceFileSystemImpl({
-        boundWorkspace,
+        primaryWorkspace,
+        workspaces,
         trusted: deps.trusted,
-        ignore,
         audit,
         ctx,
         lowFs,
@@ -842,6 +960,24 @@ function createWorkspaceFileSystemFactory(deps) {
   };
 }
 __name(createWorkspaceFileSystemFactory, "createWorkspaceFileSystemFactory");
+function assertNoNestedWorkspaces(workspaces) {
+  for (let i = 0; i < workspaces.length; i++) {
+    const a = workspaces[i];
+    if (a === void 0) continue;
+    for (let j = i + 1; j < workspaces.length; j++) {
+      const b = workspaces[j];
+      if (b === void 0) continue;
+      if (isWithinRoot(a, b) || isWithinRoot(b, a)) {
+        throw new Error(
+          `Nested workspace roots are not supported: ${JSON.stringify(
+            a
+          )} and ${JSON.stringify(b)}`
+        );
+      }
+    }
+  }
+}
+__name(assertNoNestedWorkspaces, "assertNoNestedWorkspaces");
 var WorkspaceFileSystemImpl = class {
   constructor(deps) {
     this.deps = deps;
@@ -849,11 +985,25 @@ var WorkspaceFileSystemImpl = class {
   static {
     __name(this, "WorkspaceFileSystemImpl");
   }
+  workspaceForPath(p) {
+    let match;
+    for (const workspace of this.deps.workspaces) {
+      if (isWithinRoot(p, workspace.path) && (match === void 0 || workspace.path.length > match.path.length)) {
+        match = workspace;
+      }
+    }
+    return match;
+  }
+  ignoreVerdict(p, kind = "file") {
+    const workspace = this.workspaceForPath(p);
+    if (!workspace) return { ignored: false };
+    return shouldIgnore(p, workspace.path, workspace.ignore, kind);
+  }
   async resolve(input, intent) {
     try {
       return await resolveWithinWorkspace(
         input,
-        this.deps.boundWorkspace,
+        this.deps.workspaces.map((workspace) => workspace.path),
         intent
       );
     } catch (err) {
@@ -898,12 +1048,7 @@ var WorkspaceFileSystemImpl = class {
         );
       }
       const snapshot = await readTextSnapshotFromResolvedFile(p, opts);
-      const ignoreVerdict = shouldIgnore(
-        p,
-        this.deps.boundWorkspace,
-        this.deps.ignore,
-        "file"
-      );
+      const ignoreVerdict = this.ignoreVerdict(p, "file");
       const meta = snapshot.meta;
       if (ignoreVerdict.ignored) meta.matchedIgnore = ignoreVerdict.category;
       this.deps.audit.recordAccess(this.deps.ctx, {
@@ -1005,10 +1150,8 @@ var WorkspaceFileSystemImpl = class {
       for await (const d of dir) {
         const childAbs = path4.join(p, d.name);
         const kind = kindFromStatLike(d);
-        const verdict = shouldIgnore(
+        const verdict = this.ignoreVerdict(
           childAbs,
-          this.deps.boundWorkspace,
-          this.deps.ignore,
           kind === "directory" ? "directory" : "file"
         );
         if (verdict.ignored && !opts.includeIgnored) continue;
@@ -1046,81 +1189,126 @@ var WorkspaceFileSystemImpl = class {
           { hint: 'pass a relative pattern such as "src/**/*.ts"' }
         );
       }
-      const cwd = opts.cwd ?? this.deps.boundWorkspace;
-      let cwdReal;
-      if (cwd === this.deps.boundWorkspace) {
-        cwdReal = cwd;
+      const searchRoots = [];
+      if (opts.cwd === void 0) {
+        for (const workspace of this.deps.workspaces) {
+          searchRoots.push({ cwd: workspace.path, workspace });
+        }
       } else {
-        try {
-          cwdReal = await fsp2.realpath(path4.resolve(cwd));
-        } catch (err) {
-          const code = err?.code;
-          if (code === "ENOENT") {
-            throw new FsError(
-              "path_not_found",
-              `glob cwd does not exist: ${cwd}`,
-              { cause: err }
-            );
+        const cwd = opts.cwd;
+        let cwdReal;
+        const directWorkspace = this.workspaceForPath(cwd);
+        if (directWorkspace && cwd === directWorkspace.path) {
+          cwdReal = cwd;
+        } else {
+          try {
+            cwdReal = await fsp2.realpath(path4.resolve(cwd));
+          } catch (err) {
+            const code = err?.code;
+            if (code === "ENOENT") {
+              throw new FsError(
+                "path_not_found",
+                `glob cwd does not exist: ${cwd}`,
+                { cause: err }
+              );
+            }
+            throw err;
           }
-          throw err;
         }
+        const workspace = this.workspaceForPath(cwdReal);
+        if (!workspace) {
+          throw new FsError(
+            "path_outside_workspace",
+            `glob cwd is outside workspace: ${cwd}`,
+            { hint: "opts.cwd must be a path obtained from fs.resolve()" }
+          );
+        }
+        searchRoots.push({ cwd: cwdReal, workspace });
       }
-      if (!isWithinRoot(cwdReal, this.deps.boundWorkspace)) {
-        throw new FsError(
-          "path_outside_workspace",
-          `glob cwd is outside workspace: ${cwd}`,
-          { hint: "opts.cwd must be a path obtained from fs.resolve()" }
-        );
-      }
-      const matches = await glob(pattern, {
-        cwd: cwdReal,
-        nodir: false,
-        absolute: true,
-        dot: true,
-        ignore: ["**/node_modules/**", "**/.git/**"]
-      });
       const out = [];
+      const seenCanonicals = /* @__PURE__ */ new Set();
       const max = opts.maxResults ?? Number.POSITIVE_INFINITY;
       let escapedCount = 0;
       let permissionErrorCount = 0;
       let transientErrorCount = 0;
-      for (const hit of matches) {
+      const globErrors = [];
+      let successfulGlobRoots = 0;
+      for (const searchRoot of searchRoots) {
         if (out.length >= max) break;
-        const absolute = path4.resolve(hit);
-        let canonical;
+        let matches;
         try {
-          canonical = await fsp2.realpath(absolute);
-        } catch (err) {
-          const code = err?.code;
-          if (code === "ENOENT" || code === "ELOOP") {
-            escapedCount += 1;
-          } else if (code === "EACCES" || code === "EPERM") {
-            permissionErrorCount += 1;
-          } else {
-            transientErrorCount += 1;
+          await fsp2.access(searchRoot.cwd, fsConstants.R_OK | fsConstants.X_OK);
+          const rootStat = await fsp2.stat(searchRoot.cwd);
+          if (!rootStat.isDirectory()) {
+            const err = new Error(
+              `glob workspace root is not a directory: ${searchRoot.cwd}`
+            );
+            err.code = "ENOTDIR";
+            throw err;
           }
+          matches = await glob(pattern, {
+            cwd: searchRoot.cwd,
+            nodir: false,
+            absolute: true,
+            dot: true,
+            ignore: ["**/node_modules/**", "**/.git/**"]
+          });
+        } catch (err) {
+          globErrors.push(err);
+          this.deps.audit.recordDenied(this.deps.ctx, {
+            intent: "glob",
+            input: pattern,
+            errorKind: errorKindForRealpathFailure(err),
+            hint: `glob failed for workspace root: ${errorCode(err) ?? "unknown error"}`,
+            pattern
+          });
           continue;
         }
-        const rel = path4.relative(this.deps.boundWorkspace, canonical);
-        if (rel.startsWith("..") || path4.isAbsolute(rel)) {
-          escapedCount += 1;
-          continue;
+        successfulGlobRoots += 1;
+        for (const hit of matches) {
+          if (out.length >= max) break;
+          const absolute = path4.resolve(hit);
+          let canonical;
+          try {
+            canonical = await fsp2.realpath(absolute);
+          } catch (err) {
+            const code = errorCode(err);
+            if (code === "ENOENT" || code === "ELOOP") {
+              escapedCount += 1;
+            } else if (code === "EACCES" || code === "EPERM") {
+              permissionErrorCount += 1;
+            } else {
+              transientErrorCount += 1;
+            }
+            continue;
+          }
+          const inAnyWorkspace = this.deps.workspaces.some(
+            (workspace) => isWithinRoot(canonical, workspace.path)
+          );
+          if (!inAnyWorkspace) {
+            escapedCount += 1;
+            continue;
+          }
+          if (seenCanonicals.has(canonical)) continue;
+          let dirent = null;
+          try {
+            dirent = await fsp2.lstat(canonical);
+          } catch {
+            dirent = null;
+          }
+          const kind = dirent?.isDirectory() ? "directory" : "file";
+          const verdict = this.ignoreVerdict(canonical, kind);
+          if (verdict.ignored && !opts.includeIgnored) continue;
+          seenCanonicals.add(canonical);
+          out.push(canonical);
         }
-        let dirent = null;
-        try {
-          dirent = await fsp2.lstat(canonical);
-        } catch {
-          dirent = null;
-        }
-        const kind = dirent?.isDirectory() ? "directory" : "file";
-        const verdict = shouldIgnore(
-          canonical,
-          this.deps.boundWorkspace,
-          this.deps.ignore,
-          kind
+      }
+      if (globErrors.length > 0 && successfulGlobRoots === 0) {
+        if (globErrors.length === 1) throw globErrors[0];
+        throw new AggregateError(
+          globErrors,
+          "glob failed for all workspace roots"
         );
-        if (verdict.ignored && !opts.includeIgnored) continue;
-        out.push(canonical);
       }
       if (escapedCount > 0) {
         this.deps.audit.recordDenied(this.deps.ctx, {
@@ -1144,21 +1332,14 @@ var WorkspaceFileSystemImpl = class {
         this.deps.audit.recordDenied(this.deps.ctx, {
           intent: "glob",
           input: pattern,
-          // `io_error` (not `permission_denied`) so monitoring
-          // pipelines that page security oncall on
-          // `permission_denied` aren't woken up by a failing disk
-          // or busy file. The kind was added to `FsErrorKind` for
-          // exactly this case (and for `wrapAsFsError`'s ENOSPC /
-          // EIO / EBUSY / ETXTBSY / ENAMETOOLONG / EMFILE / ENFILE
-          // mappings).
           errorKind: "io_error",
-          hint: `glob skipped ${transientErrorCount} hit(s) due to transient I/O errors (EIO/EBUSY/ENAMETOOLONG/EMFILE)`,
+          hint: `glob skipped ${transientErrorCount} hit(s) due to transient I/O errors`,
           pattern
         });
       }
       this.deps.audit.recordAccess(this.deps.ctx, {
         intent: "glob",
-        absolute: this.deps.boundWorkspace,
+        absolute: this.deps.primaryWorkspace,
         durationMs: performance.now() - start,
         sizeBytes: out.length,
         pattern
@@ -1190,12 +1371,7 @@ var WorkspaceFileSystemImpl = class {
             expectedHash: opts.expectedHash,
             meta
           });
-          const verdict = shouldIgnore(
-            p,
-            this.deps.boundWorkspace,
-            this.deps.ignore,
-            "file"
-          );
+          const verdict = this.ignoreVerdict(p, "file");
           if (verdict.ignored) meta.matchedIgnore = verdict.category;
           meta.sizeBytes = result.sizeBytes;
           meta.hash = result.hash;
@@ -1254,12 +1430,7 @@ var WorkspaceFileSystemImpl = class {
             mode: "overwrite",
             meta
           });
-          const verdict = shouldIgnore(
-            p,
-            this.deps.boundWorkspace,
-            this.deps.ignore,
-            "file"
-          );
+          const verdict = this.ignoreVerdict(p, "file");
           if (verdict.ignored) meta.matchedIgnore = verdict.category;
           meta.sizeBytes = result.sizeBytes;
           meta.hash = result.hash;
@@ -1295,12 +1466,7 @@ var WorkspaceFileSystemImpl = class {
         content,
         _meta: opts ? buildWriteMeta(opts) : void 0
       });
-      const verdict = shouldIgnore(
-        p,
-        this.deps.boundWorkspace,
-        this.deps.ignore,
-        "file"
-      );
+      const verdict = this.ignoreVerdict(p, "file");
       this.deps.audit.recordAccess(this.deps.ctx, {
         intent: "write",
         absolute: p,
@@ -1370,12 +1536,7 @@ var WorkspaceFileSystemImpl = class {
             expectedHash: opts.expectedHash,
             meta
           });
-          const verdict = shouldIgnore(
-            p,
-            this.deps.boundWorkspace,
-            this.deps.ignore,
-            "file"
-          );
+          const verdict = this.ignoreVerdict(p, "file");
           if (verdict.ignored) meta.matchedIgnore = verdict.category;
           meta.sizeBytes = result.sizeBytes;
           meta.hash = result.hash;
@@ -1454,12 +1615,7 @@ var WorkspaceFileSystemImpl = class {
         content: next,
         _meta: readResult._meta
       });
-      const editVerdict = shouldIgnore(
-        p,
-        this.deps.boundWorkspace,
-        this.deps.ignore,
-        "file"
-      );
+      const editVerdict = this.ignoreVerdict(p, "file");
       this.deps.audit.recordAccess(this.deps.ctx, {
         intent: "edit",
         absolute: p,
@@ -1513,28 +1669,6 @@ function isContentHash(value) {
   return typeof value === "string" && CONTENT_HASH_RE.test(value);
 }
 __name(isContentHash, "isContentHash");
-var PathMutexRegistry = class {
-  static {
-    __name(this, "PathMutexRegistry");
-  }
-  tails = /* @__PURE__ */ new Map();
-  async runExclusive(key, fn) {
-    const previous = this.tails.get(key) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolve4) => {
-      release = resolve4;
-    });
-    const tail = previous.catch(() => void 0).then(() => current);
-    this.tails.set(key, tail);
-    await previous.catch(() => void 0);
-    try {
-      return await fn();
-    } finally {
-      release();
-      if (this.tails.get(key) === tail) this.tails.delete(key);
-    }
-  }
-};
 function validateWriteTextAtomicOptions(opts) {
   if (opts.mode !== "create" && opts.mode !== "replace") {
     throw new FsError(
@@ -2080,6 +2214,17 @@ function kindFromStatLike(s) {
   return "other";
 }
 __name(kindFromStatLike, "kindFromStatLike");
+function errorCode(err) {
+  return err?.code;
+}
+__name(errorCode, "errorCode");
+function errorKindForRealpathFailure(err) {
+  const code = errorCode(err);
+  if (code === "EACCES" || code === "EPERM") return "permission_denied";
+  if (code === "ENOENT" || code === "ELOOP") return "symlink_escape";
+  return "io_error";
+}
+__name(errorKindForRealpathFailure, "errorKindForRealpathFailure");
 function buildWriteMeta(opts) {
   const meta = {};
   if (opts.bom !== void 0) meta["bom"] = opts.bom;
@@ -4742,8 +4887,78 @@ function createDaemonSubagentManager(boundWorkspace, safeMode = false) {
 }
 __name(createDaemonSubagentManager, "createDaemonSubagentManager");
 
+// packages/cli/src/serve/session-organization-helpers.ts
+init_esbuild_shims();
+function createSessionOrganizationService(workspaceCwd) {
+  return new SessionOrganizationService(workspaceCwd, (message) => {
+    writeStderrLine(`qwen serve: session-org: ${message}`);
+  });
+}
+__name(createSessionOrganizationService, "createSessionOrganizationService");
+
 // packages/cli/src/serve/server/session-archive.ts
 init_esbuild_shims();
+
+// packages/cli/src/serve/scheduled-task-session-lifecycle.ts
+init_esbuild_shims();
+function isBoundTask(task) {
+  return typeof task.sessionId === "string" && task.sessionId.length > 0;
+}
+__name(isBoundTask, "isBoundTask");
+async function disableTasksForSessions(projectRoot, sessionIds) {
+  if (sessionIds.length === 0) return;
+  const targets = new Set(sessionIds);
+  await updateCronTasks(projectRoot, (tasks) => {
+    let changed = false;
+    const next = tasks.map((task) => {
+      if (isBoundTask(task) && targets.has(task.sessionId) && task.enabled !== false) {
+        changed = true;
+        return { ...task, enabled: false, disabledByArchive: true };
+      }
+      return task;
+    });
+    return changed ? next : tasks;
+  });
+}
+__name(disableTasksForSessions, "disableTasksForSessions");
+async function enableTasksForSessions(projectRoot, sessionIds, now = Date.now()) {
+  if (sessionIds.length === 0) return;
+  const targets = new Set(sessionIds);
+  await updateCronTasks(projectRoot, (tasks) => {
+    let changed = false;
+    const next = tasks.map((task) => {
+      if (isBoundTask(task) && targets.has(task.sessionId) && task.enabled === false && task.disabledByArchive === true) {
+        changed = true;
+        const resumed = { ...task, enabled: true };
+        delete resumed.disabledByArchive;
+        const minute = now - now % 6e4;
+        if (resumed.recurring) {
+          resumed.lastFiredAt = minute;
+        } else {
+          resumed.createdAt = now;
+          resumed.lastFiredAt = minute;
+        }
+        return resumed;
+      }
+      return task;
+    });
+    return changed ? next : tasks;
+  });
+}
+__name(enableTasksForSessions, "enableTasksForSessions");
+async function removeTasksForSessions(projectRoot, sessionIds) {
+  if (sessionIds.length === 0) return;
+  const targets = new Set(sessionIds);
+  await updateCronTasks(projectRoot, (tasks) => {
+    const next = tasks.filter(
+      (task) => !isBoundTask(task) || !targets.has(task.sessionId)
+    );
+    return next.length === tasks.length ? tasks : next;
+  });
+}
+__name(removeTasksForSessions, "removeTasksForSessions");
+
+// packages/cli/src/serve/server/session-archive.ts
 var SessionArchiveCoordinator = class {
   static {
     __name(this, "SessionArchiveCoordinator");
@@ -4846,6 +5061,13 @@ async function deleteDaemonSessions(params) {
       }
     })
   );
+  await removeTasksForSessions(service.getProjectRoot(), removed).catch(
+    (err) => {
+      logSessionArchiveWarning(
+        `removeTasksForSessions failed for [${removed.join(", ")}]: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  );
   return { removed, notFound, errors: [...closeErrors, ...removeErrors] };
 }
 __name(deleteDaemonSessions, "deleteDaemonSessions");
@@ -5002,6 +5224,13 @@ async function archiveDaemonSessions(params) {
     notFound,
     errors
   });
+  await disableTasksForSessions(service.getProjectRoot(), archived).catch(
+    (err) => {
+      logSessionArchiveWarning(
+        `disableTasksForSessions failed for [${archived.join(", ")}]: ${err instanceof Error ? err.message : String(err)} \u2014 bound tasks may keep firing until reconciled`
+      );
+    }
+  );
   return { archived, alreadyArchived, notFound, errors };
 }
 __name(archiveDaemonSessions, "archiveDaemonSessions");
@@ -5048,6 +5277,17 @@ async function unarchiveDaemonSessions(params) {
     notFound,
     errors
   });
+  const resumeSessionIds = [.../* @__PURE__ */ new Set([...unarchived, ...alreadyActive])];
+  try {
+    await enableTasksForSessions(service.getProjectRoot(), resumeSessionIds);
+  } catch (err) {
+    logSessionArchiveWarning(
+      `enableTasksForSessions failed for [${resumeSessionIds.join(", ")}]: ${err instanceof Error ? err.message : String(err)}`
+    );
+    for (const sessionId of resumeSessionIds) {
+      errors.push({ sessionId, error: err });
+    }
+  }
   return { unarchived, alreadyActive, notFound, errors };
 }
 __name(unarchiveDaemonSessions, "unarchiveDaemonSessions");
@@ -5145,6 +5385,11 @@ var ALL_QWEN_VENDOR_METHODS = [
   `${QWEN_METHOD_NS}session/context`,
   `${QWEN_METHOD_NS}session/supported_commands`,
   `${QWEN_METHOD_NS}session/update_metadata`,
+  `${QWEN_METHOD_NS}session/update_organization`,
+  `${QWEN_METHOD_NS}workspace/session_groups/list`,
+  `${QWEN_METHOD_NS}workspace/session_groups/create`,
+  `${QWEN_METHOD_NS}workspace/session_groups/update`,
+  `${QWEN_METHOD_NS}workspace/session_groups/delete`,
   `${QWEN_METHOD_NS}workspace/mcp`,
   `${QWEN_METHOD_NS}workspace/skills`,
   `${QWEN_METHOD_NS}workspace/providers`,
@@ -5343,6 +5588,17 @@ function toRpcError(err) {
   if (err instanceof AcpParamError || err instanceof InvalidCursorError) {
     return { code: RPC.INVALID_PARAMS, message: err.message };
   }
+  if (err instanceof SessionOrganizationError) {
+    const isServerSide = err.code === "session_organization_store_unreadable";
+    return {
+      code: isServerSide ? RPC.INTERNAL_ERROR : RPC.INVALID_PARAMS,
+      message: err.message,
+      data: {
+        errorKind: err.code,
+        ...err.field ? { field: err.field } : {}
+      }
+    };
+  }
   if (err instanceof SubagentError) {
     return { code: RPC.INVALID_PARAMS, message: err.message };
   }
@@ -5529,6 +5785,19 @@ var AcpDispatcher = class {
       workspaceCwd: this.boundWorkspace
     };
   }
+  parseBoundWorkspaceParam(params) {
+    const rawWorkspace = typeof params["workspaceCwd"] === "string" ? params["workspaceCwd"] : void 0;
+    if (rawWorkspace === void 0) {
+      return this.boundWorkspace;
+    }
+    const requestedWorkspace = canonicalizeWorkspace(
+      parseOptionalWorkspaceCwd2({ cwd: rawWorkspace }, this.boundWorkspace)
+    );
+    if (requestedWorkspace !== this.boundWorkspace) {
+      throw new WorkspaceMismatchError(this.boundWorkspace, requestedWorkspace);
+    }
+    return requestedWorkspace;
+  }
   parseSessionIds(params) {
     const sessionIds = params["sessionIds"];
     if (!Array.isArray(sessionIds) || sessionIds.length === 0 || sessionIds.length > 100 || !sessionIds.every((s) => typeof s === "string")) {
@@ -5682,7 +5951,8 @@ var AcpDispatcher = class {
             methods: advertisedQwenVendorMethods(
               this.sessionShellCommandEnabled
             )
-          }
+          },
+          imageCapability: IMAGE_CAPABILITY
         }
       }
     };
@@ -5838,7 +6108,8 @@ var AcpDispatcher = class {
               return method === "session/load" ? await this.bridge.loadSession({
                 sessionId,
                 workspaceCwd: cwd,
-                clientId: conn.clientId
+                clientId: conn.clientId,
+                historyReplay: "response"
               }) : await this.bridge.resumeSession({
                 sessionId,
                 workspaceCwd: cwd,
@@ -5868,12 +6139,31 @@ var AcpDispatcher = class {
             return;
           }
           conn.getOrCreateSession(sessionId).clientId = restored.clientId;
+          if (method === "session/load") {
+            conn.markInitialReplayPending(sessionId);
+          }
           conn.ownSession(sessionId);
           const loadConfigOptions = await this.configOptionsFor(sessionId);
           const loadModels = this.extractModelState(loadConfigOptions);
           const loadModes = this.extractModeState(loadConfigOptions);
+          const loadState = restored.state ?? {};
+          const loadMeta = isObject(loadState._meta) ? loadState._meta : void 0;
+          const loadQwenMeta = isObject(loadMeta?.[QWEN_META_KEY]) ? loadMeta[QWEN_META_KEY] : void 0;
+          const replayStatus = method === "session/load" && restored.partial === true ? {
+            partial: true,
+            ...typeof restored.replayError === "string" ? { replayError: restored.replayError } : {}
+          } : void 0;
           this.replyConn(conn, id, {
-            ...restored.state ?? {},
+            ...loadState,
+            ...replayStatus ? {
+              _meta: {
+                ...loadMeta ?? {},
+                [QWEN_META_KEY]: {
+                  ...loadQwenMeta ?? {},
+                  sessionLoadReplay: replayStatus
+                }
+              }
+            } : {},
             ...loadConfigOptions ? { configOptions: loadConfigOptions } : {},
             ...loadModels ? { models: loadModels } : {},
             ...loadModes ? { modes: loadModes } : {}
@@ -5881,22 +6171,22 @@ var AcpDispatcher = class {
           return;
         }
         case "session/list": {
-          const rawWorkspace = typeof params["workspaceCwd"] === "string" ? params["workspaceCwd"] : void 0;
-          let workspaceCwd = rawWorkspace === void 0 ? this.boundWorkspace : parseOptionalWorkspaceCwd2(
-            { cwd: rawWorkspace },
-            this.boundWorkspace
-          );
-          if (rawWorkspace !== void 0) {
-            const requestedWorkspace = canonicalizeWorkspace(workspaceCwd);
-            if (requestedWorkspace !== this.boundWorkspace) {
-              throw new WorkspaceMismatchError(
-                this.boundWorkspace,
-                requestedWorkspace
-              );
+          const workspaceCwd = this.parseBoundWorkspaceParam(params);
+          const cursor = typeof params["cursor"] === "string" ? params["cursor"] : void 0;
+          const rawView = typeof params["view"] === "string" ? params["view"] : void 0;
+          let view;
+          if (rawView !== void 0) {
+            if (rawView !== "organized") {
+              throw new AcpParamError('`view` must be "organized"');
             }
-            workspaceCwd = requestedWorkspace;
+            view = rawView;
+          }
+          const group = typeof params["group"] === "string" ? params["group"] : void 0;
+          if (group !== void 0 && view !== "organized") {
+            throw new AcpParamError(
+              '`group` requires `view` to be "organized"'
+            );
           }
-          const cursor = typeof params["cursor"] === "string" ? params["cursor"] : void 0;
           const meta = isObject(params["_meta"]) ? params["_meta"] : void 0;
           const metaSize = typeof meta?.["size"] === "number" ? meta["size"] : void 0;
           const rawArchiveState = typeof params["archiveState"] === "string" ? params["archiveState"] : typeof meta?.["archiveState"] === "string" ? meta["archiveState"] : void 0;
@@ -5912,7 +6202,7 @@ var AcpDispatcher = class {
           const result = await listWorkspaceSessionsForResponse(
             this.bridge,
             workspaceCwd,
-            { cursor, size: metaSize, archiveState }
+            { cursor, size: metaSize, archiveState, view, group }
           );
           this.replyConn(conn, id, {
             sessions: result.sessions.map((s) => ({
@@ -5925,9 +6215,15 @@ var AcpDispatcher = class {
               title: s.displayName,
               clientCount: s.clientCount,
               hasActivePrompt: s.hasActivePrompt,
-              isArchived: s.isArchived === true
+              isArchived: s.isArchived === true,
+              ...s.isPinned !== void 0 ? { isPinned: s.isPinned } : {},
+              ...s.pinnedAt !== void 0 ? { pinnedAt: s.pinnedAt } : {},
+              ...s.groupId !== void 0 ? { groupId: s.groupId } : {},
+              ...s.color !== void 0 ? { color: s.color } : {}
             })),
-            ...result.nextCursor != null ? { nextCursor: result.nextCursor } : {}
+            ...result.nextCursor != null ? { nextCursor: result.nextCursor } : {},
+            ...result.liveMergeFailed ? { liveMergeFailed: true } : {},
+            ...result.truncated ? { truncated: true } : {}
           });
           return;
         }
@@ -6449,6 +6745,94 @@ var AcpDispatcher = class {
           });
           return;
         }
+        case `${QWEN_METHOD_NS}session/update_organization`: {
+          const sessionId = String(params["sessionId"] ?? "");
+          if (!sessionId) {
+            throw new AcpParamError("`sessionId` is required");
+          }
+          if ("isPinned" in params && typeof params["isPinned"] !== "boolean") {
+            throw new AcpParamError("`isPinned` must be a boolean");
+          }
+          if ("groupId" in params && params["groupId"] !== null && typeof params["groupId"] !== "string") {
+            throw new AcpParamError("`groupId` must be a string or null");
+          }
+          if ("color" in params && params["color"] !== null && (typeof params["color"] !== "string" || !GROUP_COLOR_OPTIONS.includes(
+            params["color"]
+          ))) {
+            throw new AcpParamError(
+              "`color` must be a supported color or null"
+            );
+          }
+          await this.archiveCoordinator.runSharedMany([sessionId], async () => {
+            const sessionService = new SessionService(this.boundWorkspace);
+            let exists = await sessionService.sessionExistsInAnyState(sessionId);
+            if (!exists) {
+              try {
+                const liveSummary = this.bridge.getSessionSummary(sessionId);
+                exists = liveSummary.workspaceCwd === this.boundWorkspace;
+              } catch {
+                exists = false;
+              }
+            }
+            if (!exists) {
+              throw new AcpParamError(`Session not found: ${sessionId}`);
+            }
+            const organization = await createSessionOrganizationService(
+              this.boundWorkspace
+            ).updateSessionOrganization(sessionId, {
+              ...typeof params["isPinned"] === "boolean" ? { isPinned: params["isPinned"] } : {},
+              ..."groupId" in params ? { groupId: params["groupId"] } : {},
+              ..."color" in params ? { color: params["color"] } : {}
+            });
+            this.replyConn(conn, id, { sessionId, ...organization });
+          });
+          return;
+        }
+        case `${QWEN_METHOD_NS}workspace/session_groups/list`: {
+          const workspaceCwd = this.parseBoundWorkspaceParam(params);
+          const groups = await createSessionOrganizationService(workspaceCwd).listGroups();
+          this.replyConn(conn, id, groups);
+          return;
+        }
+        case `${QWEN_METHOD_NS}workspace/session_groups/create`: {
+          const workspaceCwd = this.parseBoundWorkspaceParam(params);
+          const group = await createSessionOrganizationService(
+            workspaceCwd
+          ).createGroup({
+            name: params["name"],
+            color: params["color"]
+          });
+          this.replyConn(conn, id, { group });
+          return;
+        }
+        case `${QWEN_METHOD_NS}workspace/session_groups/update`: {
+          const workspaceCwd = this.parseBoundWorkspaceParam(params);
+          const groupId = String(params["groupId"] ?? "");
+          if (!groupId) {
+            throw new AcpParamError("`groupId` is required");
+          }
+          const group = await createSessionOrganizationService(
+            workspaceCwd
+          ).updateGroup(groupId, {
+            ..."name" in params ? { name: params["name"] } : {},
+            ..."color" in params ? { color: params["color"] } : {},
+            ..."order" in params ? { order: params["order"] } : {}
+          });
+          this.replyConn(conn, id, { group });
+          return;
+        }
+        case `${QWEN_METHOD_NS}workspace/session_groups/delete`: {
+          const workspaceCwd = this.parseBoundWorkspaceParam(params);
+          const groupId = String(params["groupId"] ?? "");
+          if (!groupId) {
+            throw new AcpParamError("`groupId` is required");
+          }
+          const deleted = await createSessionOrganizationService(workspaceCwd).deleteGroup(
+            groupId
+          );
+          this.replyConn(conn, id, { deleted });
+          return;
+        }
         case `${QWEN_METHOD_NS}workspace/mcp`:
           this.replyConn(
             conn,
@@ -8144,12 +8528,46 @@ var AcpDispatcher = class {
    */
   async pumpSessionEvents(conn, sessionId, signal, lastEventId) {
     try {
+      let lastDeliveredId = lastEventId ?? 0;
+      let sawEviction = false;
+      let subscribeFromEventId = lastEventId;
+      if (conn.hasInitialReplayPending(sessionId)) {
+        const snapshot = this.bridge.getSessionReplaySnapshot(sessionId);
+        if (snapshot) {
+          const snapshotEvents = [
+            ...snapshot.compactedTurns,
+            ...snapshot.liveJournal
+          ];
+          for (const event of snapshotEvents) {
+            if (signal.aborted) return;
+            if (typeof event.id === "number" && event.id <= lastDeliveredId) {
+              continue;
+            }
+            conn.touch();
+            this.translateEvent(conn, sessionId, event);
+            if (typeof event.id === "number") {
+              lastDeliveredId = event.id;
+              conn.releaseDeferredSessionReplies(sessionId, event.id);
+            }
+          }
+          if (signal.aborted) return;
+          lastDeliveredId = Math.max(lastDeliveredId, snapshot.lastEventId);
+          subscribeFromEventId = Math.max(
+            subscribeFromEventId ?? 0,
+            snapshot.lastEventId
+          );
+        } else {
+          writeStderrLine(
+            `qwen serve: /acp initial replay skipped (no snapshot) session=${logSafe(sessionId)}`
+          );
+          conn.markInitialReplayComplete(sessionId);
+          conn.endReplayDeferral(sessionId, lastDeliveredId, false);
+        }
+      }
       const iterable = this.bridge.subscribeEvents(sessionId, {
         signal,
-        ...lastEventId !== void 0 ? { lastEventId } : {}
+        ...subscribeFromEventId !== void 0 ? { lastEventId: subscribeFromEventId } : {}
       });
-      let lastDeliveredId = lastEventId ?? 0;
-      let sawEviction = false;
       for await (const event of iterable) {
         if (signal.aborted) break;
         conn.touch();
@@ -8161,6 +8579,7 @@ var AcpDispatcher = class {
         }
         if (event.type === "replay_complete") {
           conn.endReplayDeferral(sessionId, lastDeliveredId, sawEviction);
+          conn.markInitialReplayComplete(sessionId);
           const replayedCount = event.data?.replayedCount;
           writeStderrLine(
             `qwen serve: /acp replay complete (${logSafe(sessionId)}) from=${lastEventId ?? "none"} delivered_through=${lastDeliveredId} count=${replayedCount ?? "n/a"} evicted=${sawEviction}`
@@ -8489,6 +8908,16 @@ var AcpConnection = class {
     }
     return binding;
   }
+  markInitialReplayPending(sessionId) {
+    this.getOrCreateSession(sessionId).initialReplayPending = true;
+  }
+  hasInitialReplayPending(sessionId) {
+    return this.sessions.get(sessionId)?.initialReplayPending === true;
+  }
+  markInitialReplayComplete(sessionId) {
+    const binding = this.sessions.get(sessionId);
+    if (binding) binding.initialReplayPending = false;
+  }
   getDiagnostic() {
     const liveStreams = /* @__PURE__ */ new Set();
     if (this.connStream && !this.connStream.isClosed) {
@@ -8676,15 +9105,16 @@ var AcpConnection = class {
     if (prevStream && prevStream !== stream && prevStream !== this.connStream) {
       prevStream.close();
     }
-    binding.replayPending = resumeFromEventId !== void 0;
+    const replayingOnAttach = resumeFromEventId !== void 0 || binding.initialReplayPending === true;
+    binding.replayPending = replayingOnAttach;
     if (binding.replayPending) {
       writeStderrLine(
-        `qwen serve: /acp replay deferral armed (${logSafe(sessionId)}, from id ${resumeFromEventId})`
+        `qwen serve: /acp replay deferral armed (${logSafe(sessionId)}, from id ${resumeFromEventId ?? "initial"})`
       );
     }
     const gap = binding.buffer.splice(0);
     for (const entry of gap) {
-      if (resumeFromEventId === void 0) {
+      if (!replayingOnAttach) {
         void stream.send(entry.frame, entry.id);
       } else if (entry.id !== void 0) {
         continue;
@@ -9459,10 +9889,10 @@ function isCdpInboundFrame(frame) {
 }
 __name(isCdpInboundFrame, "isCdpInboundFrame");
 var CdpReverseLink = class {
-  constructor(sendToExtension, commandTimeoutMs = DEFAULT_COMMAND_TIMEOUT_MS, log) {
+  constructor(sendToExtension, commandTimeoutMs = DEFAULT_COMMAND_TIMEOUT_MS, log2) {
     this.sendToExtension = sendToExtension;
     this.commandTimeoutMs = commandTimeoutMs;
-    this.log = log;
+    this.log = log2;
   }
   static {
     __name(this, "CdpReverseLink");
@@ -9904,10 +10334,10 @@ var CdpBrowserEmulator = class {
 var CLOSE_NO_BRIDGE = 1011;
 var CLOSE_NORMAL = 1e3;
 var CDP_WS_HEARTBEAT_MS = 15e3;
-function attachCdpClient(ws, registry, log) {
+function attachCdpClient(ws, registry, log2) {
   const bridge = registry.getActive();
   if (!bridge) {
-    log("qwen serve: /cdp rejected \u2014 no extension bridge connected");
+    log2("qwen serve: /cdp rejected \u2014 no extension bridge connected");
     try {
       ws.close(
         CLOSE_NO_BRIDGE,
@@ -9918,7 +10348,7 @@ function attachCdpClient(ws, registry, log) {
     return;
   }
   if (bridge.cdpBound) {
-    log("qwen serve: /cdp rejected \u2014 a puppeteer client is already bound");
+    log2("qwen serve: /cdp rejected \u2014 a puppeteer client is already bound");
     try {
       ws.close(CLOSE_NO_BRIDGE, "A CDP client is already connected");
     } catch {
@@ -9929,19 +10359,19 @@ function attachCdpClient(ws, registry, log) {
   const link = new CdpReverseLink(
     (frame) => bridge.send(frame),
     void 0,
-    log
+    log2
   );
   const emulator = new CdpBrowserEmulator({
     reply: /* @__PURE__ */ __name((frame) => {
       safeWsSend(ws, JSON.stringify(frame), "CDP");
     }, "reply"),
     forwardToTab: link.forwardToTab,
-    log
+    log: log2
   });
   link.bindEmulator(emulator);
   bridge.routeInbound = (frame) => link.handleInbound(frame);
   link.onDetach = (reason) => {
-    log(`qwen serve: /cdp tab detached (${reason}); closing puppeteer socket`);
+    log2(`qwen serve: /cdp tab detached (${reason}); closing puppeteer socket`);
     try {
       ws.close(CLOSE_NORMAL, `tab detached: ${reason}`);
     } catch {
@@ -9952,7 +10382,7 @@ function attachCdpClient(ws, registry, log) {
   const heartbeat = setInterval(() => {
     if (disposed) return;
     if (!heartbeatAlive) {
-      log("qwen serve: /cdp heartbeat missed; closing puppeteer socket");
+      log2("qwen serve: /cdp heartbeat missed; closing puppeteer socket");
       dispose("puppeteer /cdp heartbeat missed");
       try {
         ws.close(CLOSE_NORMAL, "cdp heartbeat missed");
@@ -9964,7 +10394,7 @@ function attachCdpClient(ws, registry, log) {
     try {
       ws.ping();
     } catch (err) {
-      log(
+      log2(
         `qwen serve: /cdp heartbeat ping failed: ${err instanceof Error ? err.message : String(err)}`
       );
       dispose("puppeteer /cdp heartbeat ping failed");
@@ -9982,11 +10412,11 @@ function attachCdpClient(ws, registry, log) {
     if (notifyExtension && registry.getActive() === bridge) {
       try {
         bridge.send({ type: CDP_FRAME_TYPES.release });
-        log(
+        log2(
           `qwen serve: /cdp sent release to extension (puppeteer disconnected: ${reason})`
         );
       } catch (err) {
-        log(
+        log2(
           `qwen serve: /cdp release send failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }
@@ -9999,7 +10429,7 @@ function attachCdpClient(ws, registry, log) {
     }
   }, "dispose");
   link.onAttachFailure = (reason) => {
-    log(`qwen serve: /cdp attach failed (${reason}); closing puppeteer socket`);
+    log2(`qwen serve: /cdp attach failed (${reason}); closing puppeteer socket`);
     dispose(`cdp_attach failed: ${reason}`, false);
     try {
       ws.close(CLOSE_NO_BRIDGE, "cdp attach failed");
@@ -10010,7 +10440,7 @@ function attachCdpClient(ws, registry, log) {
     heartbeatAlive = true;
   });
   bridge.onExtensionGone = () => {
-    log("qwen serve: extension /acp dropped; closing puppeteer /cdp socket");
+    log2("qwen serve: extension /acp dropped; closing puppeteer /cdp socket");
     dispose("extension /acp disconnected", false);
     try {
       ws.close(CLOSE_NORMAL, "extension disconnected");
@@ -10026,19 +10456,19 @@ function attachCdpClient(ws, registry, log) {
       return;
     }
     void emulator.handleFromClient(frame).catch((err) => {
-      log(
+      log2(
         `qwen serve: /cdp emulator error: ${err instanceof Error ? err.message : String(err)}`
       );
     });
   });
   ws.on("close", () => dispose("puppeteer /cdp socket closed"));
   ws.on("error", (err) => {
-    log(
+    log2(
       `qwen serve: /cdp WS error: ${err instanceof Error ? err.message : String(err)}`
     );
     dispose("puppeteer /cdp socket error");
   });
-  log("qwen serve: /cdp puppeteer client bound to extension bridge");
+  log2("qwen serve: /cdp puppeteer client bound to extension bridge");
 }
 __name(attachCdpClient, "attachCdpClient");
 
@@ -10132,6 +10562,7 @@ var WS_READ_METHODS = /* @__PURE__ */ new Set([
   "_qwen/workspace/providers",
   "_qwen/workspace/env",
   "_qwen/workspace/preflight",
+  "_qwen/workspace/session_groups/list",
   "_qwen/workspace/trust",
   "_qwen/workspace/permissions",
   "_qwen/workspace/voice",
@@ -10176,7 +10607,7 @@ var MAX_INFLIGHT_MCP_DISPATCH = 8;
 function mountAcpHttp(app, bridge, opts) {
   const enabled = opts.enabled ?? process.env["QWEN_SERVE_ACP_HTTP"] !== "0";
   if (!enabled) return void 0;
-  const path12 = opts.path ?? "/acp";
+  const path14 = opts.path ?? "/acp";
   const dispatcherRef = {};
   const registry = new ConnectionRegistry(
     (req, clientId) => {
@@ -10313,7 +10744,7 @@ function mountAcpHttp(app, bridge, opts) {
     opts.archiveCoordinator ?? new SessionArchiveCoordinator()
   );
   dispatcherRef.current = dispatcher;
-  app.post(path12, async (req, res) => {
+  app.post(path14, async (req, res) => {
     const ct = req.headers["content-type"];
     if (!ct || !ct.startsWith("application/json")) {
       res.status(415).json({ error: "Content-Type must be application/json" });
@@ -10417,7 +10848,7 @@ function mountAcpHttp(app, bridge, opts) {
       );
     });
   });
-  app.get(path12, (req, res) => {
+  app.get(path14, (req, res) => {
     const accept = req.headers["accept"] ?? "";
     if (!accept.includes("text/event-stream")) {
       res.status(406).json({ error: "Accept header must include text/event-stream" });
@@ -10503,7 +10934,7 @@ function mountAcpHttp(app, bridge, opts) {
       onPumpSettled();
     });
   });
-  app.delete(path12, (req, res) => {
+  app.delete(path14, (req, res) => {
     const connectionId = headerOf(req, ACP_CONNECTION_HEADER);
     if (!connectionId) {
       res.status(400).json({ error: "Missing Acp-Connection-Id" });
@@ -10566,7 +10997,7 @@ function mountAcpHttp(app, bridge, opts) {
       const extraRoute = opts.extraWsRoutes?.find(
         (route) => route.path === url.pathname
       );
-      if (url.pathname !== path12 && !isCdpPath && !extraRoute) {
+      if (url.pathname !== path14 && !isCdpPath && !extraRoute) {
         logReject(`unknown-path ${url.pathname}`);
         socket.destroy();
         return;
@@ -10963,7 +11394,7 @@ function mountAcpHttp(app, bridge, opts) {
       });
     }, "upgradeListener");
     httpServer.on("upgrade", upgradeListener);
-    writeStderrLine(`qwen serve: /acp WebSocket transport enabled on ${path12}`);
+    writeStderrLine(`qwen serve: /acp WebSocket transport enabled on ${path14}`);
   }
   __name(setupWebSocket, "setupWebSocket");
   return {
@@ -11558,7 +11989,8 @@ function registerDaemonStatusRoutes(app, deps) {
           deviceFlowRegistry: deps.deviceFlowRegistry,
           sessionShellCommandEnabled: deps.sessionShellCommandEnabled,
           getChannelWorkerSnapshot: deps.getChannelWorkerSnapshot,
-          getPerfSnapshot: deps.getPerfSnapshot
+          getPerfSnapshot: deps.getPerfSnapshot,
+          getMetricsSeries: deps.getMetricsSeries
         })
       );
     } catch (err) {
@@ -13951,12 +14383,13 @@ __name(resolvePromptDeadlineMs, "resolvePromptDeadlineMs");
 init_esbuild_shims();
 var DEFAULT_SESSION_PAGE_SIZE = 20;
 var MAX_SESSION_PAGE_SIZE = 100;
+var MAX_ORGANIZED_SESSIONS = 5e4;
 var InvalidCursorError = class extends Error {
   static {
     __name(this, "InvalidCursorError");
   }
-  constructor(cursor) {
-    super(`Invalid cursor: "${cursor}" is not a valid numeric cursor`);
+  constructor(cursor, kind = "numeric") {
+    super(`Invalid cursor: "${cursor}" is not a valid ${kind} cursor`);
     this.name = "InvalidCursorError";
   }
 };
@@ -13970,34 +14403,241 @@ function parseSessionCursor(cursor) {
   return parsed;
 }
 __name(parseSessionCursor, "parseSessionCursor");
-async function listWorkspaceSessionsForResponse(bridge, workspaceCwd, options) {
-  const rawSize = options?.size;
-  const requestedSize = typeof rawSize === "number" && Number.isSafeInteger(rawSize) ? rawSize : DEFAULT_SESSION_PAGE_SIZE;
-  const pageSize = Math.min(Math.max(requestedSize, 1), MAX_SESSION_PAGE_SIZE);
-  let numericCursor;
-  if (options?.cursor != null) {
-    numericCursor = parseSessionCursor(options.cursor);
+function parseOrganizedCursor(cursor, expected) {
+  if (cursor === "") return void 0;
+  try {
+    const decoded = Buffer.from(cursor, "base64url").toString("utf8");
+    const parsed = JSON.parse(decoded);
+    const last = parsed.last;
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof last !== "object" || last === null || Array.isArray(last) || typeof last.isPinned !== "boolean" || typeof last.activityTime !== "number" || !Number.isFinite(last.activityTime) || typeof last.sessionId !== "string" || last.sessionId.length === 0 || parsed.group !== expected.group || parsed.archiveState !== expected.archiveState) {
+      throw new Error("invalid organized cursor");
+    }
+    return last;
+  } catch {
+    throw new InvalidCursorError(cursor, "organized");
   }
-  const isFirstPage = numericCursor === void 0;
-  const sessionService = new SessionService(workspaceCwd);
-  const archiveState = options?.archiveState ?? "active";
-  const persisted = await sessionService.listSessions({
-    cursor: numericCursor,
-    size: pageSize,
-    archiveState
-  });
-  const bySessionId = /* @__PURE__ */ new Map();
-  for (const item of persisted.items) {
-    bySessionId.set(item.sessionId, {
-      sessionId: item.sessionId,
-      workspaceCwd: item.cwd,
-      createdAt: item.startTime,
-      updatedAt: new Date(item.mtime).toISOString(),
-      displayName: item.customTitle || item.prompt,
-      clientCount: 0,
-      hasActivePrompt: false,
-      isArchived: item.isArchived === true
+}
+__name(parseOrganizedCursor, "parseOrganizedCursor");
+function encodeOrganizedCursor(last, group, archiveState) {
+  return Buffer.from(
+    JSON.stringify({ group, archiveState, last }),
+    "utf8"
+  ).toString("base64url");
+}
+__name(encodeOrganizedCursor, "encodeOrganizedCursor");
+function toSummary2(item) {
+  return {
+    sessionId: item.sessionId,
+    workspaceCwd: item.cwd,
+    createdAt: item.startTime,
+    updatedAt: new Date(item.mtime).toISOString(),
+    displayName: item.customTitle || item.prompt,
+    clientCount: 0,
+    hasActivePrompt: false,
+    isArchived: item.isArchived === true
+  };
+}
+__name(toSummary2, "toSummary");
+async function listAllPersistedSummaries(sessionService, archiveState) {
+  const sessions = [];
+  let truncated = false;
+  let cursor;
+  do {
+    const page = await sessionService.listSessions({
+      cursor,
+      size: 1e4,
+      archiveState
     });
+    const remaining = MAX_ORGANIZED_SESSIONS - sessions.length;
+    sessions.push(...page.items.slice(0, remaining).map(toSummary2));
+    cursor = page.nextCursor;
+    if (page.items.length === 0) {
+      break;
+    }
+    if (page.items.length > remaining || sessions.length >= MAX_ORGANIZED_SESSIONS && cursor !== void 0) {
+      writeStderrLine(
+        `qwen serve: organized session list truncated at ${MAX_ORGANIZED_SESSIONS} sessions`
+      );
+      truncated = true;
+      break;
+    }
+  } while (cursor !== void 0);
+  return { sessions, truncated };
+}
+__name(listAllPersistedSummaries, "listAllPersistedSummaries");
+function getSummaryActivityTime(session) {
+  const time = Date.parse(session.updatedAt ?? session.createdAt);
+  return Number.isFinite(time) ? time : 0;
+}
+__name(getSummaryActivityTime, "getSummaryActivityTime");
+function compareOrganizedSessions(activityTimeById, a, b) {
+  return compareOrganizedCursorKeys(
+    getOrganizedCursorKey(activityTimeById, a),
+    getOrganizedCursorKey(activityTimeById, b)
+  );
+}
+__name(compareOrganizedSessions, "compareOrganizedSessions");
+function getOrganizedCursorKey(activityTimeById, session) {
+  return {
+    isPinned: session.isPinned === true,
+    activityTime: activityTimeById.get(session.sessionId) ?? 0,
+    sessionId: session.sessionId
+  };
+}
+__name(getOrganizedCursorKey, "getOrganizedCursorKey");
+function compareOrganizedCursorKeys(a, b) {
+  const byPinned = Number(b.isPinned) - Number(a.isPinned);
+  if (byPinned !== 0) return byPinned;
+  const byTime = b.activityTime - a.activityTime;
+  if (byTime !== 0) return byTime;
+  return a.sessionId.localeCompare(b.sessionId);
+}
+__name(compareOrganizedCursorKeys, "compareOrganizedCursorKeys");
+function applyOrganization(session, organization) {
+  return {
+    ...session,
+    groupId: organization?.groupId ?? null,
+    color: organization?.color ?? null,
+    isPinned: organization?.isPinned === true,
+    ...organization?.pinnedAt !== void 0 ? { pinnedAt: organization.pinnedAt } : {}
+  };
+}
+__name(applyOrganization, "applyOrganization");
+async function listOrganizedWorkspaceSessionsForResponse(bridge, workspaceCwd, options, pageSize) {
+  const archiveState = options.archiveState ?? "active";
+  const sessionService = new SessionService(workspaceCwd);
+  const organizationService = createSessionOrganizationService(workspaceCwd);
+  const snapshot = await organizationService.readSnapshot();
+  const knownGroupIds = new Set(snapshot.groups.map((group2) => group2.id));
+  const group = options.group ?? "all";
+  if (group !== "all" && group !== "pinned" && group !== "ungrouped" && !knownGroupIds.has(group)) {
+    throw new SessionOrganizationError(
+      `Group not found: ${group}`,
+      "group_not_found",
+      "group"
+    );
+  }
+  const cursorKey = options.cursor !== void 0 ? parseOrganizedCursor(options.cursor, { group, archiveState }) : void 0;
+  const isFirstPage = cursorKey === void 0;
+  let liveMergeFailed = false;
+  const bySessionId = /* @__PURE__ */ new Map();
+  const persisted = await listAllPersistedSummaries(
+    sessionService,
+    archiveState
+  );
+  for (const session of persisted.sessions) {
+    bySessionId.set(
+      session.sessionId,
+      applyOrganization(session, snapshot.sessions.get(session.sessionId))
+    );
+  }
+  if (archiveState !== "archived" && isFirstPage) {
+    try {
+      const liveSessions = bridge.listWorkspaceSessions(workspaceCwd);
+      for (const live of liveSessions) {
+        const existing = bySessionId.get(live.sessionId);
+        const organization = snapshot.sessions.get(live.sessionId);
+        if (existing) {
+          bySessionId.set(
+            live.sessionId,
+            applyOrganization(
+              {
+                ...existing,
+                ...live,
+                createdAt: existing.createdAt,
+                displayName: live.displayName ?? existing.displayName,
+                updatedAt: live.updatedAt ?? existing.updatedAt,
+                clientCount: live.clientCount,
+                hasActivePrompt: live.hasActivePrompt,
+                isArchived: false
+              },
+              organization
+            )
+          );
+        } else if (!await sessionService.sessionExists(live.sessionId)) {
+          bySessionId.set(
+            live.sessionId,
+            applyOrganization(
+              {
+                ...live,
+                createdAt: live.createdAt,
+                clientCount: live.clientCount,
+                hasActivePrompt: live.hasActivePrompt,
+                isArchived: false
+              },
+              organization
+            )
+          );
+        }
+      }
+    } catch (error2) {
+      liveMergeFailed = true;
+      writeStderrLine(
+        `qwen serve: organized session list live merge failed; using persisted sessions only: ${error2 instanceof Error ? error2.message : String(error2)}`
+      );
+    }
+  }
+  const filtered = [...bySessionId.values()].filter((session) => {
+    if (group === "all") return true;
+    if (group === "pinned") return session.isPinned === true;
+    if (group === "ungrouped")
+      return session.groupId == null && session.color == null;
+    return session.color == null && session.groupId === group;
+  });
+  const activityTimeById = new Map(
+    filtered.map((session) => [
+      session.sessionId,
+      getSummaryActivityTime(session)
+    ])
+  );
+  filtered.sort((a, b) => compareOrganizedSessions(activityTimeById, a, b));
+  const afterCursor = cursorKey === void 0 ? filtered : filtered.filter(
+    (session) => compareOrganizedCursorKeys(
+      cursorKey,
+      getOrganizedCursorKey(activityTimeById, session)
+    ) < 0
+  );
+  const page = afterCursor.slice(0, pageSize);
+  const nextCursor = page.length < afterCursor.length ? encodeOrganizedCursor(
+    getOrganizedCursorKey(activityTimeById, page[page.length - 1]),
+    group,
+    archiveState
+  ) : void 0;
+  return {
+    sessions: page,
+    ...nextCursor !== void 0 ? { nextCursor } : {},
+    ...liveMergeFailed ? { liveMergeFailed: true } : {},
+    ...persisted.truncated ? { truncated: true } : {}
+  };
+}
+__name(listOrganizedWorkspaceSessionsForResponse, "listOrganizedWorkspaceSessionsForResponse");
+async function listWorkspaceSessionsForResponse(bridge, workspaceCwd, options) {
+  const rawSize = options?.size;
+  const requestedSize = typeof rawSize === "number" && Number.isSafeInteger(rawSize) ? rawSize : DEFAULT_SESSION_PAGE_SIZE;
+  const pageSize = Math.min(Math.max(requestedSize, 1), MAX_SESSION_PAGE_SIZE);
+  if (options?.view === "organized") {
+    return listOrganizedWorkspaceSessionsForResponse(
+      bridge,
+      workspaceCwd,
+      options,
+      pageSize
+    );
+  }
+  let numericCursor;
+  if (options?.cursor != null) {
+    numericCursor = parseSessionCursor(options.cursor);
+  }
+  const isFirstPage = numericCursor === void 0;
+  const sessionService = new SessionService(workspaceCwd);
+  const archiveState = options?.archiveState ?? "active";
+  const persisted = await sessionService.listSessions({
+    cursor: numericCursor,
+    size: pageSize,
+    archiveState
+  });
+  const bySessionId = /* @__PURE__ */ new Map();
+  for (const item of persisted.items) {
+    bySessionId.set(item.sessionId, toSummary2(item));
   }
   if (archiveState === "archived") {
     const sessions2 = [...bySessionId.values()];
@@ -14048,6 +14688,65 @@ function parseSessionPageSizeQuery(raw) {
 }
 __name(parseSessionPageSizeQuery, "parseSessionPageSizeQuery");
 
+// packages/cli/src/serve/server/session-export.ts
+init_esbuild_shims();
+var SESSION_EXPORT_FORMATS = ["html", "md", "json", "jsonl"];
+var EXPORT_FORMATS = {
+  html: {
+    mimeType: "text/html; charset=utf-8",
+    render: toHtml
+  },
+  md: {
+    mimeType: "text/markdown; charset=utf-8",
+    render: toMarkdown
+  },
+  json: {
+    mimeType: "application/json; charset=utf-8",
+    render: toJson
+  },
+  jsonl: {
+    mimeType: "application/jsonl; charset=utf-8",
+    render: toJsonl
+  }
+};
+function parseSessionExportFormat(rawFormat) {
+  if (rawFormat === void 0) return "html";
+  if (typeof rawFormat !== "string") return void 0;
+  return SESSION_EXPORT_FORMATS.includes(rawFormat) ? rawFormat : void 0;
+}
+__name(parseSessionExportFormat, "parseSessionExportFormat");
+function sessionExportFormatValues() {
+  return [...SESSION_EXPORT_FORMATS];
+}
+__name(sessionExportFormatValues, "sessionExportFormatValues");
+async function exportSessionTranscript(params) {
+  const { workspaceCwd, sessionId, format } = params;
+  const sessionData = await new SessionService(workspaceCwd).loadSession(
+    sessionId
+  );
+  if (!sessionData) {
+    throw new SessionNotFoundError(sessionId);
+  }
+  const exportConfig = params.config ?? {};
+  const collected = await collectSessionData(
+    sessionData.conversation,
+    exportConfig
+  );
+  const normalized = normalizeSessionData(
+    collected,
+    sessionData.conversation.messages,
+    exportConfig
+  );
+  const formatDefinition = EXPORT_FORMATS[format];
+  return {
+    format,
+    filename: generateExportFilename(format),
+    mimeType: formatDefinition.mimeType,
+    content: formatDefinition.render(normalized)
+  };
+}
+__name(exportSessionTranscript, "exportSessionTranscript");
+
 // packages/cli/src/serve/routes/session.ts
 function sendArtifactValidationError(res, err) {
   if (!(err instanceof SessionArtifactValidationError)) {
@@ -14064,6 +14763,19 @@ function sendArtifactValidationError(res, err) {
   return true;
 }
 __name(sendArtifactValidationError, "sendArtifactValidationError");
+function sendSessionOrganizationError(res, err) {
+  if (!(err instanceof SessionOrganizationError)) {
+    return false;
+  }
+  const status = err.code === "group_name_conflict" ? 409 : err.code === "group_not_found" ? 404 : err.code === "session_organization_store_unreadable" ? 500 : 400;
+  res.status(status).json({
+    error: err.message,
+    code: err.code,
+    ...err.field !== void 0 ? { field: err.field } : {}
+  });
+  return true;
+}
+__name(sendSessionOrganizationError, "sendSessionOrganizationError");
 function registerSessionRoutes(app, deps) {
   const {
     boundWorkspace,
@@ -14092,6 +14804,24 @@ function registerSessionRoutes(app, deps) {
     sessionId: e.sessionId,
     error: e.error instanceof Error ? e.error.message : String(e.error)
   })), "serializeSessionErrors");
+  const resolveWorkspaceParam = /* @__PURE__ */ __name((req, res) => {
+    const workspaceCwd = req.params["id"] ?? "";
+    if (!path10.isAbsolute(workspaceCwd)) {
+      res.status(400).json({ error: "`:id` must decode to an absolute workspace path" });
+      return null;
+    }
+    const key = canonicalizeWorkspace(workspaceCwd);
+    if (key !== boundWorkspace) {
+      res.status(400).json({
+        error: `Workspace mismatch: daemon is bound to "${boundWorkspace}"`,
+        code: "workspace_mismatch",
+        boundWorkspace,
+        requestedWorkspace: key
+      });
+      return null;
+    }
+    return key;
+  }, "resolveWorkspaceParam");
   const withMutableSession = /* @__PURE__ */ __name((route, handler) => async (req, res) => {
     const sessionId = requireSessionId(req, res);
     if (sessionId === null) return;
@@ -14175,6 +14905,7 @@ function registerSessionRoutes(app, deps) {
           return action === "load" ? await bridge.loadSession({
             sessionId,
             workspaceCwd: cwd,
+            historyReplay: "response",
             ...clientId !== void 0 ? { clientId } : {}
           }) : await bridge.resumeSession({
             sessionId,
@@ -14305,6 +15036,42 @@ function registerSessionRoutes(app, deps) {
       });
     }
   });
+  app.get("/session/:id/export", async (req, res) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    const rawFormat = req.query["format"];
+    const format = parseSessionExportFormat(rawFormat);
+    if (!format) {
+      res.status(400).json({
+        error: "Invalid export format",
+        code: "invalid_export_format",
+        format: typeof rawFormat === "string" ? rawFormat : String(rawFormat),
+        allowedFormats: sessionExportFormatValues()
+      });
+      return;
+    }
+    try {
+      const result = await archiveCoordinator.runSharedMany(
+        [sessionId],
+        async () => {
+          await assertSessionLoadable(boundWorkspace, sessionId);
+          return exportSessionTranscript({
+            workspaceCwd: boundWorkspace,
+            sessionId,
+            format,
+            config: { getChannel: /* @__PURE__ */ __name(() => "daemon", "getChannel") }
+          });
+        }
+      );
+      const filename = result.filename.replace(/["\\\r\n]/g, "_");
+      res.status(200).set("Cache-Control", "no-store").set("X-Content-Type-Options", "nosniff").set("Content-Type", result.mimeType).set("Content-Disposition", `attachment; filename="${filename}"`).send(result.content);
+    } catch (err) {
+      sendBridgeError2(res, err, {
+        route: "GET /session/:id/export",
+        sessionId
+      });
+    }
+  });
   app.get("/session/:id/context", async (req, res) => {
     const sessionId = requireSessionId(req, res);
     if (sessionId === null) return;
@@ -14827,6 +15594,145 @@ function registerSessionRoutes(app, deps) {
       res.status(200).json({ sessionId, ...effective });
     })
   );
+  app.patch("/session/:id/organization", mutate(), async (req, res) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    try {
+      await archiveCoordinator.runSharedMany([sessionId], async () => {
+        const sessionService = new SessionService(boundWorkspace);
+        let exists = await sessionService.sessionExistsInAnyState(sessionId);
+        if (!exists) {
+          try {
+            const summary = bridge.getSessionSummary(sessionId);
+            exists = summary.workspaceCwd === boundWorkspace;
+          } catch {
+            exists = false;
+          }
+        }
+        if (!exists) {
+          res.status(404).json({
+            error: `No session with id "${sessionId}"`,
+            sessionId
+          });
+          return;
+        }
+        const body = safeBody(req);
+        const rawIsPinned = body["isPinned"];
+        if (rawIsPinned !== void 0 && typeof rawIsPinned !== "boolean") {
+          res.status(400).json({
+            error: "`isPinned` must be a boolean",
+            code: "invalid_session_organization",
+            field: "isPinned"
+          });
+          return;
+        }
+        const rawGroupId = body["groupId"];
+        if (rawGroupId !== void 0 && rawGroupId !== null && typeof rawGroupId !== "string") {
+          res.status(400).json({
+            error: "`groupId` must be a string or null",
+            code: "invalid_session_organization",
+            field: "groupId"
+          });
+          return;
+        }
+        const rawColor = body["color"];
+        if (rawColor !== void 0 && rawColor !== null && (typeof rawColor !== "string" || !GROUP_COLOR_OPTIONS.includes(rawColor))) {
+          res.status(400).json({
+            error: "`color` must be a supported color or null",
+            code: "invalid_session_organization",
+            field: "color"
+          });
+          return;
+        }
+        const organization = await createSessionOrganizationService(
+          boundWorkspace
+        ).updateSessionOrganization(sessionId, {
+          ...rawIsPinned !== void 0 ? { isPinned: rawIsPinned } : {},
+          ...rawGroupId !== void 0 ? { groupId: rawGroupId } : {},
+          ...rawColor !== void 0 ? { color: rawColor } : {}
+        });
+        res.status(200).json({ sessionId, ...organization });
+      });
+    } catch (err) {
+      if (sendSessionOrganizationError(res, err)) return;
+      sendBridgeError2(res, err, {
+        route: "PATCH /session/:id/organization",
+        sessionId
+      });
+    }
+  });
+  app.get("/workspace/:id/session-groups", async (req, res) => {
+    const key = resolveWorkspaceParam(req, res);
+    if (key === null) return;
+    try {
+      res.status(200).json(await createSessionOrganizationService(key).listGroups());
+    } catch (err) {
+      sendBridgeError2(res, err, {
+        route: "GET /workspace/:id/session-groups"
+      });
+    }
+  });
+  app.post("/workspace/:id/session-groups", mutate(), async (req, res) => {
+    const key = resolveWorkspaceParam(req, res);
+    if (key === null) return;
+    const body = safeBody(req);
+    try {
+      const group = await createSessionOrganizationService(key).createGroup({
+        name: body["name"],
+        color: body["color"]
+      });
+      res.status(201).json({ group });
+    } catch (err) {
+      if (sendSessionOrganizationError(res, err)) return;
+      sendBridgeError2(res, err, {
+        route: "POST /workspace/:id/session-groups"
+      });
+    }
+  });
+  app.patch(
+    "/workspace/:id/session-groups/:groupId",
+    mutate(),
+    async (req, res) => {
+      const key = resolveWorkspaceParam(req, res);
+      if (key === null) return;
+      const body = safeBody(req);
+      try {
+        const group = await createSessionOrganizationService(key).updateGroup(
+          req.params["groupId"] ?? "",
+          {
+            ...Object.prototype.hasOwnProperty.call(body, "name") ? { name: body["name"] } : {},
+            ...Object.prototype.hasOwnProperty.call(body, "color") ? { color: body["color"] } : {},
+            ...Object.prototype.hasOwnProperty.call(body, "order") ? { order: body["order"] } : {}
+          }
+        );
+        res.status(200).json({ group });
+      } catch (err) {
+        if (sendSessionOrganizationError(res, err)) return;
+        sendBridgeError2(res, err, {
+          route: "PATCH /workspace/:id/session-groups/:groupId"
+        });
+      }
+    }
+  );
+  app.delete(
+    "/workspace/:id/session-groups/:groupId",
+    mutate(),
+    async (req, res) => {
+      const key = resolveWorkspaceParam(req, res);
+      if (key === null) return;
+      try {
+        const deleted = await createSessionOrganizationService(key).deleteGroup(
+          req.params["groupId"] ?? ""
+        );
+        res.status(200).json({ deleted });
+      } catch (err) {
+        if (sendSessionOrganizationError(res, err)) return;
+        sendBridgeError2(res, err, {
+          route: "DELETE /workspace/:id/session-groups/:groupId"
+        });
+      }
+    }
+  );
   app.get("/workspace/:id/sessions", async (req, res) => {
     const workspaceCwd = req.params["id"] ?? "";
     if (!path10.isAbsolute(workspaceCwd)) {
@@ -14846,6 +15752,26 @@ function registerSessionRoutes(app, deps) {
     try {
       const cursor = typeof req.query["cursor"] === "string" ? req.query["cursor"] : void 0;
       const size = parseSessionPageSizeQuery(req.query["size"]);
+      const rawView = req.query["view"];
+      let view;
+      if (rawView !== void 0) {
+        if (rawView !== "organized") {
+          res.status(400).json({
+            error: '`view` must be "organized"',
+            code: "invalid_session_view"
+          });
+          return;
+        }
+        view = "organized";
+      }
+      const group = typeof req.query["group"] === "string" ? req.query["group"] : void 0;
+      if (group !== void 0 && view !== "organized") {
+        res.status(400).json({
+          error: "`group` requires `view=organized`",
+          code: "invalid_session_group_filter"
+        });
+        return;
+      }
       const rawArchiveState = req.query["archiveState"];
       let archiveState;
       if (rawArchiveState !== void 0) {
@@ -14859,13 +15785,17 @@ function registerSessionRoutes(app, deps) {
         archiveState = rawArchiveState;
       }
       const result = await listWorkspaceSessionsForResponse(bridge, key, {
-        cursor,
-        size,
-        archiveState
+        ...cursor !== void 0 ? { cursor } : {},
+        ...size !== void 0 ? { size } : {},
+        ...archiveState !== void 0 ? { archiveState } : {},
+        ...view !== void 0 ? { view } : {},
+        ...group !== void 0 ? { group } : {}
       });
       res.status(200).json({
         sessions: result.sessions,
-        ...result.nextCursor != null ? { nextCursor: result.nextCursor } : {}
+        ...result.nextCursor != null ? { nextCursor: result.nextCursor } : {},
+        ...result.liveMergeFailed ? { liveMergeFailed: true } : {},
+        ...result.truncated ? { truncated: true } : {}
       });
     } catch (err) {
       if (err instanceof InvalidCursorError) {
@@ -14875,6 +15805,7 @@ function registerSessionRoutes(app, deps) {
         });
         return;
       }
+      if (sendSessionOrganizationError(res, err)) return;
       writeStderrLine(
         `qwen serve: failed to list sessions for workspace ${safeLogValue(
           key
@@ -15185,58 +16116,918 @@ function registerSessionRoutes(app, deps) {
           });
           return;
         }
-        const clientId = parseClientIdHeader(req, res);
-        if (clientId === null) return;
-        const response = await bridge.setSessionApprovalMode(
-          sessionId,
-          mode,
-          { persist: persist === true },
-          clientId !== void 0 ? { clientId } : void 0
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const response = await bridge.setSessionApprovalMode(
+          sessionId,
+          mode,
+          { persist: persist === true },
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(200).json(response);
+      }
+    )
+  );
+  app.post(
+    "/session/:id/language",
+    mutate(),
+    withMutableSession(
+      "POST /session/:id/language",
+      async (req, res, sessionId) => {
+        const body = safeBody(req);
+        const language = body["language"];
+        const syncOutputLanguage = body["syncOutputLanguage"];
+        if (typeof language !== "string" || !LANGUAGE_CODES.includes(language)) {
+          res.status(400).json({
+            error: "`language` is required and must be one of: " + LANGUAGE_CODES.join(", "),
+            code: "invalid_language",
+            allowed: LANGUAGE_CODES
+          });
+          return;
+        }
+        if (syncOutputLanguage !== void 0 && typeof syncOutputLanguage !== "boolean") {
+          res.status(400).json({
+            error: "`syncOutputLanguage` must be a boolean when provided",
+            code: "invalid_sync_flag"
+          });
+          return;
+        }
+        const clientId = parseClientIdHeader(req, res);
+        if (clientId === null) return;
+        const response = await bridge.setSessionLanguage(
+          sessionId,
+          {
+            language,
+            syncOutputLanguage: syncOutputLanguage === true
+          },
+          clientId !== void 0 ? { clientId } : void 0
+        );
+        res.status(200).json(response);
+      }
+    )
+  );
+}
+__name(registerSessionRoutes, "registerSessionRoutes");
+
+// packages/cli/src/serve/routes/scheduled-tasks.ts
+init_esbuild_shims();
+var MAX_SCHEDULED_TASKS = MAX_JOBS;
+var MAX_PROMPT_LENGTH = 1e5;
+var MAX_NAME_LENGTH2 = 200;
+var MAX_CRON_LENGTH = 200;
+var MAX_SESSION_NAME_LENGTH = 60;
+function scheduledTaskSessionName(label) {
+  const cleaned = stripTerminalControlSequences(label).replace(/[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, "").trim().replace(/\s+/g, " ");
+  let short = cleaned;
+  if (cleaned.length > MAX_SESSION_NAME_LENGTH) {
+    let cut = MAX_SESSION_NAME_LENGTH - 1;
+    const boundary = cleaned.charCodeAt(cut - 1);
+    if (boundary >= 55296 && boundary <= 56319) cut -= 1;
+    short = `${cleaned.slice(0, cut)}\u2026`;
+  }
+  return `\u23F0 ${short}`;
+}
+__name(scheduledTaskSessionName, "scheduledTaskSessionName");
+function computeNextRunAt(task) {
+  if (task.enabled === false) return null;
+  return nextDurableFireMs(task);
+}
+__name(computeNextRunAt, "computeNextRunAt");
+function toView(task) {
+  return {
+    id: task.id,
+    name: typeof task.name === "string" && task.name.length > 0 ? task.name : null,
+    cron: task.cron,
+    prompt: task.prompt,
+    recurring: task.recurring,
+    // Absent enabled defaults to enabled — tool-created tasks never write it.
+    enabled: task.enabled !== false,
+    createdAt: task.createdAt,
+    lastFiredAt: task.lastFiredAt,
+    nextRunAt: computeNextRunAt(task),
+    // The task's bound session (its run-history transcript), or null for an
+    // unbound tool-created/legacy task.
+    sessionId: typeof task.sessionId === "string" && task.sessionId.length > 0 ? task.sessionId : null,
+    // Absent runs (tool-created / never-fired) normalizes to [] so the client
+    // never special-cases undefined.
+    runs: Array.isArray(task.runs) ? task.runs : []
+  };
+}
+__name(toView, "toView");
+function validateCron(cron) {
+  try {
+    parseCron(cron);
+    nextFireTime(cron, /* @__PURE__ */ new Date());
+    return null;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+}
+__name(validateCron, "validateCron");
+function canonicalCron(cron) {
+  try {
+    const f = parseCron(cron);
+    const s = /* @__PURE__ */ __name((set) => [...set].sort((a, b) => a - b).join(","), "s");
+    return [
+      s(f.minute),
+      s(f.hour),
+      s(f.dayOfMonth),
+      s(f.month),
+      s(f.dayOfWeek),
+      f.domIsWild ? "W" : "",
+      f.dowIsWild ? "W" : ""
+    ].join("|");
+  } catch {
+    return null;
+  }
+}
+__name(canonicalCron, "canonicalCron");
+function registerScheduledTasksRoutes(app, deps) {
+  const { boundWorkspace, mutate, safeBody: safeBody2, bridge } = deps;
+  app.get("/scheduled-tasks", async (_req, res) => {
+    try {
+      const tasks = await readCronTasks(boundWorkspace);
+      res.status(200).json({ v: 1, tasks: tasks.map(toView) });
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: GET /scheduled-tasks failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
+        error: "Failed to read scheduled tasks (the tasks file may be corrupt)",
+        code: "scheduled_tasks_read_failed"
+      });
+    }
+  });
+  app.post("/scheduled-tasks", mutate(), async (req, res) => {
+    const body = safeBody2(req);
+    const cron = typeof body["cron"] === "string" ? body["cron"].trim() : "";
+    if (cron.length === 0) {
+      res.status(400).json({
+        error: "`cron` is required and must be a non-empty string",
+        code: "invalid_cron"
+      });
+      return;
+    }
+    if (cron.length > MAX_CRON_LENGTH) {
+      res.status(400).json({
+        error: `\`cron\` exceeds ${MAX_CRON_LENGTH}-character limit`,
+        code: "invalid_cron"
+      });
+      return;
+    }
+    const cronError = validateCron(cron);
+    if (cronError) {
+      res.status(400).json({ error: cronError, code: "invalid_cron" });
+      return;
+    }
+    const prompt = typeof body["prompt"] === "string" ? body["prompt"].trim() : "";
+    if (prompt.length === 0) {
+      res.status(400).json({
+        error: "`prompt` is required and must be a non-empty string",
+        code: "invalid_prompt"
+      });
+      return;
+    }
+    if (prompt.length > MAX_PROMPT_LENGTH) {
+      res.status(400).json({
+        error: `\`prompt\` exceeds ${MAX_PROMPT_LENGTH}-character limit`,
+        code: "invalid_prompt"
+      });
+      return;
+    }
+    const nameResult = parseNameField(body["name"]);
+    if (nameResult.error) {
+      res.status(400).json({ error: nameResult.error, code: "invalid_name" });
+      return;
+    }
+    if (body["recurring"] !== void 0 && typeof body["recurring"] !== "boolean") {
+      res.status(400).json({
+        error: "`recurring` must be a boolean",
+        code: "invalid_recurring"
+      });
+      return;
+    }
+    if (body["enabled"] !== void 0 && typeof body["enabled"] !== "boolean") {
+      res.status(400).json({
+        error: "`enabled` must be a boolean",
+        code: "invalid_enabled"
+      });
+      return;
+    }
+    const recurring = body["recurring"] !== false;
+    const enabled = body["enabled"] !== false;
+    let boundSessionId;
+    if (bridge) {
+      try {
+        if ((await readCronTasks(boundWorkspace)).length >= MAX_SCHEDULED_TASKS) {
+          res.status(409).json({
+            error: `Maximum number of scheduled tasks (${MAX_SCHEDULED_TASKS}) reached`,
+            code: "max_tasks_reached"
+          });
+          return;
+        }
+      } catch {
+      }
+      try {
+        const session = await bridge.spawnOrAttach({
+          workspaceCwd: boundWorkspace,
+          sessionScope: "thread"
+        });
+        boundSessionId = session.sessionId;
+        try {
+          bridge.updateSessionMetadata(boundSessionId, {
+            displayName: scheduledTaskSessionName(nameResult.value ?? prompt)
+          });
+        } catch {
+        }
+      } catch (err) {
+        writeStderrLine(
+          `qwen serve: POST /scheduled-tasks failed to create the task's session: ${err instanceof Error ? err.message : String(err)}`
+        );
+        res.status(500).json({
+          error: "Failed to create the task's session",
+          code: "scheduled_tasks_session_failed"
+        });
+        return;
+      }
+    }
+    const now = Date.now();
+    const task = {
+      id: generateCronTaskId(),
+      cron,
+      prompt,
+      recurring,
+      createdAt: now,
+      // Pin to the creation minute so the scheduler can't fire during the
+      // minute the task was created — same guard cronScheduler.create uses.
+      lastFiredAt: now - now % 6e4,
+      enabled,
+      ...boundSessionId !== void 0 ? { sessionId: boundSessionId } : {},
+      ...nameResult.value !== void 0 ? { name: nameResult.value } : {}
+    };
+    const rollbackSession = /* @__PURE__ */ __name(async () => {
+      if (boundSessionId !== void 0 && bridge) {
+        await bridge.closeSession(boundSessionId).catch(() => {
+        });
+        await new SessionService(boundWorkspace).removeSession(boundSessionId).catch(() => {
+        });
+      }
+    }, "rollbackSession");
+    let overCap = false;
+    try {
+      await updateCronTasks(boundWorkspace, (tasks) => {
+        if (tasks.length >= MAX_SCHEDULED_TASKS) {
+          overCap = true;
+          return tasks;
+        }
+        return [...tasks, task];
+      });
+    } catch (err) {
+      await rollbackSession();
+      writeStderrLine(
+        `qwen serve: POST /scheduled-tasks failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
+        error: "Failed to create scheduled task",
+        code: "scheduled_tasks_write_failed"
+      });
+      return;
+    }
+    if (overCap) {
+      await rollbackSession();
+      res.status(409).json({
+        error: `Maximum number of scheduled tasks (${MAX_SCHEDULED_TASKS}) reached`,
+        code: "max_tasks_reached"
+      });
+      return;
+    }
+    res.status(201).json(toView(task));
+  });
+  app.patch("/scheduled-tasks/:id", mutate(), async (req, res) => {
+    const id = typeof req.params["id"] === "string" ? req.params["id"] : "";
+    if (id.length === 0) {
+      res.status(400).json({ error: "Task id is required", code: "invalid_id" });
+      return;
+    }
+    const body = safeBody2(req);
+    const patch = {};
+    let clearName = false;
+    if ("cron" in body) {
+      const cron = typeof body["cron"] === "string" ? body["cron"].trim() : "";
+      if (cron.length === 0 || cron.length > MAX_CRON_LENGTH) {
+        res.status(400).json({
+          error: "`cron` must be a non-empty string within the length limit",
+          code: "invalid_cron"
+        });
+        return;
+      }
+      const cronError = validateCron(cron);
+      if (cronError) {
+        res.status(400).json({ error: cronError, code: "invalid_cron" });
+        return;
+      }
+      patch.cron = cron;
+    }
+    if ("prompt" in body) {
+      const prompt = typeof body["prompt"] === "string" ? body["prompt"].trim() : "";
+      if (prompt.length === 0 || prompt.length > MAX_PROMPT_LENGTH) {
+        res.status(400).json({
+          error: "`prompt` must be a non-empty string within the length limit",
+          code: "invalid_prompt"
+        });
+        return;
+      }
+      patch.prompt = prompt;
+    }
+    if ("name" in body) {
+      const nameResult = parseNameField(body["name"]);
+      if (nameResult.error) {
+        res.status(400).json({ error: nameResult.error, code: "invalid_name" });
+        return;
+      }
+      if (nameResult.value === void 0) {
+        clearName = true;
+      } else {
+        patch.name = nameResult.value;
+      }
+    }
+    if ("recurring" in body) {
+      if (typeof body["recurring"] !== "boolean") {
+        res.status(400).json({
+          error: "`recurring` must be a boolean",
+          code: "invalid_recurring"
+        });
+        return;
+      }
+      patch.recurring = body["recurring"];
+    }
+    if ("enabled" in body) {
+      if (typeof body["enabled"] !== "boolean") {
+        res.status(400).json({
+          error: "`enabled` must be a boolean",
+          code: "invalid_enabled"
+        });
+        return;
+      }
+      patch.enabled = body["enabled"];
+    }
+    if (Object.keys(patch).length === 0 && !clearName) {
+      res.status(400).json({
+        error: "No updatable fields provided",
+        code: "empty_patch"
+      });
+      return;
+    }
+    let found = false;
+    let updated;
+    let blockedByArchive = false;
+    try {
+      await updateCronTasks(boundWorkspace, (tasks) => {
+        const idx = tasks.findIndex((t) => t.id === id);
+        if (idx === -1) return tasks;
+        found = true;
+        const current = tasks[idx];
+        if (patch.enabled === true && current.disabledByArchive === true) {
+          blockedByArchive = true;
+          return tasks;
+        }
+        const next = { ...current, ...patch };
+        if (clearName) delete next.name;
+        const justReEnabled = current.enabled === false && patch.enabled === true;
+        const cronChanged = patch.cron !== void 0 && canonicalCron(patch.cron) !== canonicalCron(current.cron);
+        const becameRecurring = patch.recurring === true && current.recurring !== true;
+        const becameOneShot = patch.recurring === false && current.recurring !== false;
+        {
+          const now = Date.now();
+          const minute = now - now % 6e4;
+          if (next.recurring && (justReEnabled || cronChanged || becameRecurring)) {
+            next.lastFiredAt = minute;
+          } else if (!next.recurring && (justReEnabled || cronChanged || becameOneShot)) {
+            next.createdAt = now;
+            next.lastFiredAt = minute;
+          }
+        }
+        updated = next;
+        return tasks.map((t, i) => i === idx ? next : t);
+      });
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: PATCH /scheduled-tasks/${id} failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
+        error: "Failed to update scheduled task",
+        code: "scheduled_tasks_write_failed"
+      });
+      return;
+    }
+    if (blockedByArchive) {
+      res.status(409).json({
+        error: "This task was disabled by archiving its session; unarchive the session to re-enable it.",
+        code: "task_session_archived"
+      });
+      return;
+    }
+    if (!found || !updated) {
+      res.status(404).json({ error: "Task not found", code: "task_not_found" });
+      return;
+    }
+    const effectiveLabelChanged = patch.name !== void 0 || clearName || patch.prompt !== void 0 && updated.name === void 0;
+    if (bridge && updated.sessionId && effectiveLabelChanged) {
+      try {
+        bridge.updateSessionMetadata(updated.sessionId, {
+          displayName: scheduledTaskSessionName(updated.name ?? updated.prompt)
+        });
+      } catch {
+      }
+    }
+    res.status(200).json(toView(updated));
+  });
+  app.delete("/scheduled-tasks/:id", mutate(), async (req, res) => {
+    const id = typeof req.params["id"] === "string" ? req.params["id"] : "";
+    if (id.length === 0) {
+      res.status(400).json({ error: "Task id is required", code: "invalid_id" });
+      return;
+    }
+    let boundSessionId;
+    let removed = false;
+    try {
+      await updateCronTasks(boundWorkspace, (tasks) => {
+        const idx = tasks.findIndex((t) => t.id === id);
+        if (idx === -1) return tasks;
+        const match = tasks[idx].sessionId;
+        if (typeof match === "string" && match.length > 0) {
+          boundSessionId = match;
+        }
+        removed = true;
+        return tasks.filter((_, i) => i !== idx);
+      });
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: DELETE /scheduled-tasks/${id} failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
+        error: "Failed to delete scheduled task",
+        code: "scheduled_tasks_write_failed"
+      });
+      return;
+    }
+    if (!removed) {
+      res.status(404).json({ error: "Task not found", code: "task_not_found" });
+      return;
+    }
+    if (boundSessionId && bridge) {
+      await bridge.closeSession(boundSessionId).catch(() => {
+      });
+    }
+    res.status(200).json({ deleted: true, id });
+  });
+  app.post("/scheduled-tasks/:id/run", mutate(), async (req, res) => {
+    const id = typeof req.params["id"] === "string" ? req.params["id"] : "";
+    if (id.length === 0) {
+      res.status(400).json({ error: "Task id is required", code: "invalid_id" });
+      return;
+    }
+    const now = Date.now();
+    let found = false;
+    let blockedDisabled = false;
+    let updated;
+    try {
+      await updateCronTasks(boundWorkspace, (tasks) => {
+        const idx = tasks.findIndex((t) => t.id === id);
+        if (idx === -1) return tasks;
+        found = true;
+        const current = tasks[idx];
+        if (current.enabled === false) {
+          blockedDisabled = true;
+          return tasks;
+        }
+        const next = {
+          ...current,
+          lastFiredAt: now,
+          runs: appendCronRun(current.runs, {
+            at: now,
+            kind: "manual",
+            ...current.sessionId ? { sessionId: current.sessionId } : {}
+          })
+        };
+        updated = next;
+        if (!current.recurring) {
+          return tasks.filter((_, i) => i !== idx);
+        }
+        return tasks.map((t, i) => i === idx ? next : t);
+      });
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: POST /scheduled-tasks/${id}/run failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
+        error: "Failed to record scheduled task run",
+        code: "scheduled_tasks_write_failed"
+      });
+      return;
+    }
+    if (blockedDisabled) {
+      res.status(409).json({
+        error: "Cannot run a disabled task; enable it first (unarchive its session if it was archived).",
+        code: "task_disabled"
+      });
+      return;
+    }
+    if (!found || !updated) {
+      res.status(404).json({ error: "Task not found", code: "task_not_found" });
+      return;
+    }
+    const view = toView(updated);
+    if (!updated.recurring) view.nextRunAt = null;
+    res.status(200).json(view);
+  });
+}
+__name(registerScheduledTasksRoutes, "registerScheduledTasksRoutes");
+function parseNameField(raw) {
+  if (raw === void 0 || raw === null) return { value: void 0 };
+  if (typeof raw !== "string") {
+    return { error: "`name` must be a string" };
+  }
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return { value: void 0 };
+  if (trimmed.length > MAX_NAME_LENGTH2) {
+    return { error: `\`name\` exceeds ${MAX_NAME_LENGTH2}-character limit` };
+  }
+  return { value: trimmed };
+}
+__name(parseNameField, "parseNameField");
+
+// packages/cli/src/serve/routes/usage-stats.ts
+init_esbuild_shims();
+var DEFAULT_HEATMAP_DAYS = 183;
+var MIN_HEATMAP_DAYS = 1;
+var MAX_HEATMAP_DAYS = 366;
+var DEFAULT_CACHE_TTL_MS = 6e4;
+var USAGE_RANGES = ["today", "week", "month"];
+function parseRange(raw) {
+  return typeof raw === "string" && USAGE_RANGES.includes(raw) ? raw : "today";
+}
+__name(parseRange, "parseRange");
+function parseHeatmapDays(raw) {
+  const value = typeof raw === "string" ? Number.parseInt(raw, 10) : Number.NaN;
+  if (!Number.isFinite(value)) return DEFAULT_HEATMAP_DAYS;
+  return Math.min(MAX_HEATMAP_DAYS, Math.max(MIN_HEATMAP_DAYS, value));
+}
+__name(parseHeatmapDays, "parseHeatmapDays");
+function registerUsageStatsRoutes(app, deps = {}) {
+  const loadHistory = deps.loadHistory ?? (() => loadUsageHistory(void 0, { persistRebuild: false }));
+  const ttlMs = deps.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+  let cache = null;
+  const getRecords = /* @__PURE__ */ __name(() => {
+    const now = Date.now();
+    const fresh = cache !== null && (cache.settledAt === null || now - cache.settledAt < ttlMs);
+    if (!fresh) {
+      const entry = { promise: loadHistory(), settledAt: null };
+      cache = entry;
+      entry.promise.then(
+        () => {
+          if (cache === entry) entry.settledAt = Date.now();
+        },
+        () => {
+          if (cache === entry) cache = null;
+        }
+      );
+    }
+    return cache.promise;
+  }, "getRecords");
+  app.get("/usage/dashboard", async (req, res) => {
+    const range = parseRange(req.query["range"]);
+    const heatmapDays = parseHeatmapDays(req.query["heatmapDays"]);
+    try {
+      const records = await getRecords();
+      const dashboard = buildUsageDashboard(records, { range, heatmapDays });
+      res.status(200).json(dashboard);
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: GET /usage/dashboard failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
+        error: "Failed to load usage dashboard",
+        code: "usage_dashboard_failed"
+      });
+    }
+  });
+}
+__name(registerUsageStatsRoutes, "registerUsageStatsRoutes");
+
+// packages/cli/src/serve/scheduled-task-keepalive.ts
+init_esbuild_shims();
+import * as fsSync from "node:fs";
+import * as path11 from "node:path";
+var log = createDebugLogger("SCHED_KEEPALIVE");
+function collectBoundSessionIds(tasks) {
+  const seen = /* @__PURE__ */ new Set();
+  const ids = [];
+  for (const task of tasks) {
+    const sessionId = task.sessionId;
+    if (task.enabled === false || // disabled (e.g. archived) — let it be reaped
+    typeof sessionId !== "string" || sessionId.length === 0 || seen.has(sessionId)) {
+      continue;
+    }
+    seen.add(sessionId);
+    ids.push(sessionId);
+  }
+  return ids;
+}
+__name(collectBoundSessionIds, "collectBoundSessionIds");
+var KEEPALIVE_REVIVE_TIMEOUT_MS = 3e4;
+var KEEPALIVE_SPAWN_TIMEOUT_MS = 3e4;
+var MAX_REVIVE_BACKOFF_MS = 30 * 6e4;
+async function bindAndNameSessions(bridge, boundWorkspace, tasks, renamed, spawnTimeoutMs, binding) {
+  const unbound = tasks.filter(
+    (t) => !t.sessionId && t.enabled !== false && !binding.has(t.id)
+  );
+  const needsName = tasks.filter(
+    (t) => t.sessionId && t.enabled !== false && !renamed.has(t.sessionId)
+  );
+  for (const task of unbound) {
+    let spawnedSessionId;
+    try {
+      binding.add(task.id);
+      const rawSpawn = bridge.spawnOrAttach({
+        workspaceCwd: boundWorkspace,
+        sessionScope: "thread"
+      });
+      let timedOut = false;
+      rawSpawn.then(({ sessionId: sessionId2 }) => {
+        if (timedOut) {
+          log.debug(
+            "keepalive: late spawn resolved, cleaning up",
+            task.id,
+            sessionId2
+          );
+          bridge.closeSession(sessionId2).catch(() => {
+          });
+          new SessionService(boundWorkspace).removeSession(sessionId2).catch(() => {
+          });
+        }
+      }).catch(() => {
+      }).finally(() => {
+        binding.delete(task.id);
+      });
+      const { sessionId } = await withTimeout(
+        rawSpawn,
+        spawnTimeoutMs,
+        `spawnOrAttach(${task.id})`
+      ).catch((err) => {
+        timedOut = true;
+        throw err;
+      });
+      spawnedSessionId = sessionId;
+      try {
+        bridge.updateSessionMetadata(sessionId, {
+          displayName: scheduledTaskSessionName(task.prompt)
+        });
+        renamed.add(sessionId);
+      } catch {
+      }
+      let matched = false;
+      await updateCronTasks(boundWorkspace, (list) => {
+        if (!list.some(
+          (t) => t.id === task.id && !t.sessionId && t.enabled !== false
+        )) {
+          return list;
+        }
+        const result = list.map(
+          (t) => t.id === task.id && !t.sessionId && t.enabled !== false ? { ...t, sessionId } : t
         );
-        res.status(200).json(response);
+        matched = true;
+        return result;
+      });
+      if (!matched) {
+        throw new Error(`task ${task.id} no longer on disk`);
       }
-    )
-  );
-  app.post(
-    "/session/:id/language",
-    mutate(),
-    withMutableSession(
-      "POST /session/:id/language",
-      async (req, res, sessionId) => {
-        const body = safeBody(req);
-        const language = body["language"];
-        const syncOutputLanguage = body["syncOutputLanguage"];
-        if (typeof language !== "string" || !LANGUAGE_CODES.includes(language)) {
-          res.status(400).json({
-            error: "`language` is required and must be one of: " + LANGUAGE_CODES.join(", "),
-            code: "invalid_language",
-            allowed: LANGUAGE_CODES
-          });
-          return;
+      log.debug(
+        "keepalive: bound task",
+        task.id,
+        "to dedicated session",
+        sessionId
+      );
+    } catch (err) {
+      log.debug("keepalive: failed to bind task", task.id, err);
+      if (spawnedSessionId !== void 0) {
+        await bridge.closeSession(spawnedSessionId).catch(() => {
+        });
+        await new SessionService(boundWorkspace).removeSession(spawnedSessionId).catch(() => {
+        });
+      }
+    }
+  }
+  for (const task of needsName) {
+    const sessionId = task.sessionId;
+    try {
+      bridge.updateSessionMetadata(sessionId, {
+        displayName: scheduledTaskSessionName(task.prompt)
+      });
+      renamed.add(sessionId);
+    } catch (err) {
+      log.debug("keepalive: failed to name session", sessionId, err);
+    }
+  }
+}
+__name(bindAndNameSessions, "bindAndNameSessions");
+function startScheduledTaskKeepalive(opts) {
+  const { bridge, boundWorkspace, intervalMs } = opts;
+  const reviveTimeoutMs = opts.reviveTimeoutMs ?? KEEPALIVE_REVIVE_TIMEOUT_MS;
+  const spawnTimeoutMs = opts.spawnTimeoutMs ?? KEEPALIVE_SPAWN_TIMEOUT_MS;
+  const reviveState = /* @__PURE__ */ new Map();
+  const reviving = /* @__PURE__ */ new Set();
+  const binding = /* @__PURE__ */ new Set();
+  const renamed = /* @__PURE__ */ new Set();
+  const tick = /* @__PURE__ */ __name(async () => {
+    let tasks;
+    try {
+      tasks = await readCronTasks(boundWorkspace);
+    } catch (err) {
+      log.debug("keepalive: readCronTasks failed, skipping this pass", err);
+      return;
+    }
+    for (const sessionId of collectBoundSessionIds(tasks)) {
+      try {
+        bridge.recordHeartbeat(sessionId);
+        reviveState.delete(sessionId);
+      } catch (err) {
+        const state = reviveState.get(sessionId);
+        if (reviving.has(sessionId)) {
+          continue;
         }
-        if (syncOutputLanguage !== void 0 && typeof syncOutputLanguage !== "boolean") {
-          res.status(400).json({
-            error: "`syncOutputLanguage` must be a boolean when provided",
-            code: "invalid_sync_flag"
-          });
-          return;
+        if (state && Date.now() < state.nextAttemptAt) {
+          continue;
         }
-        const clientId = parseClientIdHeader(req, res);
-        if (clientId === null) return;
-        const response = await bridge.setSessionLanguage(
+        log.debug("keepalive: recordHeartbeat failed for", sessionId, err);
+        const load = bridge.loadSession({
           sessionId,
-          {
-            language,
-            syncOutputLanguage: syncOutputLanguage === true
-          },
-          clientId !== void 0 ? { clientId } : void 0
-        );
-        res.status(200).json(response);
+          workspaceCwd: boundWorkspace,
+          historyReplay: "response"
+        });
+        reviving.add(sessionId);
+        void load.catch(() => {
+        }).finally(() => {
+          reviving.delete(sessionId);
+        });
+        try {
+          await withTimeout(load, reviveTimeoutMs, `loadSession(${sessionId})`);
+          log.debug("keepalive: revived non-resident session", sessionId);
+          reviveState.delete(sessionId);
+        } catch (loadErr) {
+          const failures = (state?.failures ?? 0) + 1;
+          const backoff = Math.min(
+            intervalMs * 2 ** Math.min(failures - 1, 6),
+            MAX_REVIVE_BACKOFF_MS
+          );
+          reviveState.set(sessionId, {
+            failures,
+            nextAttemptAt: Date.now() + backoff
+          });
+          log.debug(
+            "keepalive: failed to revive session",
+            sessionId,
+            `(failure ${failures}, next retry in ${backoff}ms)`,
+            loadErr
+          );
+        }
+      }
+    }
+    if (reviveState.size > 0 || renamed.size > 0) {
+      const live = new Set(tasks.map((t) => t.sessionId));
+      for (const id of reviveState.keys()) {
+        if (!live.has(id)) reviveState.delete(id);
+      }
+      for (const id of renamed) {
+        if (!live.has(id)) renamed.delete(id);
+      }
+    }
+    await bindAndNameSessions(
+      bridge,
+      boundWorkspace,
+      tasks,
+      renamed,
+      spawnTimeoutMs,
+      binding
+    );
+  }, "tick");
+  let running = false;
+  const timer = setInterval(() => {
+    if (running) return;
+    running = true;
+    void tick().finally(() => {
+      running = false;
+    });
+  }, intervalMs);
+  timer.unref?.();
+  let bindDebounce;
+  const cronFilePath = getCronFilePath(boundWorkspace);
+  const cronDir = path11.dirname(cronFilePath);
+  const cronFileName = path11.basename(cronFilePath);
+  let fileWatcher;
+  try {
+    fsSync.mkdirSync(cronDir, { recursive: true });
+    fileWatcher = fsSync.watch(
+      cronDir,
+      { persistent: false },
+      (_event, filename) => {
+        if (filename !== null && filename !== cronFileName) return;
+        if (bindDebounce) clearTimeout(bindDebounce);
+        bindDebounce = setTimeout(() => {
+          if (running) return;
+          running = true;
+          void tick().finally(() => {
+            running = false;
+          });
+        }, 500);
+        bindDebounce.unref?.();
+      }
+    );
+    fileWatcher.on("error", () => {
+    });
+  } catch {
+  }
+  let stopped = false;
+  return {
+    stop: /* @__PURE__ */ __name(() => {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(timer);
+      if (bindDebounce) clearTimeout(bindDebounce);
+      fileWatcher?.close();
+    }, "stop"),
+    tick
+  };
+}
+__name(startScheduledTaskKeepalive, "startScheduledTaskKeepalive");
+var REHYDRATE_LOAD_TIMEOUT_MS = 3e4;
+var REHYDRATE_MAX_CONCURRENCY = 4;
+async function rehydrateScheduledTaskSessions(deps) {
+  const { bridge, boundWorkspace } = deps;
+  const timeoutMs = deps.loadTimeoutMs ?? REHYDRATE_LOAD_TIMEOUT_MS;
+  let tasks;
+  try {
+    tasks = await readCronTasks(boundWorkspace);
+  } catch (err) {
+    log.debug("rehydrate: readCronTasks failed", err);
+    return { loaded: [], failed: [] };
+  }
+  const sessionIds = collectBoundSessionIds(tasks);
+  const loaded = [];
+  const failed = [];
+  const loadOne = /* @__PURE__ */ __name(async (sessionId) => {
+    const load = bridge.loadSession({
+      sessionId,
+      workspaceCwd: boundWorkspace,
+      historyReplay: "response"
+    });
+    void load.catch(() => {
+    });
+    try {
+      await withTimeout(load, timeoutMs, `loadSession(${sessionId})`);
+      loaded.push(sessionId);
+    } catch (err) {
+      failed.push(sessionId);
+      try {
+        deps.onError?.(sessionId, err);
+      } catch {
       }
+    }
+  }, "loadOne");
+  const queue = sessionIds.slice();
+  const worker = /* @__PURE__ */ __name(async () => {
+    for (let sessionId = queue.shift(); sessionId !== void 0; sessionId = queue.shift()) {
+      await loadOne(sessionId);
+    }
+  }, "worker");
+  await Promise.all(
+    Array.from(
+      { length: Math.min(REHYDRATE_MAX_CONCURRENCY, queue.length) },
+      () => worker()
     )
   );
+  return { loaded, failed };
 }
-__name(registerSessionRoutes, "registerSessionRoutes");
+__name(rehydrateScheduledTaskSessions, "rehydrateScheduledTaskSessions");
+function withTimeout(p, ms, label) {
+  return new Promise((resolve4, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`${label} timed out after ${ms}ms`));
+    }, ms);
+    if (typeof timer.unref === "function") timer.unref();
+    p.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve4(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
+}
+__name(withTimeout, "withTimeout");
 
 // packages/cli/src/serve/routes/workspace-status.ts
 init_esbuild_shims();
@@ -16387,7 +18178,7 @@ __name(registerSseEventsRoutes, "registerSseEventsRoutes");
 // packages/cli/src/serve/routes/a2ui-action.ts
 init_esbuild_shims();
 import * as fsp4 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 var A2UI_MIME = "application/a2ui+json";
 var ACTION_TOOL = "action";
 var CALL_TIMEOUT_MS = 15e3;
@@ -16407,7 +18198,7 @@ __name(usableServerConfig, "usableServerConfig");
 async function findFromSettingsFile(workspaceCwd) {
   try {
     const raw = await fsp4.readFile(
-      path11.join(workspaceCwd, ".qwen", "settings.json"),
+      path12.join(workspaceCwd, ".qwen", "settings.json"),
       "utf8"
     );
     const settings = JSON.parse(raw);
@@ -16532,6 +18323,8 @@ __name(registerA2uiActionRoutes, "registerA2uiActionRoutes");
 
 // packages/cli/src/serve/server/fs-factory.ts
 init_esbuild_shims();
+import * as path13 from "node:path";
+var IDE_WORKSPACE_PATH_ENV_VAR = "QWEN_CODE_IDE_WORKSPACE_PATH";
 function createDefaultFsAuditEmit() {
   const WARN_EVERY = 100;
   let droppedCount = 0;
@@ -16554,28 +18347,100 @@ __name(createDefaultFsAuditEmit, "createDefaultFsAuditEmit");
 function resolveBridgeFsFactory(input) {
   if (input.injected) return input.injected;
   return createWorkspaceFileSystemFactory({
-    boundWorkspace: input.boundWorkspace,
+    boundWorkspaces: input.boundWorkspaces,
     trusted: input.trusted,
     emit: input.emit ?? createDefaultFsAuditEmit(),
+    pathLocks: input.pathLocks,
     ...input.customIgnoreFiles !== void 0 ? { customIgnoreFiles: input.customIgnoreFiles } : {}
   });
 }
 __name(resolveBridgeFsFactory, "resolveBridgeFsFactory");
+function resolveBoundWorkspacesFromIdeEnv(primaryWorkspace, ideWorkspacePath = process.env[IDE_WORKSPACE_PATH_ENV_VAR], includeWorkspace) {
+  let primary = primaryWorkspace;
+  const envCanonicals = [];
+  try {
+    primary = canonicalizeWorkspace(primaryWorkspace);
+  } catch (err) {
+    writeStderrLine(
+      `qwen serve: failed to canonicalize IDE workspace paths, using primary only: ${err}`
+    );
+    return [primary];
+  }
+  for (const workspace of parseIdeWorkspacePathEnv(ideWorkspacePath)) {
+    try {
+      const canonical = canonicalizeWorkspace(workspace);
+      if (envCanonicals.includes(canonical)) continue;
+      envCanonicals.push(canonical);
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: skipping IDE workspace root that failed to canonicalize: ${workspace} (${err})`
+      );
+    }
+  }
+  if (envCanonicals.length > 0 && !envCanonicals.some(
+    (workspace) => isWithinRoot2(primary, workspace) || isWithinRoot2(workspace, primary)
+  )) {
+    writeStderrLine(
+      "qwen serve: ignoring stale IDE workspace paths that do not overlap the selected workspace"
+    );
+    return [primary];
+  }
+  const workspaces = [primary, ...envCanonicals.filter((w) => w !== primary)];
+  const filteredWorkspaces = includeWorkspace === void 0 ? workspaces : workspaces.filter(includeWorkspace);
+  return dropNestedWorkspacesPreservingPrimary(filteredWorkspaces);
+}
+__name(resolveBoundWorkspacesFromIdeEnv, "resolveBoundWorkspacesFromIdeEnv");
+function parseIdeWorkspacePathEnv(value) {
+  if (value === void 0 || value.length === 0) return [];
+  if (value.trimStart().startsWith("[")) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+        return parsed.filter(
+          (workspace) => workspace.length > 0 && path13.isAbsolute(workspace)
+        );
+      }
+      throw new Error("IDE workspace path JSON must be a string array");
+    } catch {
+    }
+  }
+  return value.split(path13.delimiter).filter((workspace) => workspace.length > 0 && path13.isAbsolute(workspace));
+}
+__name(parseIdeWorkspacePathEnv, "parseIdeWorkspacePathEnv");
+function dropNestedWorkspacesPreservingPrimary(workspaces) {
+  const primary = workspaces[0];
+  if (primary === void 0) return [];
+  const withoutPrimaryOverlaps = workspaces.filter(
+    (workspace, i) => i === 0 || workspace !== primary && !isWithinRoot2(workspace, primary) && !isWithinRoot2(primary, workspace)
+  );
+  const filtered = withoutPrimaryOverlaps.filter(
+    (workspace, i) => i === 0 || !withoutPrimaryOverlaps.some(
+      (other, j) => i !== j && j !== 0 && workspace !== other && isWithinRoot2(workspace, other)
+    )
+  );
+  if (filtered.length < workspaces.length) {
+    writeStderrLine(
+      "qwen serve: dropping nested IDE workspace roots (parent folders already cover children)"
+    );
+  }
+  return filtered;
+}
+__name(dropNestedWorkspacesPreservingPrimary, "dropNestedWorkspacesPreservingPrimary");
 
 // packages/cli/src/serve/server/telemetry.ts
 init_esbuild_shims();
 function resolveDaemonTelemetryRoute(req) {
-  const path12 = req.path.replace(/\/$/, "") || "/";
-  if (req.method === "POST" && path12 === "/session") {
+  const path14 = req.path.replace(/\/$/, "") || "/";
+  if (req.method === "POST" && path14 === "/session") {
     return { route: "POST /session" };
   }
-  if (req.method === "POST" && path12 === "/sessions/delete") {
+  if (req.method === "POST" && path14 === "/sessions/delete") {
     return { route: "POST /sessions/delete" };
   }
-  if (req.method === "GET" && path12 === "/daemon/status") {
+  if (req.method === "GET" && path14 === "/daemon/status") {
     return { route: "GET /daemon/status" };
   }
-  const sessionAction = path12.match(
+  const sessionAction = path14.match(
     /^\/session\/([^/]+)\/(load|resume|prompt|cancel|recap|btw|mid-turn-message|model|shell|detach|rewind|approval-mode|language|a2ui-action)$/
   );
   const sessionActionId = sessionAction?.[1];
@@ -16586,14 +18451,14 @@ function resolveDaemonTelemetryRoute(req) {
       sessionId: sessionActionId
     };
   }
-  const sessionMetadata = path12.match(/^\/session\/([^/]+)\/metadata$/);
+  const sessionMetadata = path14.match(/^\/session\/([^/]+)\/metadata$/);
   if (sessionMetadata?.[1] && req.method === "PATCH") {
     return {
       route: "PATCH /session/:id/metadata",
       sessionId: sessionMetadata[1]
     };
   }
-  const sessionArtifacts = path12.match(/^\/session\/([^/]+)\/artifacts$/);
+  const sessionArtifacts = path14.match(/^\/session\/([^/]+)\/artifacts$/);
   if (sessionArtifacts?.[1]) {
     if (req.method === "GET") {
       return {
@@ -16608,7 +18473,7 @@ function resolveDaemonTelemetryRoute(req) {
       };
     }
   }
-  const sessionArtifact = path12.match(
+  const sessionArtifact = path14.match(
     /^\/session\/([^/]+)\/artifacts\/([^/]+)$/
   );
   if (sessionArtifact?.[1] && req.method === "DELETE") {
@@ -16617,7 +18482,7 @@ function resolveDaemonTelemetryRoute(req) {
       sessionId: sessionArtifact[1]
     };
   }
-  const sessionPermission = path12.match(
+  const sessionPermission = path14.match(
     /^\/session\/([^/]+)\/permission\/([^/]+)$/
   );
   if (sessionPermission?.[1] && sessionPermission?.[2] && req.method === "POST") {
@@ -16628,7 +18493,7 @@ function resolveDaemonTelemetryRoute(req) {
       ...rawRequestId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawRequestId) ? { permissionRequestId: rawRequestId } : {}
     };
   }
-  const globalPermission = path12.match(/^\/permission\/([^/]+)$/);
+  const globalPermission = path14.match(/^\/permission\/([^/]+)$/);
   if (globalPermission?.[1] && req.method === "POST") {
     const rawRequestId = globalPermission[1];
     return {
@@ -16636,79 +18501,87 @@ function resolveDaemonTelemetryRoute(req) {
       ...rawRequestId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawRequestId) ? { permissionRequestId: rawRequestId } : {}
     };
   }
-  const deleteSession = path12.match(/^\/session\/([^/]+)$/);
+  const deleteSession = path14.match(/^\/session\/([^/]+)$/);
   const deleteSessionId = deleteSession?.[1];
   if (deleteSessionId && req.method === "DELETE") {
     return { route: "DELETE /session/:id", sessionId: deleteSessionId };
   }
-  if (req.method === "GET" && /^\/workspace\/[^/]+\/sessions$/.test(path12)) {
+  if (req.method === "GET" && /^\/workspace\/[^/]+\/sessions$/.test(path14)) {
     return { route: "GET /workspace/:id/sessions" };
   }
-  if (req.method === "POST" && path12 === "/workspace/init") {
+  if (req.method === "POST" && path14 === "/workspace/init") {
     return { route: "POST /workspace/init" };
   }
-  if (req.method === "POST" && path12 === "/workspace/setup-github") {
+  if (req.method === "POST" && path14 === "/workspace/setup-github") {
     return { route: "POST /workspace/setup-github" };
   }
-  if (req.method === "POST" && path12 === "/workspace/reload") {
+  if (req.method === "POST" && path14 === "/workspace/reload") {
     return { route: "POST /workspace/reload" };
   }
-  const mcpRestart = path12.match(/^\/workspace\/mcp\/([^/]+)\/restart$/);
+  const mcpRestart = path14.match(/^\/workspace\/mcp\/([^/]+)\/restart$/);
   if (mcpRestart?.[1] && req.method === "POST") {
     return { route: "POST /workspace/mcp/:server/restart" };
   }
-  if (req.method === "POST" && path12 === "/workspace/mcp/servers") {
+  if (req.method === "POST" && path14 === "/workspace/mcp/servers") {
     return { route: "POST /workspace/mcp/servers" };
   }
-  const mcpDelete = path12.match(/^\/workspace\/mcp\/servers\/([^/]+)$/);
+  const mcpDelete = path14.match(/^\/workspace\/mcp\/servers\/([^/]+)$/);
   if (mcpDelete?.[1] && req.method === "DELETE") {
     return { route: "DELETE /workspace/mcp/servers/:name" };
   }
-  if (req.method === "POST" && path12 === "/workspace/auth/device-flow") {
+  if (req.method === "POST" && path14 === "/workspace/auth/device-flow") {
     return { route: "POST /workspace/auth/device-flow" };
   }
-  const deviceFlowDelete = path12.match(
+  const deviceFlowDelete = path14.match(
     /^\/workspace\/auth\/device-flow\/([^/]+)$/
   );
   if (deviceFlowDelete?.[1] && req.method === "DELETE") {
     return { route: "DELETE /workspace/auth/device-flow/:id" };
   }
-  const toolEnable = path12.match(/^\/workspace\/tools\/([^/]+)\/enable$/);
+  const toolEnable = path14.match(/^\/workspace\/tools\/([^/]+)\/enable$/);
   if (toolEnable?.[1] && req.method === "POST") {
     return { route: "POST /workspace/tools/:name/enable" };
   }
-  if (path12 === "/workspace/settings") {
+  if (path14 === "/workspace/settings") {
     if (req.method === "GET") return { route: "GET /workspace/settings" };
     if (req.method === "POST") return { route: "POST /workspace/settings" };
   }
-  if (path12 === "/workspace/permissions") {
+  if (path14 === "/workspace/permissions") {
     if (req.method === "GET") return { route: "GET /workspace/permissions" };
     if (req.method === "POST") return { route: "POST /workspace/permissions" };
   }
-  if (path12 === "/workspace/trust") {
+  if (path14 === "/workspace/trust") {
     if (req.method === "GET") return { route: "GET /workspace/trust" };
   }
-  if (req.method === "POST" && path12 === "/workspace/trust/request") {
+  if (req.method === "POST" && path14 === "/workspace/trust/request") {
     return { route: "POST /workspace/trust/request" };
   }
-  if (path12 === "/workspace/voice") {
+  if (path14 === "/workspace/voice") {
     if (req.method === "GET") return { route: "GET /workspace/voice" };
     if (req.method === "POST") return { route: "POST /workspace/voice" };
   }
-  if (req.method === "POST" && path12 === "/workspace/voice/transcribe") {
+  if (req.method === "POST" && path14 === "/workspace/voice/transcribe") {
     return { route: "POST /workspace/voice/transcribe" };
   }
   return void 0;
 }
 __name(resolveDaemonTelemetryRoute, "resolveDaemonTelemetryRoute");
-function daemonTelemetryMiddleware(boundWorkspace) {
-  const workspaceHash = hashDaemonWorkspace(boundWorkspace);
+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 workspaceHash = resolveWorkspaceHash(resolveWorkspaceCwd(req));
     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();
@@ -16727,11 +18600,11 @@ function daemonTelemetryMiddleware(boundWorkspace) {
           if (done) return;
           done = true;
           recordDaemonHttpResponse(span, res.statusCode);
-          recordDaemonHttpRequest(
-            Date.now() - startMs,
-            route.route,
-            res.statusCode
-          );
+          const durationMs = Date.now() - startMs;
+          recordDaemonHttpRequest(durationMs, route.route, res.statusCode);
+          if (route.route !== "GET /daemon/status") {
+            recordRequest?.(durationMs, res.statusCode);
+          }
           resolve4();
         }, "finish");
         res.once("finish", finish);
@@ -17055,10 +18928,10 @@ function installRateLimiter(app, opts, daemonLog) {
         { tier, key: key.slice(0, 64) }
       );
     } : void 0,
-    onError: daemonLog ? (err, path12) => {
+    onError: daemonLog ? (err, path14) => {
       daemonLog.warn(
         `rate limiter error (fail-open): ${err instanceof Error ? err.message : String(err)}`,
-        { path: path12 }
+        { path: path14 }
       );
     } : void 0
   });
@@ -17109,6 +18982,73 @@ function installSelfOriginStripMiddleware(app, getPort) {
 }
 __name(installSelfOriginStripMiddleware, "installSelfOriginStripMiddleware");
 
+// packages/cli/src/serve/workspace-registry.ts
+init_esbuild_shims();
+function createWorkspaceRegistry(inputRuntimes) {
+  if (inputRuntimes.length === 0) {
+    throw new Error(
+      "WorkspaceRegistry requires at least one workspace runtime."
+    );
+  }
+  const primaryRuntimes = inputRuntimes.filter((runtime) => runtime.primary);
+  if (primaryRuntimes.length !== 1) {
+    throw new Error(
+      "WorkspaceRegistry requires exactly one primary workspace runtime."
+    );
+  }
+  const byCwd = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  for (const runtime of inputRuntimes) {
+    if (byCwd.has(runtime.workspaceCwd)) {
+      throw new Error(
+        `Duplicate workspace runtime cwd ${JSON.stringify(
+          runtime.workspaceCwd
+        )}.`
+      );
+    }
+    byCwd.set(runtime.workspaceCwd, runtime);
+    if (byId.has(runtime.workspaceId)) {
+      throw new Error(
+        `Duplicate workspace runtime id ${JSON.stringify(
+          runtime.workspaceId
+        )}.`
+      );
+    }
+    byId.set(runtime.workspaceId, runtime);
+  }
+  const runtimes = Object.freeze([...inputRuntimes]);
+  const primary = primaryRuntimes[0];
+  return {
+    primary,
+    list: /* @__PURE__ */ __name(() => runtimes, "list"),
+    getByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => byCwd.get(workspaceCwd), "getByWorkspaceCwd"),
+    getByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => byId.get(workspaceId), "getByWorkspaceId"),
+    resolveWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => workspaceCwd === void 0 ? primary : byCwd.get(workspaceCwd), "resolveWorkspaceCwd"),
+    resolveLiveSessionOwner: /* @__PURE__ */ __name((sessionId) => {
+      const matches = [];
+      for (const runtime of runtimes) {
+        try {
+          runtime.bridge.getSessionSummary(sessionId);
+          matches.push(runtime);
+        } catch (err) {
+          if (err instanceof SessionNotFoundError) continue;
+          throw err;
+        }
+      }
+      if (matches.length === 0) return { kind: "not_found" };
+      if (matches.length === 1) {
+        return { kind: "found", runtime: matches[0] };
+      }
+      return { kind: "ambiguous", runtimes: matches };
+    }, "resolveLiveSessionOwner")
+  };
+}
+__name(createWorkspaceRegistry, "createWorkspaceRegistry");
+function createSingleWorkspaceRegistry(runtime) {
+  return createWorkspaceRegistry([runtime]);
+}
+__name(createSingleWorkspaceRegistry, "createSingleWorkspaceRegistry");
+
 // packages/cli/src/serve/routes/workspace-lifecycle.ts
 init_esbuild_shims();
 function registerWorkspaceLifecycleRoutes(app, deps) {
@@ -17407,37 +19347,101 @@ __name(registerWorkspaceToolsRoutes, "registerWorkspaceToolsRoutes");
 
 // packages/cli/src/serve/server.ts
 var warnedDefaultTrust = false;
+function describeRegistryPrimaryForConflict(registry) {
+  return `registry primary cwd=${JSON.stringify(registry.primary.workspaceCwd)}, workspaceId=${JSON.stringify(registry.primary.workspaceId)}`;
+}
+__name(describeRegistryPrimaryForConflict, "describeRegistryPrimaryForConflict");
+var DEFAULT_SESSION_IDLE_TIMEOUT_MS = 30 * 6e4;
+var KEEPALIVE_MIN_INTERVAL_MS = 3e4;
+var KEEPALIVE_MAX_INTERVAL_MS = 10 * 6e4;
+function computeKeepaliveIntervalMs(idleTimeoutMs) {
+  if (idleTimeoutMs <= 0) return KEEPALIVE_MAX_INTERVAL_MS;
+  const target = Math.min(
+    Math.max(KEEPALIVE_MIN_INTERVAL_MS, Math.floor(idleTimeoutMs / 3)),
+    KEEPALIVE_MAX_INTERVAL_MS
+  );
+  return Math.max(1, Math.min(target, Math.floor(idleTimeoutMs / 2)));
+}
+__name(computeKeepaliveIntervalMs, "computeKeepaliveIntervalMs");
 function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   const app = (0, import_express4.default)();
-  const boundWorkspace = deps.boundWorkspace ?? canonicalizeWorkspace(opts.workspace ?? process.cwd());
-  if (!deps.fsFactory && !deps.bridge && !warnedDefaultTrust) {
+  const injectedWorkspaceRegistry = deps.workspaceRegistry;
+  const boundWorkspace = injectedWorkspaceRegistry?.primary.workspaceCwd ?? deps.boundWorkspace ?? canonicalizeWorkspace(opts.workspace ?? process.cwd());
+  if (injectedWorkspaceRegistry) {
+    const primary = injectedWorkspaceRegistry.primary;
+    const registryConflictCandidates = [
+      {
+        depName: "deps.boundWorkspace",
+        depValue: deps.boundWorkspace,
+        registryValue: primary.workspaceCwd,
+        detail: `deps.boundWorkspace=${JSON.stringify(deps.boundWorkspace)}`
+      },
+      {
+        depName: "deps.bridge",
+        depValue: deps.bridge,
+        registryValue: primary.bridge,
+        detail: "deps.bridge is a different object"
+      },
+      {
+        depName: "deps.workspace",
+        depValue: deps.workspace,
+        registryValue: primary.workspaceService,
+        detail: "deps.workspace is a different object"
+      },
+      {
+        depName: "deps.fsFactory",
+        depValue: deps.fsFactory,
+        registryValue: primary.routeFileSystemFactory,
+        detail: "deps.fsFactory is a different object"
+      },
+      {
+        depName: "deps.clientMcpSenderRegistry",
+        depValue: deps.clientMcpSenderRegistry,
+        registryValue: primary.clientMcpSenderRegistry,
+        detail: "deps.clientMcpSenderRegistry is a different object"
+      }
+    ];
+    for (const candidate of registryConflictCandidates) {
+      if (candidate.depValue === void 0 || candidate.depValue === candidate.registryValue) {
+        continue;
+      }
+      throw new Error(
+        `createServeApp: workspaceRegistry conflicts with ${candidate.depName}: ${describeRegistryPrimaryForConflict(
+          injectedWorkspaceRegistry
+        )}; ${candidate.detail}.`
+      );
+    }
+  }
+  if (!injectedWorkspaceRegistry && !deps.fsFactory && !deps.bridge && !warnedDefaultTrust) {
     warnedDefaultTrust = true;
     process.stderr.write(
       "qwen serve: createServeApp default fsFactory uses trusted=false \u2014 agent ACP writeTextFile calls will reject with untrusted_workspace. Inject deps.fsFactory (with explicit trust) or deps.bridge to override.\n"
     );
   }
-  const fsFactory = resolveBridgeFsFactory({
-    boundWorkspace,
+  const fsFactory = injectedWorkspaceRegistry?.primary.routeFileSystemFactory ?? resolveBridgeFsFactory({
+    boundWorkspaces: [boundWorkspace],
     injected: deps.fsFactory,
     trusted: false
   });
   const tokenConfigured = typeof opts.token === "string" && opts.token.length > 0;
   const sessionShellCommandEnabled = opts.enableSessionShell === true && tokenConfigured;
-  if (opts.clientMcpOverWs === true && deps.bridge && !deps.clientMcpSenderRegistry) {
+  if (opts.clientMcpOverWs === true && deps.bridge && !injectedWorkspaceRegistry && !deps.clientMcpSenderRegistry) {
     throw new Error(
       "createServeApp: deps.bridge requires deps.clientMcpSenderRegistry when clientMcpOverWs is enabled (the bridge is already wired to its own sender; a fresh registry here would be an orphan)."
     );
   }
-  const clientMcpSenderRegistry = deps.clientMcpSenderRegistry ?? new ClientMcpSenderRegistry();
+  const clientMcpSenderRegistry = injectedWorkspaceRegistry?.primary.clientMcpSenderRegistry ?? deps.clientMcpSenderRegistry ?? new ClientMcpSenderRegistry();
   const { languageCodes, currentServeFeatures, invalidateServeFeaturesCache } = createServeFeatures({
     opts,
     boundWorkspace,
     persistSettingAvailable: deps.persistSetting !== void 0,
-    reloadAvailable: deps.workspace !== void 0,
+    // Registry injection supplies the primary workspace service through the
+    // runtime, so it has the same reload surface as legacy deps.workspace.
+    reloadAvailable: deps.workspace !== void 0 || injectedWorkspaceRegistry !== void 0,
     sessionShellCommandEnabled
   });
   const statusProvider = deps.statusProvider ?? createDaemonStatusProvider();
-  const bridge = deps.bridge ?? createAcpSessionBridge({
+  const bridge = injectedWorkspaceRegistry?.primary.bridge ?? deps.bridge ?? createAcpSessionBridge({
     maxSessions: opts.maxSessions,
     maxPendingPromptsPerSession: opts.maxPendingPromptsPerSession,
     eventRingSize: opts.eventRingSize,
@@ -17467,7 +19471,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   const { daemonLog } = deps;
   const sendBridgeError2 = /* @__PURE__ */ __name((res, err, ctx) => sendBridgeError(res, err, ctx, daemonLog), "sendBridgeError");
   const sendPermissionVoteError2 = /* @__PURE__ */ __name((res, err, ctx) => sendPermissionVoteError(res, err, ctx, daemonLog), "sendPermissionVoteError");
-  const workspace = deps.workspace ?? createDaemonWorkspaceService({
+  const workspace = injectedWorkspaceRegistry?.primary.workspaceService ?? deps.workspace ?? createDaemonWorkspaceService({
     boundWorkspace,
     contextFilename: deps.contextFilename ?? "QWEN.md",
     statusProvider,
@@ -17491,6 +19495,23 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       bridge.publishWorkspaceEvent(event);
     }, "publishWorkspaceEvent")
   });
+  const workspaceRegistry = injectedWorkspaceRegistry ?? createSingleWorkspaceRegistry({
+    workspaceId: hashDaemonWorkspace(boundWorkspace),
+    workspaceCwd: boundWorkspace,
+    primary: true,
+    trusted: deps.primaryWorkspaceTrusted ?? false,
+    env: { mode: "parent-process", overlayKeys: [] },
+    bridge,
+    workspaceService: workspace,
+    routeFileSystemFactory: fsFactory,
+    clientMcpSenderRegistry
+  });
+  app.locals.workspaceRegistry = workspaceRegistry;
+  const primaryRuntime = workspaceRegistry.primary;
+  const primaryBoundWorkspace = primaryRuntime.workspaceCwd;
+  const primaryBridge = primaryRuntime.bridge;
+  const primaryWorkspace = primaryRuntime.workspaceService;
+  const primaryRouteFileSystemFactory = primaryRuntime.routeFileSystemFactory;
   if (opts.allowOrigins && opts.allowOrigins.length > 0) {
     const parsedAllowOrigins = parseAllowOriginPatterns(opts.allowOrigins);
     if (parsedAllowOrigins.allowAny && !opts.token) {
@@ -17506,7 +19527,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   const healthDemoRoutes = createHealthDemoRoutes({
     opts,
     getPort,
-    bridge,
+    bridge: primaryBridge,
     getActiveSseCount,
     getRateLimiter: /* @__PURE__ */ __name(() => rateLimiter, "getRateLimiter")
   });
@@ -17531,16 +19552,21 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     tokenConfigured,
     requireAuth: opts.requireAuth === true
   });
-  app.use(daemonTelemetryMiddleware(boundWorkspace));
-  const buildWorkspaceCtx = createBuildWorkspaceCtx(boundWorkspace);
+  app.use(
+    daemonTelemetryMiddleware(
+      () => primaryBoundWorkspace,
+      deps.recordDaemonRequest
+    )
+  );
+  const buildWorkspaceCtx = createBuildWorkspaceCtx(primaryBoundWorkspace);
   const acpHandleRef = {};
-  const workspaceRememberLane = new WorkspaceRememberTaskLane(bridge);
+  const workspaceRememberLane = new WorkspaceRememberTaskLane(primaryBridge);
   const cdpTunnelRegistry = opts.cdpTunnelOverWs === true ? new CdpTunnelRegistry() : void 0;
   registerDaemonStatusRoutes(app, {
     opts,
-    boundWorkspace,
-    bridge,
-    workspace,
+    boundWorkspace: primaryBoundWorkspace,
+    bridge: primaryBridge,
+    workspace: primaryWorkspace,
     daemonLog,
     startup: deps.startup,
     qwenCodeVersion: deps.qwenCodeVersion,
@@ -17552,54 +19578,55 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     deviceFlowRegistry,
     sessionShellCommandEnabled,
     getChannelWorkerSnapshot: deps.getChannelWorkerSnapshot,
-    getPerfSnapshot: deps.getPerfSnapshot
+    getPerfSnapshot: deps.getPerfSnapshot,
+    getMetricsSeries: deps.getMetricsSeries
   });
   registerCapabilitiesRoutes(app, {
     qwenCodeVersion: deps.qwenCodeVersion,
     mode: opts.mode,
     currentServeFeatures,
-    boundWorkspace,
-    permissionPolicy: bridge.permissionPolicy,
+    boundWorkspace: primaryBoundWorkspace,
+    permissionPolicy: primaryBridge.permissionPolicy,
     maxPendingPromptsPerSession: opts.maxPendingPromptsPerSession,
     languageCodes
   });
   registerWorkspaceStatusRoutes(app, {
-    boundWorkspace,
-    bridge,
-    workspace,
+    boundWorkspace: primaryBoundWorkspace,
+    bridge: primaryBridge,
+    workspace: primaryWorkspace,
     sendBridgeError: sendBridgeError2
   });
   mountWorkspaceMemoryRoutes(app, {
-    bridge,
-    boundWorkspace,
+    bridge: primaryBridge,
+    boundWorkspace: primaryBoundWorkspace,
     mutate,
     parseClientId: parseClientIdHeader,
     safeBody
   });
   mountWorkspaceMemoryRememberRoutes(app, {
-    bridge,
+    bridge: primaryBridge,
     lane: workspaceRememberLane,
     mutate,
     parseClientId: parseClientIdHeader,
     safeBody
   });
   mountWorkspaceAgentsRoutes(app, {
-    bridge,
-    boundWorkspace,
+    bridge: primaryBridge,
+    boundWorkspace: primaryBoundWorkspace,
     mutate,
     parseClientId: parseClientIdHeader,
     safeBody
   });
   registerWorkspaceDiagnosticStatusRoutes(app, {
-    boundWorkspace,
-    bridge,
-    workspace,
+    boundWorkspace: primaryBoundWorkspace,
+    bridge: primaryBridge,
+    workspace: primaryWorkspace,
     sendBridgeError: sendBridgeError2
   });
   registerWorkspaceExtensionRoutes(app, {
-    boundWorkspace,
-    bridge,
-    workspace,
+    boundWorkspace: primaryBoundWorkspace,
+    bridge: primaryBridge,
+    workspace: primaryWorkspace,
     mutate,
     safeBody,
     sendBridgeError: sendBridgeError2,
@@ -17609,28 +19636,28 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     parseClientId: parseClientIdHeader
   });
   registerWorkspaceFileWriteRoutes(app, {
-    bridge,
+    bridge: primaryBridge,
     mutate,
     parseClientId: parseClientIdHeader,
     safeBody
   });
   registerWorkspaceSetupGithubRoutes(app, {
-    boundWorkspace,
-    bridge,
+    boundWorkspace: primaryBoundWorkspace,
+    bridge: primaryBridge,
     mutate,
     parseClientId: parseClientIdHeader,
     safeBody
   });
   registerWorkspaceTrustRoutes(app, {
-    boundWorkspace,
-    workspace,
+    boundWorkspace: primaryBoundWorkspace,
+    workspace: primaryWorkspace,
     mutate,
     safeBody,
-    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, bridge), "parseAndValidateClientId")
+    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
   });
   const broadcastSettingsChanged = /* @__PURE__ */ __name((key, value, scope, clientId) => {
     invalidateServeFeaturesCache();
-    bridge.publishWorkspaceEvent({
+    primaryBridge.publishWorkspaceEvent({
       type: "settings_changed",
       data: { key, value, scope },
       ...clientId ? { originatorClientId: clientId } : {}
@@ -17639,42 +19666,42 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   if (deps.persistSetting) {
     const persistSetting = deps.persistSetting;
     registerWorkspaceSettingsRoutes(app, {
-      boundWorkspace,
+      boundWorkspace: primaryBoundWorkspace,
       mutate,
       safeBody,
       persistSetting: /* @__PURE__ */ __name(async (...args) => {
         await persistSetting(...args);
       }, "persistSetting"),
       broadcastSettingsChanged,
-      parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, bridge), "parseAndValidateClientId")
+      parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
     });
   }
   registerWorkspacePermissionsRoutes(app, {
-    boundWorkspace,
+    boundWorkspace: primaryBoundWorkspace,
     mutate,
     safeBody,
-    workspace,
-    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, bridge), "parseAndValidateClientId")
+    workspace: primaryWorkspace,
+    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
   });
   registerWorkspaceVoiceRoutes(app, {
-    boundWorkspace,
+    boundWorkspace: primaryBoundWorkspace,
     mutate,
     safeBody,
     persistSetting: deps.persistSetting,
     persistSettings: deps.persistSettings,
     transcribe: deps.voiceTranscriber,
     broadcastSettingsChanged,
-    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, bridge), "parseAndValidateClientId")
+    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
   });
   registerA2uiActionRoutes(app, {
-    boundWorkspace,
+    boundWorkspace: primaryBoundWorkspace,
     mutate,
     safeBody,
     // UI-server discovery uses the daemon's workspace MCP status, which
     // includes servers registered at runtime.
     getMcpServers: /* @__PURE__ */ __name(async () => {
       const ctx = buildWorkspaceCtx("POST /session/:id/a2ui-action");
-      const status = await workspace.getWorkspaceMcpStatus(ctx);
+      const status = await primaryWorkspace.getWorkspaceMcpStatus(ctx);
       return status.servers ?? [];
     }, "getMcpServers")
   });
@@ -17683,13 +19710,13 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     deviceFlowRegistry,
     getSupportedDeviceFlowProviders,
     sendBridgeError: sendBridgeError2,
-    boundWorkspace,
+    boundWorkspace: primaryBoundWorkspace,
     allowPrivateAuthBaseUrl: opts.allowPrivateAuthBaseUrl === true,
     installAuthProvider: deps.installAuthProvider
   });
   registerSessionRoutes(app, {
-    boundWorkspace,
-    bridge,
+    boundWorkspace: primaryBoundWorkspace,
+    bridge: primaryBridge,
     archiveCoordinator,
     mutate,
     sendBridgeError: sendBridgeError2,
@@ -17699,47 +19726,83 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     languageCodes
   });
   registerWorkspaceMcpControlRoutes(app, {
-    boundWorkspace,
-    bridge,
-    workspace,
+    boundWorkspace: primaryBoundWorkspace,
+    bridge: primaryBridge,
+    workspace: primaryWorkspace,
     mutate,
     safeBody,
     sendBridgeError: sendBridgeError2,
-    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, bridge), "parseAndValidateClientId")
+    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
   });
   registerWorkspaceLifecycleRoutes(app, {
-    boundWorkspace,
-    workspace,
+    boundWorkspace: primaryBoundWorkspace,
+    workspace: primaryWorkspace,
     mutate,
     safeBody,
     sendBridgeError: sendBridgeError2,
     invalidateServeFeaturesCache,
-    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, bridge), "parseAndValidateClientId")
+    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
   });
   registerWorkspaceToolsRoutes(app, {
-    boundWorkspace,
-    workspace,
+    boundWorkspace: primaryBoundWorkspace,
+    workspace: primaryWorkspace,
     mutate,
     safeBody,
     sendBridgeError: sendBridgeError2,
-    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, bridge), "parseAndValidateClientId")
+    parseAndValidateClientId: /* @__PURE__ */ __name((req, res) => parseAndValidateWorkspaceClientId(req, res, primaryBridge), "parseAndValidateClientId")
   });
+  registerScheduledTasksRoutes(app, {
+    boundWorkspace: primaryBoundWorkspace,
+    mutate,
+    safeBody,
+    bridge: deps.manageScheduledTaskSessions ? bridge : void 0
+  });
+  registerUsageStatsRoutes(app);
+  if (deps.manageScheduledTaskSessions) {
+    const idleTimeoutMs = opts.sessionIdleTimeoutMs ?? DEFAULT_SESSION_IDLE_TIMEOUT_MS;
+    const keepalive = startScheduledTaskKeepalive({
+      bridge,
+      boundWorkspace,
+      intervalMs: computeKeepaliveIntervalMs(idleTimeoutMs)
+    });
+    app.locals.stopScheduledTaskKeepalive = keepalive.stop;
+    void rehydrateScheduledTaskSessions({
+      bridge,
+      boundWorkspace,
+      onError: /* @__PURE__ */ __name((sessionId, err) => {
+        process.stderr.write(
+          `qwen serve: failed to rehydrate scheduled-task session ${sessionId}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }, "onError")
+      // Outer catch is defense-in-depth: rehydrateScheduledTaskSessions already
+      // catches readCronTasks failures and per-session load errors internally
+      // (returning { loaded, failed }), so this only guards an unexpected throw
+      // from the function entry itself. Log rather than swallow it — a silent
+      // failure here leaves every bound task dormant with no diagnostic.
+    }).catch((err) => {
+      process.stderr.write(
+        `qwen serve: unexpected scheduled-task rehydration failure: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+  }
   registerPermissionRoutes(app, {
-    bridge,
+    bridge: primaryBridge,
     mutate,
     sendPermissionVoteError: sendPermissionVoteError2
   });
   registerSseEventsRoutes(app, {
-    bridge,
+    bridge: primaryBridge,
     daemonLog,
     writerIdleTimeoutMs: opts.writerIdleTimeoutMs,
     sendBridgeError: sendBridgeError2
   });
-  acpHandleRef.current = mountAcpHttp(app, bridge, {
-    boundWorkspace,
+  acpHandleRef.current = mountAcpHttp(app, primaryBridge, {
+    boundWorkspace: primaryBoundWorkspace,
     archiveCoordinator,
-    workspace,
-    fsFactory,
+    workspace: primaryWorkspace,
+    fsFactory: primaryRouteFileSystemFactory,
     deviceFlowRegistry,
     token: opts.token,
     // Mirror the REST CORS allowlist onto the WS CSRF wall so an
@@ -17758,8 +19821,8 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     // `clientMcpOverWs` is on; the WS layer never builds a provider otherwise.
     ...opts.clientMcpOverWs === true ? {
       clientMcpProviderFactory: /* @__PURE__ */ __name((connectionId) => createClientMcpServerProvider(
-        clientMcpSenderRegistry,
-        bridge,
+        primaryRuntime.clientMcpSenderRegistry,
+        primaryBridge,
         connectionId
       ), "clientMcpProviderFactory")
     } : {},
@@ -17773,7 +19836,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     extraWsRoutes: [
       {
         path: "/voice/stream",
-        onConnection: createVoiceWsConnectionHandler(boundWorkspace)
+        onConnection: createVoiceWsConnectionHandler(primaryBoundWorkspace)
       }
     ]
   });
@@ -17793,11 +19856,13 @@ __name(createServeApp, "createServeApp");
 export {
   InvalidCursorError,
   PromptDeadlineExceededError,
+  computeKeepaliveIntervalMs,
   createDefaultFsAuditEmit,
   createServeApp,
   detectFromLoopback,
   getActiveSseCount,
   listWorkspaceSessionsForResponse,
+  resolveBoundWorkspacesFromIdeEnv,
   resolveBridgeFsFactory,
   resolvePromptDeadlineMs
 };