@goodandready/dsh-cron 0.2.9 → 0.2.10

package/README.md

@@ -325,6 +325,13 @@ Developer-facing, no behaviour change. `parseScheduleExpression` was split into
 - **History Rotation & Archival**: Active store holds the latest 100 runs per task; older entries are automatically archived into `tasks-history-archive.json`.
 - **Autonomous PR Reviewer Recipe (#33)**: Preconfigured recipe in Template Hub with optional toggle `prReviewerEnabled` in settings.
 
+### 22. Automation, Task Chaining & Observability Pack (Added in v0.2.10, #137)
+- **Two-Way Telegram Interactive Controls**: Run completion notifications include inline keyboard buttons (`🚀 Run Now`, `⏸️ Pause` / `▶️ Resume`, `📋 Last Output`). Actions are securely routed via `POST /dsh-cron/telegram/webhook` with Chat ID authorization matching plugin settings or harness defaults.
+- **Task Chaining & Pipelines**: Tasks can declare `onSuccess` and `onFailure` downstream task triggers. Upstream output is automatically forwarded to child tasks via `$DSH_PREV_OUTPUT` environment variable for shell/script tasks and `{{prevOutput}}` variable interpolation in LLM prompts. Infinite execution loops are strictly prevented with a recursion depth limit (max 5 consecutive executions).
+- **Structured LLM Actions**: Autonomous model runs can output structured JSON directives to trigger secondary tasks, dispatch channel notifications, or open issues. Controlled via `llmActionsEnabled: false` settings toggle (strictly disabled by default).
+- **History Archival & Latency Insights**: Active task store retains the most recent 100 runs for instant performance, while older runs are archived in `tasks_archive.json`. New REST endpoints `GET /dsh-cron/tasks/:id/archive` and `GET /dsh-cron/tasks/:id/stats` expose historical records and aggregated latency statistics. Task UI displays execution duration latency badges with color thresholds (<5s green, <30s yellow, >=30s red).
+- **Enriched Prometheus Observability**: The `/dsh-cron/metrics` endpoint exports the active concurrency gauge `dsh_cron_concurrent_running`, per-task prompt/completion token consumption counters `dsh_cron_task_tokens_total{task,model,type}`, and per-task cost estimation counters `dsh_cron_task_cost_usd_total{task,model}`.
+
 ---
 
 ## 📦 Installation

package/lib/api.js

@@ -12,6 +12,7 @@ import { CHANNEL_IDS, unknownChannelIds } from './channels.js';
 import { applyTaskPatch } from './task-patch.js';
 import { MANAGED_BY_CONFIG, configOwnedMessage } from './config-jobs.js';
 import { sendJson, rejectCrossOrigin, readBody, pickPatchableFields, SCRIPT_CONFIRM_HEADER } from './http-utils.js';
+import { answerTelegramCallbackQuery, sendTelegramMessage, getDshDefaultTelegramCredentials } from './telegram.js';
 import {
   validateTaskType,
   buildDuplicateTask,
@@ -54,6 +55,11 @@ export function createCronApiHandler(store, scheduler, collection) {
       const id = parts[2];
       const action = parts[3];
 
+      if (scope === 'telegram' && id === 'webhook') {
+        await handleTelegramWebhook({ store, scheduler, req, res });
+        return;
+      }
+
       if (!id) {
         await handleTaskCollection({ store, scheduler, collection, req, res, url, scope });
         return;
@@ -346,6 +352,21 @@ function applyImportPlan({ store, scheduler, plan }) {
 // ------------------------------------------------------------ single task
 
 async function handleTaskItem({ store, scheduler, req, res, url, id, action }) {
+  if (req.method === 'GET' && action === 'archive') {
+    const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+    const offset = parseInt(url.searchParams.get('offset') || '0', 10);
+    const search = url.searchParams.get('search') || '';
+    const result = typeof store.getArchivedRuns === 'function'
+      ? store.getArchivedRuns(id, { limit, offset, search })
+      : { runs: [], total: 0 };
+    sendJson(res, 200, { ok: true, taskId: id, ...result });
+    return;
+  }
+  if (req.method === 'GET' && action === 'stats') {
+    const stats = typeof store.getTaskStats === 'function' ? store.getTaskStats(id) : null;
+    sendJson(res, 200, { ok: true, taskId: id, stats });
+    return;
+  }
   if (req.method === 'GET' && (action === 'history' || !action)) {
     const limit = parseInt(url.searchParams.get('limit') || '20', 10);
     sendJson(res, 200, { ok: true, history: store.getHistory(id, limit) });
@@ -550,3 +571,113 @@ export async function handleExternalTaskRequest({ store, scheduler, req, res, ur
   }
   sendJson(res, 405, NOT_ALLOWED);
 }
+
+export async function handleTelegramWebhook({ store, scheduler, req, res }) {
+  if (req.method !== 'POST') {
+    sendJson(res, 405, NOT_ALLOWED);
+    return;
+  }
+  const { body, error } = await readBody(req, res);
+  if (error || !body) return;
+
+  const callbackQuery = body.callback_query;
+  if (!callbackQuery) {
+    sendJson(res, 200, { ok: true });
+    return;
+  }
+
+  const queryId = callbackQuery.id;
+  const data = String(callbackQuery.data || '');
+  const fromId = String(callbackQuery.from?.id || '');
+  const chatId = String(callbackQuery.message?.chat?.id || fromId);
+
+  const settings = typeof store.getSettings === 'function' ? store.getSettings() : {};
+  const defaults = getDshDefaultTelegramCredentials();
+  const botToken = settings.botToken || defaults.botToken;
+  const allowedChatId = String(settings.chatId || defaults.chatId || '').trim();
+
+  if (allowedChatId && chatId !== allowedChatId && fromId !== allowedChatId) {
+    console.warn(`[dsh-cron] unauthorized telegram callback from chat ${chatId} / user ${fromId}`);
+    if (botToken) {
+      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Unauthorized', showAlert: true });
+    }
+    sendJson(res, 403, { ok: false, error: 'Forbidden' });
+    return;
+  }
+
+  const parts = data.split(':');
+  if (parts[0] !== 'cron' || parts.length < 3) {
+    if (botToken) {
+      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Unknown action' });
+    }
+    sendJson(res, 200, { ok: true, ignored: true });
+    return;
+  }
+
+  const verb = parts[1];
+  const taskId = parts.slice(2).join(':');
+  const task = store.get(taskId);
+
+  if (!task) {
+    if (botToken) {
+      await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: 'Task not found', showAlert: true });
+    }
+    sendJson(res, 200, { ok: false, error: 'Task not found' });
+    return;
+  }
+
+  if (verb === 'run') {
+    try {
+      await scheduler.triggerManualRun(taskId);
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `🚀 Run triggered: ${task.title}` });
+      }
+    } catch (runErr) {
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `Run error: ${runErr.message}`, showAlert: true });
+      }
+    }
+  } else if (verb === 'pause') {
+    const isPaused = task.status === 'paused';
+    const newStatus = isPaused ? 'active' : 'paused';
+    if (typeof store.update === 'function') {
+      store.update(taskId, { status: newStatus });
+    } else {
+      store.set({ ...task, status: newStatus });
+    }
+    if (isPaused) {
+      scheduler.resume(taskId);
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `▶️ Resumed: ${task.title}` });
+      }
+    } else {
+      scheduler.pause(taskId);
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `⏸ Paused: ${task.title}` });
+      }
+    }
+  } else if (verb === 'log') {
+    const history = store.getHistory(taskId, 1);
+    const lastRun = history && history[0];
+    if (!lastRun) {
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: `No runs recorded for ${task.title}`, showAlert: true });
+      }
+    } else {
+      const summary = `[${task.title}] Last run: ${lastRun.status} (${lastRun.durationMs}ms)\n${lastRun.output || lastRun.error || 'Empty output'}`;
+      if (botToken) {
+        await answerTelegramCallbackQuery({ botToken, callbackQueryId: queryId, text: summary.slice(0, 190) });
+        if (summary.length > 190 && chatId) {
+          await sendTelegramMessage({
+            botToken,
+            chatId,
+            text: `*Full Output for ${task.title}:*\n\`\`\`\n${summary.slice(0, 3000)}\n\`\`\``,
+            parseMode: 'Markdown',
+          }).catch(() => {});
+        }
+      }
+    }
+  }
+
+  sendJson(res, 200, { ok: true, verb, taskId });
+}

package/lib/channels.js

@@ -7,7 +7,7 @@
  * collected so one broken channel cannot hide another.
  */
 
-import { formatTaskTelegramMessage, sendTelegramMessage } from './telegram.js';
+import { formatTaskTelegramMessage, sendTelegramMessage, createTelegramTaskKeyboard } from './telegram.js';
 import { createKanbanCard, shouldCreateKanbanCard } from './integrations.js';
 import { resolveTemplateText, truncateText } from './templates.js';
 
@@ -256,7 +256,8 @@ export const CHANNEL_HANDLERS = {
       ? messageTextFor('telegram', task, runInfo, settings)
       : formatTaskTelegramMessage(task, runInfo);
     try {
-      await sendTelegramMessage({ botToken, chatId, text, fetchFn: http, signal });
+      const replyMarkup = createTelegramTaskKeyboard(task, runInfo);
+      await sendTelegramMessage({ botToken, chatId, text, replyMarkup, fetchFn: http, signal });
     } catch (err) {
       if (isAbort(err)) throw new Error(`telegram: timed out after ${timeoutMs} ms`);
       throw err;

package/lib/client.js

@@ -875,6 +875,8 @@ window.__ModuleLoader__.load({
       const [formTimeoutSeconds, setFormTimeoutSeconds] = React.useState(1800);
       const [formOverlapPolicy, setFormOverlapPolicy] = React.useState('skip');
       const [formKanbanMode, setFormKanbanMode] = React.useState('none');
+      const [formOnSuccess, setFormOnSuccess] = React.useState('');
+      const [formOnFailure, setFormOnFailure] = React.useState('');
       const [formTimezone, setFormTimezone] = React.useState('');
       const [formMisfirePolicy, setFormMisfirePolicy] = React.useState('skip');
       const [formMaxRetries, setFormMaxRetries] = React.useState(0);
@@ -1465,6 +1467,8 @@ window.__ModuleLoader__.load({
         setFormTimeoutSeconds(task.timeoutSeconds !== undefined ? task.timeoutSeconds : 1800);
         setFormOverlapPolicy(task.overlapPolicy || 'skip');
         setFormKanbanMode(task.kanbanMode || 'none');
+        setFormOnSuccess(task.onSuccess || '');
+        setFormOnFailure(task.onFailure || '');
         setFormTimezone(task.timezone || '');
         setFormMisfirePolicy(task.misfirePolicy || 'skip');
         setFormMaxRetries(task.maxRetries !== undefined ? task.maxRetries : 0);
@@ -1527,6 +1531,8 @@ window.__ModuleLoader__.load({
             maxRetries: Number(formMaxRetries) || 0,
             permissionPreset: formPermissionPreset,
             kanbanMode: formKanbanMode,
+            onSuccess: formOnSuccess.trim() || undefined,
+            onFailure: formOnFailure.trim() || undefined,
             env: parseEnvText(formEnv),
             cwd: formCwd.trim(),
             workspaceId: formWorkspaceId.trim(),
@@ -1832,6 +1838,8 @@ window.__ModuleLoader__.load({
                           className: 'dsh-cron-config-tag',
                           title: T_KEY(t, 'list.configManagedHint')
                         }, T_KEY(t, 'list.configManaged')) : null,
+                        task.lastDurationMs > 0 ? React.createElement('span', { className: 'dsh-cron-cost-tag', title: 'Last execution duration' }, task.lastDurationMs + 'ms') : null,
+                        task.onSuccess ? React.createElement('span', { className: 'dsh-cron-type-tag', title: 'On success: triggers ' + task.onSuccess, style: { background: 'rgba(56, 189, 248, 0.15)', color: '#38bdf8' } }, '➜ ' + task.onSuccess) : null,
                         task.totalCostUsd > 0 ? React.createElement('span', { className: 'dsh-cron-cost-tag' }, '$' + task.totalCostUsd.toFixed(4)) : null,
                         task.totalTokens > 0 ? React.createElement('span', { className: 'dsh-cron-tokens-tag' }, (task.totalTokens > 1000 ? Math.round(task.totalTokens / 1000) + 'k' : task.totalTokens) + ' tok') : null
                       ),
@@ -2653,6 +2661,7 @@ window.__ModuleLoader__.load({
       const [chatId, setChatId] = React.useState('');
       const [notify, setNotify] = React.useState(false);
       const [onlyFailure, setOnlyFailure] = React.useState(false);
+      const [llmActionsEnabled, setLlmActionsEnabled] = React.useState(false);
       const [kanbanUrl, setKanbanUrl] = React.useState('http://127.0.0.1:3000');
       const [delivery, setDelivery] = React.useState({});
       const [sections, setSections] = React.useState({ channels: true });
@@ -2679,6 +2688,7 @@ window.__ModuleLoader__.load({
               setChatId(data.settings.chatId || '');
               setNotify(Boolean(data.settings.notifyTelegram));
               setOnlyFailure(Boolean(data.settings.onlyOnFailure));
+              setLlmActionsEnabled(Boolean(data.settings.llmActionsEnabled));
               setKanbanUrl(data.settings.kanbanBaseUrl || 'http://127.0.0.1:3000');
               setDelivery(pickDeliverySettings(data.settings));
               setHasDefault(Boolean(data.settings.hasDefaultCredentials));
@@ -2702,6 +2712,7 @@ window.__ModuleLoader__.load({
               chatId,
               notifyTelegram: notify,
               onlyOnFailure: onlyFailure,
+              llmActionsEnabled: llmActionsEnabled,
               kanbanBaseUrl: kanbanUrl
             }, delivery))
           });
@@ -2831,6 +2842,14 @@ window.__ModuleLoader__.load({
                 onChange: (e) => setOnlyFailure(e.target.checked)
               }),
               React.createElement('span', null, T_KEY(t, 'settings.globalOnlyFailure'))
+            ),
+            React.createElement('label', { className: 'dsh-cron-checkbox-row' },
+              React.createElement('input', {
+                type: 'checkbox',
+                checked: llmActionsEnabled,
+                onChange: (e) => setLlmActionsEnabled(e.target.checked)
+              }),
+              React.createElement('span', null, 'Enable Structured LLM Actions (trigger tasks, notify, create issues)')
             )
           ),
           ...renderDeliverySettings({

package/lib/index.js

@@ -3,7 +3,7 @@ import { TaskScheduler, parseScheduleExpression } from './scheduler.js';
 import { SessionRunner } from './runner.js';
 import { getModelsHandler } from './models-handler.js';
 import { chatStartHandler } from './chat-start.js';
-import { sendTelegramMessage } from './telegram.js';
+import { sendTelegramMessage, createTelegramTaskKeyboard } from './telegram.js';
 import { createKanbanCard } from './integrations.js';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { randomUUID } from 'node:crypto';
@@ -527,7 +527,8 @@ export function apply(ctx, config) {
         }
 
         const text = `🔔 *dsh-cron test notification*\n\nConnection between DSH Cron and Telegram is working! Checked at: \`${new Date().toISOString()}\``;
-        await sendTelegramMessage({ botToken, chatId, text });
+        const replyMarkup = createTelegramTaskKeyboard(task, runInfo);
+        await sendTelegramMessage({ botToken, chatId, text, replyMarkup });
         sendJson(res, 200, { ok: true, message: 'Test message sent successfully' });
       } catch (err) {
         sendJson(res, 500, { ok: false, error: err.message });

package/lib/llm-actions.js

@@ -0,0 +1,141 @@
+import fs from 'node:fs';
+
+/**
+ * Extract structured action directives from LLM output text (#137).
+ * Supports JSON code fences ```json ... ``` and inline { "dsh_action": ... } blocks.
+ */
+export function parseLlmActionDirectives(text) {
+  if (!text || typeof text !== 'string') return [];
+  const directives = [];
+
+  // 1. Check for ```json ... ``` or ``` ... ``` blocks
+  const blockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/gi;
+  let match;
+  while ((match = blockRegex.exec(text)) !== null) {
+    const raw = match[1].trim();
+    if ((raw.startsWith('{') && raw.endsWith('}')) || (raw.startsWith('[') && raw.endsWith(']'))) {
+      try {
+        const parsed = JSON.parse(raw);
+        collectDirectives(parsed, directives);
+      } catch {}
+    }
+  }
+
+  // 2. Check for inline JSON object with dsh_action or dsh_actions if nothing found in fences
+  if (directives.length === 0) {
+    const inlineMatch = /\{(?:[^{}]|(\{(?:[^{}]|\{[^{}]*\})*\}))*"dsh_action[s]?"(?:[^{}]|(\{(?:[^{}]|\{[^{}]*\})*\}))*\}/gi;
+    let im;
+    while ((im = inlineMatch.exec(text)) !== null) {
+      try {
+        const parsed = JSON.parse(im[0]);
+        collectDirectives(parsed, directives);
+      } catch {}
+    }
+  }
+
+  return directives;
+}
+
+function collectDirectives(obj, list) {
+  if (!obj || typeof obj !== 'object') return;
+  if (Array.isArray(obj)) {
+    for (const item of obj) collectDirectives(item, list);
+    return;
+  }
+  if (Array.isArray(obj.dsh_actions)) {
+    for (const item of obj.dsh_actions) collectDirectives(item, list);
+    return;
+  }
+  if (Array.isArray(obj.actions)) {
+    for (const item of obj.actions) collectDirectives(item, list);
+    return;
+  }
+  const type = obj.dsh_action || obj.action || obj.type;
+  if (typeof type === 'string' && type.trim()) {
+    list.push({
+      type: type.trim(),
+      payload: obj.payload || {},
+      ...obj,
+    });
+  }
+}
+
+/**
+ * Execute parsed LLM action directives if enabled in plugin settings (#137).
+ */
+export async function executeLlmActionDirectives({ directives, task, runInfo, scheduler, store, settings = {}, fetchFn = globalThis.fetch }) {
+  if (!Array.isArray(directives) || directives.length === 0) return [];
+  if (!settings.llmActionsEnabled) {
+    return [];
+  }
+
+  const results = [];
+  for (const dir of directives) {
+    const type = dir.type || dir.action;
+    try {
+      if (type === 'trigger_task' || type === 'run_task') {
+        const targetId = dir.taskId || dir.payload?.taskId;
+        if (targetId && typeof scheduler.runNow === 'function') {
+          await scheduler.runNow(targetId, {
+            prevOutput: runInfo?.output || '',
+            prevTaskId: task?.id || '',
+          });
+          results.push({ type, targetId, status: 'triggered' });
+        }
+      } else if (type === 'notify') {
+        const msg = dir.message || dir.text || dir.payload?.message;
+        const botToken = settings.botToken;
+        const chatId = settings.chatId;
+        if (msg && botToken && chatId) {
+          const url = `https://api.telegram.org/bot${botToken}/sendMessage`;
+          await fetchFn(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ chat_id: chatId, text: String(msg) }),
+          });
+          results.push({ type, status: 'sent' });
+        }
+      } else if (type === 'create_issue') {
+        const title = dir.title || dir.payload?.title || `Issue from task ${task?.title || 'Cron'}`;
+        const body = dir.body || dir.payload?.body || String(runInfo?.output || '');
+        const giteaRes = await tryCreateGiteaIssue({ title, body, fetchFn });
+        results.push({ type, status: giteaRes ? 'created' : 'skipped', details: giteaRes });
+      }
+    } catch (err) {
+      console.warn(`[dsh-cron] action directive ${type} execution failed:`, err.message);
+      results.push({ type, status: 'error', error: err.message });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Best-effort helper to post an issue to local Gitea if credentials are present.
+ */
+async function tryCreateGiteaIssue({ title, body, repo = 'goodandready/dsh-cron', fetchFn }) {
+  try {
+    let token = process.env.GITEA_TOKEN;
+    const credPath = '/mnt/external/Project/DEV/.gitea-agent-credentials.json';
+    if (!token && fs.existsSync(credPath)) {
+      const data = JSON.parse(fs.readFileSync(credPath, 'utf-8'));
+      token = data?.agents?.antigravity?.token || data?.token;
+    }
+    if (!token) return null;
+
+    const url = `http://127.0.0.1:3005/api/v1/repos/${repo}/issues`;
+    const res = await fetchFn(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `token ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ title, body }),
+    });
+    if (res.ok) {
+      const json = await res.json().catch(() => ({}));
+      return { number: json.number, url: json.html_url };
+    }
+  } catch {}
+  return null;
+}

package/lib/metrics.js

@@ -36,7 +36,7 @@ function sample(name, labels, value) {
  * Render the current scheduler state as Prometheus text exposition.
  * Pure function over plain data so it is testable without a store.
  */
-export function renderMetrics({ tasks = [], stats = {}, runCounters = {} } = {}) {
+export function renderMetrics({ tasks = [], stats = {}, runCounters = {}, scheduler } = {}) {
   const lines = [];
   const byStatus = {};
   for (const task of tasks) {
@@ -72,6 +72,28 @@ export function renderMetrics({ tasks = [], stats = {}, runCounters = {} } = {})
   lines.push('# TYPE dsh_cron_run_records gauge');
   lines.push('dsh_cron_run_records ' + (Number(stats.totalRuns) || 0));
 
+  if (scheduler && typeof scheduler.runningCount === 'function') {
+    lines.push('# HELP dsh_cron_concurrent_running Number of currently executing tasks.');
+    lines.push('# TYPE dsh_cron_concurrent_running gauge');
+    lines.push('dsh_cron_concurrent_running ' + (Number(scheduler.runningCount()) || 0));
+  }
+
+  lines.push('# HELP dsh_cron_task_tokens_total Cumulative tokens consumed by task.');
+  lines.push('# TYPE dsh_cron_task_tokens_total counter');
+  for (const task of tasks) {
+    if (Number(task.totalTokens) > 0) {
+      lines.push(sample('dsh_cron_task_tokens_total', { task: task.id }, task.totalTokens));
+    }
+  }
+
+  lines.push('# HELP dsh_cron_task_cost_usd_total Estimated cumulative LLM cost in USD.');
+  lines.push('# TYPE dsh_cron_task_cost_usd_total counter');
+  for (const task of tasks) {
+    if (Number(task.totalCostUsd) > 0) {
+      lines.push(sample('dsh_cron_task_cost_usd_total', { task: task.id }, task.totalCostUsd));
+    }
+  }
+
   return lines.join(NL) + NL;
 }
 
@@ -90,6 +112,7 @@ export function createMetricsHandler({ store, scheduler }) {
       tasks: store.list({ status: 'all' }),
       stats: store.getAggregatedStats(),
       runCounters: typeof scheduler.getRunCounters === 'function' ? scheduler.getRunCounters() : {},
+      scheduler,
     });
     res.writeHead(200, { 'Content-Type': METRICS_CONTENT_TYPE, 'Cache-Control': 'no-store' });
     res.end(req.method === 'HEAD' ? undefined : body);

package/lib/runner.js

@@ -54,7 +54,7 @@ export class SessionRunner {
       }, timeoutMs);
     });
 
-    const executionPromise = this._run(task, controller.signal);
+    const executionPromise = this._run(task, controller.signal, options);
 
     try {
       return await Promise.race([executionPromise, timeoutPromise]);
@@ -195,7 +195,7 @@ export class SessionRunner {
   }
 
   /** Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9). */
-  async _runExternal(task, runtime, signal) {
+  async _runExternal(task, runtime, signal, execOptions = {}) {
     if (runtime === 'ssh' && task.sshProfileId) {
       const viaService = await this._runViaRemoteWorkspace(task, signal);
       if (viaService) return viaService;
@@ -239,9 +239,13 @@ export class SessionRunner {
         signal.addEventListener('abort', abortHandler, { once: true });
       }
 
+      const runEnv = { ...invocation.env };
+      if (execOptions?.prevOutput !== undefined) {
+        runEnv.DSH_PREV_OUTPUT = String(execOptions.prevOutput);
+      }
       const options = {
         cwd,
-        env: invocation.env,
+        env: runEnv,
         detached: isPosix,
         stdio: ['ignore', 'pipe', 'pipe'],
       };
@@ -293,27 +297,27 @@ export class SessionRunner {
     });
   }
 
-  async _run(task, signal) {
+  async _run(task, signal, options = {}) {
     console.log(`[dsh-cron] executing task "${task.title}" (${task.id})`);
 
     // 1. Non-LLM runtimes: shell, Node.js, Python, HTTP, SSH, Docker (#4 #5 #7 #8 #9)
     const runtime = normalizeTaskType(task.type);
     if (EXTERNAL_RUNTIMES.includes(runtime) || task.mode === 'no-llm') {
-      return this._runExternal(task, runtime === 'llm' ? 'script' : runtime, signal);
+      return this._runExternal(task, runtime === 'llm' ? 'script' : runtime, signal, options);
     }
 
     // 2. Agent session, when the harness exposes one
     if (this.ctx && this.ctx.agents && typeof this.ctx.agents.create === 'function') {
-      return this._runAgentSession(task, runtime, signal);
+      return this._runAgentSession(task, runtime, signal, options);
     }
 
     // 3. Legacy session service
     if (this.ctx && this.ctx.session && typeof this.ctx.session.create === 'function') {
-      return this._runLegacySession(task);
+      return this._runLegacySession(task, options);
     }
 
     // 4. Nothing to run through: report the prompt as triggered
-    return this._runBare(task);
+    return this._runBare(task, options);
   }
 
   /** Legacy session service path; falls back to the bare report. */
@@ -336,7 +340,7 @@ export class SessionRunner {
     return this._runBare(task);
   }
 
-  _runBare(task) {
+  _runBare(task, execOptions = {}) {
     return {
       output: `[dsh-cron] Prompt triggered: "${task.prompt.slice(0, 100)}..."`,
       usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
@@ -344,9 +348,18 @@ export class SessionRunner {
     };
   }
 
-  async _runAgentSession(task, runtime, signal) {
+  async _runAgentSession(task, runtime, signal, execOptions = {}) {
     try {
-      const prep = await this._prepareAgentRun(task, runtime, signal);
+      let effectiveTask = task;
+      if (execOptions?.prevOutput) {
+        const prev = String(execOptions.prevOutput);
+        const prompt = task.prompt || '';
+        const newPrompt = prompt.includes('{{prevOutput}}')
+          ? prompt.replaceAll('{{prevOutput}}', prev)
+          : `[Previous Output]:\n${prev}\n\n${prompt}`;
+        effectiveTask = { ...task, prompt: newPrompt };
+      }
+      const prep = await this._prepareAgentRun(effectiveTask, runtime, signal);
       return await this._executeAgentTurn(task, prep);
     } catch (err) {
       console.error(`[dsh-cron] agent execution failed:`, err.message);

package/lib/scheduler.js

@@ -1,4 +1,5 @@
 import { Cron } from 'croner';
+import { parseLlmActionDirectives, executeLlmActionDirectives } from './llm-actions.js';
 import { applySilentRule } from './silent-rule.js';
 import { inspectFailure } from './failure-inspector.js';
 
@@ -403,7 +404,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 +417,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 +445,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 +455,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,7 +473,7 @@ export class TaskScheduler {
   }
 
 
-  async runTask(taskId) {
+  async runTask(taskId, options = {}) {
     const task = this.store.get(taskId);
     if (!task) return;
 
@@ -480,15 +481,15 @@ export class TaskScheduler {
     if (currentRun === null) return;
 
     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);
   }
 
   /**
    * 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 runInfo = {
       at: start,
       status: outcome.status,
@@ -522,6 +523,55 @@ export class TaskScheduler {
 
     if (!silent.skipped) await this.deliverNotifications(task, runInfo);
     this.finishRun(task, taskId, outcome.status, queuedCount);
+
+    // 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 isSuccess = outcome.status === 'success';
+    const isFailure = outcome.status === 'error' || outcome.status === 'timeout';
+    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 +775,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,6 +236,8 @@ 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),
       totalTokens: prev.totalTokens || 0,
       totalCostUsd: prev.totalCostUsd || 0,
@@ -335,6 +339,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,8 @@ export const PATCHABLE_TASK_FIELDS = [
   'timeoutSeconds',
   'overlapPolicy',
   'kanbanMode',
+  'onSuccess',
+  'onFailure',
   '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.10",
   "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",