@h-ai/scheduler 0.1.0-alpha.53 → 0.1.0-alpha.55

package/dist/index.js

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { cache } from '@h-ai/cache';
-import { core, err, ok } from '@h-ai/core';
+import { core, ok, err } from '@h-ai/core';
 import { reldb, BaseReldbCrudRepository } from '@h-ai/reldb';
 import { createHash } from 'crypto';
 import { Script } from 'vm';
+import { Worker } from 'worker_threads';
 import { Cron } from 'croner';
 
 // src/scheduler-config.ts
@@ -29,16 +30,22 @@ var en_US_default = {
   scheduler_initFailed: "Failed to initialize scheduler: {error}",
   scheduler_alreadyRunning: "Scheduler is already running",
   scheduler_notRunning: "Scheduler is not running",
+  scheduler_closing: "Scheduler is closing; task execution cancelled",
+  scheduler_definitionsChanged: "Task definitions changed during refresh; retry the operation",
+  scheduler_taskNoLongerDue: "Task {taskId} was removed, disabled, or rescheduled",
   scheduler_taskNotFound: "Task not found: {taskId}",
   scheduler_taskAlreadyExists: "Task already exists: {taskId}",
   scheduler_invalidCron: "Invalid cron expression: {expression}",
   scheduler_executionFailed: "Task execution failed: {error}",
   scheduler_jsExecutionFailed: "JS code execution failed: {error}",
+  scheduler_jsTimedOut: "JS task timed out after {timeout}ms",
   scheduler_apiExecutionFailed: "API call failed: {error}",
+  scheduler_apiResponseTooLarge: "API response exceeds the {maxResponseBytes} byte limit",
   scheduler_dbSaveFailed: "Failed to save execution log: {error}",
   scheduler_dbNotInitialized: "Database not initialized, cannot save execution logs",
   scheduler_configError: "Scheduler config validation failed: {error}",
   scheduler_taskIdEmpty: "Task ID cannot be empty",
+  scheduler_invalidPersistedTask: "Invalid persisted task {taskId}: {error}",
   scheduler_taskRunning: "Task is currently running: {taskId}",
   scheduler_invalidApiConfig: "Invalid api_config for task: {taskId}",
   scheduler_lockAcquireFailed: "Failed to acquire distributed lock, another node already holds it: {taskId}",
@@ -57,16 +64,22 @@ var zh_CN_default = {
   scheduler_initFailed: "\u5B9A\u65F6\u4EFB\u52A1\u6A21\u5757\u521D\u59CB\u5316\u5931\u8D25: {error}",
   scheduler_alreadyRunning: "\u5B9A\u65F6\u4EFB\u52A1\u8C03\u5EA6\u5668\u5DF2\u5728\u8FD0\u884C\u4E2D",
   scheduler_notRunning: "\u5B9A\u65F6\u4EFB\u52A1\u8C03\u5EA6\u5668\u672A\u8FD0\u884C",
+  scheduler_closing: "\u8C03\u5EA6\u5668\u6B63\u5728\u5173\u95ED\uFF0C\u4EFB\u52A1\u6267\u884C\u5DF2\u53D6\u6D88",
+  scheduler_definitionsChanged: "\u5237\u65B0\u671F\u95F4\u4EFB\u52A1\u5B9A\u4E49\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u8BD5\u64CD\u4F5C",
+  scheduler_taskNoLongerDue: "\u4EFB\u52A1 {taskId} \u5DF2\u5220\u9664\u3001\u7981\u7528\u6216\u6539\u53D8\u8C03\u5EA6\u65F6\u95F4",
   scheduler_taskNotFound: "\u4EFB\u52A1\u672A\u627E\u5230: {taskId}",
   scheduler_taskAlreadyExists: "\u4EFB\u52A1\u5DF2\u5B58\u5728: {taskId}",
   scheduler_invalidCron: "\u65E0\u6548\u7684 cron \u8868\u8FBE\u5F0F: {expression}",
   scheduler_executionFailed: "\u4EFB\u52A1\u6267\u884C\u5931\u8D25: {error}",
   scheduler_jsExecutionFailed: "JS \u4EE3\u7801\u6267\u884C\u5931\u8D25: {error}",
+  scheduler_jsTimedOut: "JS \u4EFB\u52A1\u6267\u884C\u8D85\u8FC7 {timeout} \u6BEB\u79D2",
   scheduler_apiExecutionFailed: "API \u8C03\u7528\u5931\u8D25: {error}",
+  scheduler_apiResponseTooLarge: "API \u54CD\u5E94\u8D85\u8FC7 {maxResponseBytes} \u5B57\u8282\u4E0A\u9650",
   scheduler_dbSaveFailed: "\u4FDD\u5B58\u6267\u884C\u8BB0\u5F55\u5931\u8D25: {error}",
   scheduler_dbNotInitialized: "\u6570\u636E\u5E93\u672A\u521D\u59CB\u5316\uFF0C\u65E0\u6CD5\u4FDD\u5B58\u6267\u884C\u8BB0\u5F55",
   scheduler_configError: "\u8C03\u5EA6\u5668\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF1A{error}",
   scheduler_taskIdEmpty: "\u4EFB\u52A1 ID \u4E0D\u80FD\u4E3A\u7A7A",
+  scheduler_invalidPersistedTask: "\u6301\u4E45\u5316\u4EFB\u52A1 {taskId} \u65E0\u6548\uFF1A{error}",
   scheduler_taskRunning: "\u4EFB\u52A1\u6B63\u5728\u6267\u884C\u4E2D: {taskId}",
   scheduler_invalidApiConfig: "\u4EFB\u52A1 api_config \u683C\u5F0F\u65E0\u6548: {taskId}",
   scheduler_lockAcquireFailed: "\u83B7\u53D6\u5206\u5E03\u5F0F\u9501\u5931\u8D25\uFF0C\u5176\u4ED6\u8282\u70B9\u5DF2\u83B7\u9501: {taskId}",
@@ -451,18 +464,15 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
       for (const row of rows.data) {
         const paramsResult = TaskParamsSchema.safeParse(row.params ?? {});
         if (!paramsResult.success) {
-          logger2.warn("Skipping task with invalid params", { taskId: row.taskId, error: paramsResult.error.message });
-          continue;
+          return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", { params: { taskId: row.taskId, error: paramsResult.error.message } }));
         }
         const handlerResult = row.handler == null ? { success: true, data: void 0 } : TaskHandlerConfigSchema.safeParse(row.handler);
         if (!handlerResult.success) {
-          logger2.warn("Skipping task with invalid handler config", { taskId: row.taskId, error: handlerResult.error.message });
-          continue;
+          return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", { params: { taskId: row.taskId, error: handlerResult.error.message } }));
         }
         const retryResult = row.retry == null ? { success: true, data: void 0 } : TaskRetryPolicySchema.safeParse(row.retry);
         if (!retryResult.success) {
-          logger2.warn("Skipping task with invalid retry policy", { taskId: row.taskId, error: retryResult.error.message });
-          continue;
+          return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidPersistedTask", { params: { taskId: row.taskId, error: retryResult.error.message } }));
         }
         tasks.push({
           id: row.taskId,
@@ -490,6 +500,18 @@ var SchedulerTaskRepository = class extends BaseReldbCrudRepository {
     }
   }
 };
+
+// src/scheduler-cancellation.ts
+async function waitWithSignal(operation, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const aborted = () => reject(signal.reason);
+    signal.addEventListener("abort", aborted, { once: true });
+    Promise.resolve().then(operation).then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", aborted);
+    });
+  });
+}
 var compiledHandlerCache = /* @__PURE__ */ new Map();
 function createCacheKey(config) {
   const keySource = `${config.code}:${config.timeout ?? 0}`;
@@ -504,32 +526,36 @@ function compileJsTaskHandler(config) {
   if (cachedHandler)
     return ok(cachedHandler);
   try {
-    const script = new Script(`(${config.code})`);
-    const candidate = script.runInNewContext({});
-    if (typeof candidate !== "function") {
-      return err(
-        HaiSchedulerError.JS_COMPILE_FAILED,
-        schedulerM("scheduler_jsCompileFailed", { params: { error: "Compiled result is not a function" } })
-      );
-    }
-    const handler = async (context) => {
-      const functionResult = candidate(context);
-      if (!config.timeout || config.timeout <= 0)
-        return functionResult;
+    void new Script(`(${config.code})`);
+    const handler = async (context, signal) => {
+      signal?.throwIfAborted();
       return await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-          reject(new Error(`JS task timed out after ${config.timeout}ms`));
-        }, config.timeout);
-        Promise.resolve(functionResult).then(
-          (result) => {
-            clearTimeout(timer);
-            resolve(result);
-          },
-          (error) => {
-            clearTimeout(timer);
-            reject(error);
-          }
-        );
+        const timeout = config.timeout ?? 3e4;
+        const worker = new Worker(new URL("./scheduler-js-worker.js", import.meta.url), {
+          workerData: { code: config.code, context },
+          execArgv: []
+        });
+        let settled = false;
+        let timer;
+        const aborted = () => finish(new Error(schedulerM("scheduler_closing")));
+        function finish(error, result) {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timer);
+          signal?.removeEventListener("abort", aborted);
+          void worker.terminate().then(() => error ? reject(error) : resolve(result), reject);
+        }
+        timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", { params: { timeout } }))), timeout);
+        signal?.addEventListener("abort", aborted, { once: true });
+        worker.once("error", (error) => finish(error instanceof Error ? error : new Error(String(error))));
+        worker.once("exit", (code) => finish(new Error(`JS worker exited before returning a result (${code})`)));
+        worker.once("message", (message) => {
+          if (message.success)
+            finish(void 0, message.data);
+          else
+            finish(new Error(message.message));
+        });
       });
     };
     compiledHandlerCache.set(cacheKey, handler);
@@ -584,7 +610,7 @@ async function notifyTaskStart(hooks, event) {
   if (!hooks.onTaskStart)
     return;
   try {
-    await hooks.onTaskStart(event);
+    await waitWithSignal(() => hooks.onTaskStart(event), event.signal);
   } catch (error) {
     logger3.warn("Task start hook failed", { taskId: event.task.id, error });
   }
@@ -593,7 +619,7 @@ async function notifyTaskInterrupted(hooks, event) {
   if (!hooks.onTaskInterrupted)
     return;
   try {
-    await hooks.onTaskInterrupted(event);
+    await waitWithSignal(() => hooks.onTaskInterrupted(event), event.signal);
   } catch (error) {
     logger3.warn("Task interrupted hook failed", { taskId: event.task.id, error });
   }
@@ -602,7 +628,7 @@ async function notifyTaskFinish(hooks, event) {
   if (!hooks.onTaskFinish)
     return;
   try {
-    await hooks.onTaskFinish(event);
+    await waitWithSignal(() => hooks.onTaskFinish(event), event.signal);
   } catch (error) {
     logger3.warn("Task finish hook failed", { taskId: event.task.id, error });
   }
@@ -639,10 +665,10 @@ async function saveExecutionLog(task, trigger, taskType, status, startedAt, fini
 async function saveInterruptedTaskLog(task, trigger, reason, taskType, startedAt, finishedAt) {
   return saveExecutionLog(task, trigger, taskType, "interrupted", startedAt, finishedAt, null, reason);
 }
-async function interruptTask(task, trigger, reason, hooks) {
+async function interruptTask(task, trigger, reason, hooks, signal = new AbortController().signal) {
   const startedAt = Date.now();
   const taskType = resolveTaskType(task, hooks);
-  await notifyTaskStart(hooks, { task, trigger, startedAt });
+  await notifyTaskStart(hooks, { task, trigger, startedAt, signal });
   const finishedAt = Date.now();
   const interruptedLog = await saveInterruptedTaskLog(task, trigger, reason, taskType, startedAt, finishedAt);
   await notifyTaskInterrupted(hooks, {
@@ -650,11 +676,12 @@ async function interruptTask(task, trigger, reason, hooks) {
     trigger,
     startedAt,
     interruptedAt: finishedAt,
+    signal,
     reason
   });
   return interruptedLog;
 }
-async function executeJsTask(task, context) {
+async function executeJsTask(task, context, signal = new AbortController().signal) {
   const handler = task.handler;
   if (!handler || handler.kind !== "js") {
     return err(
@@ -666,7 +693,7 @@ async function executeJsTask(task, context) {
   if (!compileResult.success)
     return compileResult;
   try {
-    const result = await compileResult.data(context);
+    const result = await compileResult.data(context, signal);
     return ok(result !== void 0 ? JSON.stringify(result) : null);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -678,7 +705,7 @@ async function executeJsTask(task, context) {
     );
   }
 }
-async function executeApiTask(task, context) {
+async function executeApiTask(task, context, signal = new AbortController().signal) {
   const handler = task.handler;
   if (!handler || handler.kind !== "api") {
     return err(
@@ -686,7 +713,9 @@ async function executeApiTask(task, context) {
       schedulerM("scheduler_invalidHandlerConfig", { params: { taskId: task.id } })
     );
   }
-  const { url, method = "GET", headers, body, timeout = 3e4 } = handler;
+  const { url, method = "GET", headers, body, timeout = 3e4, maxResponseBytes = 1024 * 1024 } = handler;
+  if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0)
+    return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_invalidHandlerConfig", { params: { taskId: task.id } }));
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeout);
   try {
@@ -696,11 +725,31 @@ async function executeApiTask(task, context) {
         ...headers,
         ...body !== void 0 ? { "Content-Type": "application/json" } : {}
       },
-      signal: controller.signal,
+      signal: AbortSignal.any([signal, controller.signal]),
       ...body !== void 0 ? { body: JSON.stringify(body) } : {}
     });
-    clearTimeout(timer);
-    const responseText = await response.text();
+    let receivedBytes = 0;
+    let responseText = "";
+    const reader = response.body?.getReader();
+    if (reader) {
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const chunk = await reader.read();
+          if (chunk.done)
+            break;
+          receivedBytes += chunk.value.byteLength;
+          if (receivedBytes > maxResponseBytes) {
+            controller.abort();
+            return err(HaiSchedulerError.API_EXECUTION_FAILED, schedulerM("scheduler_apiResponseTooLarge", { params: { maxResponseBytes } }));
+          }
+          responseText += decoder.decode(chunk.value, { stream: true });
+        }
+        responseText += decoder.decode();
+      } finally {
+        reader.releaseLock();
+      }
+    }
     if (!response.ok) {
       logger3.error("API task returned non-OK status", {
         taskId: context.taskId,
@@ -716,7 +765,6 @@ async function executeApiTask(task, context) {
     }
     return ok(responseText || null);
   } catch (error) {
-    clearTimeout(timer);
     const message = error instanceof Error ? error.message : String(error);
     logger3.error("API task execution failed", { taskId: context.taskId, error: message, url: sanitizeUrl(url) });
     return err(
@@ -724,9 +772,11 @@ async function executeApiTask(task, context) {
       schedulerM("scheduler_apiExecutionFailed", { params: { error: message } }),
       error
     );
+  } finally {
+    clearTimeout(timer);
   }
 }
-async function executeHookTask(task, context, hooks, startedAt) {
+async function executeHookTask(task, context, hooks, startedAt, signal) {
   if (!hooks.onTaskExecute) {
     return err(
       HaiSchedulerError.EXECUTION_FAILED,
@@ -737,10 +787,11 @@ async function executeHookTask(task, context, hooks, startedAt) {
     task,
     trigger: context.trigger,
     startedAt,
-    context
+    context,
+    signal
   };
   try {
-    const result = await hooks.onTaskExecute(executeEvent);
+    const result = await waitWithSignal(() => hooks.onTaskExecute(executeEvent), signal);
     return ok(result !== void 0 ? JSON.stringify(result) : null);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -752,21 +803,25 @@ async function executeHookTask(task, context, hooks, startedAt) {
     );
   }
 }
-async function executeTask(task, trigger, hooks) {
+async function executeTask(task, trigger, hooks, signal = new AbortController().signal) {
   const startedAt = Date.now();
   const taskType = resolveTaskType(task, hooks);
   const context = createTaskContext(task, trigger);
-  await notifyTaskStart(hooks, { task, trigger, startedAt });
+  await notifyTaskStart(hooks, { task, trigger, startedAt, signal });
   let executionResult;
   let shouldNotifyInterrupted = false;
-  if (!task.handler) {
-    executionResult = await executeHookTask(task, context, hooks, startedAt);
+  if (signal.aborted) {
+    executionResult = err(HaiSchedulerError.EXECUTION_FAILED, schedulerM("scheduler_closing"));
+    shouldNotifyInterrupted = true;
+  } else if (!task.handler) {
+    executionResult = await executeHookTask(task, context, hooks, startedAt, signal);
     shouldNotifyInterrupted = !executionResult.success;
   } else if (task.handler.kind === "api") {
-    executionResult = await executeApiTask(task, context);
+    executionResult = await executeApiTask(task, context, signal);
   } else {
-    executionResult = await executeJsTask(task, context);
+    executionResult = await executeJsTask(task, context, signal);
   }
+  shouldNotifyInterrupted ||= signal.aborted;
   const finishedAt = Date.now();
   const status = executionResult.success ? "success" : shouldNotifyInterrupted ? "interrupted" : "failed";
   const log = await saveExecutionLog(
@@ -785,11 +840,12 @@ async function executeTask(task, trigger, hooks) {
       trigger,
       startedAt,
       interruptedAt: finishedAt,
+      signal,
       reason: executionResult.error.message
     });
   }
   if (status !== "interrupted")
-    await notifyTaskFinish(hooks, { task, trigger, startedAt, finishedAt, log });
+    await notifyTaskFinish(hooks, { task, trigger, startedAt, finishedAt, log, signal });
   return log;
 }
 function parseCronExpression(expression, timezone) {
@@ -808,6 +864,8 @@ function parseCronExpression(expression, timezone) {
 var logger4 = core.logger.child({ module: "scheduler", scope: "functions" });
 var taskRegistry = /* @__PURE__ */ new Map();
 var cronCache = /* @__PURE__ */ new Map();
+var persistedTaskIds = /* @__PURE__ */ new Set();
+var definitionEpoch = 0;
 var currentHooks = {};
 function getTaskRegistry() {
   return taskRegistry;
@@ -819,9 +877,11 @@ function hasTask(taskId) {
   return taskRegistry.has(taskId);
 }
 function setTask(taskId, task) {
+  definitionEpoch++;
   taskRegistry.set(taskId, task);
 }
 function deleteTask(taskId) {
+  definitionEpoch++;
   taskRegistry.delete(taskId);
 }
 function getCron(taskId) {
@@ -843,6 +903,8 @@ function getHooks() {
   return currentHooks;
 }
 function resetTaskState() {
+  definitionEpoch++;
+  persistedTaskIds.clear();
   taskRegistry.clear();
   cronCache.clear();
   currentHooks = {};
@@ -876,46 +938,45 @@ function validateRetryPolicy(taskId, retry) {
 }
 async function loadPersistedTasks(taskRepo2) {
   if (!taskRepo2)
-    return;
+    return ok(void 0);
+  const epoch = definitionEpoch;
   const loadResult = await taskRepo2.loadTasks();
-  if (!loadResult.success) {
-    logger4.warn("Failed to load persisted tasks", { error: loadResult.error.message });
-    return;
-  }
-  let loadedCount = 0;
+  if (!loadResult.success)
+    return loadResult;
+  if (epoch !== definitionEpoch)
+    return err(HaiSchedulerError.EXECUTION_FAILED, schedulerM("scheduler_definitionsChanged"));
+  const nextTasks = new Map([...taskRegistry].filter(([id]) => !persistedTaskIds.has(id)));
+  const nextCrons = new Map([...cronCache].filter(([id]) => !persistedTaskIds.has(id)));
   for (const task of loadResult.data) {
-    const registerResult = await registerTask(task);
-    if (registerResult.success) {
-      loadedCount++;
-      logger4.debug("Loaded persisted task", { taskId: task.id, taskName: task.name });
-      continue;
-    }
-    logger4.warn("Failed to load persisted task", { taskId: task.id, error: registerResult.error.message });
+    if (!task.id)
+      return err(HaiSchedulerError.CONFIG_ERROR, schedulerM("scheduler_taskIdEmpty"));
+    if (nextTasks.has(task.id))
+      return err(HaiSchedulerError.TASK_ALREADY_EXISTS, schedulerM("scheduler_taskAlreadyExists", { params: { taskId: task.id } }));
+    const cronResult = parseCronExpression(task.cron, task.timezone);
+    if (!cronResult.success)
+      return cronResult;
+    nextTasks.set(task.id, task);
+    nextCrons.set(task.id, cronResult.data);
   }
-  if (loadedCount > 0)
-    logger4.info("Loaded persisted tasks", { count: loadedCount });
+  definitionEpoch++;
+  taskRegistry.clear();
+  cronCache.clear();
+  persistedTaskIds.clear();
+  for (const [id, task] of nextTasks)
+    taskRegistry.set(id, task);
+  for (const [id, cron] of nextCrons)
+    cronCache.set(id, cron);
+  for (const task of loadResult.data)
+    persistedTaskIds.add(task.id);
+  return ok(void 0);
 }
 async function loadConfigTasks(tasks) {
-  let loadedCount = 0;
   for (const task of tasks) {
-    if (!task.id) {
-      logger4.warn("Skipping config task with empty id");
-      continue;
-    }
-    if (hasTask(task.id)) {
-      logger4.debug("Skipping config task, already registered from DB", { taskId: task.id });
-      continue;
-    }
     const registerResult = await registerTask(task);
-    if (registerResult.success) {
-      loadedCount++;
-      logger4.debug("Loaded config task", { taskId: task.id, taskName: task.name });
-      continue;
-    }
-    logger4.warn("Failed to load config task", { taskId: task.id, error: registerResult.error.message });
+    if (!registerResult.success)
+      return registerResult;
   }
-  if (loadedCount > 0)
-    logger4.info("Loaded config tasks", { count: loadedCount });
+  return ok(void 0);
 }
 async function registerTask(task, taskRepo2) {
   if (!task.id) {
@@ -959,6 +1020,7 @@ async function registerTask(task, taskRepo2) {
         saveResult.error
       );
     }
+    persistedTaskIds.add(task.id);
   }
   return ok(void 0);
 }
@@ -1058,7 +1120,9 @@ async function queryTaskLogs(logRepo2, options) {
 }
 var logger5 = core.logger.child({ module: "scheduler", scope: "runner" });
 var runningTasks = /* @__PURE__ */ new Set();
+var activeRuns = /* @__PURE__ */ new Map();
 var tickTimer = null;
+var tickInProgress = false;
 var lastTickMinute = -1;
 var currentNodeId = "";
 var currentLockTtlSec = 300;
@@ -1087,10 +1151,25 @@ function resetRunner() {
   currentLockTtlSec = 300;
   currentTaskRepo = null;
 }
-async function sleep(ms) {
-  if (ms <= 0)
+async function sleep(ms, signal) {
+  if (ms <= 0 || signal.aborted)
     return;
-  await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise((resolve) => {
+    let timer;
+    const finish = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", finish, { once: true });
+  });
+}
+async function drainRunner() {
+  stopTimer();
+  for (const controller of activeRuns.values())
+    controller.abort(new Error(schedulerM("scheduler_closing")));
+  await Promise.allSettled([...activeRuns.keys()]);
 }
 function resolveRetryBackoffMs(task, attempt) {
   const backoff = task.retry?.backoffMs;
@@ -1099,7 +1178,24 @@ function resolveRetryBackoffMs(task, attempt) {
   const index = Math.min(Math.max(attempt - 2, 0), backoff.length - 1);
   return backoff[index] ?? 0;
 }
-function tick() {
+async function tick() {
+  if (tickInProgress)
+    return;
+  tickInProgress = true;
+  try {
+    const refreshed = await loadPersistedTasks(currentTaskRepo);
+    if (!refreshed.success) {
+      logger5.warn("Task definition refresh failed; skipping scheduling", { error: refreshed.error.message });
+      return;
+    }
+    if (!tickTimer)
+      return;
+    scheduleDueTasks();
+  } finally {
+    tickInProgress = false;
+  }
+}
+function scheduleDueTasks() {
   const now = /* @__PURE__ */ new Date();
   const currentMinute = Math.floor(now.getTime() / 6e4);
   if (currentMinute === lastTickMinute)
@@ -1109,7 +1205,7 @@ function tick() {
     if (task.enabled === false)
       continue;
     const cron = getCron(taskId);
-    if (!cron || !cron.match(now))
+    if (!cron || !cron.match(new Date(currentMinute * 6e4)))
       continue;
     if (runningTasks.has(taskId)) {
       logger5.debug("Skipping task already running", { taskId, taskName: task.name });
@@ -1120,17 +1216,30 @@ function tick() {
     });
   }
 }
-async function runTask(task, minuteTimestamp, trigger = { type: "manual", source: null }) {
+function runTask(task, minuteTimestamp, trigger = { type: "manual", source: null }) {
+  const controller = new AbortController();
+  const run = runTaskExecution(task, minuteTimestamp, trigger, controller.signal);
+  activeRuns.set(run, controller);
+  void run.finally(() => activeRuns.delete(run)).catch(() => {
+  });
+  return run;
+}
+async function runTaskExecution(task, minuteTimestamp, trigger, signal) {
+  const hooks = getHooks();
+  const repository = currentTaskRepo;
   const lockKey = minuteTimestamp !== void 0 ? `hai:scheduler:${task.id}:${minuteTimestamp}` : void 0;
   if (cache.isInitialized && lockKey) {
-    const lockResult = await cache.lock.acquire(lockKey, { ttl: currentLockTtlSec, owner: currentNodeId });
+    const lockResult = await waitWithSignal(() => cache.lock.acquire(lockKey, { ttl: currentLockTtlSec, owner: currentNodeId }), signal).catch(() => null);
+    if (!lockResult)
+      return interruptTask(task, trigger, schedulerM("scheduler_closing"), {}, signal);
     if (!lockResult.success) {
       logger5.warn("Failed to acquire distributed lock, interrupting task", { taskId: task.id, error: lockResult.error.message });
       return interruptTask(
         task,
         trigger,
         schedulerM("scheduler_lockAcquireFailed", { params: { taskId: task.id } }),
-        getHooks()
+        hooks,
+        signal
       );
     }
     if (!lockResult.data) {
@@ -1139,7 +1248,8 @@ async function runTask(task, minuteTimestamp, trigger = { type: "manual", source
         task,
         trigger,
         schedulerM("scheduler_lockAcquireFailed", { params: { taskId: task.id } }),
-        getHooks()
+        hooks,
+        signal
       );
     }
   }
@@ -1148,7 +1258,8 @@ async function runTask(task, minuteTimestamp, trigger = { type: "manual", source
       task,
       trigger,
       schedulerM("scheduler_taskRunning", { params: { taskId: task.id } }),
-      getHooks()
+      hooks,
+      signal
     );
   }
   runningTasks.add(task.id);
@@ -1156,7 +1267,23 @@ async function runTask(task, minuteTimestamp, trigger = { type: "manual", source
     const maxAttempts = Math.max(1, task.retry?.maxAttempts ?? 1);
     let log = null;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      log = await executeTask(task, trigger, getHooks());
+      if (signal.aborted) {
+        log = await interruptTask(task, trigger, schedulerM("scheduler_closing"), {}, signal);
+        break;
+      }
+      const refreshed = await loadPersistedTasks(repository);
+      if (!refreshed.success) {
+        log = await interruptTask(task, trigger, refreshed.error.message, hooks, signal);
+        break;
+      }
+      const latest = getTask(task.id);
+      const stillDue = minuteTimestamp === void 0 || getCron(task.id)?.match(new Date(minuteTimestamp * 6e4));
+      if (!latest || latest.enabled === false || !stillDue) {
+        log = await interruptTask(task, trigger, schedulerM("scheduler_taskNoLongerDue", { params: { taskId: task.id } }), hooks, signal);
+        break;
+      }
+      task = latest;
+      log = await executeTask(task, trigger, hooks, signal);
       if (log.status !== "failed")
         break;
       if (attempt >= maxAttempts)
@@ -1168,14 +1295,15 @@ async function runTask(task, minuteTimestamp, trigger = { type: "manual", source
         maxAttempts,
         backoffMs
       });
-      await sleep(backoffMs);
+      await sleep(backoffMs, signal);
     }
     if (!log) {
       return interruptTask(
         task,
         trigger,
         schedulerM("scheduler_executionFailed", { params: { error: "Task execution produced no log" } }),
-        getHooks()
+        hooks,
+        signal
       );
     }
     if (log.status === "failed")
@@ -1184,8 +1312,8 @@ async function runTask(task, minuteTimestamp, trigger = { type: "manual", source
       logger5.debug("Task execution interrupted", { taskId: task.id, error: log.error });
     else
       logger5.debug("Task execution succeeded", { taskId: task.id, duration: log.duration });
-    if (task.deleteAfterRun === true) {
-      const unregisterResult = await unregisterTask(task.id, currentTaskRepo);
+    if (task.deleteAfterRun === true && !signal.aborted && log.status !== "interrupted") {
+      const unregisterResult = await unregisterTask(task.id, repository);
       if (!unregisterResult.success) {
         logger5.warn("Failed to auto-delete one-time task after run", {
           taskId: task.id,
@@ -1215,6 +1343,7 @@ function stopTimer() {
 var logger6 = core.logger.child({ module: "scheduler", scope: "main" });
 var currentConfig = null;
 var initInProgress = false;
+var closeInProgress = null;
 var taskRepo = null;
 var logRepo = null;
 var notInitialized = core.module.createNotInitializedKit(
@@ -1261,6 +1390,8 @@ var scheduler = {
     }
     initInProgress = true;
     try {
+      if (closeInProgress)
+        await closeInProgress;
       if (currentConfig) {
         logger6.warn("Scheduler module is already initialized, reinitializing");
         await scheduler.close();
@@ -1279,9 +1410,16 @@ var scheduler = {
       try {
         currentConfig = await initDatabase(parseResult.data);
         setHooks(hooks);
-        await loadPersistedTasks(taskRepo);
-        if (tasks.length > 0)
-          await loadConfigTasks(tasks);
+        const persistedResult = await loadPersistedTasks(taskRepo);
+        if (!persistedResult.success) {
+          await scheduler.close();
+          return persistedResult;
+        }
+        const configResult = await loadConfigTasks(tasks);
+        if (!configResult.success) {
+          await scheduler.close();
+          return configResult;
+        }
         logger6.info("Scheduler module initialized", { enableDb: currentConfig.enableDb, taskCount: getTaskRegistry().size });
         return ok(void 0);
       } catch (error) {
@@ -1302,6 +1440,12 @@ var scheduler = {
   async register(task) {
     if (!currentConfig)
       return notInitialized.result();
+    const config = currentConfig;
+    const refreshed = await loadPersistedTasks(taskRepo);
+    if (!refreshed.success)
+      return refreshed;
+    if (currentConfig !== config)
+      return notInitialized.result();
     const registerResult = await registerTask(task, taskRepo);
     if (registerResult.success) {
       logger6.info("Task registered", { taskId: task.id, taskName: task.name, cron: task.cron });
@@ -1311,6 +1455,12 @@ var scheduler = {
   async unregister(taskId) {
     if (!currentConfig)
       return notInitialized.result();
+    const config = currentConfig;
+    const refreshed = await loadPersistedTasks(taskRepo);
+    if (!refreshed.success)
+      return refreshed;
+    if (currentConfig !== config)
+      return notInitialized.result();
     const unregisterResult = await unregisterTask(taskId, taskRepo);
     if (unregisterResult.success)
       logger6.info("Task unregistered", { taskId });
@@ -1319,6 +1469,12 @@ var scheduler = {
   async updateTask(taskId, updates) {
     if (!currentConfig)
       return notInitialized.result();
+    const config = currentConfig;
+    const refreshed = await loadPersistedTasks(taskRepo);
+    if (!refreshed.success)
+      return refreshed;
+    if (currentConfig !== config)
+      return notInitialized.result();
     const updateResult = await updateRegisteredTask(taskId, updates, taskRepo);
     if (updateResult.success)
       logger6.info("Task updated", { taskId, updates: Object.keys(updates) });
@@ -1353,6 +1509,12 @@ var scheduler = {
   async trigger(taskId, options) {
     if (!currentConfig)
       return notInitialized.result();
+    const config = currentConfig;
+    const refreshed = await loadPersistedTasks(taskRepo);
+    if (!refreshed.success)
+      return refreshed;
+    if (currentConfig !== config)
+      return notInitialized.result();
     const task = getTask(taskId);
     if (!task) {
       return err(
@@ -1402,21 +1564,27 @@ var scheduler = {
     return isTimerRunning();
   },
   async close() {
-    if (!currentConfig) {
-      logger6.info("Scheduler module already closed, skipping");
-      return;
-    }
+    if (closeInProgress)
+      return closeInProgress;
     logger6.info("Closing scheduler module");
-    stopTimer();
-    clearJsTaskHandlerCache();
-    resetTaskState();
-    resetRunner();
-    setLogRepository(null);
-    setTaskRepository(null);
     currentConfig = null;
-    taskRepo = null;
-    logRepo = null;
-    logger6.info("Scheduler module closed");
+    stopTimer();
+    closeInProgress = (async () => {
+      await drainRunner();
+      clearJsTaskHandlerCache();
+      resetTaskState();
+      resetRunner();
+      setLogRepository(null);
+      setTaskRepository(null);
+      taskRepo = null;
+      logRepo = null;
+      logger6.info("Scheduler module closed");
+    })();
+    try {
+      await closeInProgress;
+    } finally {
+      closeInProgress = null;
+    }
   }
 };