@goodandready/dsh-cron 0.3.1 → 0.3.3

package/lib/scheduler-execution.js

@@ -1,3 +1,4 @@
+import { evaluateAdaptiveRun, calculateNextAdaptiveState } from './adaptive.js';
 import { approvalManager } from './approval.js';
 import { globalBudgetManager } from './global-budgets.js';
 import { validateRunResult } from './validators.js';
@@ -10,6 +11,7 @@ import fs from 'node:fs';
 import { parseLlmActionDirectives, executeLlmActionDirectives } from './llm-actions.js';
 import { applySilentRule } from './silent-rule.js';
 import { inspectFailure } from './failure-inspector.js';
+import { parseChainTargets, sanitizeDependsOn } from './dag.js';
 
 /** Task types that talk to a model and can therefore use a fallback model. */
 export const AGENT_TASK_TYPES = ['llm', 'skill', 'workflow'];
@@ -511,6 +513,28 @@ export async function deliverNotifications(task, runInfo, { store, resolveSecret
 export function finishRun(scheduler, taskSnapshot, taskId, status, queuedCount, meta = {}) {
   scheduler.countRun(status);
 
+  // Adaptive polling backoff (#329)
+  if (taskSnapshot && taskSnapshot.adaptive && taskSnapshot.adaptive.enabled && !taskSnapshot.oneShot && taskSnapshot.status === 'active' && !scheduler.isStopped) {
+    const history = scheduler.store.getHistory ? scheduler.store.getHistory(taskId, 2) : [];
+    const prevRun = history.length > 1 ? history[1] : null;
+    const outcomeForEval = meta?.outcome || { status };
+    const runInfoForEval = meta?.runInfo || {};
+    const evalRes = evaluateAdaptiveRun(taskSnapshot, outcomeForEval, runInfoForEval, prevRun);
+    const nextAdaptiveState = calculateNextAdaptiveState(taskSnapshot, evalRes.isIdle);
+    taskSnapshot.adaptiveState = nextAdaptiveState;
+    scheduler.store.set(taskSnapshot);
+
+    if (nextAdaptiveState.backedOff) {
+      logger.info(`[dsh-cron] adaptive backoff active for "${taskSnapshot.title}" (${taskSnapshot.id}): interval scaled to ${nextAdaptiveState.effectiveIntervalStr} (idle count: ${nextAdaptiveState.idleCount})`);
+      scheduler.armAdaptiveTimer(taskId, nextAdaptiveState.currentIntervalMs);
+    } else {
+      scheduler.clearAdaptiveTimer(taskId);
+      if (!scheduler.jobs.has(taskId)) {
+        scheduler.scheduleTask(taskSnapshot);
+      }
+    }
+  }
+
   // If this run was superseded by a newer run or scheduler is stopped, skip updating task
   if (meta.isCurrentRun === false || scheduler.isStopped) {
     return;
@@ -735,15 +759,24 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     runInfo.artifacts = scheduler.store.getArtifactsForRun(runInfo.runId);
   }
 
-  // Chain Checkpoints (#319)
-  const chainedTarget = outcome.status === 'success' ? task.onSuccess : task.onFailure;
-  const chainRunId = options.chainRunId || (chainedTarget ? ('chain_' + Math.random().toString(36).slice(2, 10)) : null);
+  // Chain Checkpoints (#319, #328)
+  const chainedTargets = parseChainTargets(outcome.status === 'success' ? task.onSuccess : task.onFailure);
+  let hasDependents = false;
+  if (scheduler.store?.tasks) {
+    for (const t of Object.values(scheduler.store.tasks)) {
+      if (t && sanitizeDependsOn(t.dependsOn).includes(taskId)) {
+        hasDependents = true;
+        break;
+      }
+    }
+  }
+  const chainRunId = options.chainRunId || ((chainedTargets.length > 0 || hasDependents) ? ('chain_' + Math.random().toString(36).slice(2, 10)) : null);
   if (chainRunId) {
     runInfo.chainRunId = chainRunId;
     if (scheduler.store.chainCheckpointManager) {
       scheduler.store.chainCheckpointManager.recordStepSnapshot(chainRunId, taskId, {
         status: outcome.status,
-        input: { prompt: task.prompt, prevOutput: options.prevOutput || options.chainPrevOutput || '' },
+        input: { prompt: task.prompt, prevOutput: options.prevOutput || options.chainPrevOutput || '', prevOutputs: options.prevOutputs || {} },
         output: outcome.output || outcome.error || '',
         durationMs: executionMs,
       });
@@ -773,6 +806,9 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     isCurrentRun,
     runId: currentRun?.id,
     queuedRuns,
+    outcome,
+    runInfo,
+    silent,
   });
 
   if (scheduler.isStopped) return;
@@ -842,14 +878,42 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     }
   }
 
-  // 2. Task Chaining (#137)
-  const nextTaskId = isSuccess ? task.onSuccess : (isFailure ? task.onFailure : null);
-  if (nextTaskId && typeof nextTaskId === 'string' && nextTaskId.trim()) {
-    const currentDepth = options.chainDepth || 0;
-    if (currentDepth < 4) {
-      const targetId = nextTaskId.trim();
+  // 2. Task Chaining (#137, #328 Fan-Out / Fan-In)
+  const targets = parseChainTargets(isSuccess ? task.onSuccess : (isFailure ? task.onFailure : null));
+  const currentDepth = options.chainDepth || 0;
+
+  if (currentDepth < 4) {
+    // 2.1 Trigger explicit targets (Fan-Out)
+    for (const targetId of targets) {
       const nextTask = scheduler.store.get(targetId);
-      if (nextTask) {
+      if (!nextTask) {
+        logger.warn(`[dsh-cron] chained task target not found: ${targetId}`);
+        continue;
+      }
+      const deps = sanitizeDependsOn(nextTask.dependsOn);
+      if (deps.length > 0 && scheduler.store.chainCheckpointManager) {
+        const barrier = scheduler.store.chainCheckpointManager.checkJoinBarrier(chainRunId, nextTask);
+        if (barrier.ready && scheduler.store.chainCheckpointManager.canTriggerBarrier(chainRunId, nextTask.id)) {
+          scheduler.store.chainCheckpointManager.markBarrierTriggered(chainRunId, nextTask.id);
+          logger.info(`[dsh-cron] triggering joined task "${nextTask.title}" (${targetId}) (barrier satisfied)`);
+          scheduler.runNow(targetId, {
+            chainRunId,
+            chainDepth: currentDepth + 1,
+            prevOutputs: barrier.outputs,
+            prevOutput: barrier.latestOutput,
+            prevTaskId: task.id,
+            prevStatus: outcome.status,
+            prevDurationMs: Date.now() - start,
+            prevCostUsd: outcome.costUsd || 0,
+          }).catch((err) => {
+            logger.warn(`[dsh-cron] chained joined task ${targetId} failed to trigger:`, err.message);
+          });
+        } else if (barrier.pending) {
+          logger.info(`[dsh-cron] task "${nextTask.title}" (${targetId}) waiting for dependencies: ${barrier.waitingFor?.join(', ')}`);
+        } else if (barrier.failed) {
+          logger.warn(`[dsh-cron] task "${nextTask.title}" (${targetId}) barrier failed due to dependency: ${barrier.failedDep}`);
+        }
+      } else {
         logger.info(`[dsh-cron] triggering chained task "${nextTask.title}" (${targetId}) from "${task.title}" (depth ${currentDepth + 1})`);
         scheduler.runNow(targetId, {
           chainRunId,
@@ -862,12 +926,41 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
         }).catch((err) => {
           logger.warn(`[dsh-cron] chained task ${targetId} failed to trigger:`, err.message);
         });
-      } else {
-        logger.warn(`[dsh-cron] chained task target not found: ${targetId}`);
       }
-    } else {
-      logger.warn(`[dsh-cron] chained task depth limit (5) reached for task ${task.id} -> ${nextTaskId}. Loop prevented.`);
     }
+
+    // 2.2 Trigger any other tasks in store that depend on this task via dependsOn (Fan-In join step)
+    if (chainRunId && scheduler.store?.tasks && scheduler.store.chainCheckpointManager) {
+      for (const candidate of Object.values(scheduler.store.tasks)) {
+        if (!candidate || candidate.id === taskId || targets.includes(candidate.id)) continue;
+        const deps = sanitizeDependsOn(candidate.dependsOn);
+        if (deps.includes(taskId)) {
+          const barrier = scheduler.store.chainCheckpointManager.checkJoinBarrier(chainRunId, candidate);
+          if (barrier.ready && scheduler.store.chainCheckpointManager.canTriggerBarrier(chainRunId, candidate.id)) {
+            scheduler.store.chainCheckpointManager.markBarrierTriggered(chainRunId, candidate.id);
+            logger.info(`[dsh-cron] triggering dependent joined task "${candidate.title}" (${candidate.id}) (barrier satisfied)`);
+            scheduler.runNow(candidate.id, {
+              chainRunId,
+              chainDepth: currentDepth + 1,
+              prevOutputs: barrier.outputs,
+              prevOutput: barrier.latestOutput,
+              prevTaskId: task.id,
+              prevStatus: outcome.status,
+              prevDurationMs: Date.now() - start,
+              prevCostUsd: outcome.costUsd || 0,
+            }).catch((err) => {
+              logger.warn(`[dsh-cron] dependent joined task ${candidate.id} failed to trigger:`, err.message);
+            });
+          } else if (barrier.pending) {
+            logger.info(`[dsh-cron] task "${candidate.title}" (${candidate.id}) waiting for dependencies: ${barrier.waitingFor?.join(', ')}`);
+          } else if (barrier.failed) {
+            logger.warn(`[dsh-cron] task "${candidate.title}" (${candidate.id}) barrier failed due to dependency: ${barrier.failedDep}`);
+          }
+        }
+      }
+    }
+  } else {
+    logger.warn(`[dsh-cron] chained task depth limit (5) reached for task ${task.id}. Loop prevented.`);
   }
 }
 

package/lib/scheduler.js

@@ -317,6 +317,7 @@ export class TaskScheduler {
     this.jobs = new Map();
     this.timers = new Map();
     this.retryTimers = new Map();
+    this.adaptiveTimers = new Map();
     this.running = new Map();
     this.runCounters = {};
     this.queue = [];
@@ -349,6 +350,37 @@ export class TaskScheduler {
     }
   }
 
+  clearAdaptiveTimer(taskId) {
+    const t = this.adaptiveTimers.get(taskId);
+    if (t) {
+      clearTimeout(t);
+      this.adaptiveTimers.delete(taskId);
+    }
+  }
+
+  armAdaptiveTimer(taskId, delayMs) {
+    this.clearAdaptiveTimer(taskId);
+    if (this.jobs.has(taskId)) {
+      this.jobs.get(taskId).stop();
+      this.jobs.delete(taskId);
+    }
+    const task = this.store.get(taskId);
+    if (task) {
+      task.nextRunAt = Date.now() + delayMs;
+      this.store.set(task);
+    }
+    const timer = setTimeout(() => {
+      this.adaptiveTimers.delete(taskId);
+      if (!this.isStopped) {
+        this.runTask(taskId, { isAdaptive: true }).catch((err) => {
+          logger.error(`[dsh-cron] adaptive run of task ${taskId} failed:`, (err && err.message) || err);
+        });
+      }
+    }, delayMs);
+    if (timer.unref) timer.unref();
+    this.adaptiveTimers.set(taskId, timer);
+  }
+
   startHeartbeatWatcher(intervalMs = 30000) {
     return startHeartbeatWatcher(this, intervalMs);
   }
@@ -450,6 +482,11 @@ export class TaskScheduler {
     }
     this.retryTimers.clear();
 
+    for (const [, timer] of this.adaptiveTimers.entries()) {
+      bestEffort('clear-adaptive-timer', () => clearTimeout(timer), this.logger);
+    }
+    this.adaptiveTimers.clear();
+
     for (const [, run] of this.running.entries()) {
       bestEffort('abort-running', () => run.controller.abort(new Error('Scheduler stopped')), this.logger);
     }
@@ -461,6 +498,7 @@ export class TaskScheduler {
   }
 
   clearScheduled(taskId) {
+    this.clearAdaptiveTimer(taskId);
     if (this.watcherManager) {
       this.watcherManager.unwatchTask(taskId);
     }

package/lib/task-create.js

@@ -1,9 +1,11 @@
+import { sanitizeAdaptiveConfig } from './adaptive.js';
 import { sanitizeValidators } from './validators.js';
 import { normalizeTaskType, EXTERNAL_RUNTIMES } from './runtimes.js';
 import { validateTaskType } from './task-transfer.js';
 import { parseScheduleExpression } from './scheduler.js';
 import { CHANNEL_IDS } from './channels.js';
 import { redactTaskSecrets } from './http-utils.js';
+import { sanitizeDependsOn, sanitizeJoinPolicy, validateDAG } from './dag.js';
 
 export function sanitizeFileWatch(fw) {
   if (!fw || typeof fw !== 'object') return undefined;
@@ -45,6 +47,9 @@ export function executeCreateTask(store, scheduler, args) {
     targetSessionReset: args.targetSessionReset ? String(args.targetSessionReset).trim() : 'never',
     onSuccess: args.onSuccess ? String(args.onSuccess).trim() : '',
     onFailure: args.onFailure ? String(args.onFailure).trim() : '',
+    dependsOn: args.dependsOn !== undefined ? sanitizeDependsOn(args.dependsOn) : undefined,
+    joinPolicy: args.joinPolicy !== undefined ? sanitizeJoinPolicy(args.joinPolicy) : undefined,
+    adaptive: args.adaptive !== undefined ? sanitizeAdaptiveConfig(args.adaptive) : undefined,
     heartbeatIntervalSeconds: Number(args.heartbeatIntervalSeconds) || 0,
     gracePeriodSeconds: Number(args.gracePeriodSeconds) || 300,
     preflightType: args.preflightType ? String(args.preflightType).trim().toLowerCase() : 'none',
@@ -93,12 +98,20 @@ export function executeCreateTask(store, scheduler, args) {
     requireApproval: Boolean(args.requireApproval),
     fileWatch: args.fileWatch && typeof args.fileWatch === 'object' ? sanitizeFileWatch(args.fileWatch) : undefined,
   };
+
   // Issue #310 / GH #5: strip any undefined properties before store.set()
   for (const k of Object.keys(taskData)) {
     if (taskData[k] === undefined) {
       delete taskData[k];
     }
   }
+
+  // DAG cycle validation (#328)
+  const dagCheck = validateDAG(store?.tasks || {}, taskData);
+  if (!dagCheck.ok) {
+    throw new Error(dagCheck.error);
+  }
+
   const task = store.set(taskData);
   scheduler.scheduleTask(task);
   return {
@@ -107,4 +120,3 @@ export function executeCreateTask(store, scheduler, args) {
     task: redactTaskSecrets(task),
   };
 }
-

package/lib/task-patch.js

@@ -1,5 +1,7 @@
+import { sanitizeAdaptiveConfig } from './adaptive.js';
 import { sanitizeValidators } from './validators.js';
 import { sanitizeFileWatch } from './task-create.js';
+import { sanitizeDependsOn, sanitizeJoinPolicy, validateDAG } from './dag.js';
 /**
  * Partial task updates, shared by the HTTP PATCH route and the cron tool (action: 'update')
  * tool (#49).
@@ -91,9 +93,18 @@ export function buildTaskPatch(current, body) {
   if (patch.requireApproval !== undefined) {
     patch.requireApproval = Boolean(patch.requireApproval);
   }
+  if (patch.dependsOn !== undefined) {
+    patch.dependsOn = sanitizeDependsOn(patch.dependsOn);
+  }
+  if (patch.joinPolicy !== undefined) {
+    patch.joinPolicy = sanitizeJoinPolicy(patch.joinPolicy);
+  }
   if (patch.fileWatch !== undefined) {
     patch.fileWatch = patch.fileWatch && typeof patch.fileWatch === 'object' ? sanitizeFileWatch(patch.fileWatch) : null;
   }
+  if (patch.adaptive !== undefined) {
+    patch.adaptive = patch.adaptive ? sanitizeAdaptiveConfig(patch.adaptive) : null;
+  }
   if (patch.validators !== undefined) {
     patch.validators = Array.isArray(patch.validators) ? sanitizeValidators(patch.validators) : [];
   }
@@ -149,6 +160,12 @@ export function applyTaskPatch({ store, scheduler, id, body, allowCodeSwitch = f
   }
   const built = buildTaskPatch(current, body);
   if (!built.ok) return built;
+  if (built.patch.dependsOn !== undefined || built.patch.onSuccess !== undefined) {
+    const dagCheck = validateDAG(store?.tasks || {}, { ...current, ...built.patch, id });
+    if (!dagCheck.ok) {
+      return { ok: false, error: dagCheck.error };
+    }
+  }
   try {
     const task = store.set({ ...current, ...built.patch, id });
     if (task.status === 'active') scheduler.scheduleTask(task);

package/lib/task-transfer.js

@@ -77,6 +77,10 @@ export const PATCHABLE_TASK_FIELDS = [
   'validators',
   'requireApproval',
   'fileWatch',
+  'dependsOn',
+  'joinPolicy',
+  'adaptive',
+  'adaptiveState',
 ];
 
 /** Fields a duplicate inherits; anything else is runtime state, not config. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",