@qwen-code/qwen-code 0.19.6-nightly.20260707.bcdb44c5d → 0.19.6-preview.0

package/chunks/{server-W64GXOEJ.js → server-TDFPIDC3.js}

@@ -11,7 +11,7 @@ import {
   openQwenAsrRealtimeStream,
   openVoiceStream,
   openVoiceStreamWithRetry
-} from "./chunk-65P5ZXUE.js";
+} from "./chunk-4XV2MRNK.js";
 import {
   SetupGithubError,
   collectSessionData,
@@ -22,24 +22,25 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-UOGOM4NJ.js";
+} from "./chunk-AJ3CEJRJ.js";
+import "./chunk-7VCI24VZ.js";
+import "./chunk-LGFAYIKX.js";
 import "./chunk-54YZOP7P.js";
-import "./chunk-OGAC66WF.js";
 import {
   createDaemonStatusProvider
-} from "./chunk-2BJWUJCW.js";
-import "./chunk-HLJMZYTD.js";
+} from "./chunk-7SAH6M3Y.js";
+import "./chunk-2D5Q33PT.js";
 import "./chunk-KHDZHZMH.js";
 import {
   createWorkspaceProvidersStatusProvider
-} from "./chunk-XUYYEFCM.js";
+} from "./chunk-27QGW3BK.js";
 import {
   getAuthTypeFromEnv,
   resolveCliGenerationConfig
-} from "./chunk-FTEFJT6V.js";
+} from "./chunk-QM4FKX7H.js";
 import {
   createWorkspaceSkillsStatusProvider
-} from "./chunk-HT553O4R.js";
+} from "./chunk-WRLMLPWI.js";
 import "./chunk-6IAWPIQ6.js";
 import {
   EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
@@ -51,14 +52,14 @@ import {
   transcribeWorkspaceVoiceAudio,
   validateWorkspaceVoiceState,
   voiceSettingsScopeToWire
-} from "./chunk-AY7CP32Q.js";
+} from "./chunk-A7UKINBT.js";
 import {
   PermissionRulesValidationError,
   buildPermissionSettings,
   isPermissionRuleType,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-N7BUPX4V.js";
+} from "./chunk-6GHEZDDX.js";
 import {
   assertVoiceBaseUrlNetworkAllowed,
   isStreamingVoiceModel,
@@ -66,12 +67,12 @@ import {
   resolveVoiceTranscriptionConfig,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-IEFMDFCG.js";
+} from "./chunk-WKTLDGD6.js";
 import {
   isVoiceEnabled,
   isVoiceMode,
   readVoiceModel
-} from "./chunk-B2FUQ22Z.js";
+} from "./chunk-ILFQAFWH.js";
 import "./chunk-E7KNELIZ.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
@@ -134,16 +135,16 @@ import {
   getSettingDefinition,
   loadSettings,
   validateSettingValue
-} from "./chunk-INNPK6XG.js";
+} from "./chunk-O6T7PBUM.js";
 import {
   SUPPORTED_LANGUAGES
-} from "./chunk-VCKMHAEZ.js";
+} from "./chunk-2MJAXDFK.js";
 import "./chunk-TLRYABYP.js";
 import "./chunk-4RQIB5UZ.js";
 import {
   SessionArtifactValidationError,
   createAcpSessionBridge
-} from "./chunk-R57UD732.js";
+} from "./chunk-SKO6VJHG.js";
 import "./chunk-P7M4GA57.js";
 import {
   BranchWhilePromptActiveError,
@@ -185,18 +186,19 @@ import {
   SubscriberLimitExceededError
 } from "./chunk-G7ZG7CA6.js";
 import "./chunk-VRDMOSQS.js";
-import "./chunk-V63Q7BVE.js";
+import "./chunk-GW67O5SO.js";
 import "./chunk-EXPMGZZV.js";
 import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceMemoryStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-QU6OLW25.js";
+} from "./chunk-7O6DD2ES.js";
 import "./chunk-HLKG6CZN.js";
-import "./chunk-XZ2LJL4O.js";
+import "./chunk-RODQXLGZ.js";
+import "./chunk-43W4YSO6.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-32KIF557.js";
+} from "./chunk-WKBA74DD.js";
 import {
   writeStderrLine
 } from "./chunk-Y6Z2O3WR.js";
@@ -234,14 +236,16 @@ import {
   parseInstallSource,
   redactUrlCredentials,
   shouldShowStep,
+  stripTerminalControlSequences,
   writeWorkspaceContextFile
-} from "./chunk-KD4KV6XW.js";
+} from "./chunk-ZWFS7YCB.js";
 import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
 import "./chunk-K5PGHDBN.js";
 import {
-  MAX_JOBS
-} from "./chunk-FVMWEHWU.js";
+  MAX_JOBS,
+  nextDurableFireMs
+} from "./chunk-3B26UVCX.js";
 import "./chunk-W7EEOR7D.js";
 import "./chunk-42XGFRJS.js";
 import "./chunk-X2XNQQJI.js";
@@ -252,11 +256,12 @@ import {
 } from "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
 import {
+  appendCronRun,
   generateCronTaskId,
+  getCronFilePath,
   readCronTasks,
-  removeCronTasks,
   updateCronTasks
-} from "./chunk-2NL7ED5Q.js";
+} from "./chunk-FV7425LN.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-E5A7LHNN.js";
@@ -283,7 +288,7 @@ import {
   recordDaemonHttpRequest,
   recordDaemonHttpResponse,
   withDaemonRequestSpan
-} from "./chunk-IPKM25FZ.js";
+} from "./chunk-N33JAGJ7.js";
 import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
@@ -305,8 +310,8 @@ import "./chunk-AHNJGLFV.js";
 import "./chunk-22IFUCVR.js";
 import "./chunk-7LTB54MK.js";
 import "./chunk-SIUQ3YYX.js";
-import "./chunk-2A6XOMBQ.js";
-import "./chunk-NCFY7PWS.js";
+import "./chunk-HW4N45EE.js";
+import "./chunk-CCGOFQV3.js";
 import "./chunk-IRJWHZWU.js";
 import "./chunk-SYCJMSIJ.js";
 import "./chunk-55ZMG67I.js";
@@ -4893,6 +4898,67 @@ __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");
@@ -4995,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");
@@ -5151,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");
@@ -5197,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");
@@ -9798,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");
@@ -10243,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,
@@ -10257,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 {
@@ -10268,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 {
@@ -10291,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");
@@ -10303,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");
@@ -10321,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)}`
         );
       }
@@ -10338,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");
@@ -10349,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");
@@ -10365,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");
 
@@ -10516,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 path13 = opts.path ?? "/acp";
+  const path14 = opts.path ?? "/acp";
   const dispatcherRef = {};
   const registry = new ConnectionRegistry(
     (req, clientId) => {
@@ -10653,7 +10744,7 @@ function mountAcpHttp(app, bridge, opts) {
     opts.archiveCoordinator ?? new SessionArchiveCoordinator()
   );
   dispatcherRef.current = dispatcher;
-  app.post(path13, 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" });
@@ -10757,7 +10848,7 @@ function mountAcpHttp(app, bridge, opts) {
       );
     });
   });
-  app.get(path13, (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" });
@@ -10843,7 +10934,7 @@ function mountAcpHttp(app, bridge, opts) {
       onPumpSettled();
     });
   });
-  app.delete(path13, (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" });
@@ -10906,7 +10997,7 @@ function mountAcpHttp(app, bridge, opts) {
       const extraRoute = opts.extraWsRoutes?.find(
         (route) => route.path === url.pathname
       );
-      if (url.pathname !== path13 && !isCdpPath && !extraRoute) {
+      if (url.pathname !== path14 && !isCdpPath && !extraRoute) {
         logReject(`unknown-path ${url.pathname}`);
         socket.destroy();
         return;
@@ -11303,7 +11394,7 @@ function mountAcpHttp(app, bridge, opts) {
       });
     }, "upgradeListener");
     httpServer.on("upgrade", upgradeListener);
-    writeStderrLine(`qwen serve: /acp WebSocket transport enabled on ${path13}`);
+    writeStderrLine(`qwen serve: /acp WebSocket transport enabled on ${path14}`);
   }
   __name(setupWebSocket, "setupWebSocket");
   return {
@@ -16084,6 +16175,24 @@ 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,
@@ -16094,7 +16203,14 @@ function toView(task) {
     // Absent enabled defaults to enabled — tool-created tasks never write it.
     enabled: task.enabled !== false,
     createdAt: task.createdAt,
-    lastFiredAt: task.lastFiredAt
+    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");
@@ -16108,8 +16224,26 @@ function validateCron(cron) {
   }
 }
 __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 } = deps;
+  const { boundWorkspace, mutate, safeBody: safeBody2, bridge } = deps;
   app.get("/scheduled-tasks", async (_req, res) => {
     try {
       const tasks = await readCronTasks(boundWorkspace);
@@ -16182,6 +16316,41 @@ function registerScheduledTasksRoutes(app, deps) {
     }
     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(),
@@ -16193,8 +16362,17 @@ function registerScheduledTasksRoutes(app, deps) {
       // 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) => {
@@ -16205,6 +16383,7 @@ function registerScheduledTasksRoutes(app, deps) {
         return [...tasks, task];
       });
     } catch (err) {
+      await rollbackSession();
       writeStderrLine(
         `qwen serve: POST /scheduled-tasks failed: ${err instanceof Error ? err.message : String(err)}`
       );
@@ -16215,6 +16394,7 @@ function registerScheduledTasksRoutes(app, deps) {
       return;
     }
     if (overCap) {
+      await rollbackSession();
       res.status(409).json({
         error: `Maximum number of scheduled tasks (${MAX_SCHEDULED_TASKS}) reached`,
         code: "max_tasks_reached"
@@ -16300,17 +16480,32 @@ function registerScheduledTasksRoutes(app, deps) {
     }
     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;
-        if (current.enabled === false && patch.enabled === true && next.recurring) {
+        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();
-          next.lastFiredAt = now - now % 6e4;
+          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);
@@ -16325,10 +16520,26 @@ function registerScheduledTasksRoutes(app, deps) {
       });
       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) => {
@@ -16337,9 +16548,19 @@ function registerScheduledTasksRoutes(app, deps) {
       res.status(400).json({ error: "Task id is required", code: "invalid_id" });
       return;
     }
-    let removed;
+    let boundSessionId;
+    let removed = false;
     try {
-      removed = await removeCronTasks(boundWorkspace, [id]);
+      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)}`
@@ -16350,12 +16571,76 @@ function registerScheduledTasksRoutes(app, deps) {
       });
       return;
     }
-    if (removed === 0) {
+    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) {
@@ -16430,6 +16715,320 @@ function registerUsageStatsRoutes(app, deps = {}) {
 }
 __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
+        );
+        matched = true;
+        return result;
+      });
+      if (!matched) {
+        throw new Error(`task ${task.id} no longer on disk`);
+      }
+      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 (state && Date.now() < state.nextAttemptAt) {
+          continue;
+        }
+        log.debug("keepalive: recordHeartbeat failed for", sessionId, err);
+        const load = bridge.loadSession({
+          sessionId,
+          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(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();
 function registerWorkspaceStatusRoutes(app, deps) {
@@ -17579,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;
@@ -17599,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);
@@ -17724,7 +18323,7 @@ __name(registerA2uiActionRoutes, "registerA2uiActionRoutes");
 
 // packages/cli/src/serve/server/fs-factory.ts
 init_esbuild_shims();
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 var IDE_WORKSPACE_PATH_ENV_VAR = "QWEN_CODE_IDE_WORKSPACE_PATH";
 function createDefaultFsAuditEmit() {
   const WARN_EVERY = 100;
@@ -17798,14 +18397,14 @@ function parseIdeWorkspacePathEnv(value) {
       const parsed = JSON.parse(value);
       if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
         return parsed.filter(
-          (workspace) => workspace.length > 0 && path12.isAbsolute(workspace)
+          (workspace) => workspace.length > 0 && path13.isAbsolute(workspace)
         );
       }
       throw new Error("IDE workspace path JSON must be a string array");
     } catch {
     }
   }
-  return value.split(path12.delimiter).filter((workspace) => workspace.length > 0 && path12.isAbsolute(workspace));
+  return value.split(path13.delimiter).filter((workspace) => workspace.length > 0 && path13.isAbsolute(workspace));
 }
 __name(parseIdeWorkspacePathEnv, "parseIdeWorkspacePathEnv");
 function dropNestedWorkspacesPreservingPrimary(workspaces) {
@@ -17831,17 +18430,17 @@ __name(dropNestedWorkspacesPreservingPrimary, "dropNestedWorkspacesPreservingPri
 // packages/cli/src/serve/server/telemetry.ts
 init_esbuild_shims();
 function resolveDaemonTelemetryRoute(req) {
-  const path13 = req.path.replace(/\/$/, "") || "/";
-  if (req.method === "POST" && path13 === "/session") {
+  const path14 = req.path.replace(/\/$/, "") || "/";
+  if (req.method === "POST" && path14 === "/session") {
     return { route: "POST /session" };
   }
-  if (req.method === "POST" && path13 === "/sessions/delete") {
+  if (req.method === "POST" && path14 === "/sessions/delete") {
     return { route: "POST /sessions/delete" };
   }
-  if (req.method === "GET" && path13 === "/daemon/status") {
+  if (req.method === "GET" && path14 === "/daemon/status") {
     return { route: "GET /daemon/status" };
   }
-  const sessionAction = path13.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];
@@ -17852,14 +18451,14 @@ function resolveDaemonTelemetryRoute(req) {
       sessionId: sessionActionId
     };
   }
-  const sessionMetadata = path13.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 = path13.match(/^\/session\/([^/]+)\/artifacts$/);
+  const sessionArtifacts = path14.match(/^\/session\/([^/]+)\/artifacts$/);
   if (sessionArtifacts?.[1]) {
     if (req.method === "GET") {
       return {
@@ -17874,7 +18473,7 @@ function resolveDaemonTelemetryRoute(req) {
       };
     }
   }
-  const sessionArtifact = path13.match(
+  const sessionArtifact = path14.match(
     /^\/session\/([^/]+)\/artifacts\/([^/]+)$/
   );
   if (sessionArtifact?.[1] && req.method === "DELETE") {
@@ -17883,7 +18482,7 @@ function resolveDaemonTelemetryRoute(req) {
       sessionId: sessionArtifact[1]
     };
   }
-  const sessionPermission = path13.match(
+  const sessionPermission = path14.match(
     /^\/session\/([^/]+)\/permission\/([^/]+)$/
   );
   if (sessionPermission?.[1] && sessionPermission?.[2] && req.method === "POST") {
@@ -17894,7 +18493,7 @@ function resolveDaemonTelemetryRoute(req) {
       ...rawRequestId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawRequestId) ? { permissionRequestId: rawRequestId } : {}
     };
   }
-  const globalPermission = path13.match(/^\/permission\/([^/]+)$/);
+  const globalPermission = path14.match(/^\/permission\/([^/]+)$/);
   if (globalPermission?.[1] && req.method === "POST") {
     const rawRequestId = globalPermission[1];
     return {
@@ -17902,66 +18501,66 @@ function resolveDaemonTelemetryRoute(req) {
       ...rawRequestId.length <= MAX_CLIENT_ID_LENGTH && CLIENT_ID_RE.test(rawRequestId) ? { permissionRequestId: rawRequestId } : {}
     };
   }
-  const deleteSession = path13.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(path13)) {
+  if (req.method === "GET" && /^\/workspace\/[^/]+\/sessions$/.test(path14)) {
     return { route: "GET /workspace/:id/sessions" };
   }
-  if (req.method === "POST" && path13 === "/workspace/init") {
+  if (req.method === "POST" && path14 === "/workspace/init") {
     return { route: "POST /workspace/init" };
   }
-  if (req.method === "POST" && path13 === "/workspace/setup-github") {
+  if (req.method === "POST" && path14 === "/workspace/setup-github") {
     return { route: "POST /workspace/setup-github" };
   }
-  if (req.method === "POST" && path13 === "/workspace/reload") {
+  if (req.method === "POST" && path14 === "/workspace/reload") {
     return { route: "POST /workspace/reload" };
   }
-  const mcpRestart = path13.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" && path13 === "/workspace/mcp/servers") {
+  if (req.method === "POST" && path14 === "/workspace/mcp/servers") {
     return { route: "POST /workspace/mcp/servers" };
   }
-  const mcpDelete = path13.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" && path13 === "/workspace/auth/device-flow") {
+  if (req.method === "POST" && path14 === "/workspace/auth/device-flow") {
     return { route: "POST /workspace/auth/device-flow" };
   }
-  const deviceFlowDelete = path13.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 = path13.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 (path13 === "/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 (path13 === "/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 (path13 === "/workspace/trust") {
+  if (path14 === "/workspace/trust") {
     if (req.method === "GET") return { route: "GET /workspace/trust" };
   }
-  if (req.method === "POST" && path13 === "/workspace/trust/request") {
+  if (req.method === "POST" && path14 === "/workspace/trust/request") {
     return { route: "POST /workspace/trust/request" };
   }
-  if (path13 === "/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" && path13 === "/workspace/voice/transcribe") {
+  if (req.method === "POST" && path14 === "/workspace/voice/transcribe") {
     return { route: "POST /workspace/voice/transcribe" };
   }
   return void 0;
@@ -18329,10 +18928,10 @@ function installRateLimiter(app, opts, daemonLog) {
         { tier, key: key.slice(0, 64) }
       );
     } : void 0,
-    onError: daemonLog ? (err, path13) => {
+    onError: daemonLog ? (err, path14) => {
       daemonLog.warn(
         `rate limiter error (fail-open): ${err instanceof Error ? err.message : String(err)}`,
-        { path: path13 }
+        { path: path14 }
       );
     } : void 0
   });
@@ -18385,14 +18984,69 @@ __name(installSelfOriginStripMiddleware, "installSelfOriginStripMiddleware");
 
 // packages/cli/src/serve/workspace-registry.ts
 init_esbuild_shims();
-function createSingleWorkspaceRegistry(runtime) {
-  const runtimes = Object.freeze([runtime]);
+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: runtime,
+    primary,
     list: /* @__PURE__ */ __name(() => runtimes, "list"),
-    getByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => workspaceCwd === runtime.workspaceCwd ? runtime : void 0, "getByWorkspaceCwd")
+    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
@@ -18693,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({
+  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,
@@ -18753,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,
@@ -18777,8 +19495,12 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       bridge.publishWorkspaceEvent(event);
     }, "publishWorkspaceEvent")
   });
-  const workspaceRegistry = createSingleWorkspaceRegistry({
+  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,
@@ -19032,9 +19754,39 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   registerScheduledTasksRoutes(app, {
     boundWorkspace: primaryBoundWorkspace,
     mutate,
-    safeBody
+    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: primaryBridge,
     mutate,
@@ -19104,6 +19856,7 @@ __name(createServeApp, "createServeApp");
 export {
   InvalidCursorError,
   PromptDeadlineExceededError,
+  computeKeepaliveIntervalMs,
   createDefaultFsAuditEmit,
   createServeApp,
   detectFromLoopback,