@goodandready/dsh-cron 0.2.50 → 0.2.52

package/lib/cron-tool.js

@@ -152,6 +152,30 @@ export const cronToolParameters = {
     enum: ['default', 'read-only', 'workspace-write', 'full'],
     description: 'Permission preset applied to the task session (only used for agent session tasks: llm, skill, workflow)',
   },
+  requireApproval: {
+    type: 'boolean',
+    description: 'Require explicit human approval before execution (#318)',
+  },
+  validators: {
+    type: 'array',
+    description: 'Declarative post-execution validation checks (json, regex, text, exitCode, file)',
+    items: {
+      type: 'object',
+      properties: {
+        type: { type: 'string', enum: ['json', 'regex', 'text', 'exitCode', 'file'] },
+        pattern: { type: 'string' },
+        text: { type: 'string' },
+        negate: { type: 'boolean' },
+        statusKey: { type: 'string' },
+        expected: { type: 'string' },
+        path: { type: 'string' },
+        mustExist: { type: 'boolean' },
+        minBytes: { type: 'number' },
+        target: { type: 'string' },
+      },
+      additionalProperties: true,
+    },
+  },
   kanbanMode: {
     type: 'string',
     enum: ['none', 'on_failure', 'always'],

package/lib/global-budgets.js

@@ -0,0 +1,137 @@
+import { logger } from './logger.js';
+
+/**
+ * Global & Provider/Model Budgets and Rate Limits (#320).
+ * Manages shared expenditure windows and concurrent reservations
+ * across all scheduled tasks.
+ */
+
+export class GlobalBudgetManager {
+  constructor() {
+    this.reservations = new Map(); // reservationId -> { provider, model, costUsd, at }
+  }
+
+  /**
+   * Calculate total expenditure from store history across all tasks
+   * filtered by provider/model and window.
+   */
+  calculateUsage(store, { provider = null, model = null, windowMs = 86400000, now = Date.now() } = {}) {
+    const cutoff = now - windowMs;
+    let totalCostUsd = 0;
+    let totalTokens = 0;
+    let runCount = 0;
+
+    const allTasks = store.list ? store.list() : [];
+    for (const task of allTasks) {
+      if (provider && task.provider && task.provider !== provider) continue;
+      if (model && task.model && task.model !== model) continue;
+
+      const runs = (store.history && store.history.get(task.id)) || [];
+      for (const r of runs) {
+        if (r && typeof r.at === 'number' && r.at >= cutoff) {
+          totalCostUsd += Number(r.costUsd) || 0;
+          if (typeof r.tokens === 'number') {
+            totalTokens += r.tokens;
+          } else if (r.usage) {
+            totalTokens += (r.usage.inputTokens || 0) + (r.usage.outputTokens || 0) + (r.usage.cacheReadTokens || 0);
+          }
+          runCount++;
+        }
+      }
+    }
+
+    return {
+      totalCostUsd: Number(totalCostUsd.toFixed(6)),
+      totalTokens,
+      runCount,
+    };
+  }
+
+  /**
+   * Check if global or provider budget limits are exceeded.
+   */
+  checkBudget(store, task, settings = {}, now = Date.now()) {
+    // 1. Global Monthly / Daily Cost Limit
+    const globalDailyCostLimit = Number(settings.globalDailyCostLimitUsd) || 0;
+    if (globalDailyCostLimit > 0) {
+      const usage = this.calculateUsage(store, { windowMs: 86400000, now });
+      const pendingReservationsCost = this.getActiveReservationsCost();
+      if ((usage.totalCostUsd + pendingReservationsCost) >= globalDailyCostLimit) {
+        return {
+          exceeded: true,
+          type: 'globalDailyCostLimitUsd',
+          reason: `Global daily budget exceeded: $${(usage.totalCostUsd + pendingReservationsCost).toFixed(4)} >= $${globalDailyCostLimit.toFixed(4)}`,
+          current: usage.totalCostUsd,
+          limit: globalDailyCostLimit,
+        };
+      }
+    }
+
+    // 2. Provider Rate Limit (max runs per minute / hour)
+    const provider = task.provider || 'default';
+    const providerHourlyLimit = (settings.providerHourlyRunLimits && Number(settings.providerHourlyRunLimits[provider])) || 0;
+    if (providerHourlyLimit > 0) {
+      const pUsage = this.calculateUsage(store, { provider, windowMs: 3600000, now });
+      if (pUsage.runCount >= providerHourlyLimit) {
+        return {
+          exceeded: true,
+          type: 'providerHourlyLimit',
+          reason: `Provider "${provider}" hourly run limit reached: ${pUsage.runCount} >= ${providerHourlyLimit}`,
+          current: pUsage.runCount,
+          limit: providerHourlyLimit,
+        };
+      }
+    }
+
+    // 3. Model Rate Limit
+    const model = task.model || 'default';
+    const modelHourlyLimit = (settings.modelHourlyRunLimits && Number(settings.modelHourlyRunLimits[model])) || 0;
+    if (modelHourlyLimit > 0) {
+      const mUsage = this.calculateUsage(store, { model, windowMs: 3600000, now });
+      if (mUsage.runCount >= modelHourlyLimit) {
+        return {
+          exceeded: true,
+          type: 'modelHourlyLimit',
+          reason: `Model "${model}" hourly run limit reached: ${mUsage.runCount} >= ${modelHourlyLimit}`,
+          current: mUsage.runCount,
+          limit: modelHourlyLimit,
+        };
+      }
+    }
+
+    return { exceeded: false };
+  }
+
+  reserve(task, estimatedCostUsd = 0.05) {
+    const id = 'res_' + Math.random().toString(36).slice(2, 9);
+    this.reservations.set(id, {
+      taskId: task.id,
+      provider: task.provider || 'default',
+      model: task.model || 'default',
+      costUsd: Number(estimatedCostUsd) || 0,
+      at: Date.now(),
+    });
+    return id;
+  }
+
+  settle(reservationId) {
+    if (reservationId) {
+      this.reservations.delete(reservationId);
+    }
+  }
+
+  getActiveReservationsCost() {
+    let sum = 0;
+    const cutoff = Date.now() - 300000; // 5 min TTL on stale reservations
+    for (const [id, r] of this.reservations.entries()) {
+      if (r.at < cutoff) {
+        this.reservations.delete(id);
+      } else {
+        sum += r.costUsd;
+      }
+    }
+    return sum;
+  }
+}
+
+export const globalBudgetManager = new GlobalBudgetManager();

package/lib/index.js

@@ -165,7 +165,10 @@ export function apply(ctx, rawConfig) {
     deliver: (task, runInfo, settings) => deliverRun({
       task,
       runInfo,
-      settings,
+      settings: {
+        ...settings,
+        _webServerPort: ctx.webServer?.port || 3080,
+      },
       secrets: {
         botToken: settings.botToken || '',
         resolveSecret: (ref) => resolveCredentialValue(ctx, ref),

package/lib/recipes-catalog.js

@@ -0,0 +1,107 @@
+import { RECIPES as BASE_RECIPES } from './recipes.js';
+
+/**
+ * Enhanced Verified Recipes Catalog with guided parameters, dependencies, and test runs (#322).
+ */
+
+export const EXTENDED_RECIPES = [
+  ...BASE_RECIPES,
+  {
+    id: 'recipe_gitea_issues_digest',
+    category: 'maintenance',
+    title: 'Gitea Issues Weekly Digest',
+    description: 'Summarises open bugs and feature issues from local Gitea and reports triage status.',
+    type: 'llm',
+    schedule: '0 9 * * 1',
+    scheduleText: 'Mondays at 09:00',
+    prompt: 'Query open Gitea issues. Group by priority and scope, highlight stale issues, and produce an actionable weekly triage digest.',
+    channels: ['telegram'],
+    silentRule: 'Stay silent when there are no new or updated issues in the past 7 days.',
+    dependencies: {
+      integrations: ['gitea'],
+      credentials: ['giteaTokenRef'],
+    },
+    parameters: [
+      { name: 'repo', label: 'Repository (owner/name)', type: 'string', default: 'goodandready/dsh-cron' },
+      { name: 'daysBack', label: 'Days back', type: 'number', default: 7 },
+    ],
+  },
+  {
+    id: 'recipe_security_dependency_audit',
+    category: 'security',
+    title: 'NPM Dependency Security Audit',
+    description: 'Runs npm audit in repository directory and alerts on critical or high vulnerabilities.',
+    type: 'script',
+    schedule: '0 6 * * 1',
+    scheduleText: 'Mondays at 06:00',
+    prompt: 'npm audit --audit-level=high 2>&1 || { echo "CRITICAL / HIGH vulnerabilities found!"; exit 1; }',
+    channels: ['telegram'],
+    silentRule: 'Stay silent when npm audit finds 0 high/critical vulnerabilities.',
+    dependencies: {
+      integrations: ['shell'],
+    },
+    parameters: [
+      { name: 'cwd', label: 'Working Directory', type: 'string', default: '.' },
+    ],
+  },
+  {
+    id: 'recipe_model_cost_summary',
+    category: 'system',
+    title: 'Daily Model Spend & Token Telemetry',
+    description: 'Computes rolling 24h spend across all models and warns if daily cost exceeds threshold.',
+    type: 'llm',
+    schedule: '0 23 * * *',
+    scheduleText: 'Every day at 23:00',
+    prompt: 'Analyze token usage ledger across all active cron jobs. Provide cost breakdown per model and identify anomalies.',
+    channels: ['telegram'],
+    silentRule: 'Stay silent when total daily expenditure is under $0.10.',
+    dependencies: {
+      integrations: ['cron-store'],
+    },
+    parameters: [
+      { name: 'thresholdUsd', label: 'Alert Threshold (USD)', type: 'number', default: 1.0 },
+    ],
+  },
+];
+
+/**
+ * Validate recipe dependencies against host settings.
+ * Returns { ok: boolean, missing: string[] }
+ */
+export function validateRecipeDependencies(recipe, settings = {}) {
+  if (!recipe || !recipe.dependencies) return { ok: true, missing: [] };
+  const missing = [];
+  const deps = recipe.dependencies;
+
+  if (Array.isArray(deps.credentials)) {
+    for (const cred of deps.credentials) {
+      if (!settings[cred] && !settings[cred.replace('Ref', '')]) {
+        missing.push(`Credential: ${cred}`);
+      }
+    }
+  }
+
+  if (Array.isArray(deps.integrations)) {
+    for (const integ of deps.integrations) {
+      if (integ === 'gitea' && !settings.giteaBaseUrl) {
+        missing.push('Integration: Gitea (giteaBaseUrl not configured)');
+      }
+    }
+  }
+
+  return {
+    ok: missing.length === 0,
+    missing,
+  };
+}
+
+export function listVerifiedRecipes(settings = {}) {
+  return EXTENDED_RECIPES.map((r) => {
+    const depCheck = validateRecipeDependencies(r, settings);
+    return {
+      ...r,
+      dependenciesValid: depCheck.ok,
+      missingDependencies: depCheck.missing,
+    };
+  });
+}

package/lib/routes.js

@@ -1,3 +1,4 @@
+import { listVerifiedRecipes } from './recipes-catalog.js';
 import { randomUUID } from 'node:crypto';
 import { createCronApiHandler } from './api.js';
 import { createMetricsHandler } from './metrics.js';
@@ -93,8 +94,9 @@ export function registerRoutes(ctx, { store, scheduler, recommendations }) {
           sendJson(res, 405, { ok: false, error: 'Method not allowed' });
           return;
         }
+        const settings = store.getSettings ? store.getSettings() : {};
         const categories = recipesByCategory();
-        const recipes = categories.reduce((acc, category) => acc.concat(category.recipes), []);
+        const recipes = listVerifiedRecipes(settings);
         sendJson(res, 200, { ok: true, categories, recipes });
       } catch (err) {
         sendJson(res, err.statusCode || 500, { ok: false, error: err.message });

package/lib/scheduler-execution.js

@@ -1,3 +1,6 @@
+import { approvalManager } from './approval.js';
+import { globalBudgetManager } from './global-budgets.js';
+import { validateRunResult } from './validators.js';
 import { logger } from './logger.js';
 import { checkAndApplyBurnGuard, checkTaskBudgetLimits } from './burn-guard.js';
 import { resolveTaskForExecution } from './prompt-interpolation.js';
@@ -308,6 +311,30 @@ export async function executeTask(scheduler, taskId, options = {}) {
     };
   }
 
+  // 1. Approval Gate (#318): Human-in-the-loop check before executing actions requiring approval
+  if (task.requireApproval && !options.approvedBy) {
+    let pending = approvalManager.getPendingProposalForTask(taskId);
+    if (!pending) {
+      pending = approvalManager.createProposal(taskId, null, {
+        actionType: 'run',
+        summary: `Execution of task "${task.title}" requires human approval`,
+        details: { prompt: task.prompt, type: task.type, model: task.model }
+      });
+    }
+    logger.info(`[dsh-cron] Task "${task.title}" (${taskId}) paused awaiting human approval (${pending.id})`);
+    scheduler.recordSkipped(taskId, `Awaiting human approval: proposal ${pending.id}`);
+    return { ok: false, status: 'waiting_approval', proposalId: pending.id, stoppedReason: 'Awaiting human approval' };
+  }
+
+  // 2. Global & Provider/Model Budgets (#320)
+  const settings = typeof scheduler.store.getSettings === 'function' ? scheduler.store.getSettings() : {};
+  const globalBudget = globalBudgetManager.checkBudget(scheduler.store, task, settings);
+  if (globalBudget.exceeded) {
+    logger.warn(`[dsh-cron] Global budget limit blocked task "${task.title}" (${taskId}): ${globalBudget.reason}`);
+    scheduler.recordSkipped(taskId, `Budget limit reached: ${globalBudget.reason}`);
+    return { ok: false, status: 'error', error: globalBudget.reason, budgetBlocked: true };
+  }
+
   // Pre-flight Burn Guard check (#181): prevent executing task if budget already breached
   const runs = (scheduler.store.history && scheduler.store.history.get(taskId)) || [];
   const guard = checkTaskBudgetLimits(task, runs);
@@ -327,7 +354,9 @@ export async function executeTask(scheduler, taskId, options = {}) {
   const currentRun = scheduler.beginRun(task, taskId, options);
   if (currentRun === null) return null;
 
+  const preflightStart = Date.now();
   const preflight = await executePreflight(task);
+  const preflightDurationMs = Date.now() - preflightStart;
   if (!preflight.ok) {
     logger.info(`[dsh-cron] task "${task.title}" (${taskId}) skipped: ${preflight.reason}`);
     scheduler.running.delete(taskId);
@@ -336,8 +365,17 @@ export async function executeTask(scheduler, taskId, options = {}) {
   }
 
   const start = Date.now();
-  const outcome = await scheduler.executeWithFallback(task, currentRun.controller.signal, options);
-  await scheduler.completeRun(task, taskId, currentRun, outcome, start, options);
+  const reservationId = globalBudgetManager.reserve(task);
+  let outcome;
+  try {
+    outcome = await scheduler.executeWithFallback(task, currentRun.controller.signal, options);
+  } finally {
+    globalBudgetManager.settle(reservationId);
+  }
+  await scheduler.completeRun(task, taskId, currentRun, outcome, start, {
+    ...options,
+    preflightDurationMs,
+  });
   return outcome;
 }
 
@@ -429,7 +467,7 @@ export async function deliverNotifications(task, runInfo, { store, resolveSecret
         logger.warn('[dsh-cron] credential resolution failed:', secErr.message);
       }
     }
-    if (typeof deliver !== 'function') return;
+    if (typeof deliver !== 'function') return { status: 'skipped', delivered: [], failures: [] };
     const result = await deliver(task, runInfo, settings);
     if (result && Array.isArray(result.delivered) && result.delivered.length) {
       logger.info(`[dsh-cron] delivered "${task.title}" to: ${result.delivered.map((d) => d.channel).join(', ')}`);
@@ -437,8 +475,16 @@ export async function deliverNotifications(task, runInfo, { store, resolveSecret
     if (result && Array.isArray(result.failures) && result.failures.length) {
       logger.warn(`[dsh-cron] delivery failures for "${task.title}": ${result.failures.map((f) => `${f.channel}: ${f.error}`).join('; ')}`);
     }
+    const delivered = Array.isArray(result?.delivered) ? result.delivered : [];
+    const failures = Array.isArray(result?.failures) ? result.failures : [];
+    let status = 'skipped';
+    if (delivered.length > 0 && failures.length === 0) status = 'delivered';
+    else if (delivered.length > 0 && failures.length > 0) status = 'partial';
+    else if (delivered.length === 0 && failures.length > 0) status = 'failed';
+    return { status, delivered, failures };
   } catch (notifyErr) {
     logger.error('[dsh-cron] notification error:', notifyErr.message);
+    return { status: 'failed', delivered: [], failures: [{ channel: 'all', error: notifyErr.message }] };
   }
 }
 
@@ -522,13 +568,41 @@ export function finishRun(scheduler, taskSnapshot, taskId, status, queuedCount,
 /**
  * Handle complete run lifecycle: metrics, self-healing, diagnosis, silent rule, storage, delivery, chaining.
  */
+function computeStoppedReason(status, valRes, error) {
+  if (status === 'validation_failed') return `Validation failed: ${valRes?.error || 'Check failed'}`;
+  if (status === 'validator_error') return `Validator configuration error: ${valRes?.error || 'Check failed'}`;
+  if (status === 'timeout') return 'Execution timed out';
+  if (status === 'error') return error ? `Execution error: ${error}` : 'Execution error';
+  if (status === 'success') return 'Completed successfully';
+  if (status === 'skipped') return error || 'Run skipped';
+  return null;
+}
+
 export async function handleCompleteRun(scheduler, task, taskId, currentRun, outcome, start, options = {}) {
+  // Post-execution declarative validation (#316)
+  let valRes = { ok: true, skipped: true };
+  let valDurationMs = 0;
+  if (outcome.status === 'success' && Array.isArray(task.validators) && task.validators.length > 0) {
+    const vStart = Date.now();
+    valRes = validateRunResult(task, outcome, { cwd: task.cwd });
+    valDurationMs = Date.now() - vStart;
+    if (!valRes.ok) {
+      outcome.status = valRes.status === 'error' ? 'validator_error' : 'validation_failed';
+      outcome.error = valRes.error || 'Validation failed';
+    }
+  }
+
   const isSuccess = outcome.status === 'success';
-  const isFailure = outcome.status === 'error' || outcome.status === 'timeout';
+  const isFailure = outcome.status === 'error' || outcome.status === 'timeout' || outcome.status === 'validation_failed' || outcome.status === 'validator_error';
+  const executionMs = Date.now() - start;
+  const queueWaitMs = (currentRun && currentRun.startedAt && currentRun.queuedAt) ? (currentRun.startedAt - currentRun.queuedAt) : 0;
+  const preflightMs = options.preflightDurationMs || 0;
+
   const runInfo = {
+    runId: currentRun?.id || ('run_' + Math.random().toString(36).slice(2, 9) + '_' + Date.now()),
     at: start,
     status: outcome.status,
-    durationMs: Date.now() - start,
+    durationMs: executionMs,
     output: outcome.output,
     error: outcome.error,
     usage: outcome.usage,
@@ -536,6 +610,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     sessionId: outcome.sessionId,
     model: outcome.model || task.model || '',
     fallback: Boolean(outcome.fallback),
+    validation: valRes.skipped ? null : valRes,
   };
 
   if (isFailure && task.selfHealingCommand) {
@@ -573,6 +648,58 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
 
   const silent = await scheduler.applyModelAssists(task, runInfo);
 
+  let deliveryResult = { status: 'skipped', delivered: [], failures: [] };
+  let delivStart = Date.now();
+  if (!silent.skipped) {
+    deliveryResult = (await scheduler.deliverNotifications(task, runInfo)) || deliveryResult;
+  }
+  const delivDurationMs = Date.now() - delivStart;
+
+  const stages = [
+    {
+      name: 'queue',
+      status: 'success',
+      durationMs: queueWaitMs,
+    },
+    {
+      name: 'preflight',
+      status: 'success',
+      durationMs: preflightMs,
+      error: null,
+    },
+    {
+      name: 'execution',
+      status: (outcome.status === 'error' || outcome.status === 'timeout') ? 'failed' : 'success',
+      durationMs: executionMs,
+      error: (outcome.status === 'error' || outcome.status === 'timeout') ? (outcome.error || null) : null,
+    },
+    {
+      name: 'validation',
+      status: valRes.skipped ? 'skipped' : (valRes.ok ? 'success' : 'failed'),
+      durationMs: valDurationMs,
+      error: valRes.ok ? null : (valRes.error || null),
+    },
+    {
+      name: 'delivery',
+      status: deliveryResult?.status || 'skipped',
+      durationMs: delivDurationMs,
+      error: (deliveryResult?.failures && deliveryResult.failures.length > 0)
+        ? deliveryResult.failures.map(f => `${f.channel}: ${f.error}`).join('; ')
+        : null,
+      delivered: deliveryResult?.delivered || [],
+      failures: deliveryResult?.failures || [],
+    },
+  ];
+
+  runInfo.stages = stages;
+  runInfo.delivery = deliveryResult;
+  runInfo.cost = {
+    amount: Number(outcome.costUsd) || 0,
+    currency: 'USD',
+    kind: (Number(outcome.costUsd) > 0) ? 'exact' : ((task.type === 'llm' || task.type === 'skill' || task.type === 'workflow') ? 'unknown' : 'exact'),
+  };
+  runInfo.stoppedReason = computeStoppedReason(outcome.status, valRes, outcome.error);
+
   try {
     scheduler.store.recordRun(taskId, runInfo);
   } catch (recordErr) {
@@ -585,7 +712,6 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
   const queuedRuns = isCurrentRun ? (finishedRun?.queuedRuns || []) : [];
   const queuedCount = isCurrentRun ? (finishedRun?.queueCount || 0) : 0;
 
-  if (!silent.skipped) await scheduler.deliverNotifications(task, runInfo);
   scheduler.finishRun(task, taskId, outcome.status, queuedCount, {
     isCurrentRun,
     runId: currentRun?.id,

package/lib/scheduler.js

@@ -548,7 +548,9 @@ export class TaskScheduler {
 
   recordSkipped(taskId, reason) {
     this.countRun('skipped');
+    const runId = 'run_' + Math.random().toString(36).slice(2, 9) + '_' + Date.now();
     this.store.recordRun(taskId, {
+      runId,
       at: Date.now(),
       status: 'skipped',
       durationMs: 0,
@@ -556,6 +558,16 @@ export class TaskScheduler {
       error: null,
       usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 },
       costUsd: 0,
+      stoppedReason: reason,
+      stages: [
+        { name: 'queue', status: 'skipped', durationMs: 0 },
+        { name: 'preflight', status: 'skipped', durationMs: 0, error: reason },
+        { name: 'execution', status: 'skipped', durationMs: 0 },
+        { name: 'validation', status: 'skipped', durationMs: 0 },
+        { name: 'delivery', status: 'skipped', durationMs: 0 },
+      ],
+      cost: { amount: 0, currency: 'USD', kind: 'exact' },
+      delivery: { status: 'skipped', delivered: [], failures: [] },
     });
   }
 

package/lib/settings.js

@@ -40,13 +40,17 @@ export const Config = z.object({
   barkKey: z.string().default('').description('Bark device key').volatile(),
   pushplusTokenRef: z.string().default('').description('Credential name for the PushPlus token').volatile(),
   pushplusUrl: z.string().default('https://www.pushplus.plus/send').description('PushPlus send endpoint (override for a self-hosted proxy)').volatile(),
-  ttsBaseUrl: z.string().default('http://127.0.0.1:3080').description('Base URL of the harness used to reach the dsh-tts speak route').volatile(),
+  ttsBaseUrl: z.string().default('').description('Base URL of the harness used to reach the dsh-tts speak route (empty = auto-resolved from webServer port or http://127.0.0.1:3080)').volatile(),
   giteaBaseUrl: z.string().default('').description('Gitea base URL for alert issues').volatile(),
   giteaRepo: z.string().default('').description('Gitea repository (owner/name) for alert issues').volatile(),
   giteaTokenRef: z.string().default('').description('Credential name for the Gitea API token').volatile(),
   giteaLabels: z.any().default([]).description('Gitea label names or IDs for alert issues').volatile(),
   giteaLabelIds: z.any().default({}).description('Mapping of label name to integer ID for Gitea issues').volatile(),
   prReviewerEnabled: z.boolean().default(false).description('Enable automated PR Reviewer scheduled agent (#33)').volatile(),
+  // --- Global Budgets (#320) ---
+  globalDailyCostLimitUsd: z.number().default(0).description('Global daily expenditure limit in USD across all tasks (0 = unlimited)').volatile(),
+  providerHourlyRunLimits: z.object({}).default({}).description('Max runs per hour keyed by provider').volatile(),
+  modelHourlyRunLimits: z.object({}).default({}).description('Max runs per hour keyed by model').volatile(),
   // --- Declarative jobs (#50, ADR-0001) ---
   jobs: z.array(z.any()).default([]).description('Static jobs owned by the config; each entry needs id, title, schedule and (for agent types) prompt'),
   // --- External REST API (#54, ADR-0001) ---
@@ -83,6 +87,7 @@ export const SETTINGS_SYNC_KEYS = [
   'ttsBaseUrl',
   'giteaBaseUrl', 'giteaRepo', 'giteaTokenRef', 'giteaLabels', 'giteaLabelIds', 'prReviewerEnabled',
   'apiToken',
+  'globalDailyCostLimitUsd', 'providerHourlyRunLimits', 'modelHourlyRunLimits',
 ];
 
 /**

package/lib/store.js

@@ -689,7 +689,7 @@ export class TaskStore {
     const prevRuns = this.history.get(id) || [];
     const runs = [
       {
-        id: 'run_' + Math.random().toString(36).slice(2, 9),
+        id: runInfo.runId || runInfo.id || ('run_' + Math.random().toString(36).slice(2, 9)),
         at: task.lastRunAt,
         status: task.lastStatus,
         durationMs: task.lastDurationMs,
@@ -697,6 +697,15 @@ export class TaskStore {
         error: runInfo.error ? String(runInfo.error).slice(0, 1000) : null,
         usage,
         costUsd,
+        stages: Array.isArray(runInfo.stages) ? runInfo.stages : null,
+        stoppedReason: runInfo.stoppedReason || null,
+        cost: runInfo.cost || {
+          amount: costUsd,
+          currency: 'USD',
+          kind: costUsd > 0 ? 'exact' : ((task.type === 'llm' || task.type === 'skill' || task.type === 'workflow') ? 'unknown' : 'exact')
+        },
+        delivery: runInfo.delivery || null,
+        validation: runInfo.validation || null,
         sessionId: runInfo.sessionId || null,
         // #45: which model produced the run, and whether it only finished thanks
         // to the configured fallback.

package/lib/task-create.js

@@ -1,3 +1,4 @@
+import { sanitizeValidators } from './validators.js';
 import { normalizeTaskType, EXTERNAL_RUNTIMES } from './runtimes.js';
 import { validateTaskType } from './task-transfer.js';
 import { parseScheduleExpression } from './scheduler.js';
@@ -72,6 +73,8 @@ export function executeCreateTask(store, scheduler, args) {
     costLimitUsd: Number(args.costLimitUsd) > 0 ? Number(args.costLimitUsd) : undefined,
     dailyCostLimitUsd: Number(args.dailyCostLimitUsd) > 0 ? Number(args.dailyCostLimitUsd) : undefined,
     tokenLimit: Number(args.tokenLimit) > 0 ? Number(args.tokenLimit) : undefined,
+    validators: Array.isArray(args.validators) ? sanitizeValidators(args.validators) : undefined,
+    requireApproval: Boolean(args.requireApproval),
   };
   // Issue #310 / GH #5: strip any undefined properties before store.set()
   for (const k of Object.keys(taskData)) {

package/lib/task-patch.js

@@ -1,3 +1,4 @@
+import { sanitizeValidators } from './validators.js';
 /**
  * Partial task updates, shared by the HTTP PATCH route and the cron tool (action: 'update')
  * tool (#49).
@@ -86,6 +87,12 @@ export function buildTaskPatch(current, body) {
       return { ok: false, error: err.message };
     }
   }
+  if (patch.requireApproval !== undefined) {
+    patch.requireApproval = Boolean(patch.requireApproval);
+  }
+  if (patch.validators !== undefined) {
+    patch.validators = Array.isArray(patch.validators) ? sanitizeValidators(patch.validators) : [];
+  }
   if (patch.costLimitUsd !== undefined) {
     patch.costLimitUsd = patch.costLimitUsd === null ? null : (Number(patch.costLimitUsd) > 0 ? Number(patch.costLimitUsd) : null);
   }

package/lib/task-transfer.js

@@ -74,6 +74,8 @@ export const PATCHABLE_TASK_FIELDS = [
   'dailyCostLimitUsd',
   'tokenLimit',
   'pausedReason',
+  'validators',
+  'requireApproval',
 ];
 
 /** Fields a duplicate inherits; anything else is runtime state, not config. */

package/lib/telegram.js

@@ -210,7 +210,7 @@ export function shouldNotifyTask(task, runInfo, globalSettings = {}) {
   const isEnabled = task.notifyTelegram ?? globalSettings.notifyTelegram ?? false;
   if (!isEnabled) return false;
 
-  const failed = runInfo.status === 'error' || runInfo.status === 'timeout' || runInfo.status === 'missed';
+  const failed = runInfo.status === 'error' || runInfo.status === 'timeout' || runInfo.status === 'missed' || runInfo.status === 'validation_failed' || runInfo.status === 'validator_error';
   const onlyOnFail = task.onlyOnFailure ?? globalSettings.onlyOnFailure ?? false;
   if (onlyOnFail && !failed) {
     return false;