@goodandready/dsh-cron 0.2.9 → 0.2.11

package/lib/scheduler.js

@@ -1,4 +1,7 @@
 import { Cron } from 'croner';
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import { parseLlmActionDirectives, executeLlmActionDirectives } from './llm-actions.js';
 import { applySilentRule } from './silent-rule.js';
 import { inspectFailure } from './failure-inspector.js';
 
@@ -165,6 +168,98 @@ export function parseScheduleExpression(input) {
     || 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,
+  };
+}
+
+/**
+ * Execute pre-flight check gate before running task body.
+ */
+export async function executePreflight(task) {
+  const type = String(task.preflightType || 'none').toLowerCase();
+  const target = String(task.preflightTarget || '').trim();
+  if (!type || type === 'none' || !target) {
+    return { ok: true };
+  }
+
+  if (type === 'http') {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const res = await fetch(target, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (res.ok) return { ok: true };
+      return { ok: false, reason: `HTTP check returned status ${res.status}` };
+    } catch (err) {
+      return { ok: false, reason: `HTTP check failed: ${err.message}` };
+    }
+  }
+
+  if (type === 'command') {
+    return new Promise((resolve) => {
+      exec(target, { timeout: 5000 }, (err, stdout, stderr) => {
+        if (err) {
+          resolve({ ok: false, reason: `Preflight command failed (code ${err.code || 1}): ${(stderr || stdout || err.message).trim().slice(0, 150)}` });
+        } else {
+          resolve({ ok: true });
+        }
+      });
+    });
+  }
+
+  if (type === 'disk') {
+    const requiredMb = Number(target) || 100;
+    try {
+      if (typeof fs.statfsSync === 'function') {
+        const stats = fs.statfsSync(process.cwd());
+        const freeMb = Math.round((stats.bavail * stats.bsize) / (1024 * 1024));
+        if (freeMb < requiredMb) {
+          return { ok: false, reason: `Free disk space (${freeMb} MB) is below required ${requiredMb} MB` };
+        }
+      }
+      return { ok: true };
+    } catch {
+      return { ok: true }; // Fail-open
+    }
+  }
+
+  return { ok: true };
+}
+
 export class TaskScheduler {
   constructor(store, executeFn, options = {}) {
     this.store = store;
@@ -178,6 +273,8 @@ export class TaskScheduler {
     this.retryTimers = new Map(); // taskId -> setTimeout handle (for #18 retries)
     this.running = new Map(); // taskId -> { controller, startedAt, queueCount }
     this.runCounters = {}; // status -> finished runs since start (#53, /dsh-cron/metrics)
+    this.queue = []; // [{ taskId, priority, queuedAt, options }]
+    this.heartbeatTimer = null;
   }
 
   isRunning(taskId) {
@@ -201,6 +298,67 @@ export class TaskScheduler {
     }
   }
 
+  startHeartbeatWatcher(intervalMs = 30000) {
+    this.stopHeartbeatWatcher();
+    this.heartbeatTimer = setInterval(() => this.checkHeartbeats(), intervalMs);
+    if (this.heartbeatTimer && typeof this.heartbeatTimer.unref === 'function') {
+      this.heartbeatTimer.unref();
+    }
+  }
+
+  stopHeartbeatWatcher() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  async checkHeartbeats() {
+    const now = Date.now();
+    const tasks = typeof this.store.list === 'function' ? this.store.list({ status: 'active' }) : Array.from(this.store.tasks.values());
+    for (const task of tasks) {
+      if (task.status !== 'active' || !task.heartbeatIntervalSeconds || task.heartbeatIntervalSeconds <= 0) {
+        continue;
+      }
+      const grace = task.gracePeriodSeconds !== undefined ? task.gracePeriodSeconds : 300;
+      const last = task.lastPingAt || task.createdAt || now;
+      const deadline = last + (task.heartbeatIntervalSeconds + grace) * 1000;
+
+      if (now > deadline && !task.heartbeatAlerted) {
+        task.heartbeatAlerted = true;
+        task.lastStatus = 'missed';
+        task.updatedAt = now;
+        this.store.save();
+
+        console.warn(`[dsh-cron] Heartbeat missed for "${task.title}" (${task.id})!`);
+        const runInfo = {
+          at: now,
+          status: 'missed',
+          durationMs: 0,
+          output: `Heartbeat missed: expected ping within ${task.heartbeatIntervalSeconds + grace}s, last ping was at ${new Date(last).toISOString()}`,
+          error: 'Heartbeat deadline exceeded',
+          usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+          costUsd: 0,
+        };
+
+        try {
+          this.store.recordRun(task.id, runInfo);
+        } catch {}
+
+        await this.deliverNotifications(task, runInfo);
+
+        if (task.onFailure && String(task.onFailure).trim()) {
+          const targetId = task.onFailure.trim();
+          this.runNow(targetId, {
+            chainDepth: 1,
+            prevOutput: runInfo.output,
+            prevTaskId: task.id,
+          }).catch((err) => console.warn(`[dsh-cron] heartbeat onFailure trigger error:`, err.message));
+        }
+      }
+    }
+  }
+
   start() {
     const tasks = this.store.list();
     const now = Date.now();
@@ -240,9 +398,11 @@ export class TaskScheduler {
       }
       this.scheduleTask(task);
     }
+    this.startHeartbeatWatcher();
   }
 
   stopAll() {
+    this.stopHeartbeatWatcher();
     for (const [id, job] of this.jobs.entries()) {
       try {
         job.stop();
@@ -347,6 +507,12 @@ export class TaskScheduler {
     // skipped and recorded; already-running tasks are never throttled against
     // themselves.
     if (!this.running.has(taskId) && this.maxConcurrent > 0 && this.running.size >= this.maxConcurrent) {
+      if (task.overlapPolicy === 'queue') {
+        console.log(`[dsh-cron] Task "${task.title}" (${taskId}) queued by concurrency limit (${this.maxConcurrent})`);
+        this.queue.push({ taskId, priority: task.priority !== undefined ? task.priority : 5, queuedAt: Date.now() });
+        this.queue.sort((a, b) => (a.priority - b.priority) || (a.queuedAt - b.queuedAt));
+        return null;
+      }
       console.log(`[dsh-cron] Task "${task.title}" (${taskId}) skipped: concurrency limit (${this.maxConcurrent})`);
       this.recordSkipped(taskId, `Skipped: concurrency limit reached (${this.maxConcurrent} parallel runs)`);
       return null;
@@ -403,7 +569,7 @@ export class TaskScheduler {
   }
 
   /** Run the task body once and normalise whatever the executor returned. */
-  async executeOnce(task, signal) {
+  async executeOnce(task, signal, options = {}) {
     const result = {
       status: 'success',
       output: '',
@@ -416,7 +582,7 @@ export class TaskScheduler {
     };
     if (typeof this.executeFn !== 'function') return result;
     try {
-      const res = await this.executeFn(task, { signal });
+      const res = await this.executeFn(task, { signal, ...options });
       if (typeof res === 'object' && res !== null) {
         result.output = res.output || '';
         result.usage = res.usage || result.usage;
@@ -444,8 +610,8 @@ export class TaskScheduler {
    * afterwards — and usage and cost of BOTH attempts are summed, because both
    * were really spent.
    */
-  async executeWithFallback(task, signal) {
-    const primary = await this.executeOnce(task, signal);
+  async executeWithFallback(task, signal, options = {}) {
+    const primary = await this.executeOnce(task, signal, options);
     if (!this.shouldUseFallback(task, primary)) return primary;
 
     const fallbackTask = {
@@ -454,7 +620,7 @@ export class TaskScheduler {
       model: task.fallbackModel,
     };
     console.log(`[dsh-cron] task "${task.title}" failed on ${task.model || 'the default model'}, retrying once on ${task.fallbackModel}`);
-    const secondary = await this.executeOnce(fallbackTask, signal);
+    const secondary = await this.executeOnce(fallbackTask, signal, options);
     return {
       ...secondary,
       fallback: true,
@@ -472,23 +638,50 @@ export class TaskScheduler {
   }
 
 
-  async runTask(taskId) {
+  async runTask(taskId, options = {}) {
     const task = this.store.get(taskId);
-    if (!task) return;
+    if (!task) return null;
+
+    if (options.dryRun) {
+      const start = Date.now();
+      const outcome = await this.executeWithFallback(task, AbortSignal.timeout(Math.min((task.timeoutSeconds || 1800) * 1000, 30000)), options);
+      return {
+        ok: true,
+        dryRun: true,
+        status: outcome.status,
+        output: outcome.output,
+        error: outcome.error,
+        durationMs: Date.now() - start,
+        usage: outcome.usage,
+        costUsd: outcome.costUsd,
+        model: outcome.model || task.model || '',
+      };
+    }
 
     const currentRun = this.beginRun(task, taskId);
-    if (currentRun === null) return;
+    if (currentRun === null) return null;
+
+    const preflight = await executePreflight(task);
+    if (!preflight.ok) {
+      console.log(`[dsh-cron] task "${task.title}" (${taskId}) skipped: ${preflight.reason}`);
+      this.running.delete(taskId);
+      this.recordSkipped(taskId, `Preflight check skipped: ${preflight.reason}`);
+      return null;
+    }
 
     const start = Date.now();
-    const outcome = await this.executeWithFallback(task, currentRun.controller.signal);
-    await this.completeRun(task, taskId, currentRun, outcome, start);
+    const outcome = await this.executeWithFallback(task, currentRun.controller.signal, options);
+    await this.completeRun(task, taskId, currentRun, outcome, start, options);
+    return outcome;
   }
 
   /**
    * Record the run, release the run slot and hand the result to delivery and
    * bookkeeping. Kept separate from runTask so the run flow reads in steps.
    */
-  async completeRun(task, taskId, currentRun, outcome, start) {
+  async completeRun(task, taskId, currentRun, outcome, start, options = {}) {
+    const isSuccess = outcome.status === 'success';
+    const isFailure = outcome.status === 'error' || outcome.status === 'timeout';
     const runInfo = {
       at: start,
       status: outcome.status,
@@ -506,6 +699,40 @@ export class TaskScheduler {
 
     // #43/#44 decide before the run is recorded, so the single history entry
     // already carries the diagnosis and the silence verdict.
+    // 3. Self-healing & Auto-diagnose (#139)
+    if (isFailure && task.selfHealingCommand) {
+      console.log(`[dsh-cron] running self-healing command for task "${task.title}": ${task.selfHealingCommand}`);
+      try {
+        await new Promise((resolve) => {
+          exec(task.selfHealingCommand, { timeout: 30000 }, (shErr, stdout, stderr) => {
+            runInfo.selfHealing = {
+              command: task.selfHealingCommand,
+              success: !shErr,
+              output: (stdout + (stderr ? '\n' + stderr : '')).trim().slice(0, 500),
+            };
+            resolve();
+          });
+        });
+      } catch (shErr) {
+        runInfo.selfHealing = { command: task.selfHealingCommand, success: false, error: shErr.message };
+      }
+    }
+
+    if (isFailure && task.autoDiagnose && typeof this.executeFn === 'function') {
+      try {
+        const diagRes = await this.executeFn({
+          type: 'llm',
+          prompt: `Diagnose this task failure in 1-2 concise sentences. Error: ${outcome.error || 'unknown'}. Recent output: ${(outcome.output || '').slice(-300)}`,
+          model: task.fallbackModel || task.model,
+        }, { signal: AbortSignal.timeout(10000) });
+        if (diagRes && diagRes.output) {
+          runInfo.autoDiagnosis = diagRes.output.trim();
+        }
+      } catch {
+        // Fail-open
+      }
+    }
+
     const silent = await this.applyModelAssists(task, runInfo);
 
     try {
@@ -522,6 +749,64 @@ export class TaskScheduler {
 
     if (!silent.skipped) await this.deliverNotifications(task, runInfo);
     this.finishRun(task, taskId, outcome.status, queuedCount);
+
+    if (this.queue.length > 0 && this.running.size < this.maxConcurrent) {
+      const nextItem = this.queue.shift();
+      if (nextItem) {
+        setImmediate(() => {
+          this.runTask(nextItem.taskId).catch(() => {});
+        });
+      }
+    }
+
+    // 1. Structured LLM Actions (#137)
+    if (task.type === 'llm' && outcome.status === 'success' && outcome.output) {
+      try {
+        const settings = typeof this.store.getSettings === 'function' ? this.store.getSettings() : {};
+        if (settings.llmActionsEnabled) {
+          const directives = parseLlmActionDirectives(outcome.output);
+          if (directives.length > 0) {
+            await executeLlmActionDirectives({
+              directives,
+              task,
+              runInfo,
+              scheduler: this,
+              store: this.store,
+              settings,
+            });
+          }
+        }
+      } catch (actErr) {
+        console.warn(`[dsh-cron] structured action error for ${taskId}:`, actErr.message);
+      }
+    }
+
+    
+
+    // 2. Task Chaining (#137)
+    const nextTaskId = isSuccess ? task.onSuccess : (isFailure ? task.onFailure : null);
+
+    if (nextTaskId && typeof nextTaskId === 'string' && nextTaskId.trim()) {
+      const currentDepth = options.chainDepth || 0;
+      if (currentDepth < 4) {
+        const targetId = nextTaskId.trim();
+        const nextTask = this.store.get(targetId);
+        if (nextTask) {
+          console.log(`[dsh-cron] triggering chained task "${nextTask.title}" (${targetId}) from "${task.title}" (depth ${currentDepth + 1})`);
+          this.runNow(targetId, {
+            chainDepth: currentDepth + 1,
+            prevOutput: outcome.output || outcome.error || '',
+            prevTaskId: task.id,
+          }).catch(err => {
+            console.warn(`[dsh-cron] chained task ${targetId} failed to trigger:`, err.message);
+          });
+        } else {
+          console.warn(`[dsh-cron] chained task target not found: ${targetId}`);
+        }
+      } else {
+        console.warn(`[dsh-cron] chained task depth limit (5) reached for task ${task.id} -> ${nextTaskId}. Loop prevented.`);
+      }
+    }
   }
 
   /**
@@ -725,7 +1010,11 @@ export class TaskScheduler {
     }
   }
 
-  triggerManualRun(taskId) {
-    return this.runTask(taskId);
+  triggerManualRun(taskId, options = {}) {
+    return this.runTask(taskId, options);
+  }
+
+  runNow(taskId, options = {}) {
+    return this.runTask(taskId, options);
   }
 }

package/lib/store.js

@@ -98,6 +98,7 @@ export class TaskStore {
     base.onlyOnFailure = Boolean(base.onlyOnFailure);
     base.kanbanBaseUrl = base.kanbanBaseUrl || 'http://127.0.0.1:3000';
     base.hasDefaultCredentials = Boolean(defaults.botToken && defaults.chatId);
+    base.llmActionsEnabled = Boolean(base.llmActionsEnabled);
     return base;
   }
 
@@ -187,6 +188,7 @@ export class TaskStore {
         : (this.settings.kanbanBaseUrl || 'http://127.0.0.1:3000'),
       notifyTelegram: patch.notifyTelegram !== undefined ? Boolean(patch.notifyTelegram) : Boolean(this.settings.notifyTelegram),
       onlyOnFailure: patch.onlyOnFailure !== undefined ? Boolean(patch.onlyOnFailure) : Boolean(this.settings.onlyOnFailure),
+      llmActionsEnabled: patch.llmActionsEnabled !== undefined ? Boolean(patch.llmActionsEnabled) : Boolean(this.settings.llmActionsEnabled),
     };
     this.save();
     return this.getSettings();
@@ -234,7 +236,19 @@ export class TaskStore {
       timeoutSeconds: task.timeoutSeconds !== undefined ? Number(task.timeoutSeconds) : (prev.timeoutSeconds || 1800),
       overlapPolicy: task.overlapPolicy !== undefined ? String(task.overlapPolicy) : (prev.overlapPolicy || 'skip'),
       kanbanMode: task.kanbanMode !== undefined ? String(task.kanbanMode) : (prev.kanbanMode || 'none'), // 'none' | 'on_failure' | 'always'
+      onSuccess: task.onSuccess !== undefined ? String(task.onSuccess).trim() : (prev.onSuccess || ''),
+      onFailure: task.onFailure !== undefined ? String(task.onFailure).trim() : (prev.onFailure || ''),
       oneShot: task.oneShot !== undefined ? Boolean(task.oneShot) : Boolean(prev.oneShot),
+      heartbeatIntervalSeconds: task.heartbeatIntervalSeconds !== undefined ? Number(task.heartbeatIntervalSeconds) : (prev.heartbeatIntervalSeconds || 0),
+      gracePeriodSeconds: task.gracePeriodSeconds !== undefined ? Number(task.gracePeriodSeconds) : (prev.gracePeriodSeconds || 300),
+      lastPingAt: task.lastPingAt !== undefined ? task.lastPingAt : (prev.lastPingAt || null),
+      heartbeatAlerted: task.heartbeatAlerted !== undefined ? Boolean(task.heartbeatAlerted) : (prev.heartbeatAlerted || false),
+      preflightType: task.preflightType !== undefined ? String(task.preflightType) : (prev.preflightType || 'none'),
+      preflightTarget: task.preflightTarget !== undefined ? String(task.preflightTarget).trim() : (prev.preflightTarget || ''),
+      concurrencyGroup: task.concurrencyGroup !== undefined ? String(task.concurrencyGroup).trim() : (prev.concurrencyGroup || 'default'),
+      priority: task.priority !== undefined ? Number(task.priority) : (prev.priority || 5),
+      selfHealingCommand: task.selfHealingCommand !== undefined ? String(task.selfHealingCommand).trim() : (prev.selfHealingCommand || ''),
+      autoDiagnose: task.autoDiagnose !== undefined ? Boolean(task.autoDiagnose) : (prev.autoDiagnose || false),
       totalTokens: prev.totalTokens || 0,
       totalCostUsd: prev.totalCostUsd || 0,
       createdAt: prev.createdAt || task.createdAt || now,
@@ -249,6 +263,27 @@ export class TaskStore {
     return record;
   }
 
+  recordHeartbeat(id) {
+    const task = this.tasks.get(id);
+    if (!task) return null;
+    const now = Date.now();
+    task.lastPingAt = now;
+    task.heartbeatAlerted = false;
+    task.updatedAt = now;
+    if (task.lastStatus === 'missed') {
+      task.lastStatus = 'active';
+    }
+    this.save();
+    const interval = (task.heartbeatIntervalSeconds || 0) + (task.gracePeriodSeconds || 300);
+    return {
+      ok: true,
+      id,
+      taskId: id,
+      lastPingAt: now,
+      nextDeadline: now + interval * 1000,
+    };
+  }
+
   delete(id) {
     const existed = this.tasks.delete(id);
     this.history.delete(id);
@@ -293,6 +328,8 @@ export class TaskStore {
       // #43: the failure diagnosis and the prompt change it proposes.
       diagnosis: runInfo.diagnosis ? String(runInfo.diagnosis).slice(0, 1000) : '',
       suggestion: runInfo.suggestion ? String(runInfo.suggestion).slice(0, 2000) : '',
+      selfHealing: runInfo.selfHealing || null,
+      autoDiagnosis: runInfo.autoDiagnosis ? String(runInfo.autoDiagnosis).slice(0, 1000) : '',
       confidence: runInfo.confidence || '',
     });
     // Keep up to 100 runs in active store; archive older runs to tasks-history-archive.json (#134)
@@ -335,6 +372,59 @@ export class TaskStore {
     return runs.slice(0, limit);
   }
 
+  getArchivedRuns(id, { limit = 50, offset = 0, search = '' } = {}) {
+    try {
+      const dir = path.dirname(this.filePath);
+      const archivePath = path.join(dir, 'tasks-history-archive.json');
+      if (!fs.existsSync(archivePath)) return { runs: [], total: 0 };
+      const archive = JSON.parse(fs.readFileSync(archivePath, 'utf-8')) || {};
+      let runs = Array.isArray(archive[id]) ? archive[id] : [];
+      if (search && search.trim()) {
+        const q = search.toLowerCase();
+        runs = runs.filter(r => (r.output && r.output.toLowerCase().includes(q)) || (r.error && r.error.toLowerCase().includes(q)));
+      }
+      const total = runs.length;
+      const paged = runs.slice(offset, offset + limit);
+      return { runs: paged, total };
+    } catch (err) {
+      return { runs: [], total: 0, error: err.message };
+    }
+  }
+
+  getTaskStats(id) {
+    const runs = this.history.get(id) || [];
+    const total = runs.length;
+    let success = 0;
+    let error = 0;
+    let timeout = 0;
+    const recentDurations = [];
+
+    for (let i = 0; i < runs.length; i++) {
+      const r = runs[i];
+      if (r.status === 'success') success++;
+      else if (r.status === 'error') error++;
+      else if (r.status === 'timeout') timeout++;
+
+      if (recentDurations.length < 10 && r.durationMs !== undefined) {
+        recentDurations.push({
+          at: r.at,
+          durationMs: r.durationMs,
+          status: r.status,
+        });
+      }
+    }
+
+    const successRate = total > 0 ? Number((success / total).toFixed(2)) : 1.0;
+    return {
+      totalRuns: total,
+      successRuns: success,
+      errorRuns: error,
+      timeoutRuns: timeout,
+      successRate,
+      recentDurations,
+    };
+  }
+
   getAggregatedStats() {
     let totalRuns = 0;
     let totalTokens = 0;

package/lib/task-transfer.js

@@ -53,6 +53,16 @@ export const PATCHABLE_TASK_FIELDS = [
   'timeoutSeconds',
   'overlapPolicy',
   'kanbanMode',
+  'onSuccess',
+  'onFailure',
+  'heartbeatIntervalSeconds',
+  'gracePeriodSeconds',
+  'preflightType',
+  'preflightTarget',
+  'concurrencyGroup',
+  'priority',
+  'selfHealingCommand',
+  'autoDiagnose',
   'channels',
   'template',
   'status',

package/lib/telegram.js

@@ -84,6 +84,25 @@ export function escapeMarkdown(str) {
   return String(str).replace(/[_*[\]()~`>#+\-=|{}.!]/g, '\\$&');
 }
 
+/**
+ * Create Telegram inline keyboard for interactive task controls (#137).
+ */
+export function createTelegramTaskKeyboard(task, runInfo = {}) {
+  const isPaused = task && task.status === 'paused';
+  const taskId = task?.id || '';
+  return {
+    inline_keyboard: [
+      [
+        { text: '▶️ Run Now', callback_data: `cron:run:${taskId}` },
+        { text: isPaused ? '▶️ Resume' : '⏸ Pause', callback_data: `cron:pause:${taskId}` },
+      ],
+      [
+        { text: '📄 Last Output', callback_data: `cron:log:${taskId}` },
+      ]
+    ]
+  };
+}
+
 /**
  * Format task execution report for Telegram.
  * Dynamic values are escaped so titles/schedules cannot break the markup (#93).
@@ -116,10 +135,32 @@ export function formatTaskTelegramMessage(task, runInfo) {
   return lines.join('\n');
 }
 
+/**
+ * Answer a Telegram callback query (#137).
+ */
+export async function answerTelegramCallbackQuery({ botToken, callbackQueryId, text = '', showAlert = false, fetchFn = globalThis.fetch }) {
+  if (!botToken || !callbackQueryId) return;
+  const url = `https://api.telegram.org/bot${botToken}/answerCallbackQuery`;
+  const body = {
+    callback_query_id: callbackQueryId,
+    text: text ? String(text).slice(0, 200) : undefined,
+    show_alert: Boolean(showAlert),
+  };
+  try {
+    await fetchFn(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+  } catch (err) {
+    console.warn('[dsh-cron] answerCallbackQuery failed:', err.message);
+  }
+}
+
 /**
  * Send telegram message via Bot API.
  */
-export async function sendTelegramMessage({ botToken, chatId, text, parseMode = 'Markdown', fetchFn = globalThis.fetch, signal }) {
+export async function sendTelegramMessage({ botToken, chatId, text, parseMode = 'Markdown', replyMarkup, fetchFn = globalThis.fetch, signal }) {
   if (!botToken) throw new Error('Telegram botToken is not configured');
   if (!chatId) throw new Error('Telegram chatId is not configured');
 
@@ -130,6 +171,7 @@ export async function sendTelegramMessage({ botToken, chatId, text, parseMode =
     disable_notification: false,
   };
   if (parseMode) body.parse_mode = parseMode;
+  if (replyMarkup) body.reply_markup = replyMarkup;
 
   const res = await fetchFn(url, {
     method: 'POST',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",