@goodandready/dsh-cron 0.2.8 → 0.2.10

package/README.md

@@ -317,6 +317,21 @@ Environment used by the check: `DSH_WEB_BASE` (default `http://127.0.0.1:3080`),
 ### 20. Internal Refactor: Schedule Parsing and Arming (#97)
 Developer-facing, no behaviour change. `parseScheduleExpression` was split into small functions that keep the same branch order — `parseAtExpression`, `parseRelativeOneShot`, `parseIntervalExpression`, `parseAliasExpression`, `parseCronExpression` — and `scheduleTask` into `clearScheduled`, `scheduleOneShot` and `scheduleCron`. The existing test suite passed unchanged and targeted tests were added for branch precedence and error messages.
 
+### 21. Performance & Process Isolation Pack (Added in v0.2.9, #134)
+- **Process-Tree Termination**: Shell and script tasks run in an isolated process group (`detached: true` on POSIX); aborts and timeouts send `SIGTERM` followed by `SIGKILL` to the entire group (`-child.pid`) to eliminate orphan and zombie processes.
+- **Concurrency Throttling**: Default safe limit `maxConcurrent = 2` prevents CPU and memory spikes during overlapping scheduled runs.
+- **Transient Error Retry**: Exponential backoff retry (up to 3 attempts) for transient network and provider errors (`429`, `502`, `503`, `504`, `ECONNRESET`).
+- **Network & UI Optimization**: `GET /dsh-cron/tasks` provides `ETag` and responds with `304 Not Modified`; client UI adapts polling frequency (`visibilitychange`: 30s in background tabs, 8s in active tabs).
+- **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

@@ -5,13 +5,14 @@
  * unchanged.
  */
 
-import { randomUUID } from 'node:crypto';
+import { randomUUID, createHash } from 'node:crypto';
 import { parseScheduleExpression } from './scheduler.js';
 import { normalizeTaskType, CODE_EXECUTING_TYPES } from './runtimes.js';
 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;
@@ -88,7 +94,7 @@ async function handleTaskCollection({ store, scheduler, collection, req, res, ur
     return;
   }
   if (req.method === 'GET') {
-    listTasks({ store, scheduler, collection, res, url });
+    listTasks({ store, scheduler, collection, req, res, url });
     return;
   }
   if (req.method === 'POST') {
@@ -98,7 +104,7 @@ async function handleTaskCollection({ store, scheduler, collection, req, res, ur
   sendJson(res, 405, NOT_ALLOWED);
 }
 
-function listTasks({ store, scheduler, collection, res, url }) {
+function listTasks({ store, scheduler, collection, req, res, url }) {
   const status = url.searchParams.get('status') || 'all';
   const query = url.searchParams.get('query') || '';
   const list = store.list({ status, query }).map((t) => ({
@@ -107,7 +113,26 @@ function listTasks({ store, scheduler, collection, res, url }) {
     runningSince: scheduler.runningSince(t.id),
   }));
   const stats = store.getAggregatedStats();
-  sendJson(res, 200, { ok: true, tasks: list, recommendations: collection.recommendations, stats });
+  const payload = { ok: true, tasks: list, recommendations: collection.recommendations, stats };
+
+  // Calculate ETag based on payload JSON representation (#134)
+  const bodyString = JSON.stringify(payload);
+  const etag = 'W/"' + createHash('sha1').update(bodyString).digest('hex') + '"';
+
+  if (req && req.headers) {
+    const ifNoneMatch = req.headers['if-none-match'];
+    if (ifNoneMatch && (ifNoneMatch === etag || ifNoneMatch === etag.slice(2))) {
+      res.writeHead(304, { 'ETag': etag, 'Cache-Control': 'no-cache' });
+      res.end();
+      return;
+    }
+  }
+
+  if (typeof res.setHeader === 'function') {
+    res.setHeader('ETag', etag);
+    res.setHeader('Cache-Control', 'no-cache');
+  }
+  sendJson(res, 200, payload);
 }
 
 async function createOrUpdateTask({ store, scheduler, req, res }) {
@@ -327,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) });
@@ -531,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);
@@ -1035,11 +1037,29 @@ window.__ModuleLoader__.load({
         }
       };
 
+      const lastEtagRef = React.useRef('');
+
       React.useEffect(() => {
         fetchTasks();
-        const pollInterval = setInterval(() => {          // Background polling without resetting loading spinner
-          fetch('/dsh-cron/tasks?status=' + encodeURIComponent(tab) + '&query=' + encodeURIComponent(query))
-            .then(res => res.json())
+
+        let timerId = null;
+        let isDestroyed = false;
+
+        const doPoll = () => {
+          if (isDestroyed) return;
+          const headers = {};
+          if (lastEtagRef.current) headers['If-None-Match'] = lastEtagRef.current;
+
+          fetch('/dsh-cron/tasks?status=' + encodeURIComponent(tab) + '&query=' + encodeURIComponent(query), { headers })
+            .then(res => {
+              if (res.status === 304) {
+                // Not modified: skip parsing JSON
+                return null;
+              }
+              const etag = res.headers.get('ETag');
+              if (etag) lastEtagRef.current = etag;
+              return res.json();
+            })
             .then(data => {
               if (data && data.ok) {
                 setTasks(data.tasks || []);
@@ -1047,9 +1067,36 @@ window.__ModuleLoader__.load({
                 setStats(data.stats || null);
               }
             })
-            .catch(() => {});
-        }, 8000);
-        return () => clearInterval(pollInterval);
+            .catch(() => {})
+            .finally(() => {
+              if (isDestroyed) return;
+              // Adaptive interval: 30s when tab is hidden, 8s when active (#134)
+              const intervalMs = (typeof document !== 'undefined' && document.hidden) ? 30000 : 8000;
+              timerId = setTimeout(doPoll, intervalMs);
+            });
+        };
+
+        // Trigger immediate fetch when visibility returns
+        const onVisibilityChange = () => {
+          if (typeof document !== 'undefined' && !document.hidden) {
+            if (timerId) clearTimeout(timerId);
+            doPoll();
+          }
+        };
+
+        if (typeof document !== 'undefined') {
+          document.addEventListener('visibilitychange', onVisibilityChange);
+        }
+
+        timerId = setTimeout(doPoll, 8000);
+
+        return () => {
+          isDestroyed = true;
+          if (timerId) clearTimeout(timerId);
+          if (typeof document !== 'undefined') {
+            document.removeEventListener('visibilitychange', onVisibilityChange);
+          }
+        };
       }, [tab, query]);
       React.useEffect(() => { loadModels(); }, []);
 
@@ -1420,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);
@@ -1482,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(),
@@ -1787,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
                       ),
@@ -2608,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 });
@@ -2634,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));
@@ -2657,6 +2712,7 @@ window.__ModuleLoader__.load({
               chatId,
               notifyTelegram: notify,
               onlyOnFailure: onlyFailure,
+              llmActionsEnabled: llmActionsEnabled,
               kanbanBaseUrl: kanbanUrl
             }, delivery))
           });
@@ -2786,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';
@@ -100,6 +100,7 @@ export const Config = z.object({
   giteaBaseUrl: z.string().default('').description('Gitea base URL for alert issues'),
   giteaRepo: z.string().default('').description('Gitea repository (owner/name) for alert issues'),
   giteaTokenRef: z.string().default('').description('Credential name for the Gitea API token'),
+  prReviewerEnabled: z.boolean().default(false).description('Enable automated PR Reviewer scheduled agent (#33)'),
   // --- Declarative jobs (#50, ADR-0001) ---
   // The array is intentionally permissive: each entry is validated on its own
   // with a precise message (see lib/config-jobs.js), so one broken entry cannot
@@ -122,7 +123,7 @@ export const SETTINGS_SYNC_KEYS = [
   'pushplusTokenRef',
   'pushplusUrl',
   'ttsBaseUrl',
-  'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef',
+  'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef', 'prReviewerEnabled',
   'apiToken',
 ];
 
@@ -526,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/recipes.js

@@ -19,6 +19,7 @@ export const RECIPE_CATEGORIES = [
   { id: 'storage', title: 'Storage' },
   { id: 'security', title: 'Security' },
   { id: 'maintenance', title: 'Maintenance windows' },
+  { id: 'ci', title: 'CI & Code review' },
 ];
 
 /** Commands a recipe must never contain, checked by the test suite. */
@@ -190,6 +191,18 @@ export const RECIPES = [
     prompt: 'uptime && echo "---" && uname -r && echo "---" && df -h / | tail -n 1',
     channels: ['telegram'],
   },
+  {
+    id: 'recipe_pr_reviewer',
+    category: 'ci',
+    title: 'Autonomous PR Reviewer (#33)',
+    description: 'Periodic inspection of open Pull Requests in Gitea with agent review analysis.',
+    type: 'llm',
+    schedule: '*/30 * * * *',
+    scheduleText: 'Every 30 minutes',
+    prompt: 'Check open Pull Requests in Gitea repository. Inspect changed diffs, evaluate code quality, verify test coverage and post a concise review summary.',
+    channels: ['telegram', 'gitea'],
+    silentRule: 'Stay silent when there are no open PRs or no new commits to review.',
+  },
 ];
 
 /** Detached copy of the catalog, safe to hand to the UI. */

package/lib/runner.js

@@ -1,3 +1,18 @@
+/**
+ * Helper to test if an error code or status is transient and eligible for retry (#134).
+ */
+export function isTransientError(errOrStatus) {
+  if (typeof errOrStatus === 'number') {
+    return errOrStatus === 429 || errOrStatus === 502 || errOrStatus === 503 || errOrStatus === 504;
+  }
+  const str = String(errOrStatus?.message || errOrStatus || '').toLowerCase();
+  return str.includes('429') || str.includes('too many requests') ||
+         str.includes('502') || str.includes('bad gateway') ||
+         str.includes('503') || str.includes('service unavailable') ||
+         str.includes('504') || str.includes('gateway timeout') ||
+         str.includes('econnreset') || str.includes('etimedout');
+}
+
 import { estimateTokenCost } from './integrations.js';
 import {
   EXTERNAL_RUNTIMES,
@@ -39,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]);
@@ -99,24 +114,44 @@ export class SessionRunner {
     });
   }
 
-  /** HTTP trigger runtime (#7). */
+  /** HTTP trigger runtime (#7) with transient retry (#134). */
   async _runHttp(task, request, signal) {
-    const res = await fetch(request.url, {
-      method: request.method,
-      headers: request.headers,
-      body: request.body,
-      signal,
-    });
-    const text = await res.text().catch(() => '');
-    const summary = `${request.method} ${request.url} -> ${res.status} ${res.statusText || ''}`.trim();
-    if (!res.ok) {
-      throw new Error(`${summary}\n${String(text).slice(0, 500)}`);
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (attempts < maxAttempts) {
+      attempts++;
+      try {
+        const res = await fetch(request.url, {
+          method: request.method,
+          headers: request.headers,
+          body: request.body,
+          signal,
+        });
+        const text = await res.text().catch(() => '');
+        const summary = `${request.method} ${request.url} -> ${res.status} ${res.statusText || ''}`.trim();
+        if (!res.ok) {
+          const err = new Error(`${summary}\n${String(text).slice(0, 500)}`);
+          if (isTransientError(res.status) && attempts < maxAttempts && !signal?.aborted) {
+            console.warn(`[dsh-cron] HTTP request returned ${res.status}, retrying attempt ${attempts + 1}/${maxAttempts}...`);
+            await new Promise((r) => setTimeout(r, attempts * 1000));
+            continue;
+          }
+          throw err;
+        }
+        return {
+          output: `${summary}\n${String(text).trim().slice(0, 4000)}`.trim(),
+          usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
+          costUsd: 0,
+        };
+      } catch (err) {
+        if (isTransientError(err) && attempts < maxAttempts && !signal?.aborted) {
+          console.warn(`[dsh-cron] HTTP request failed (${err.message}), retrying attempt ${attempts + 1}/${maxAttempts}...`);
+          await new Promise((r) => setTimeout(r, attempts * 1000));
+          continue;
+        }
+        throw err;
+      }
     }
-    return {
-      output: `${summary}\n${String(text).trim().slice(0, 4000)}`.trim(),
-      usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
-      costUsd: 0,
-    };
   }
 
   /**
@@ -160,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;
@@ -172,54 +207,117 @@ export class SessionRunner {
     const invocation = buildInvocation({ ...task, type: runtime }, cwd);
     if (invocation.http) return this._runHttp(task, invocation.http, signal);
 
-    const { exec, execFile } = await import('node:child_process');
+    const { spawn } = await import('node:child_process');
     return new Promise((resolve, reject) => {
-      const done = (err, stdout, stderr) => {
-        if (err) {
-          if (signal && signal.aborted) {
-            return reject(signal.reason || new Error('Command aborted'));
+      let child = null;
+      let settled = false;
+      let stdout = '';
+      let stderr = '';
+      const maxBuffer = 10 * 1024 * 1024;
+      const isPosix = process.platform !== 'win32';
+
+      const killProcessTree = (sig = 'SIGTERM') => {
+        if (!child || child.killed) return;
+        try {
+          if (isPosix && child.pid) {
+            try { process.kill(-child.pid, sig); } catch {}
+          } else if (child.pid) {
+            child.kill(sig);
           }
+        } catch {}
+      };
+
+      const abortHandler = () => {
+        killProcessTree('SIGTERM');
+        setTimeout(() => killProcessTree('SIGKILL'), 300);
+      };
+
+      if (signal) {
+        if (signal.aborted) {
+          return reject(signal.reason || new Error('Command aborted'));
+        }
+        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: runEnv,
+        detached: isPosix,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      };
+
+      if (invocation.file) {
+        child = spawn(invocation.file, invocation.args || [], options);
+      } else {
+        const shellPath = isPosix ? (process.env.SHELL || '/bin/bash') : (process.env.ComSpec || 'cmd.exe');
+        const shellArgs = isPosix ? ['-c', invocation.shellCommand] : ['/d', '/s', '/c', invocation.shellCommand];
+        child = spawn(shellPath, shellArgs, options);
+      }
+
+      child.stdout.on('data', (chunk) => {
+        if (stdout.length < maxBuffer) stdout += chunk;
+      });
+      child.stderr.on('data', (chunk) => {
+        if (stderr.length < maxBuffer) stderr += chunk;
+      });
+
+      child.on('error', (err) => {
+        if (settled) return;
+        settled = true;
+        if (signal) signal.removeEventListener('abort', abortHandler);
+        reject(err);
+      });
+
+      child.on('close', (code, sig) => {
+        if (settled) return;
+        settled = true;
+        if (signal) signal.removeEventListener('abort', abortHandler);
+
+        if (signal && signal.aborted) {
+          return reject(signal.reason || new Error('Command aborted'));
+        }
+
+        if (code !== 0 && code !== null) {
           const detail = String(stderr || '').trim();
-          return reject(new Error(detail ? `${err.message}\n${detail}` : err.message));
+          const msg = `${runtime} task exited with code ${code}`;
+          return reject(new Error(detail ? `${msg}\n${detail}` : msg));
         }
+
         const out = (stdout || stderr || '').trim();
         resolve({
           output: out || `${runtime} task completed with code 0`,
           usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
           costUsd: 0,
         });
-      };
-      const options = { cwd, signal, maxBuffer: 10 * 1024 * 1024, env: invocation.env };
-      if (invocation.file) {
-        execFile(invocation.file, invocation.args || [], options, done);
-      } else {
-        const shellPath = process.platform === 'win32' ? undefined : (process.env.SHELL || '/bin/bash');
-        exec(invocation.shellCommand, { ...options, shell: shellPath }, done);
-      }
+      });
     });
   }
 
-  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. */
@@ -242,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 },
@@ -250,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';
 
@@ -169,7 +170,7 @@ export class TaskScheduler {
   constructor(store, executeFn, options = {}) {
     this.store = store;
     this.executeFn = executeFn;
-    this.maxConcurrent = Number(options.maxConcurrent) > 0 ? Number(options.maxConcurrent) : 0; // 0 = unlimited (#52)
+    this.maxConcurrent = options.maxConcurrent !== undefined && Number(options.maxConcurrent) >= 0 ? Number(options.maxConcurrent) : 2; // default 2 parallel runs (#134, #52)
     this.defaultTimezone = options.defaultTimezone || ''; // #13
     this.resolveSecrets = typeof options.resolveSecrets === 'function' ? options.resolveSecrets : null; // #51
     this.deliver = typeof options.deliver === 'function' ? options.deliver : null; // #26 channel router
@@ -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,
@@ -295,16 +299,99 @@ export class TaskStore {
       suggestion: runInfo.suggestion ? String(runInfo.suggestion).slice(0, 2000) : '',
       confidence: runInfo.confidence || '',
     });
-    if (runs.length > 50) runs.length = 50;
+    // Keep up to 100 runs in active store; archive older runs to tasks-history-archive.json (#134)
+    if (runs.length > 100) {
+      const overflow = runs.splice(100);
+      this._archiveHistoryRuns(id, overflow);
+    }
     this.history.set(id, runs);
     this.save();
   }
 
+  /**
+   * Append rotated overflow history entries into tasks-history-archive.json (#134).
+   */
+  _archiveHistoryRuns(id, overflowRuns) {
+    if (!Array.isArray(overflowRuns) || overflowRuns.length === 0) return;
+    try {
+      const dir = path.dirname(this.filePath);
+      const archivePath = path.join(dir, 'tasks-history-archive.json');
+      let archive = {};
+      if (fs.existsSync(archivePath)) {
+        try {
+          archive = JSON.parse(fs.readFileSync(archivePath, 'utf-8')) || {};
+        } catch {}
+      }
+      if (!Array.isArray(archive[id])) archive[id] = [];
+      archive[id].push(...overflowRuns);
+      // Write atomically with tmp file
+      const rand = Math.random().toString(36).slice(2, 8);
+      const tmp = `${archivePath}.tmp.${process.pid}_${Date.now()}_${rand}`;
+      fs.writeFileSync(tmp, JSON.stringify(archive, null, 2), 'utf-8');
+      fs.renameSync(tmp, archivePath);
+    } catch (archiveErr) {
+      console.error('[dsh-cron] history archive error:', archiveErr.message);
+    }
+  }
+
   getHistory(id, limit = 20) {
     const runs = this.history.get(id) || [];
     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.8",
+  "version": "0.2.10",
   "description": "Scheduled cron tasks, background automation and agent execution for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",