@goodandready/dsh-cron 0.3.2 → 0.3.4

package/lib/log-streamer.js

@@ -0,0 +1,153 @@
+/**
+ * Real-time Task Execution Log Streaming (SSE) (#336)
+ *
+ * Keeps an in-memory Ring Buffer of output chunks for active tasks and
+ * broadcasts them to connected Server-Sent Events (SSE) clients.
+ */
+
+import { EventEmitter } from 'node:events';
+import { logger } from './logger.js';
+
+const MAX_BUFFER_LINES = 500;
+const RETENTION_MS = 60000; // retain logs for 60s after completion for late inspectors
+
+export class LogStreamer extends EventEmitter {
+  constructor() {
+    super();
+    this.streams = new Map(); // taskId -> StreamEntry
+  }
+
+  startStream(taskId, runId) {
+    if (!taskId) return;
+    const existing = this.streams.get(taskId);
+    if (existing && existing.cleanupTimer) {
+      clearTimeout(existing.cleanupTimer);
+    }
+    const entry = {
+      taskId,
+      runId: runId || `run_${Date.now()}`,
+      startTime: Date.now(),
+      buffer: [],
+      subscribers: new Set(),
+      completed: false,
+      outcome: null,
+      cleanupTimer: null,
+    };
+    this.streams.set(taskId, entry);
+    this.emit('start', { taskId, runId: entry.runId });
+    return entry;
+  }
+
+  appendLog(taskId, text, streamType = 'stdout') {
+    if (!taskId || text === undefined || text === null) return;
+    const entry = this.streams.get(taskId);
+    if (!entry) return;
+
+    const chunkStr = String(text);
+    const item = {
+      chunk: chunkStr,
+      stream: streamType,
+      ts: Date.now(),
+    };
+
+    entry.buffer.push(item);
+    if (entry.buffer.length > MAX_BUFFER_LINES) {
+      entry.buffer.shift();
+    }
+
+    const ssePayload = `event: log\ndata: ${JSON.stringify(item)}\n\n`;
+    for (const res of entry.subscribers) {
+      try {
+        res.write(ssePayload);
+      } catch (err) {
+        entry.subscribers.delete(res);
+      }
+    }
+  }
+
+  completeStream(taskId, outcome = {}) {
+    if (!taskId) return;
+    const entry = this.streams.get(taskId);
+    if (!entry) return;
+
+    entry.completed = true;
+    entry.outcome = {
+      status: outcome.status || 'success',
+      durationMs: Date.now() - entry.startTime,
+      error: outcome.error || null,
+      exitCode: outcome.exitCode !== undefined ? outcome.exitCode : (outcome.status === 'error' ? 1 : 0),
+    };
+
+    const ssePayload = `event: complete\ndata: ${JSON.stringify(entry.outcome)}\n\n`;
+    for (const res of entry.subscribers) {
+      try {
+        res.write(ssePayload);
+        res.end();
+      } catch (err) {
+        // client closed
+      }
+    }
+    entry.subscribers.clear();
+
+    // Schedule cleanup of memory after retention period
+    entry.cleanupTimer = setTimeout(() => {
+      this.streams.delete(taskId);
+    }, RETENTION_MS);
+    if (entry.cleanupTimer.unref) entry.cleanupTimer.unref();
+  }
+
+  getStream(taskId) {
+    return this.streams.get(taskId) || null;
+  }
+
+  handleSseRequest(taskId, req, res) {
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream; charset=utf-8',
+      'Cache-Control': 'no-cache, no-transform',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+      'Access-Control-Allow-Origin': '*',
+    });
+
+    const entry = this.streams.get(taskId);
+
+    // Initial event with current state and buffered logs
+    const initData = {
+      taskId,
+      runId: entry?.runId || null,
+      status: entry ? (entry.completed ? 'completed' : 'running') : 'idle',
+      bufferedLogs: entry?.buffer || [],
+    };
+    res.write(`event: init\ndata: ${JSON.stringify(initData)}\n\n`);
+
+    if (!entry || entry.completed) {
+      // Not running or already completed
+      if (entry?.completed) {
+        res.write(`event: complete\ndata: ${JSON.stringify(entry.outcome)}\n\n`);
+      }
+      res.end();
+      return;
+    }
+
+    // Subscribe to live events
+    entry.subscribers.add(res);
+
+    // Keepalive ping every 15 seconds
+    const pingTimer = setInterval(() => {
+      try {
+        res.write(': keepalive\n\n');
+      } catch (e) {
+        clearInterval(pingTimer);
+        entry.subscribers.delete(res);
+      }
+    }, 15000);
+    if (pingTimer.unref) pingTimer.unref();
+
+    req.on('close', () => {
+      clearInterval(pingTimer);
+      entry.subscribers.delete(res);
+    });
+  }
+}
+
+export const logStreamer = new LogStreamer();

package/lib/prompt-evolver.js

@@ -0,0 +1,148 @@
+/**
+ * Prompt Auto-Evolver & Versioning Engine (#331)
+ *
+ * Tracks prompt revisions, maintains versioned prompt history, computes
+ * empirical Success Rates across versions, and enables 1-click rollback.
+ */
+
+const MAX_PROMPT_HISTORY = 20;
+
+export function sanitizePromptHistory(history) {
+  if (!Array.isArray(history)) return [];
+  return history
+    .filter((h) => h && typeof h === 'object' && typeof h.prompt === 'string')
+    .slice(-MAX_PROMPT_HISTORY)
+    .map((h, idx) => ({
+      version: typeof h.version === 'number' && h.version > 0 ? h.version : (idx + 1),
+      prompt: String(h.prompt || ''),
+      note: typeof h.note === 'string' ? h.note.slice(0, 100) : 'Revision',
+      runs: typeof h.runs === 'number' && h.runs >= 0 ? h.runs : 0,
+      successes: typeof h.successes === 'number' && h.successes >= 0 ? h.successes : 0,
+      successRate: typeof h.successRate === 'number' && h.successRate >= 0 && h.successRate <= 1
+        ? Number(h.successRate.toFixed(3))
+        : (typeof h.runs === 'number' && h.runs > 0 ? Number(((h.successes || 0) / h.runs).toFixed(3)) : 1.0),
+      createdAt: typeof h.createdAt === 'number' ? h.createdAt : Date.now(),
+      lastRunAt: typeof h.lastRunAt === 'number' ? h.lastRunAt : null,
+    }));
+}
+
+export function trackPromptEdit(currentTask, newPrompt, note = 'Manual edit') {
+  if (!currentTask || typeof newPrompt !== 'string') {
+    return {
+      prompt: currentTask ? currentTask.prompt : newPrompt,
+      promptVersion: currentTask ? (currentTask.promptVersion || 1) : 1,
+      promptHistory: currentTask ? sanitizePromptHistory(currentTask.promptHistory) : [],
+    };
+  }
+
+  const trimmedNew = newPrompt.trim();
+  const trimmedOld = (currentTask.prompt || '').trim();
+
+  let history = sanitizePromptHistory(currentTask.promptHistory);
+
+  // If prompt has not changed, keep current version and baseline history if needed
+  if (trimmedNew === trimmedOld) {
+    if (history.length === 0 && trimmedOld) {
+      history.push({
+        version: currentTask.promptVersion || 1,
+        prompt: currentTask.prompt,
+        note: 'Initial baseline',
+        runs: typeof currentTask.runs === 'number' ? currentTask.runs : 0,
+        successes: typeof currentTask.successes === 'number' ? currentTask.successes : 0,
+        successRate: currentTask.runs > 0
+          ? Number(((currentTask.successes || 0) / currentTask.runs).toFixed(3))
+          : 1.0,
+        createdAt: currentTask.createdAt || Date.now(),
+        lastRunAt: currentTask.lastRun || null,
+      });
+    }
+    return {
+      prompt: currentTask.prompt,
+      promptVersion: currentTask.promptVersion || 1,
+      promptHistory: history,
+    };
+  }
+
+  // If no history exists yet, record baseline version 1 with existing task metrics before bumping
+  if (history.length === 0 && trimmedOld) {
+    history.push({
+      version: 1,
+      prompt: currentTask.prompt,
+      note: 'Initial baseline',
+      runs: typeof currentTask.runs === 'number' ? currentTask.runs : 0,
+      successes: typeof currentTask.successes === 'number' ? currentTask.successes : 0,
+      successRate: currentTask.runs > 0
+        ? Number(((currentTask.successes || 0) / currentTask.runs).toFixed(3))
+        : 1.0,
+      createdAt: currentTask.createdAt || Date.now(),
+      lastRunAt: currentTask.lastRun || null,
+    });
+  }
+
+  const maxVersion = history.reduce((max, h) => Math.max(max, h.version || 1), currentTask.promptVersion || 1);
+  const nextVersion = maxVersion + 1;
+
+  history.push({
+    version: nextVersion,
+    prompt: newPrompt,
+    note: String(note || 'Manual edit').slice(0, 100),
+    runs: 0,
+    successes: 0,
+    successRate: 1.0,
+    createdAt: Date.now(),
+    lastRunAt: null,
+  });
+
+  return {
+    prompt: newPrompt,
+    promptVersion: nextVersion,
+    promptHistory: sanitizePromptHistory(history),
+  };
+}
+
+export function recordPromptRunOutcome(task, isSuccess) {
+  if (!task || typeof task.prompt !== 'string') return task?.promptHistory || [];
+
+  let history = sanitizePromptHistory(task.promptHistory);
+  const activeVersion = task.promptVersion || 1;
+
+  let entry = history.find((h) => h.version === activeVersion);
+  if (!entry) {
+    entry = {
+      version: activeVersion,
+      prompt: task.prompt,
+      note: 'Active prompt',
+      runs: 0,
+      successes: 0,
+      successRate: 1.0,
+      createdAt: Date.now(),
+      lastRunAt: null,
+    };
+    history.push(entry);
+  }
+
+  entry.runs = (entry.runs || 0) + 1;
+  if (isSuccess) {
+    entry.successes = (entry.successes || 0) + 1;
+  }
+  entry.successRate = Number((entry.successes / entry.runs).toFixed(3));
+  entry.lastRunAt = Date.now();
+
+  task.promptHistory = sanitizePromptHistory(history);
+  return task.promptHistory;
+}
+
+export function rollbackPromptVersion(task, targetVersion) {
+  if (!task) return null;
+  const history = sanitizePromptHistory(task.promptHistory);
+  const target = history.find((h) => h.version === targetVersion);
+  if (!target) {
+    throw new Error(`Target prompt version ${targetVersion} not found in history`);
+  }
+
+  const edit = trackPromptEdit(task, target.prompt, `Rollback to v${targetVersion}`);
+  task.prompt = edit.prompt;
+  task.promptVersion = edit.promptVersion;
+  task.promptHistory = edit.promptHistory;
+  return task;
+}

package/lib/routes.js

@@ -1,3 +1,4 @@
+import { buildAnalyticsDigest, formatDigestMarkdown, sendAnalyticsDigest } from './analytics-digest.js';
 import { listVerifiedRecipes } from './recipes-catalog.js';
 import { randomUUID } from 'node:crypto';
 import { createCronApiHandler } from './api.js';
@@ -100,6 +101,84 @@ export function registerRoutes(ctx, { store, scheduler, recommendations }) {
     }
   }), 'dsh-cron: /chat/start');
 
+  // Analytics digest routes (#330)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/analytics',
+    handler: async (req, res) => {
+      try {
+        const url = new URL(req.url, 'http://127.0.0.1');
+        const path = url.pathname;
+
+        if (req.method === 'GET') {
+          const days = parseInt(url.searchParams.get('days') || '7', 10);
+          const tasks = store.list ? store.list() : Object.values(store.tasks || {});
+          let history = [];
+          if (store.history) {
+            if (typeof store.history.values === 'function') {
+              for (const runs of store.history.values()) {
+                if (Array.isArray(runs)) history.push(...runs);
+              }
+            } else if (typeof store.history === 'object') {
+              for (const runs of Object.values(store.history)) {
+                if (Array.isArray(runs)) history.push(...runs);
+              }
+            }
+          }
+          const costLedger = store.costLedger || [];
+          const digest = buildAnalyticsDigest({ tasks, history, costLedger, periodDays: days });
+          const markdown = formatDigestMarkdown(digest);
+          sendJson(res, 200, { ok: true, digest, markdown });
+          return;
+        }
+
+        if (req.method === 'POST') {
+          if (rejectCrossOrigin(req, res)) return;
+          const { body } = await readBody(req, res);
+          const days = parseInt(body?.days || url.searchParams.get('days') || '7', 10);
+          const tasks = store.list ? store.list() : Object.values(store.tasks || {});
+          let history = [];
+          if (store.history) {
+            if (typeof store.history.values === 'function') {
+              for (const runs of store.history.values()) {
+                if (Array.isArray(runs)) history.push(...runs);
+              }
+            } else if (typeof store.history === 'object') {
+              for (const runs of Object.values(store.history)) {
+                if (Array.isArray(runs)) history.push(...runs);
+              }
+            }
+          }
+          const costLedger = store.costLedger || [];
+          const digest = buildAnalyticsDigest({ tasks, history, costLedger, periodDays: days });
+          const settings = store.getSettings ? store.getSettings() : {};
+          const deliveryConfig = {
+            telegram: body?.telegram !== false && Boolean(settings.botToken && settings.chatId),
+            webhookUrl: body?.webhookUrl || settings.webhookUrl,
+          };
+          const channels = {
+            sendTelegram: async (text) => sendTelegramMessage({ botToken: settings.botToken, chatId: settings.chatId, text }),
+            sendWebhook: async (targetUrl, payload) => {
+              const r = await fetch(targetUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+              });
+              return { ok: r.ok, status: r.status };
+            },
+          };
+          const delivery = await sendAnalyticsDigest({ digest, channels, deliveryConfig });
+          sendJson(res, 200, { ok: true, digest, delivery });
+          return;
+        }
+
+        sendJson(res, 405, { ok: false, error: 'Method not allowed' });
+      } catch (err) {
+        sendJson(res, 500, { ok: false, error: err.message });
+      }
+    }
+  }), 'dsh-cron: /analytics');
+
   // GET /dsh-cron/recipes (#48): the built-in recipe catalog.
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',

package/lib/runner-external.js

@@ -1,3 +1,4 @@
+import { logStreamer } from './log-streamer.js';
 import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import {
@@ -59,6 +60,10 @@ export function isTransientError(errOrStatus) {
 
 /** HTTP trigger runtime (#7) with transient retry (#134). */
 export async function runHttp(task, request, signal) {
+  const streamRunId = `run_${Date.now()}`;
+  logStreamer.startStream(task.id, streamRunId);
+  logStreamer.appendLog(task.id, `> ${request.method} ${request.url}
+`, 'stdout');
   let attempts = 0;
   const maxAttempts = 3;
   while (attempts < maxAttempts) {
@@ -201,6 +206,8 @@ export async function runExternal(task, runtime, signal, execOptions = {}, { ctx
     if (execOptions?.prevOutput !== undefined) {
       runEnv.DSH_PREV_OUTPUT = String(execOptions.prevOutput);
     }
+    const streamRunId = execOptions?.runId || `run_${Date.now()}`;
+    logStreamer.startStream(task.id, streamRunId);
     const options = {
       cwd,
       env: runEnv,
@@ -218,15 +225,18 @@ export async function runExternal(task, runtime, signal, execOptions = {}, { ctx
 
     child.stdout.on('data', (chunk) => {
       if (stdout.length < maxBuffer) stdout += chunk;
+      logStreamer.appendLog(task.id, chunk.toString('utf-8'), 'stdout');
     });
     child.stderr.on('data', (chunk) => {
       if (stderr.length < maxBuffer) stderr += chunk;
+      logStreamer.appendLog(task.id, chunk.toString('utf-8'), 'stderr');
     });
 
     child.on('error', (err) => {
       if (settled) return;
       settled = true;
       if (signal) signal.removeEventListener('abort', abortHandler);
+      logStreamer.completeStream(task.id, { status: 'error', error: err.message, exitCode: 1 });
       reject(err);
     });
 

package/lib/runner.js

@@ -1,3 +1,4 @@
+import { logStreamer } from './log-streamer.js';
 import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import { estimateTokenCost } from './integrations.js';
@@ -92,6 +93,11 @@ export class SessionRunner {
       }, { once: true });
     }
 
+    const streamRunId = options.runId || `run_${Date.now()}`;
+    logStreamer.startStream(task.id, streamRunId);
+    logStreamer.appendLog(task.id, `[dsh-cron] Starting task "${task.title}" (type: ${task.type || 'llm'})
+`, 'stdout');
+
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(() => {
         const timeoutErr = new Error(`Task execution timed out after ${timeoutSeconds} seconds`);
@@ -103,7 +109,18 @@ export class SessionRunner {
     const executionPromise = this._run(task, controller.signal, options);
 
     try {
-      return await Promise.race([executionPromise, timeoutPromise]);
+      const res = await Promise.race([executionPromise, timeoutPromise]);
+      logStreamer.appendLog(task.id, `
+[dsh-cron] Task execution finished
+`, 'stdout');
+      logStreamer.completeStream(task.id, { status: 'success' });
+      return res;
+    } catch (err) {
+      logStreamer.appendLog(task.id, `
+[dsh-cron] Task execution error: ${err.message}
+`, 'stderr');
+      logStreamer.completeStream(task.id, { status: 'error', error: err.message });
+      throw err;
     } finally {
       if (timeoutId) clearTimeout(timeoutId);
     }

package/lib/scheduler-execution.js

@@ -1,3 +1,5 @@
+import { recordPromptRunOutcome } from './prompt-evolver.js';
+import { evaluateAdaptiveRun, calculateNextAdaptiveState } from './adaptive.js';
 import { approvalManager } from './approval.js';
 import { globalBudgetManager } from './global-budgets.js';
 import { validateRunResult } from './validators.js';
@@ -512,6 +514,37 @@ export async function deliverNotifications(task, runInfo, { store, resolveSecret
 export function finishRun(scheduler, taskSnapshot, taskId, status, queuedCount, meta = {}) {
   scheduler.countRun(status);
 
+  // Track prompt version success rate outcome (#331)
+  if (taskSnapshot && taskSnapshot.prompt && (taskSnapshot.promptVersion || taskSnapshot.promptHistory)) {
+    const isSuccess = status === 'success';
+    recordPromptRunOutcome(taskSnapshot, isSuccess);
+    if (scheduler.store && typeof scheduler.store.set === 'function') {
+      scheduler.store.set(taskSnapshot);
+    }
+  }
+
+  // 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;
@@ -783,6 +816,9 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     isCurrentRun,
     runId: currentRun?.id,
     queuedRuns,
+    outcome,
+    runInfo,
+    silent,
   });
 
   if (scheduler.isStopped) return;

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,3 +1,5 @@
+import { sanitizePromptHistory } from './prompt-evolver.js';
+import { sanitizeAdaptiveConfig } from './adaptive.js';
 import { sanitizeValidators } from './validators.js';
 import { normalizeTaskType, EXTERNAL_RUNTIMES } from './runtimes.js';
 import { validateTaskType } from './task-transfer.js';
@@ -32,6 +34,8 @@ export function executeCreateTask(store, scheduler, args) {
     schedule: parsed.cronPattern || args.schedule,
     scheduleText: parsed.humanText,
     prompt: args.prompt,
+    promptVersion: args.prompt ? 1 : undefined,
+    promptHistory: args.prompt ? [{ version: 1, prompt: args.prompt, note: 'Initial creation', runs: 0, successes: 0, successRate: 1.0, createdAt: Date.now(), lastRunAt: null }] : undefined,
     type: taskType,
     delivery: args.delivery || 'isolated',
     status: 'active',
@@ -48,6 +52,7 @@ export function executeCreateTask(store, scheduler, args) {
     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',

package/lib/task-patch.js

@@ -1,3 +1,5 @@
+import { trackPromptEdit, sanitizePromptHistory } from './prompt-evolver.js';
+import { sanitizeAdaptiveConfig } from './adaptive.js';
 import { sanitizeValidators } from './validators.js';
 import { sanitizeFileWatch } from './task-create.js';
 import { sanitizeDependsOn, sanitizeJoinPolicy, validateDAG } from './dag.js';
@@ -101,9 +103,20 @@ export function buildTaskPatch(current, body) {
   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) : [];
   }
+  if (patch.prompt !== undefined && current && typeof current.prompt === 'string') {
+    const edit = trackPromptEdit(current, patch.prompt, body && body.promptNote ? body.promptNote : 'Manual edit');
+    patch.prompt = edit.prompt;
+    patch.promptVersion = edit.promptVersion;
+    patch.promptHistory = edit.promptHistory;
+  } else if (patch.promptHistory !== undefined) {
+    patch.promptHistory = sanitizePromptHistory(patch.promptHistory);
+  }
   if (patch.costLimitUsd !== undefined) {
     patch.costLimitUsd = patch.costLimitUsd === null ? null : (Number(patch.costLimitUsd) > 0 ? Number(patch.costLimitUsd) : null);
   }

package/lib/task-transfer.js

@@ -79,6 +79,10 @@ export const PATCHABLE_TASK_FIELDS = [
   'fileWatch',
   'dependsOn',
   'joinPolicy',
+  'adaptive',
+  'adaptiveState',
+  'promptVersion',
+  'promptHistory',
 ];
 
 /** 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.2",
+  "version": "0.3.4",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",