@goodandready/dsh-cron 0.3.24 → 0.3.26

package/lib/scheduler/scheduler.js

@@ -0,0 +1,751 @@
+import { logger } from '../logger.js';
+import { bestEffort } from '../best-effort.js';
+import { Cron } from 'croner';
+import { FileSystemWatcherManager } from '../watcher.js';
+import { parseNaturalSchedule } from '../nl-schedule.js';
+
+const MAX_TIMEOUT_MS = 2147483647; // 2^31 - 1 ms (~24.85 days)
+import {
+  AGENT_TASK_TYPES,
+  addUsage,
+  executePreflight,
+  shouldUseFallback,
+  executeOnce,
+  executeWithFallback,
+  beginRun,
+  executeTask,
+  inspectFailureRun,
+  applySilentRuleToRun,
+  applyModelAssists,
+  deliverNotifications,
+  finishRun,
+  handleCompleteRun,
+} from './scheduler-execution.js';
+import {
+  startHeartbeatWatcher,
+  stopHeartbeatWatcher,
+  checkHeartbeats,
+  pauseTask,
+  removeTask,
+  resumeTask,
+  toggleTask,
+} from './scheduler-lifecycle.js';
+
+export {
+  parseNaturalSchedule,
+  executePreflight,
+  AGENT_TASK_TYPES,
+  addUsage,
+  shouldUseFallback,
+  executeOnce,
+  executeWithFallback,
+  beginRun,
+  executeTask,
+  inspectFailureRun,
+  applySilentRuleToRun,
+  applyModelAssists,
+  deliverNotifications,
+  finishRun,
+  handleCompleteRun,
+  startHeartbeatWatcher,
+  stopHeartbeatWatcher,
+  checkHeartbeats,
+  pauseTask,
+  removeTask,
+  resumeTask,
+  toggleTask,
+  FileSystemWatcherManager,
+};
+
+function pad(v) {
+  return String(v).padStart(2, '0');
+}
+
+export function describeCron(cronPattern) {
+  const parts = cronPattern.trim().split(/\s+/);
+  if (parts.length === 5) {
+    const [m, h, dom, mon, dow] = parts;
+    if (m.startsWith('*/')) return `Every ${m.slice(2)} minutes`;
+    if (dow === '1-5' && dom === '*' && mon === '*') {
+      return `Weekdays at ${pad(h)}:${pad(m)}`;
+    }
+    if (dow === '*' && dom === '*' && mon === '*') {
+      return `Every day at ${pad(h)}:${pad(m)}`;
+    }
+    if (dow === '5' && dom === '*' && mon === '*') {
+      return `Fridays at ${pad(h)}:${pad(m)}`;
+    }
+  }
+  return cronPattern;
+}
+
+/** One-shot from an ISO timestamp or an explicit "at:" prefix, else null. */
+function parseAtExpression(str) {
+  const atPrefixMatch = str.match(/^(?:at:\s*|at\s+)(.+)$/i);
+  const candidateIso = atPrefixMatch ? atPrefixMatch[1].trim() : str;
+  const parsedDate = new Date(candidateIso);
+  if (isNaN(parsedDate.getTime()) || !(candidateIso.includes('-') || candidateIso.includes('T') || atPrefixMatch)) {
+    return null;
+  }
+  const targetMs = parsedDate.getTime();
+  return {
+    cronPattern: null,
+    isOneShot: true,
+    targetTimestamp: targetMs,
+    humanText: `One-shot at ${parsedDate.toISOString()}`,
+    nextRun: targetMs
+  };
+}
+
+/**
+ * Relative one-shot: "in 20m", "in 2h", "in 30s", "in 1d" and the accepted
+ * Russian input aliases ("через 15 минут").
+ */
+function parseRelativeOneShot(str) {
+  const match = str.match(/^(?:in\s+|через\s+)(\d+)\s*(s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|days?|мин|минут|часа?|часов)?$/i);
+  if (!match) return null;
+  const num = parseInt(match[1], 10);
+  const unit = (match[2] || 'm').toLowerCase();
+  let delayMs = num * 60 * 1000;
+  let unitText = `${num} min`;
+  if (unit.startsWith('s')) {
+    delayMs = num * 1000;
+    unitText = `${num} sec`;
+  } else if (unit.startsWith('h') || unit.startsWith('час')) {
+    delayMs = num * 3600 * 1000;
+    unitText = `${num} h`;
+  } else if (unit.startsWith('d')) {
+    delayMs = num * 86400 * 1000;
+    unitText = `${num} d`;
+  }
+  const targetMs = Date.now() + delayMs;
+  return {
+    cronPattern: null,
+    isOneShot: true,
+    targetTimestamp: targetMs,
+    humanText: `One-shot in ${unitText} (at ${new Date(targetMs).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })})`,
+    nextRun: targetMs
+  };
+}
+
+/** Repeating interval: "every 5m", "every 2h", "every 1d". */
+function parseIntervalExpression(str) {
+  const match = str.match(/^every\s+(\d+)\s*(m|min|minute|minutes|h|hr|hour|hours|d|day|days)?$/i);
+  if (!match) return null;
+  const num = parseInt(match[1], 10);
+  const unit = (match[2] || 'm').toLowerCase();
+  let pattern = null;
+  let humanText = null;
+
+  if (unit.startsWith('m')) {
+    if (num < 1) {
+      throw new Error('Invalid interval: minute interval must be at least 1 minute');
+    }
+    if (num >= 60) {
+      if (num % 60 === 0) {
+        const hours = num / 60;
+        if (hours >= 24) {
+          if (hours % 24 === 0) {
+            const days = hours / 24;
+            if (days > 31) {
+              throw new Error(`Invalid interval: minute interval "${num}m" (${days} days) exceeds 31 days`);
+            }
+            pattern = `0 0 */${days} * *`;
+            humanText = `Every ${days} days`;
+          } else {
+            throw new Error(`Invalid interval: minute interval "${num}m" (${hours} hours) cannot be expressed as a cron step`);
+          }
+        } else {
+          pattern = `0 */${hours} * * *`;
+          humanText = `Every ${hours} hours`;
+        }
+      } else {
+        throw new Error(`Invalid interval: minute interval "${num}m" exceeds 59 minutes and is not a multiple of 60. Use hours (e.g. every 2h) or a multiple of 60m`);
+      }
+    } else {
+      pattern = `*/${num} * * * *`;
+      humanText = `Every ${num} minutes`;
+    }
+  } else if (unit.startsWith('h')) {
+    if (num < 1) {
+      throw new Error('Invalid interval: hour interval must be at least 1 hour');
+    }
+    if (num >= 24) {
+      if (num % 24 === 0) {
+        const days = num / 24;
+        if (days > 31) {
+          throw new Error(`Invalid interval: hour interval "${num}h" (${days} days) exceeds 31 days`);
+        }
+        pattern = `0 0 */${days} * *`;
+        humanText = `Every ${days} days`;
+      } else {
+        throw new Error(`Invalid interval: hour interval "${num}h" exceeds 23 hours and is not a multiple of 24. Use days (e.g. every 2d) or a multiple of 24h`);
+      }
+    } else {
+      pattern = `0 */${num} * * *`;
+      humanText = `Every ${num} hours`;
+    }
+  } else if (unit.startsWith('d')) {
+    if (num < 1 || num > 31) {
+      throw new Error(`Invalid interval: day interval "${num}d" must be between 1 and 31 days`);
+    }
+    pattern = `0 0 */${num} * *`;
+    humanText = `Every ${num} days`;
+  }
+
+  if (pattern) {
+    try {
+      const testJob = new Cron(pattern, { sloppyRanges: true });
+      const next = testJob.nextRun();
+      return {
+        cronPattern: pattern,
+        humanText,
+        isInterval: true,
+        nextRun: next ? next.getTime() : null,
+      };
+    } catch (err) {
+      throw new Error(`Invalid interval pattern "${pattern}": ${err.message}`);
+    }
+  }
+  return null;
+}
+
+/**
+ * @-shorthands (#15) and the friendly aliases, including the Russian input
+ * aliases. Russian keywords are accepted input, not display strings.
+ */
+function makeAliasResult(cronPattern, humanText) {
+  try {
+    const job = new Cron(cronPattern, { sloppyRanges: true });
+    const next = job.nextRun();
+    return { cronPattern, humanText, nextRun: next ? next.getTime() : null };
+  } catch {
+    return { cronPattern, humanText };
+  }
+}
+
+function parseAliasExpression(str) {
+  const lower = str.toLowerCase();
+  if (lower === '@hourly') return makeAliasResult('0 * * * *', 'Every hour');
+  if (lower === '@daily' || lower === '@midnight') return makeAliasResult('0 0 * * *', 'Every day at 00:00');
+  if (lower === '@weekly') return makeAliasResult('0 0 * * 0', 'Every week on Sunday at 00:00');
+  if (lower === '@monthly') return makeAliasResult('0 0 1 * *', 'Every month on the 1st at 00:00');
+  if (lower === '@yearly' || lower === '@annually') return makeAliasResult('0 0 1 1 *', 'Every year on Jan 1 at 00:00');
+  const everyAlias = str.match(/^@every\s+(\d+)\s*(sec|seconds?|m|min|minutes?|h|hr|hours?|d|days?)$/i);
+  if (everyAlias) {
+    return parseIntervalExpression(`every ${everyAlias[1]} ${everyAlias[2]}`);
+  }
+  if (lower === 'daily' || lower === 'каждый день') {
+    return makeAliasResult('0 9 * * *', 'Every day at 09:00');
+  }
+  if (lower === 'weekdays' || lower === 'в будние дни' || lower === 'по будням') {
+    return makeAliasResult('0 9 * * 1-5', 'Weekdays at 09:00');
+  }
+  if (lower === 'hourly' || lower === 'каждый час') {
+    return makeAliasResult('0 * * * *', 'Every hour');
+  }
+  return null;
+}
+
+/** Validate a 5-field cron expression; the only branch that throws. */
+function parseCronExpression(str) {
+  try {
+    const testJob = new Cron(str, { sloppyRanges: true });
+    const next = testJob.nextRun();
+    return {
+      cronPattern: str,
+      humanText: describeCron(str),
+      nextRun: next ? next.getTime() : null,
+    };
+  } catch (err) {
+    throw new Error('Invalid cron schedule: ' + err.message);
+  }
+}
+
+/**
+ * Turn a typed schedule into a cron pattern or a one-shot target.
+ */
+export function parseScheduleExpression(input) {
+  const str = String(input || '').trim();
+  if (!str) throw new Error('Schedule expression must not be empty');
+
+  return parseAtExpression(str)
+    || parseRelativeOneShot(str)
+    || parseIntervalExpression(str)
+    || parseAliasExpression(str)
+    || parseNaturalSchedule(str)
+    || parseCronExpression(str);
+}
+
+/**
+ * Preview future execution timestamps for a cron or interval schedule.
+ */
+export function previewSchedule(scheduleStr, options = {}) {
+  const str = String(scheduleStr || '').trim();
+  if (!str) throw new Error('Schedule expression must not be empty');
+  const parsed = parseScheduleExpression(str);
+  const count = Math.min(Math.max(Number(options.count) || 5, 1), 10);
+  const timezone = options.timezone || undefined;
+
+  if (parsed.isOneShot) {
+    return {
+      isOneShot: true,
+      humanText: parsed.humanText,
+      runs: [new Date(parsed.nextRun).toISOString()],
+    };
+  }
+
+  const job = new Cron(parsed.cronPattern, {
+    timezone,
+    sloppyRanges: true,
+  });
+  const runs = [];
+  let current = new Date();
+  for (let i = 0; i < count; i++) {
+    const next = job.nextRun(current);
+    if (!next) break;
+    runs.push(next.toISOString());
+    current = new Date(next.getTime() + 1000);
+  }
+  return {
+    isOneShot: false,
+    cronPattern: parsed.cronPattern,
+    humanText: describeCron(parsed.cronPattern),
+    runs,
+  };
+}
+
+export class TaskScheduler {
+  constructor(store, executeFn, options = {}) {
+    const opts = (typeof executeFn === 'object' && executeFn !== null && typeof executeFn !== 'function') ? executeFn : (options || {});
+    this.store = store;
+    this.executeFn = typeof executeFn === 'function' ? executeFn : (opts.executeFn || null);
+    this.maxConcurrent = opts.maxConcurrent !== undefined && Number(opts.maxConcurrent) >= 0 ? Number(opts.maxConcurrent) : 2;
+    this.defaultTimezone = opts.defaultTimezone || '';
+    this.resolveSecrets = typeof opts.resolveSecrets === 'function' ? opts.resolveSecrets : null;
+    this.deliver = typeof opts.deliver === 'function' ? opts.deliver : null;
+    this.askModel = typeof opts.askModel === 'function' ? opts.askModel : null;
+    this.inspectTimeoutMs = opts.inspectTimeoutMs;
+    this.silentRuleTimeoutMs = opts.silentRuleTimeoutMs;
+    this.jobs = new Map();
+    this.timers = new Map();
+    this.retryTimers = new Map();
+    this.adaptiveTimers = new Map();
+    this.running = new Map();
+    this.runCounters = {};
+    this.queue = [];
+    this.groupLimits = opts.groupLimits instanceof Map ? opts.groupLimits : new Map(Object.entries(opts.groupLimits || {}));
+    this.heartbeatTimer = null;
+    this.watcherManager = new FileSystemWatcherManager(this);
+    this.logger = opts.logger || null;
+    this.isStopped = false;
+    this.generation = 0;
+  }
+
+  isRunning(taskId) {
+    return this.running.has(taskId);
+  }
+
+  runningCount() {
+    return this.running.size;
+  }
+
+  runningSince(taskId) {
+    const r = this.running.get(taskId);
+    return r ? r.startedAt : null;
+  }
+
+  clearRetryTimer(taskId) {
+    const t = this.retryTimers.get(taskId);
+    if (t) {
+      clearTimeout(t);
+      this.retryTimers.delete(taskId);
+    }
+  }
+
+  clearAdaptiveTimer(taskId) {
+    const t = this.adaptiveTimers.get(taskId);
+    if (t) {
+      clearTimeout(t);
+      this.adaptiveTimers.delete(taskId);
+    }
+  }
+
+  armAdaptiveTimer(taskId, delayMs) {
+    this.clearAdaptiveTimer(taskId);
+    if (this.jobs.has(taskId)) {
+      this.jobs.get(taskId).stop();
+      this.jobs.delete(taskId);
+    }
+    const task = this.store.get(taskId);
+    if (task) {
+      task.nextRunAt = Date.now() + delayMs;
+      this.store.set(task);
+    }
+    const timer = setTimeout(() => {
+      this.adaptiveTimers.delete(taskId);
+      if (!this.isStopped) {
+        this.runTask(taskId, { isAdaptive: true }).catch((err) => {
+          logger.error(`[dsh-cron] adaptive run of task ${taskId} failed:`, (err && err.message) || err);
+        });
+      }
+    }, delayMs);
+    if (timer.unref) timer.unref();
+    this.adaptiveTimers.set(taskId, timer);
+  }
+
+  startHeartbeatWatcher(intervalMs = 30000) {
+    return startHeartbeatWatcher(this, intervalMs);
+  }
+
+  stopHeartbeatWatcher() {
+    return stopHeartbeatWatcher(this);
+  }
+
+  checkHeartbeats() {
+    return checkHeartbeats(this);
+  }
+
+  start() {
+    this.isStopped = false;
+    this.generation = (this.generation || 0) + 1;
+
+    // Recovery & cleanup on restart (#317, #321)
+    if (this.store && this.store.durableJournal) {
+      try {
+        const recovered = this.store.durableJournal.recoverPendingRuns(this);
+        if (recovered.uncertain.length > 0) {
+          logger.warn(`[dsh-cron] Recovered ${recovered.uncertain.length} in-flight run(s) interrupted by restart -> status marked uncertain`);
+        }
+      } catch (recErr) {
+        logger.error('[dsh-cron] restart recovery failed:', recErr.message);
+      }
+    }
+    if (this.store && this.store.artifactManager) {
+      try {
+        this.store.artifactManager.cleanupArtifacts(this.store);
+      } catch (cleanErr) {
+        logger.warn('[dsh-cron] artifact cleanup failed:', cleanErr.message);
+      }
+    }
+
+    const tasks = this.store.list();
+    const now = Date.now();
+    for (const task of tasks) {
+      if (task.status !== 'active') continue;
+      const missed = task.nextRunAt && (now - task.nextRunAt) > 5 * 60 * 1000;
+      if (missed) {
+        const missedAt = task.nextRunAt;
+        const policy = task.misfirePolicy || 'skip';
+        logger.warn(`[dsh-cron] Task "${task.title}" (${task.id}) missed scheduled run at ${new Date(missedAt).toISOString()} (misfire: ${policy})`);
+        this.countRun('missed');
+        this.store.recordRun(task.id, {
+          at: missedAt,
+          status: 'missed',
+          durationMs: 0,
+          output: `Skipped: the service was offline or restarting at the scheduled time (${new Date(missedAt).toISOString()})`,
+          error: null,
+          usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+          costUsd: 0,
+        });
+        if (policy === 'skip') {
+          if (task.oneShot) {
+            task.status = 'completed';
+            this.store.set(task);
+            continue;
+          }
+          this.scheduleTask(task);
+          continue;
+        }
+        this.scheduleTask(task);
+        setImmediate(() => this.runTask(task.id));
+        continue;
+      }
+      this.scheduleTask(task);
+    }
+    this.startHeartbeatWatcher();
+    if (this.watcherManager) {
+      this.watcherManager.syncAll(tasks);
+    }
+  }
+
+  stopAll() {
+    this.isStopped = true;
+    this.generation = (this.generation || 0) + 1;
+    this.stopHeartbeatWatcher();
+    if (this.watcherManager) {
+      this.watcherManager.stopAll();
+    }
+
+    // Clear concurrency queue (#217)
+    this.queue = [];
+
+    for (const [, job] of this.jobs.entries()) {
+      bestEffort('stop-job', () => job.stop(), this.logger);
+    }
+    this.jobs.clear();
+
+    for (const [, timer] of this.timers.entries()) {
+      bestEffort('clear-timer', () => clearTimeout(timer), this.logger);
+    }
+    this.timers.clear();
+
+    for (const [, timer] of this.retryTimers.entries()) {
+      bestEffort('clear-retry-timer', () => clearTimeout(timer), this.logger);
+    }
+    this.retryTimers.clear();
+
+    for (const [, timer] of this.adaptiveTimers.entries()) {
+      bestEffort('clear-adaptive-timer', () => clearTimeout(timer), this.logger);
+    }
+    this.adaptiveTimers.clear();
+
+    for (const [, run] of this.running.entries()) {
+      bestEffort('abort-running', () => run.controller.abort(new Error('Scheduler stopped')), this.logger);
+    }
+    this.running.clear();
+
+    if (this.store && typeof this.store.flushSync === 'function') {
+      bestEffort('store-flush-on-stop', () => this.store.flushSync(), this.logger);
+    }
+  }
+
+  clearScheduled(taskId) {
+    this.clearAdaptiveTimer(taskId);
+    if (this.watcherManager) {
+      this.watcherManager.unwatchTask(taskId);
+    }
+    if (this.jobs.has(taskId)) {
+      this.jobs.get(taskId).stop();
+      this.jobs.delete(taskId);
+    }
+    if (this.timers.has(taskId)) {
+      clearTimeout(this.timers.get(taskId));
+      this.timers.delete(taskId);
+    }
+  }
+
+  scheduleOneShot(task, parsed) {
+    task.oneShot = true;
+    task.targetTimestamp = parsed.targetTimestamp;
+    task.nextRunAt = parsed.targetTimestamp;
+    this.store.set(task);
+
+    const armTimer = () => {
+      const remaining = parsed.targetTimestamp - Date.now();
+      if (remaining <= 0) {
+        this.timers.delete(task.id);
+        this.runTask(task.id).catch((err) => {
+          logger.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
+        });
+        return;
+      }
+      const delay = Math.min(remaining, MAX_TIMEOUT_MS);
+      const timer = setTimeout(() => {
+        if (Date.now() >= parsed.targetTimestamp) {
+          this.timers.delete(task.id);
+          this.runTask(task.id).catch((err) => {
+            logger.error(`[dsh-cron] one-shot run of task ${task.id} failed:`, (err && err.message) || err);
+          });
+        } else {
+          armTimer();
+        }
+      }, delay);
+      this.timers.set(task.id, timer);
+    };
+
+    armTimer();
+  }
+
+  scheduleCron(task, parsed) {
+    const timezone = task.timezone || this.defaultTimezone || undefined;
+    const job = new Cron(parsed.cronPattern, {
+      sloppyRanges: true,
+      catch: (err) => logger.error(`[dsh-cron] scheduled run of "${task.title}" (${task.id}) failed:`, (err && err.message) || err),
+      ...(timezone ? { timezone } : {}),
+    }, async () => {
+      await this.runTask(task.id);
+    });
+
+    this.jobs.set(task.id, job);
+    const next = job.nextRun();
+    if (next) {
+      task.nextRunAt = next.getTime();
+      this.store.set(task);
+    }
+  }
+
+  scheduleTask(task) {
+    this.clearScheduled(task.id);
+    if (task.status !== 'active') return;
+    this.clearRetryTimer(task.id);
+    if (this.watcherManager) {
+      this.watcherManager.watchTask(task);
+    }
+
+    try {
+      const parsed = parseScheduleExpression(task.schedule);
+      if (parsed.isOneShot) {
+        const existingTarget = task.targetTimestamp || task.nextRunAt;
+        if (existingTarget && typeof existingTarget === 'number' && !isNaN(existingTarget)) {
+          parsed.targetTimestamp = existingTarget;
+          parsed.nextRun = existingTarget;
+        }
+        this.scheduleOneShot(task, parsed);
+        return;
+      }
+      this.scheduleCron(task, parsed);
+    } catch (err) {
+      logger.error(`[dsh-cron] failed to schedule task ${task.id}:`, err.message);
+    }
+  }
+
+  getGroupLimit(group) {
+    if (!group || group === 'default') return 0;
+    if (this.groupLimits && this.groupLimits.has(group)) {
+      return Number(this.groupLimits.get(group)) || 0;
+    }
+    return 1;
+  }
+
+  getRunningGroupCount(group) {
+    if (!group || group === 'default') return 0;
+    let count = 0;
+    for (const [, run] of this.running.entries()) {
+      if (run.concurrencyGroup === group) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  beginRun(task, taskId, options = {}) {
+    return beginRun(this, task, taskId, options);
+  }
+
+  countRun(status) {
+    const key = status || 'unknown';
+    this.runCounters[key] = (this.runCounters[key] || 0) + 1;
+  }
+
+  getRunCounters() {
+    return { ...this.runCounters };
+  }
+
+  recordSkipped(taskId, reason) {
+    this.countRun('skipped');
+    const runId = 'run_' + Math.random().toString(36).slice(2, 9) + '_' + Date.now();
+    this.store.recordRun(taskId, {
+      runId,
+      at: Date.now(),
+      status: 'skipped',
+      durationMs: 0,
+      output: reason,
+      error: null,
+      usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+      costUsd: 0,
+      stoppedReason: reason,
+      stages: [
+        { name: 'queue', status: 'skipped', durationMs: 0 },
+        { name: 'preflight', status: 'skipped', durationMs: 0, error: reason },
+        { name: 'execution', status: 'skipped', durationMs: 0 },
+        { name: 'validation', status: 'skipped', durationMs: 0 },
+        { name: 'delivery', status: 'skipped', durationMs: 0 },
+      ],
+      cost: { amount: 0, currency: 'USD', kind: 'exact' },
+      delivery: { status: 'skipped', delivered: [], failures: [] },
+    });
+  }
+
+  async executeOnce(task, signal, options = {}) {
+    return executeOnce(this, task, signal, options);
+  }
+
+  async executeWithFallback(task, signal, options = {}) {
+    return executeWithFallback(this, task, signal, options);
+  }
+
+  shouldUseFallback(task, outcome) {
+    return shouldUseFallback(task, outcome);
+  }
+
+  async runTask(taskId, options = {}) {
+    if (this.isStopped) return null;
+    return executeTask(this, taskId, options);
+  }
+
+  async completeRun(task, taskId, currentRun, outcome, start, options = {}) {
+    return handleCompleteRun(this, task, taskId, currentRun, outcome, start, options);
+  }
+
+  async applyModelAssists(task, runInfo) {
+    return applyModelAssists(task, runInfo, {
+      askModel: this.askModel,
+      readSettingsFn: () => this.readSettings(),
+      inspectTimeoutMs: this.inspectTimeoutMs,
+      silentRuleTimeoutMs: this.silentRuleTimeoutMs,
+    });
+  }
+
+  async inspectFailureRun(task, runInfo) {
+    return inspectFailureRun(task, runInfo, {
+      askModel: this.askModel,
+      readSettingsFn: () => this.readSettings(),
+      inspectTimeoutMs: this.inspectTimeoutMs || 25000,
+    });
+  }
+
+  readSettings() {
+    try {
+      return typeof this.store.getSettings === 'function' ? this.store.getSettings() : {};
+    } catch (err) {
+      bestEffort('readSettings', () => {}, this.logger);
+      return {};
+    }
+  }
+
+  async applySilentRuleToRun(task, runInfo) {
+    return applySilentRuleToRun(task, runInfo, {
+      askModel: this.askModel,
+      readSettingsFn: () => this.readSettings(),
+      silentRuleTimeoutMs: this.silentRuleTimeoutMs || 20000,
+    });
+  }
+
+  async deliverNotifications(task, runInfo) {
+    return deliverNotifications(task, runInfo, {
+      store: this.store,
+      resolveSecrets: this.resolveSecrets,
+      deliver: this.deliver,
+    });
+  }
+
+  finishRun(task, taskId, status, queuedCount, meta) {
+    return finishRun(this, task, taskId, status, queuedCount, meta);
+  }
+
+  pauseTask(taskId, reason) {
+    return pauseTask(this, taskId, reason);
+  }
+
+  removeTask(taskId) {
+    return removeTask(this, taskId);
+  }
+
+  resumeTask(taskId) {
+    return resumeTask(this, taskId);
+  }
+
+  toggleTask(taskId) {
+    return toggleTask(this, taskId);
+  }
+
+  triggerManualRun(taskId, options = {}) {
+    return this.runTask(taskId, options);
+  }
+
+  runNow(taskId, options = {}) {
+    return this.runTask(taskId, options);
+  }
+}
+