@qwen-code/qwen-code 0.23.3 → 0.23.4

package/chunks/{chunk-53GWJOLP.js → chunk-2P2IXKDR.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-MR3PXB6E.js";
 import {
   ideContextStore
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-DCRVSIK6.js";
 import {
   require_proper_lockfile
 } from "./chunk-MLXTMF7H.js";
@@ -2133,7 +2133,9 @@ function isWorkspaceTrusted(settings, trustConfig, workspacePath) {
 __name(isWorkspaceTrusted, "isWorkspaceTrusted");
 
 export {
+  writeWithBackupSync,
   updateSettingsFilePreservingFormat,
+  parseJsoncObject,
   TRUSTED_FOLDERS_FILENAME,
   getTrustedFoldersPath,
   TrustLevel,

package/chunks/{chunk-6JACAGYH.js → chunk-2S2WIGCM.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-VZUCTJ2P.js";
+} from "./chunk-I6YJZGHS.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-IUVIBDKU.js → chunk-2YMRRI2C.js}

@@ -1,14 +1,17 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  MissingCliEntryError
-} from "./chunk-HGEUHUEV.js";
+  detectAvailableMemoryMb
+} from "./chunk-LYD3T3H7.js";
 import {
-  redactLogCredentials
-} from "./chunk-M5GB774H.js";
+  MissingCliEntryError
+} from "./chunk-54B2LTKP.js";
 import {
   EXTERNAL_TOOL_GUARD_TOKEN_ENV
 } from "./chunk-3VUENPWF.js";
+import {
+  redactLogCredentials
+} from "./chunk-M5GB774H.js";
 import {
   CLIENT_METHODS,
   zCreateTerminalRequest,
@@ -31,7 +34,6 @@ import {
 // packages/acp-bridge/src/spawnChannel.ts
 init_esbuild_shims();
 import { spawn } from "node:child_process";
-import * as os from "node:os";
 import { Readable, Writable } from "node:stream";
 import { getHeapStatistics } from "node:v8";
 
@@ -1675,11 +1677,8 @@ function isPlainRecord(value) {
 __name(isPlainRecord, "isPlainRecord");
 function getAcpMemoryArgs() {
   if (cachedMemoryArgs) return cachedMemoryArgs;
-  const constrainedMemory = process.constrainedMemory;
-  const constrained = typeof constrainedMemory === "function" ? constrainedMemory() : 0;
-  const totalBytes = constrained && constrained > 0 ? constrained : os.totalmem();
-  const totalMB = Math.floor(totalBytes / (1024 * 1024));
-  const targetMB = Math.min(Math.floor(totalMB * 0.5), 16384);
+  const { memoryMb } = detectAvailableMemoryMb();
+  const targetMB = Math.min(Math.floor(memoryMb * 0.5), 16384);
   const currentLimitMB = Math.floor(
     getHeapStatistics().heap_size_limit / (1024 * 1024)
   );

package/chunks/{chunk-MLQNSPRZ.js → chunk-3AYIKQTJ.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   t
-} from "./chunk-VZUCTJ2P.js";
+} from "./chunk-I6YJZGHS.js";
 import {
   SessionReferenceService,
   readManyFiles
-} from "./chunk-BZM5U74J.js";
+} from "./chunk-I6JRN375.js";
 import {
   emptyMcpResourceText,
   formatMcpResourceContents,
@@ -15,10 +15,13 @@ import {
 import {
   SessionService,
   stripTerminalControlSequences
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-DCRVSIK6.js";
+import {
+  qualifySkillName
+} from "./chunk-NJ2OFVUX.js";
 import {
   shouldRunVisionBridge
-} from "./chunk-HBU7EKY4.js";
+} from "./chunk-TRKIKBUW.js";
 import {
   Storage,
   getErrorMessage,
@@ -63,6 +66,10 @@ init_esbuild_shims();
 // packages/cli/src/ui/utils/suggestions.ts
 init_esbuild_shims();
 var MAX_SUGGESTIONS_TO_SHOW = 8;
+function normalizeDescription(description) {
+  return description.replace(/\s+/g, " ").trim();
+}
+__name(normalizeDescription, "normalizeDescription");
 
 // packages/cli/src/utils/extension-mention.ts
 init_esbuild_shims();
@@ -113,7 +120,9 @@ function buildExtensionContextText(extension) {
   }
   const capabilities = [];
   if (extension.skills && extension.skills.length > 0) {
-    const skillNames = extension.skills.map((s) => sanitizeDisplayText(s.name) || s.name).join(", ");
+    const skillNames = extension.skills.map(
+      (s) => sanitizeDisplayText(qualifySkillName(extension.name, s.name)) || s.name
+    ).join(", ");
     capabilities.push(`- Skills: ${skillNames} (invoke via /<skill-name>)`);
   }
   if (extension.mcpServers && Object.keys(extension.mcpServers).length > 0) {
@@ -985,6 +994,7 @@ export {
   matchMcpServerPrefix,
   buildMcpResourceRef,
   MAX_SUGGESTIONS_TO_SHOW,
+  normalizeDescription,
   EXTENSION_CONTEXT_BUDGET,
   parseExtensionRef,
   matchExtensionByRef,

package/chunks/{chunk-F53KKZUD.js → chunk-3LMDSCLU.js}

@@ -21,6 +21,14 @@ import {
 init_esbuild_shims();
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+var MAX_CRON_TASK_ROUTING_ID_LENGTH = 256;
+function isValidCronTaskRoutingId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_CRON_TASK_ROUTING_ID_LENGTH && !Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code === 127;
+  });
+}
+__name(isValidCronTaskRoutingId, "isValidCronTaskRoutingId");
 var MAX_TASK_RUNS = 20;
 var MAX_CHANNEL_DELIVERY_NAME_LENGTH = 2048;
 var MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH = 2048;
@@ -68,6 +76,7 @@ var UPDATE_LOCK_STALE_MS = 2e3;
 var UPDATE_LOCK_TIMEOUT_MS = 3e3;
 var updateStaleSeq = 0;
 var updateMutexes = /* @__PURE__ */ new Map();
+var MAX_TASK_DELETION_GENERATIONS = 1e4;
 function getUpdateMutex(filePath) {
   let mutex = updateMutexes.get(filePath);
   if (!mutex) {
@@ -77,6 +86,60 @@ function getUpdateMutex(filePath) {
   return mutex;
 }
 __name(getUpdateMutex, "getUpdateMutex");
+async function readTaskDeletionGenerations(filePath) {
+  const statePath = `${filePath}.deletions`;
+  let raw;
+  try {
+    raw = await fs.readFile(statePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { generations: /* @__PURE__ */ new Map(), watermark: 0 };
+    }
+    throw error;
+  }
+  const parsed = JSON.parse(raw);
+  if (parsed.version !== 2 || !Number.isSafeInteger(parsed.watermark) || parsed.watermark < 0 || !Array.isArray(parsed.entries)) {
+    throw new Error(`Invalid scheduled-task deletion state: ${statePath}`);
+  }
+  const generations = /* @__PURE__ */ new Map();
+  let maximumGeneration = 0;
+  for (const entry of parsed.entries) {
+    if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || !Number.isSafeInteger(entry[1]) || entry[1] < 1 || generations.has(entry[0])) {
+      throw new Error(`Invalid scheduled-task deletion state: ${statePath}`);
+    }
+    generations.set(entry[0], entry[1]);
+    maximumGeneration = Math.max(maximumGeneration, entry[1]);
+  }
+  const watermark = parsed.watermark;
+  if (watermark < maximumGeneration) {
+    throw new Error(`Invalid scheduled-task deletion state: ${statePath}`);
+  }
+  return { generations, watermark };
+}
+__name(readTaskDeletionGenerations, "readTaskDeletionGenerations");
+async function readTaskDeletionGenerationsOrUnknown(filePath) {
+  try {
+    return await readTaskDeletionGenerations(filePath);
+  } catch (error) {
+    console.warn(
+      `Ignoring unreadable scheduled-task deletion state at ${filePath}.deletions (${error instanceof Error ? error.message : String(error)}) \u2014 task updates proceed without it; delete the file to rebuild it.`
+    );
+    return void 0;
+  }
+}
+__name(readTaskDeletionGenerationsOrUnknown, "readTaskDeletionGenerationsOrUnknown");
+async function writeTaskDeletionGenerations(filePath, deletionState, assertCanCommit) {
+  const state = {
+    version: 2,
+    watermark: deletionState.watermark,
+    entries: [...deletionState.generations]
+  };
+  await atomicWriteJSON(`${filePath}.deletions`, state, {
+    noFollow: true,
+    assertCanCommit
+  });
+}
+__name(writeTaskDeletionGenerations, "writeTaskDeletionGenerations");
 function getCronFilePath(projectRoot) {
   return path.join(
     Storage.getGlobalTempDir(),
@@ -107,14 +170,25 @@ async function readCronTasks(projectRoot) {
       `Expected a JSON array in ${filePath} \u2014 fix or delete the file; refusing to treat it as an empty schedule.`
     );
   }
-  for (const [index, task] of parsed.entries()) {
+  const normalized = parsed.map((entry) => {
+    if (typeof entry !== "object" || entry === null) return entry;
+    const record = entry;
+    if ((record["modelServiceId"] !== void 0 || record["groupId"] !== void 0) && record["sessionMode"] !== "per_run") {
+      const copy = { ...record };
+      delete copy["modelServiceId"];
+      delete copy["groupId"];
+      return copy;
+    }
+    return entry;
+  });
+  for (const [index, task] of normalized.entries()) {
     if (!isValidTask(task)) {
       throw new Error(
         `Invalid task entry at index ${index} in ${filePath} \u2014 fix or delete the entry; refusing to drop it from the schedule.`
       );
     }
   }
-  return parsed;
+  return normalized;
 }
 __name(readCronTasks, "readCronTasks");
 async function writeCronTasks(projectRoot, tasks, options = {}) {
@@ -171,13 +245,76 @@ async function acquireUpdateLock(filePath) {
   }
 }
 __name(acquireUpdateLock, "acquireUpdateLock");
+function cronTaskSessionDeletionId(sessionId) {
+  const canonicalId = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    sessionId
+  ) ? sessionId.toLowerCase() : sessionId;
+  return `session:${canonicalId}`;
+}
+__name(cronTaskSessionDeletionId, "cronTaskSessionDeletionId");
 async function updateCronTasks(projectRoot, mutate, options = {}) {
   const filePath = getCronFilePath(projectRoot);
   return getUpdateMutex(filePath).runExclusive(async () => {
     const release = await acquireUpdateLock(filePath);
     try {
       const tasks = await readCronTasks(projectRoot);
+      const observedIds = new Set(
+        typeof options.observeDeletionIds === "function" ? options.observeDeletionIds(tasks) : options.observeDeletionIds ?? []
+      );
+      let deletionState;
+      let deletionStateUnknown = false;
+      const loadDeletionState = /* @__PURE__ */ __name(async () => {
+        if (deletionState === void 0 && !deletionStateUnknown) {
+          const state = await readTaskDeletionGenerationsOrUnknown(filePath);
+          if (state === void 0) {
+            deletionStateUnknown = true;
+          } else {
+            deletionState = state;
+          }
+        }
+        return deletionState;
+      }, "loadDeletionState");
+      if (observedIds.size > 0) {
+        const observedDeletionState = await loadDeletionState();
+        if (observedDeletionState !== void 0) {
+          options.onDeletionGenerations?.(
+            new Map(
+              [...observedIds].map((id) => [
+                id,
+                observedDeletionState.generations.get(id) ?? 0
+              ])
+            )
+          );
+        }
+      }
       const next = mutate(tasks);
+      const deletionIds = typeof options.deletionIds === "function" ? options.deletionIds() : options.deletionIds;
+      if (deletionIds?.length) {
+        deletionState = await loadDeletionState() ?? {
+          generations: /* @__PURE__ */ new Map(),
+          watermark: 0
+        };
+        for (const id of new Set(deletionIds)) {
+          if (deletionState.watermark === Number.MAX_SAFE_INTEGER) {
+            throw new Error(
+              `Scheduled-task deletion generation overflow for ${id}`
+            );
+          }
+          deletionState.watermark += 1;
+          deletionState.generations.delete(id);
+          deletionState.generations.set(id, deletionState.watermark);
+        }
+        while (deletionState.generations.size > MAX_TASK_DELETION_GENERATIONS) {
+          const oldest = deletionState.generations.keys().next().value;
+          if (oldest === void 0) break;
+          deletionState.generations.delete(oldest);
+        }
+        await writeTaskDeletionGenerations(
+          filePath,
+          deletionState,
+          options.assertCanCommit
+        );
+      }
       if (next !== tasks) {
         await writeCronTasks(projectRoot, next, options);
       }
@@ -193,14 +330,22 @@ async function addCronTask(projectRoot, task) {
 __name(addCronTask, "addCronTask");
 async function removeCronTasks(projectRoot, ids) {
   const idSet = new Set(ids);
-  const current = await readCronTasks(projectRoot);
-  if (!current.some((t) => idSet.has(t.id))) return 0;
+  try {
+    await fs.access(getCronFilePath(projectRoot));
+  } catch (error) {
+    if (error.code === "ENOENT") return 0;
+    throw error;
+  }
   let removed = 0;
-  await updateCronTasks(projectRoot, (tasks) => {
-    const remaining = tasks.filter((t) => !idSet.has(t.id));
-    removed = tasks.length - remaining.length;
-    return removed === 0 ? tasks : remaining;
-  });
+  await updateCronTasks(
+    projectRoot,
+    (tasks) => {
+      const remaining = tasks.filter((t) => !idSet.has(t.id));
+      removed = tasks.length - remaining.length;
+      return removed === 0 ? tasks : remaining;
+    },
+    { deletionIds: ids }
+  );
   return removed;
 }
 __name(removeCronTasks, "removeCronTasks");
@@ -242,11 +387,13 @@ function isValidTask(value) {
   (obj["name"] === void 0 || typeof obj["name"] === "string") && (obj["enabled"] === void 0 || typeof obj["enabled"] === "boolean") && (obj["disabledByArchive"] === void 0 || typeof obj["disabledByArchive"] === "boolean") && // A bound sessionId must be a NON-EMPTY string: an empty string would pass
   // a bare `typeof` check but the scheduler's truthy `task.sessionId` guard
   // would treat it as unbound, so a "bound" task would silently run unbound.
-  (obj["sessionId"] === void 0 || typeof obj["sessionId"] === "string" && obj["sessionId"].length > 0) && (obj["sessionOwnedByTask"] === void 0 || typeof obj["sessionOwnedByTask"] === "boolean") && (obj["sessionMode"] === void 0 || obj["sessionMode"] === "persistent" || obj["sessionMode"] === "per_run") && (obj["delivery"] === void 0 || isValidDelivery(obj["delivery"])) && (obj["runs"] === void 0 || isValidRuns(obj["runs"]));
+  (obj["sessionId"] === void 0 || typeof obj["sessionId"] === "string" && obj["sessionId"].length > 0) && (obj["sessionOwnedByTask"] === void 0 || typeof obj["sessionOwnedByTask"] === "boolean") && (obj["sessionMode"] === void 0 || obj["sessionMode"] === "persistent" || obj["sessionMode"] === "per_run") && (obj["modelServiceId"] === void 0 || isValidCronTaskRoutingId(obj["modelServiceId"])) && (obj["groupId"] === void 0 || isValidCronTaskRoutingId(obj["groupId"])) && (obj["delivery"] === void 0 || isValidDelivery(obj["delivery"])) && (obj["runs"] === void 0 || isValidRuns(obj["runs"]));
 }
 __name(isValidTask, "isValidTask");
 
 export {
+  MAX_CRON_TASK_ROUTING_ID_LENGTH,
+  isValidCronTaskRoutingId,
   MAX_CHANNEL_DELIVERY_NAME_LENGTH,
   MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH,
   annotateCronRunSession,
@@ -257,6 +404,7 @@ export {
   CRON_TASKS_DISPLAY_PATH,
   getCronFilePath,
   readCronTasks,
+  cronTaskSessionDeletionId,
   updateCronTasks,
   addCronTask,
   removeCronTasks

package/chunks/{chunk-WG7BL3FY.js → chunk-473RJLIH.js}

@@ -6,7 +6,7 @@ import {
   conversationRuntimeInUseError,
   conversationRuntimeOwnershipCompromisedError,
   conversationRuntimeUnavailableError
-} from "./chunk-2Z3T52OC.js";
+} from "./chunk-Y5TM7SBV.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-BWAMMKIS.js → chunk-4XP7WXC4.js}

@@ -1,19 +1,23 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  sanitizeFilenameForDisplay
+  sanitizeFilenameForDisplay,
+  truncateToWidth
 } from "./chunk-47ECGEJC.js";
 import {
   t
-} from "./chunk-VZUCTJ2P.js";
+} from "./chunk-I6YJZGHS.js";
 import {
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-AEY27Z35.js";
+} from "./chunk-7JGH6IMU.js";
 import {
   fetchGitDiff,
   isCompressionFailureStatus
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-DCRVSIK6.js";
+import {
+  skillRestrictionNames
+} from "./chunk-NJ2OFVUX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -155,6 +159,14 @@ var computeSessionStats = /* @__PURE__ */ __name((metrics) => {
 
 // packages/cli/src/services/commandUtils.ts
 init_esbuild_shims();
+function commandRestrictionNames(cmd) {
+  const names = cmd.skillDetail ? skillRestrictionNames(cmd.skillDetail) : [cmd.name.trim().toLowerCase()];
+  return [
+    ...names,
+    ...(cmd.altNames ?? []).map((name) => name.trim().toLowerCase())
+  ];
+}
+__name(commandRestrictionNames, "commandRestrictionNames");
 function getEffectiveSupportedModes(cmd) {
   if (cmd.supportedModes !== void 0) {
     return cmd.supportedModes;
@@ -178,6 +190,104 @@ function filterCommandsForMode(commands, mode) {
 }
 __name(filterCommandsForMode, "filterCommandsForMode");
 
+// packages/cli/src/services/commandMetadata.ts
+init_esbuild_shims();
+function extensionOwnerLabel(owner) {
+  return `${t("Extension:")} ${owner.displayName || owner.name || "unknown"}`;
+}
+__name(extensionOwnerLabel, "extensionOwnerLabel");
+var MAX_EXTENSION_OWNER_LABEL_WIDTH = 35;
+function getCommandSourceBadge(command) {
+  switch (command.source) {
+    case "bundled-skill":
+      return "[Skill]";
+    case "skill-dir-command":
+      if (command.sourceDetail === "user") {
+        return "[User]";
+      }
+      if (command.sourceDetail === "project") {
+        return "[Project]";
+      }
+      return "[Custom]";
+    case "plugin-command":
+      if (command.sourceDetail !== "extension") {
+        return "[Plugin]";
+      }
+      return command.sourceLabel ? `[${truncateToWidth(command.sourceLabel, MAX_EXTENSION_OWNER_LABEL_WIDTH)}]` : "[Extension]";
+    case "mcp-prompt":
+      return "[MCP]";
+    case "builtin-command":
+    default:
+      return null;
+  }
+}
+__name(getCommandSourceBadge, "getCommandSourceBadge");
+function getCommandSourceGroup(command) {
+  switch (command.source) {
+    case "builtin-command":
+      return { key: "built-in", title: "Built-in Commands", order: 0 };
+    case "bundled-skill":
+      return { key: "bundled-skill", title: "Bundled Skills", order: 1 };
+    case "skill-dir-command":
+      return { key: "custom", title: "Custom Commands", order: 2 };
+    case "plugin-command":
+      return { key: "plugin", title: "Plugin Commands", order: 3 };
+    case "mcp-prompt":
+      return { key: "mcp", title: "MCP Commands", order: 4 };
+    default:
+      return { key: "other", title: "Other Commands", order: 5 };
+  }
+}
+__name(getCommandSourceGroup, "getCommandSourceGroup");
+function formatSupportedModes(command) {
+  const modes = getEffectiveSupportedModes(command);
+  const hasInteractive = modes.includes("interactive");
+  const hasNonInteractive = modes.includes("non_interactive");
+  const hasAcp = modes.includes("acp");
+  if (hasInteractive && hasNonInteractive && hasAcp) {
+    return "[all]";
+  }
+  if (!hasInteractive && hasNonInteractive && hasAcp) {
+    return "[headless]";
+  }
+  if (hasInteractive && !hasNonInteractive && !hasAcp) {
+    return "[interactive]";
+  }
+  return modes.map((mode) => {
+    switch (mode) {
+      case "interactive":
+        return "[i]";
+      case "non_interactive":
+        return "[ni]";
+      case "acp":
+        return "[acp]";
+      default:
+        return `[${mode}]`;
+    }
+  }).join(" ");
+}
+__name(formatSupportedModes, "formatSupportedModes");
+function getCommandDisplayName(command, options = {}) {
+  const prefix = options.prefix ?? "";
+  const baseLabel = `${prefix}${command.name}`;
+  if (options.matchedAlias) {
+    return `${baseLabel} (alias: ${options.matchedAlias})`;
+  }
+  if (options.includeAliases === false) {
+    return baseLabel;
+  }
+  const altNames = command.altNames?.filter(Boolean);
+  if (!altNames || altNames.length === 0) {
+    return baseLabel;
+  }
+  return `${baseLabel} (${altNames.join(", ")})`;
+}
+__name(getCommandDisplayName, "getCommandDisplayName");
+function getCommandSubcommandNames(command) {
+  return command.subCommands?.filter((subCommand) => !subCommand.hidden).map((subCommand) => subCommand.name) ?? [];
+}
+__name(getCommandSubcommandNames, "getCommandSubcommandNames");
+
 // packages/cli/src/ui/commands/diffCommand.ts
 init_esbuild_shims();
 async function diffAction(context) {
@@ -603,6 +713,16 @@ function levelLabel(level) {
   }
 }
 __name(levelLabel, "levelLabel");
+function skillOriginLabel(skill) {
+  if (skill.level === "extension") {
+    return `(${extensionOwnerLabel({
+      name: skill.extensionName,
+      displayName: skill.extensionDisplayName
+    })})`;
+  }
+  return `(${levelLabel(skill.level)})`;
+}
+__name(skillOriginLabel, "skillOriginLabel");
 
 export {
   INLINE_CODE_SPAN_PATTERN_SOURCE,
@@ -621,9 +741,18 @@ export {
   calculateCacheHitRate,
   computeSessionStats,
   calculateCost,
+  commandRestrictionNames,
   getEffectiveSupportedModes,
   filterCommandsForMode,
+  extensionOwnerLabel,
+  MAX_EXTENSION_OWNER_LABEL_WIDTH,
+  getCommandSourceBadge,
+  getCommandSourceGroup,
+  formatSupportedModes,
+  getCommandDisplayName,
+  getCommandSubcommandNames,
   levelLabel,
+  skillOriginLabel,
   computeDiffColumnWidths,
   diffCommand
 };
@@ -634,11 +763,11 @@ export {
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */

package/chunks/{chunk-W5ZQMAEM.js → chunk-4Y2I3CI3.js}

@@ -1226,7 +1226,7 @@ function initializeTelemetry(config) {
   telemetryInitPromise ??= (async () => {
     const debugLogger3 = createDebugLogger("OTEL");
     try {
-      const { startTelemetrySdk } = await import("./sdk-impl-G6FVTBQZ.js");
+      const { startTelemetrySdk } = await import("./sdk-impl-4WF3VZ2F.js");
       if (telemetryInitialized) return;
       const started = await startTelemetrySdk(config);
       if (!started) return;

package/chunks/{chunk-HGEUHUEV.js → chunk-54B2LTKP.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   SkillError
-} from "./chunk-2SZH22YO.js";
+} from "./chunk-NJ2OFVUX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-IRH27ZC2.js → chunk-5EZRLTLQ.js}

@@ -117,9 +117,9 @@ function matches(cronExpr, date) {
 __name(matches, "matches");
 function nextFireTime(cronExpr, after) {
   const fields = parseCron(cronExpr);
-  const candidate = new Date(after.getTime());
-  candidate.setSeconds(0, 0);
-  candidate.setMinutes(candidate.getMinutes() + 1);
+  const candidate = new Date(
+    Math.floor(after.getTime() / 6e4) * 6e4 + 6e4
+  );
   const maxIterations = 4 * 366 * 24 * 60;
   for (let i = 0; i < maxIterations; i++) {
     const minuteOk = fields.minute.has(candidate.getMinutes());
@@ -131,7 +131,7 @@ function nextFireTime(cronExpr, after) {
     if (minuteOk && hourOk && monthOk && dayOk) {
       return candidate;
     }
-    candidate.setMinutes(candidate.getMinutes() + 1);
+    candidate.setTime(candidate.getTime() + 6e4);
   }
   throw new Error(
     `No matching fire time found within 4 years for: "${cronExpr}"`

package/chunks/{chunk-DLH7YIX6.js → chunk-5FK4MSHB.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   createTask
-} from "./chunk-XKBFYTCD.js";
+} from "./chunk-WK6DEH3Q.js";
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-PLLIWEM3.js";
+} from "./chunk-AEWCOE64.js";
 import {
   resolveActiveTeamName
 } from "./chunk-S6LOFUVP.js";
@@ -15,7 +15,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";