@qwen-code/qwen-code 0.19.8 → 0.19.9

package/chunks/create-sub-session-INX7TXJI.js

@@ -0,0 +1,207 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolDisplayNames,
+  ToolNames
+} from "./chunk-B5ORX3FG.js";
+import "./chunk-J4TSQ5EQ.js";
+import "./chunk-TB6UDU4T.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/tools/create-sub-session.ts
+init_esbuild_shims();
+var DAEMON_ONLY_MESSAGE = "create_sub_session is only available when running under `qwen serve` (daemon mode). There is no session bridge in this environment, so a sub-session cannot be spawned.";
+var MAX_SUB_SESSION_PROMPT_CHARS = 1e5;
+var CANCELLED = Symbol("create_sub_session:cancelled");
+async function raceCancellation(start, signal) {
+  if (signal.aborted) return CANCELLED;
+  const spawn = start();
+  void spawn.catch(() => {
+  });
+  return new Promise((resolve, reject) => {
+    const onAbort = /* @__PURE__ */ __name(() => resolve(CANCELLED), "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+    spawn.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (err) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(err);
+      }
+    );
+  });
+}
+__name(raceCancellation, "raceCancellation");
+var CreateSubSessionInvocation = class extends BaseToolInvocation {
+  constructor(config, params) {
+    super(params);
+    this.config = config;
+  }
+  static {
+    __name(this, "CreateSubSessionInvocation");
+  }
+  getDescription() {
+    const mode = this.params.completion ?? "first-turn";
+    const raw = this.params.name ?? this.params.prompt;
+    const cleaned = raw.replace(/[\r\n\t\x00-\x1f]/g, " ").trim();
+    const label = cleaned.length > 80 ? cleaned.slice(0, 77) + "\u2026" : cleaned;
+    return `[${mode}] ${label}`;
+  }
+  /**
+   * `create_sub_session` runs a model-authored prompt with full tool access in
+   * a fresh session — the same privileged-sink shape as `cron_create`,
+   * `send_message` and `task_create`, which all return `'ask'`. The L3 default
+   * must NOT be `'allow'`: AUTO mode short-circuits before the L5 classifier
+   * when `finalPermission === 'allow'`, and DEFAULT mode skips confirmation,
+   * so the delegated prompt would never be reviewed. `'ask'` lets AUTO route
+   * the call through the classifier, which resolves it without a human.
+   */
+  async getDefaultPermission() {
+    return "ask";
+  }
+  async execute(signal) {
+    const spawner = this.config.getSubSessionSpawner();
+    if (!spawner) {
+      return {
+        llmContent: DAEMON_ONLY_MESSAGE,
+        returnDisplay: "Unavailable (daemon-only)",
+        error: { message: DAEMON_ONLY_MESSAGE }
+      };
+    }
+    const completion = this.params.completion ?? "first-turn";
+    const prompt = this.params.prompt.trim();
+    let spawnStarted = false;
+    try {
+      const res = await raceCancellation(() => {
+        spawnStarted = true;
+        return spawner({
+          prompt,
+          completion,
+          ...this.params.model ? { model: this.params.model } : {},
+          ...this.params.name ? { name: this.params.name } : {}
+        });
+      }, signal);
+      if (res === CANCELLED) {
+        const message = spawnStarted ? "create_sub_session was cancelled. A sub-session may already have been created; it runs independently and is not cancelled." : "create_sub_session was cancelled before it started. No sub-session was created.";
+        return { llmContent: message, returnDisplay: "Cancelled" };
+      }
+      const sessionLink = `[\u{1F9F5} ${res.sessionId.slice(0, 8)}](qwen-session://${res.sessionId})`;
+      const parentWarning = res.parentSessionPersisted === false ? " Note: the parent-session link could not be persisted and is live-only \u2014 it will not survive a daemon restart." : "";
+      if (completion === "sent") {
+        return {
+          llmContent: `Sub-session ${sessionLink} created and the prompt was dispatched. It runs independently \u2014 this call did not wait for a result.${parentWarning}`,
+          returnDisplay: `${sessionLink} started`
+        };
+      }
+      const stop = res.stopReason ? ` (stopReason: ${res.stopReason})` : "";
+      const body = res.result && res.result.length > 0 ? res.result : `Sub-session ${sessionLink} completed its first turn but produced no text output.`;
+      return {
+        llmContent: `Sub-session ${sessionLink} first-turn result${stop}:
+
+${body}${parentWarning}`,
+        returnDisplay: `${sessionLink} completed${stop}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        llmContent: `Error creating sub-session: ${message}`,
+        returnDisplay: message,
+        error: { message }
+      };
+    }
+  }
+};
+var CreateSubSessionTool = class _CreateSubSessionTool extends BaseDeclarativeTool {
+  constructor(config) {
+    super(
+      _CreateSubSessionTool.Name,
+      ToolDisplayNames.CREATE_SUB_SESSION,
+      "Spawn a fresh, independent sub-session (its own clean context and transcript) and run a prompt in it. Use to fan work out into a separate session \u2014 e.g. a self-contained sub-task you want isolated from this conversation.\n\nONLY available when running under `qwen serve` (daemon mode); it is inert in a plain interactive session.\n\n## Completion modes\n- `first-turn` (default): waits for the sub-session's first turn to finish and returns its result to you. Use when you need the answer back.\n- `sent`: returns immediately after dispatching the prompt, without waiting. Use for fire-and-forget launches whose output you do not need inline.\n\nThe sub-session runs the prompt with full tool access, starting from zero context \u2014 brief it completely in `prompt` (it cannot see this conversation).",
+      "other" /* Other */,
+      {
+        type: "object",
+        properties: {
+          prompt: {
+            type: "string",
+            description: "The full, self-contained prompt to run in the new sub-session. It starts with no context from this conversation, so include everything it needs."
+          },
+          completion: {
+            type: "string",
+            enum: ["sent", "first-turn"],
+            description: "'first-turn' (default) waits for the sub-session's first turn and returns its result. 'sent' returns immediately after the prompt is dispatched (fire-and-forget)."
+          },
+          model: {
+            type: "string",
+            description: "Optional model service id for the sub-session. Omit to use the default model."
+          },
+          name: {
+            type: "string",
+            description: "Optional display name for the sub-session in the session list."
+          }
+        },
+        required: ["prompt"],
+        additionalProperties: false
+      },
+      true,
+      // isOutputMarkdown
+      false,
+      // canUpdateOutput
+      true,
+      // shouldDefer — spawning is infrequent
+      false,
+      // alwaysLoad
+      "sub-session spawn delegate fan-out isolated session"
+    );
+    this.config = config;
+  }
+  static {
+    __name(this, "CreateSubSessionTool");
+  }
+  static Name = ToolNames.CREATE_SUB_SESSION;
+  createInvocation(params) {
+    return new CreateSubSessionInvocation(this.config, params);
+  }
+  validateToolParamValues(params) {
+    if (!params.prompt || params.prompt.trim() === "") {
+      return 'Parameter "prompt" must be a non-empty string.';
+    }
+    if (params.prompt.length > MAX_SUB_SESSION_PROMPT_CHARS) {
+      return `Parameter "prompt" exceeds the ${MAX_SUB_SESSION_PROMPT_CHARS}-character limit.`;
+    }
+    if (params.completion !== void 0 && params.completion !== "sent" && params.completion !== "first-turn") {
+      return 'Parameter "completion" must be "sent" or "first-turn".';
+    }
+    return null;
+  }
+  /**
+   * Surface the delegated prompt + mode to the AUTO classifier. The sub-session
+   * executes this prompt with tool access, so it must face the same scrutiny as
+   * a direct command — without this the classifier sees `create_sub_session({})`
+   * and is blind to what the sub-session will be asked to do.
+   */
+  toAutoClassifierInput(params) {
+    return {
+      prompt: params.prompt,
+      completion: params.completion ?? "first-turn",
+      ...params.model ? { model: params.model } : {}
+    };
+  }
+};
+export {
+  CreateSubSessionTool,
+  MAX_SUB_SESSION_PROMPT_CHARS
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/create-sub-session-KPRT7ECJ.js

@@ -0,0 +1,375 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  writeStderrLine
+} from "./chunk-YUZI3WAC.js";
+import {
+  stripTerminalControlSequences
+} from "./chunk-NVYTCB5Z.js";
+import "./chunk-CU3L64TP.js";
+import "./chunk-ZJE7NSL3.js";
+import "./chunk-H6XPXXMH.js";
+import "./chunk-MC23XKFE.js";
+import "./chunk-LUODI7WD.js";
+import "./chunk-ORBGV7NJ.js";
+import "./chunk-KKNMOEZH.js";
+import "./chunk-W2UIXQDL.js";
+import "./chunk-XU457J4V.js";
+import "./chunk-VDDGDZMA.js";
+import "./chunk-CEA3E3JB.js";
+import "./chunk-SZRN75WQ.js";
+import "./chunk-HTO4JFDZ.js";
+import "./chunk-CPBF7KYF.js";
+import "./chunk-4GORAUCN.js";
+import "./chunk-6AM5D4ME.js";
+import "./chunk-7R3CZA3Q.js";
+import "./chunk-GWHYEOV2.js";
+import "./chunk-4QLQE5WJ.js";
+import "./chunk-5XUCZNSY.js";
+import "./chunk-3VAGG5T5.js";
+import "./chunk-4WKAA4KS.js";
+import "./chunk-CR3C7WXL.js";
+import "./chunk-CARU2RR2.js";
+import "./chunk-VGC4I5JJ.js";
+import "./chunk-YLV3XXFB.js";
+import "./chunk-TDEXZKMT.js";
+import "./chunk-J3JA76CF.js";
+import "./chunk-B5ORX3FG.js";
+import "./chunk-BZIFY5TF.js";
+import "./chunk-UOZWKTQG.js";
+import "./chunk-JESCGQM3.js";
+import "./chunk-ZLXQN2QS.js";
+import "./chunk-XVNQMZ2I.js";
+import "./chunk-524RQP4Q.js";
+import "./chunk-JSG7ZSBC.js";
+import "./chunk-A4UCTEB5.js";
+import "./chunk-XWRJCPHC.js";
+import "./chunk-4LD5APFL.js";
+import "./chunk-TYAMGABM.js";
+import "./chunk-FCMNKVXT.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-4ZVWQHEQ.js";
+import {
+  createDebugLogger
+} from "./chunk-J4TSQ5EQ.js";
+import "./chunk-75DOP5OR.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
+import "./chunk-TB6UDU4T.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/create-sub-session.ts
+init_esbuild_shims();
+import { randomUUID } from "node:crypto";
+var log = createDebugLogger("SUB_SESSION");
+var MAX_CONCURRENT_SUB_SESSIONS_PER_CALLER = 5;
+var MAX_CONCURRENT_SUB_SESSIONS_TOTAL = 20;
+var FIRST_TURN_TIMEOUT_MS = 5 * 6e4;
+var SENT_MODE_DRAIN_TIMEOUT_MS = 30 * 6e4;
+var MAX_RESULT_CHARS = 32e3;
+var MAX_NAME_LENGTH = 60;
+var MAX_TRACKED_SPAWNED_SESSIONS = 1024;
+var BIDI_CONTROL_MARKS = new RegExp(
+  "[\\u061C\\u200E\\u200F\\u202A-\\u202E\\u2066-\\u2069]",
+  "g"
+);
+function subSessionName(label) {
+  const cleaned = stripTerminalControlSequences(label).replace(BIDI_CONTROL_MARKS, "").trim().replace(/\s+/g, " ");
+  let short = cleaned;
+  if (cleaned.length > MAX_NAME_LENGTH) {
+    let cut = MAX_NAME_LENGTH - 1;
+    const boundary = cleaned.charCodeAt(cut - 1);
+    if (boundary >= 55296 && boundary <= 56319) cut -= 1;
+    short = `${cleaned.slice(0, cut)}\u2026`;
+  }
+  return `\u{1F9F5} ${short}`;
+}
+__name(subSessionName, "subSessionName");
+async function awaitFirstTurn(bridge, sessionId, promptId, lastEventId, timeoutMs, stopSignal) {
+  const ac = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    ac.abort();
+  }, timeoutMs);
+  if (typeof timer.unref === "function") timer.unref();
+  const composed = stopSignal ? AbortSignal.any([ac.signal, stopSignal]) : ac.signal;
+  let acc = "";
+  let truncated = false;
+  let stopReason;
+  const appendChunk = /* @__PURE__ */ __name((text) => {
+    if (truncated) return;
+    if (acc.length + text.length > MAX_RESULT_CHARS) {
+      let cut = Math.max(0, MAX_RESULT_CHARS - acc.length);
+      if (cut > 0) {
+        const code = text.charCodeAt(cut - 1);
+        if (code >= 55296 && code <= 56319) cut -= 1;
+      }
+      acc += text.slice(0, cut);
+      truncated = true;
+    } else {
+      acc += text;
+    }
+  }, "appendChunk");
+  try {
+    for await (const e of bridge.subscribeEvents(sessionId, {
+      lastEventId,
+      signal: composed
+    })) {
+      if (e.type === "session_update") {
+        const d = e.data;
+        if (d?.update?.sessionUpdate === "agent_message_chunk" && typeof d.update.content?.text === "string") {
+          appendChunk(d.update.content.text);
+        }
+      } else if (e.type === "turn_complete") {
+        const d = e.data;
+        if (d?.promptId === promptId) {
+          stopReason = d.stopReason ?? "end_turn";
+          break;
+        }
+      } else if (e.type === "turn_error") {
+        const d = e.data;
+        if (d?.promptId === promptId) {
+          stopReason = "error";
+          if (d.message && !truncated) {
+            const suffix = `${acc ? "\n" : ""}[turn error] ${d.message}`;
+            if (acc.length + suffix.length <= MAX_RESULT_CHARS) {
+              acc += suffix;
+            } else {
+              truncated = true;
+            }
+          }
+          break;
+        }
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+    ac.abort();
+  }
+  if (stopReason === void 0) {
+    stopReason = stopSignal?.aborted ? "shutdown" : timedOut ? "timeout" : "incomplete";
+  }
+  if (truncated) acc += "\n[\u2026output truncated]";
+  return { result: acc, stopReason };
+}
+__name(awaitFirstTurn, "awaitFirstTurn");
+function createSubSessionLauncher(opts) {
+  const { getBridge, boundWorkspace } = opts;
+  const firstTurnTimeoutMs = opts.firstTurnTimeoutMs ?? FIRST_TURN_TIMEOUT_MS;
+  const sentModeDrainTimeoutMs = opts.sentModeDrainTimeoutMs ?? SENT_MODE_DRAIN_TIMEOUT_MS;
+  const inflight = /* @__PURE__ */ new Map();
+  const spawnedSessionIds = /* @__PURE__ */ new Set();
+  const stopAc = new AbortController();
+  let inflightTotal = 0;
+  const release = /* @__PURE__ */ __name((key) => {
+    const n = (inflight.get(key) ?? 1) - 1;
+    if (n <= 0) inflight.delete(key);
+    else inflight.set(key, n);
+    inflightTotal = Math.max(0, inflightTotal - 1);
+  }, "release");
+  const rememberSpawned = /* @__PURE__ */ __name((sessionId) => {
+    spawnedSessionIds.add(sessionId);
+    while (spawnedSessionIds.size > MAX_TRACKED_SPAWNED_SESSIONS) {
+      const oldest = spawnedSessionIds.values().next().value;
+      if (oldest === void 0) break;
+      spawnedSessionIds.delete(oldest);
+    }
+  }, "rememberSpawned");
+  const launch = /* @__PURE__ */ __name(async (info) => {
+    if (stopAc.signal.aborted) {
+      throw new Error(
+        "The daemon is shutting down; cannot create a sub-session."
+      );
+    }
+    const bridge = getBridge();
+    if (!bridge) {
+      throw new Error("Session bridge is not available.");
+    }
+    if (spawnedSessionIds.has(info.callerSessionId)) {
+      throw new Error(
+        "A sub-session cannot create further sub-sessions (nesting is capped at one level)."
+      );
+    }
+    const key = info.callerSessionId;
+    const current = inflight.get(key) ?? 0;
+    if (current >= MAX_CONCURRENT_SUB_SESSIONS_PER_CALLER) {
+      throw new Error(
+        `Too many concurrent sub-sessions for this session (cap ${MAX_CONCURRENT_SUB_SESSIONS_PER_CALLER}); wait for one to finish.`
+      );
+    }
+    if (inflightTotal >= MAX_CONCURRENT_SUB_SESSIONS_TOTAL) {
+      throw new Error(
+        `Too many concurrent sub-sessions in this workspace (cap ${MAX_CONCURRENT_SUB_SESSIONS_TOTAL}); wait for one to finish.`
+      );
+    }
+    inflight.set(key, current + 1);
+    inflightTotal += 1;
+    let released = false;
+    const releaseOnce = /* @__PURE__ */ __name(() => {
+      if (released) return;
+      released = true;
+      release(key);
+    }, "releaseOnce");
+    let spawnedSessionId;
+    try {
+      const sub = await bridge.spawnOrAttach({
+        workspaceCwd: boundWorkspace,
+        sessionScope: "thread",
+        // force a fresh top-level session, never attach
+        // Record the caller as the sub-session's parent so the UI can link it
+        // back. Persisted into the sub-session's transcript at spawn time.
+        parentSessionId: info.callerSessionId,
+        ...info.model ? { modelServiceId: info.model } : {}
+      });
+      spawnedSessionId = sub.sessionId;
+      const sessionId = sub.sessionId;
+      rememberSpawned(sessionId);
+      try {
+        bridge.updateSessionMetadata(sessionId, {
+          displayName: subSessionName(info.name ?? info.prompt)
+        });
+      } catch (err) {
+        log.debug("sub-session: updateSessionMetadata failed", sessionId, err);
+      }
+      const lastEventId = bridge.getSessionLastEventId(sessionId);
+      const promptId = randomUUID();
+      const turn = bridge.sendPrompt(
+        sessionId,
+        {
+          sessionId,
+          prompt: [{ type: "text", text: info.prompt }]
+        },
+        void 0,
+        { promptId }
+      );
+      void turn.catch((err) => {
+        log.debug("sub-session: sendPrompt rejected", sessionId, String(err));
+      });
+      if (info.completion === "sent") {
+        const drainAc = new AbortController();
+        let drainTimedOut = false;
+        const drainTimer = setTimeout(() => {
+          drainTimedOut = true;
+          drainAc.abort();
+        }, sentModeDrainTimeoutMs);
+        if (typeof drainTimer.unref === "function") drainTimer.unref();
+        const drainSignal = AbortSignal.any([stopAc.signal, drainAc.signal]);
+        void (async () => {
+          try {
+            const turnSettled = turn.then(
+              () => "ok",
+              () => "rejected"
+            );
+            const drainDone = (async () => {
+              for await (const e of bridge.subscribeEvents(sessionId, {
+                lastEventId,
+                signal: drainSignal
+              })) {
+                if (e.type === "turn_complete" || e.type === "turn_error") {
+                  const d = e.data;
+                  if (d?.promptId === promptId) break;
+                }
+              }
+              return "drained";
+            })();
+            await Promise.race([turnSettled, drainDone]);
+          } catch (err) {
+            if (!(err instanceof Error && err.name === "AbortError") && !(stopAc.signal.aborted || drainAc.signal.aborted)) {
+              log.debug(
+                "sub-session: sent-mode drain error",
+                sessionId,
+                String(err)
+              );
+            }
+          } finally {
+            clearTimeout(drainTimer);
+            if (drainTimedOut) {
+              writeStderrLine(
+                `qwen serve: sub-session ${sessionId} drain timed out after ${Math.round(sentModeDrainTimeoutMs / 6e4)}min; releasing its concurrency slot (the sub-session may still be running)`
+              );
+            }
+            drainAc.abort();
+            releaseOnce();
+          }
+        })();
+        return {
+          sessionId,
+          ...sub.parentSessionPersisted !== void 0 ? { parentSessionPersisted: sub.parentSessionPersisted } : {}
+        };
+      }
+      try {
+        const turnError = turn.then(
+          () => new Promise(() => {
+          }),
+          // never resolves on success
+          (err) => Promise.reject(
+            new Error(
+              `sub-session dispatch failed: ${err instanceof Error ? err.message : String(err)}`
+            )
+          )
+        );
+        const firstTurn = awaitFirstTurn(
+          bridge,
+          sessionId,
+          promptId,
+          lastEventId,
+          firstTurnTimeoutMs,
+          stopAc.signal
+        );
+        const { result, stopReason } = await Promise.race([
+          firstTurn,
+          turnError
+        ]);
+        return {
+          sessionId,
+          result,
+          stopReason,
+          ...sub.parentSessionPersisted !== void 0 ? { parentSessionPersisted: sub.parentSessionPersisted } : {}
+        };
+      } finally {
+        releaseOnce();
+      }
+    } catch (err) {
+      releaseOnce();
+      if (spawnedSessionId !== void 0) {
+        try {
+          void bridge.closeSession(spawnedSessionId).catch(() => {
+          });
+        } catch (closeErr) {
+          log.debug(
+            "sub-session: closeSession threw",
+            spawnedSessionId,
+            closeErr
+          );
+        }
+      }
+      writeStderrLine(
+        `qwen serve: create_sub_session failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      throw err instanceof Error ? err : new Error(String(err));
+    }
+  }, "launch");
+  return {
+    launch,
+    stop: /* @__PURE__ */ __name(() => {
+      stopAc.abort();
+    }, "stop")
+  };
+}
+__name(createSubSessionLauncher, "createSubSessionLauncher");
+export {
+  MAX_CONCURRENT_SUB_SESSIONS_PER_CALLER,
+  MAX_CONCURRENT_SUB_SESSIONS_TOTAL,
+  createSubSessionLauncher
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{cron-create-JSXEIPVS.js → cron-create-AMBKGZX6.js}

@@ -3,26 +3,26 @@
 import {
   nextFireTime,
   parseCron
-} from "./chunk-2MPVVENX.js";
+} from "./chunk-XU457J4V.js";
 import {
   humanReadableCron
-} from "./chunk-ZTQ26VBE.js";
+} from "./chunk-VDDGDZMA.js";
 import {
   CRON_TASKS_DISPLAY_PATH
-} from "./chunk-FV7425LN.js";
-import "./chunk-OMX7CUOE.js";
+} from "./chunk-CEA3E3JB.js";
+import "./chunk-VGC4I5JJ.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
-import "./chunk-7LTB54MK.js";
-import "./chunk-22MNNNXE.js";
-import "./chunk-Z2Z3GUXZ.js";
+} from "./chunk-B5ORX3FG.js";
+import "./chunk-ZLXQN2QS.js";
+import "./chunk-J4TSQ5EQ.js";
+import "./chunk-TB6UDU4T.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{cron-delete-OIFVEPGU.js → cron-delete-LRU4OJYG.js}

@@ -3,22 +3,22 @@
 import {
   CRON_TASKS_DISPLAY_PATH,
   removeCronTasks
-} from "./chunk-FV7425LN.js";
-import "./chunk-OMX7CUOE.js";
+} from "./chunk-CEA3E3JB.js";
+import "./chunk-VGC4I5JJ.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
-import "./chunk-7LTB54MK.js";
+} from "./chunk-B5ORX3FG.js";
+import "./chunk-ZLXQN2QS.js";
 import {
   getErrorMessage
-} from "./chunk-22MNNNXE.js";
-import "./chunk-Z2Z3GUXZ.js";
+} from "./chunk-J4TSQ5EQ.js";
+import "./chunk-TB6UDU4T.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{cron-list-D4ZX4IOE.js → cron-list-WVP2JXER.js}

@@ -2,24 +2,25 @@
 "use strict";
 import {
   humanReadableCron
-} from "./chunk-ZTQ26VBE.js";
+} from "./chunk-VDDGDZMA.js";
 import {
   CRON_TASKS_DISPLAY_PATH,
-  readCronTasks
-} from "./chunk-FV7425LN.js";
-import "./chunk-OMX7CUOE.js";
+  readCronTasks,
+  taskHasLegacyCondition
+} from "./chunk-CEA3E3JB.js";
+import "./chunk-VGC4I5JJ.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
-import "./chunk-7LTB54MK.js";
-import "./chunk-22MNNNXE.js";
-import "./chunk-Z2Z3GUXZ.js";
+} from "./chunk-B5ORX3FG.js";
+import "./chunk-ZLXQN2QS.js";
+import "./chunk-J4TSQ5EQ.js";
+import "./chunk-TB6UDU4T.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -69,7 +70,10 @@ var CronListInvocation = class extends BaseToolInvocation {
         recurring: task.recurring,
         durable: true,
         ...task.name ? { name: task.name } : {},
-        enabled: task.enabled !== false
+        // A legacy guarded task (removed isolated mode + precondition) can never
+        // fire — the scheduler skips it — so report it disabled here too rather
+        // than as an enabled task that silently never runs.
+        enabled: task.enabled !== false && !taskHasLegacyCondition(task)
       })),
       ...scheduler.list().filter((job) => !job.durable).map((job) => ({
         id: job.id,