@goodandready/dsh-cron 0.2.52 → 0.3.0

package/lib/api.js

@@ -407,6 +407,30 @@ async function handleItemPost({ store, scheduler, req, res, url, id, action }) {
     sendJson(res, 200, { ok: true, proposal: result.proposal });
     return true;
   }
+  if (action === 'resolve-uncertain') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req).then(b => JSON.parse(b || '{}')).catch(() => ({}));
+    const runId = body.runId || url.searchParams.get('runId');
+    if (!runId) {
+      sendJson(res, 400, { ok: false, error: 'runId is required' });
+      return true;
+    }
+    const result = store.durableJournal.resolveUncertain(id, runId, {
+      decision: body.decision || 'mark_failed',
+      note: body.note || '',
+      resolvedBy: body.resolvedBy || 'user',
+    });
+    if (!result.ok) {
+      sendJson(res, 400, result);
+      return true;
+    }
+    sendJson(res, 200, result);
+    return true;
+  }
   if (action === 'run') {
     if (!store.get(id)) {
       sendJson(res, 404, NOT_FOUND);

package/lib/artifacts.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+
+export const SAFE_MIME_TYPES = {
+  '.csv': 'text/csv; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.txt': 'text/plain; charset=utf-8',
+  '.log': 'text/plain; charset=utf-8',
+  '.md': 'text/markdown; charset=utf-8',
+  '.pdf': 'application/pdf',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webp': 'image/webp',
+};
+
+export class ArtifactManager {
+  constructor(baseDir) {
+    this.baseDir = baseDir || path.join(process.cwd(), 'artifacts');
+    this.maxArtifactBytes = 10 * 1024 * 1024; // 10 MiB per artifact
+    this.defaultRetentionDays = 7;
+    this.maxTotalStorageBytes = 50 * 1024 * 1024; // 50 MiB total quota
+  }
+
+  ensureDir() {
+    if (!fs.existsSync(this.baseDir)) {
+      fs.mkdirSync(this.baseDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Sanitizes a requested filename to prevent path traversal (#321)
+   */
+  sanitizeFilename(name) {
+    if (!name || typeof name !== 'string') return 'artifact.txt';
+    const clean = path.basename(name).replace(/[\0\r\n\\\/]/g, '_');
+    return clean || 'artifact.txt';
+  }
+
+  getFilePath(artifactId, filename) {
+    if (!filename || filename.includes('..') || path.isAbsolute(filename)) {
+      throw new Error('Path traversal attempt detected in artifact storage');
+    }
+    const safeName = this.sanitizeFilename(filename);
+    const target = path.resolve(this.baseDir, `${artifactId}_${safeName}`);
+    // Security check: ensure path stays strictly within baseDir
+    if (!target.startsWith(path.resolve(this.baseDir) + path.sep)) {
+      throw new Error('Path traversal attempt detected in artifact storage');
+    }
+    return target;
+  }
+
+  /**
+   * Resolves safe MIME type for download/preview
+   */
+  resolveMimeType(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    // Neutralize dangerous web formats to prevent XSS / script execution
+    if (ext === '.html' || ext === '.htm' || ext === '.svg' || ext === '.js') {
+      return 'text/plain; charset=utf-8';
+    }
+    return SAFE_MIME_TYPES[ext] || 'application/octet-stream';
+  }
+
+  /**
+   * Saves a new artifact file bound to a run (#321)
+   */
+  saveArtifact(runId, taskId, filename, contentBuffer) {
+    this.ensureDir();
+    const buf = Buffer.isBuffer(contentBuffer) ? contentBuffer : Buffer.from(contentBuffer || '', 'utf8');
+
+    if (buf.length > this.maxArtifactBytes) {
+      throw new Error(`Artifact size (${buf.length} bytes) exceeds limit of ${this.maxArtifactBytes} bytes`);
+    }
+
+    const artifactId = 'art_' + randomUUID().replace(/-/g, '').slice(0, 16);
+    const safeName = this.sanitizeFilename(filename);
+    const filePath = this.getFilePath(artifactId, safeName);
+
+    fs.writeFileSync(filePath, buf);
+
+    const sha256 = createHash('sha256').update(buf).digest('hex');
+    const mimeType = this.resolveMimeType(safeName);
+
+    return {
+      id: artifactId,
+      name: safeName,
+      sizeBytes: buf.length,
+      mimeType,
+      sha256,
+      runId,
+      taskId,
+      createdAt: Date.now(),
+      status: 'available',
+    };
+  }
+
+  /**
+   * Reads an artifact file buffer
+   */
+  readArtifact(artifactId, filename) {
+    const filePath = this.getFilePath(artifactId, filename);
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    return fs.readFileSync(filePath);
+  }
+
+  /**
+   * Generates a safe preview of the artifact content (first 64 KiB)
+   */
+  generatePreview(artifactId, filename) {
+    const buf = this.readArtifact(artifactId, filename);
+    if (!buf) return { ok: false, error: 'Artifact file not found on disk' };
+
+    const ext = path.extname(filename).toLowerCase();
+    const isText = ['.txt', '.csv', '.json', '.log', '.md'].includes(ext);
+
+    if (isText) {
+      const slice = buf.subarray(0, 64 * 1024);
+      return {
+        ok: true,
+        kind: 'text',
+        mimeType: this.resolveMimeType(filename),
+        content: slice.toString('utf8'),
+        truncated: buf.length > slice.length,
+        sizeBytes: buf.length,
+      };
+    }
+
+    return {
+      ok: true,
+      kind: 'binary',
+      mimeType: this.resolveMimeType(filename),
+      sizeBytes: buf.length,
+      preview: `[Binary file: ${filename} (${buf.length} bytes)]`,
+    };
+  }
+
+  /**
+   * Cleans up expired artifacts and enforces size quotas (#321)
+   */
+  cleanupArtifacts(store, { retentionDays = this.defaultRetentionDays, maxTotalBytes = this.maxTotalStorageBytes } = {}) {
+    if (!fs.existsSync(this.baseDir)) return { removedCount: 0, freedBytes: 0 };
+
+    const cutoff = Date.now() - retentionDays * 86400000;
+    let files = fs.readdirSync(this.baseDir);
+    let totalBytes = 0;
+    const fileStats = [];
+
+    for (const f of files) {
+      const p = path.join(this.baseDir, f);
+      try {
+        const stat = fs.statSync(p);
+        totalBytes += stat.size;
+        fileStats.push({ path: p, filename: f, mtime: stat.mtimeMs, size: stat.size });
+      } catch (e) {
+        // file unlinked concurrently
+      }
+    }
+
+    let removedCount = 0;
+    let freedBytes = 0;
+
+    // 1. Remove files older than retentionDays
+    for (const item of fileStats) {
+      if (item.mtime < cutoff) {
+        try {
+          fs.unlinkSync(item.path);
+          removedCount++;
+          freedBytes += item.size;
+          totalBytes -= item.size;
+        } catch (e) {
+          void e;
+        }
+      }
+    }
+
+    // 2. Enforce quota: remove oldest files if totalBytes > maxTotalBytes
+    if (totalBytes > maxTotalBytes) {
+      fileStats.sort((a, b) => a.mtime - b.mtime);
+      for (const item of fileStats) {
+        if (totalBytes <= maxTotalBytes) break;
+        if (fs.existsSync(item.path)) {
+          try {
+            fs.unlinkSync(item.path);
+            removedCount++;
+            freedBytes += item.size;
+            totalBytes -= item.size;
+          } catch (e) {
+          void e;
+        }
+        }
+      }
+    }
+
+    return { removedCount, freedBytes };
+  }
+}

package/lib/chain-checkpoints.js

@@ -0,0 +1,125 @@
+/**
+ * Chain Checkpoint and Step Replay Manager (#319)
+ */
+
+export class ChainCheckpointManager {
+  constructor(store) {
+    this.store = store;
+    this.activeRetries = new Set();
+  }
+
+  /**
+   * Records a snapshot of a completed or failed chain step
+   */
+  recordStepSnapshot(chainRunId, stepTaskId, snapshot) {
+    if (!chainRunId || !stepTaskId) return;
+    this.store.chainCheckpoints = this.store.chainCheckpoints || {};
+    this.store.chainCheckpoints[chainRunId] = this.store.chainCheckpoints[chainRunId] || [];
+
+    const list = this.store.chainCheckpoints[chainRunId];
+    const existingIndex = list.findIndex((s) => s.stepTaskId === stepTaskId);
+
+    const record = {
+      chainRunId,
+      stepTaskId,
+      status: snapshot.status || 'completed',
+      input: snapshot.input || {},
+      output: snapshot.output || '',
+      at: Date.now(),
+      durationMs: snapshot.durationMs || 0,
+      retryCount: (existingIndex >= 0 ? (list[existingIndex].retryCount || 0) + 1 : 0),
+    };
+
+    if (existingIndex >= 0) {
+      list[existingIndex] = record;
+    } else {
+      list.push(record);
+    }
+
+    this.store.scheduleSave(50);
+    return record;
+  }
+
+  /**
+   * Retrieves all step snapshots for a given chain run
+   */
+  getChainSnapshots(chainRunId) {
+    if (!chainRunId || !this.store.chainCheckpoints) return [];
+    return this.store.chainCheckpoints[chainRunId] || [];
+  }
+
+  /**
+   * Checks whether a step can be retried in a chain run
+   */
+  canRetryFromStep(chainRunId, stepTaskId) {
+    if (!chainRunId || !stepTaskId) return { ok: false, error: 'Missing chainRunId or stepTaskId' };
+
+    const lockKey = `${chainRunId}:${stepTaskId}`;
+    if (this.activeRetries.has(lockKey)) {
+      return { ok: false, error: 'Retry already in progress for this step' };
+    }
+
+    const snapshots = this.getChainSnapshots(chainRunId);
+    const stepSnapshot = snapshots.find((s) => s.stepTaskId === stepTaskId);
+    if (!stepSnapshot) {
+      return { ok: false, error: `No checkpoint found for step "${stepTaskId}" in chain "${chainRunId}"` };
+    }
+
+    if (stepSnapshot.status === 'success' || stepSnapshot.status === 'completed') {
+      return { ok: false, error: 'Step already completed successfully; cannot retry a successful step' };
+    }
+
+    const task = this.store.get(stepTaskId);
+    if (!task) {
+      return { ok: false, error: `Task "${stepTaskId}" was deleted or no longer exists` };
+    }
+
+    return { ok: true, task, stepSnapshot };
+  }
+
+  /**
+   * Retries chain execution from the specified failed step (#319)
+   * Reuses upstream outputs without re-executing successful upstream steps.
+   */
+  async retryChainFromStep(scheduler, chainRunId, stepTaskId) {
+    const check = this.canRetryFromStep(chainRunId, stepTaskId);
+    if (!check.ok) return check;
+
+    const lockKey = `${chainRunId}:${stepTaskId}`;
+    this.activeRetries.add(lockKey);
+
+    try {
+      const snapshots = this.getChainSnapshots(chainRunId);
+      // Find the nearest successful preceding step snapshot
+      const stepIndex = snapshots.findIndex((s) => s.stepTaskId === stepTaskId);
+      let prevSnapshot = null;
+      for (let i = stepIndex - 1; i >= 0; i--) {
+        if (snapshots[i].status === 'success' || snapshots[i].status === 'completed') {
+          prevSnapshot = snapshots[i];
+          break;
+        }
+      }
+
+      const prevOutput = prevSnapshot ? prevSnapshot.output : '';
+      const prevTaskId = prevSnapshot ? prevSnapshot.stepTaskId : '';
+
+      // Execute only the failed step, passing reconstructed chain context
+      const runFn = (scheduler.runTask || scheduler.runNow).bind(scheduler);
+      const res = await runFn(stepTaskId, {
+        chainRunId,
+        chainPrevOutput: prevOutput,
+        chainPrevTaskId: prevTaskId,
+        isRetry: true,
+      });
+
+      return {
+        ok: true,
+        chainRunId,
+        stepTaskId,
+        result: res,
+      };
+    } finally {
+      this.activeRetries.delete(lockKey);
+    }
+  }
+}

package/lib/client.js

@@ -140,8 +140,10 @@ window.__ModuleLoader__.load({
         'history.stage_validation': 'Validation',
         'history.stage_delivery': 'Delivery',
         'history.refresh': 'Refresh history',
-        'history.stage_delivery': '推送',
-        'history.statusSuccess': 'Success',
+        'history.statusSuccess': 'Success', 'history.statusUncertain': 'Uncertain',
+        'history.artifacts': 'Artifacts',
+        'history.resolveCompleted': 'Mark Completed', 'history.resolveFailed': 'Mark Failed',
+        'history.statusUncertainHint': 'Interrupted by restart — verify outcome',
         'history.statusSkipped': 'Skipped',
         'history.statusMissed': 'Missed',
         'history.statusTimeout': 'Timeout',
@@ -361,11 +363,9 @@ window.__ModuleLoader__.load({
         'form.targetSessionResetHint': 'Automatically rotates the session identifier to prevent context window explosion over long periods.',
                 'form.requireApprovalLabel': 'Require human approval before execution',
         'form.requireApprovalHint': 'When enabled, the task will not execute until an authorized user approves the run proposal (#318).',
-        'actions.approve': 'Approve',
-        'actions.reject': 'Reject',
+        'actions.approve': 'Approve', 'actions.reject': 'Reject',
         'approval.waiting': 'Awaiting human approval',
-        'approval.approved': 'Approved',
-        'approval.rejected': 'Rejected',
+        'approval.approved': 'Approved', 'approval.rejected': 'Rejected',
         'recipe.dependenciesMissing': 'Missing required integrations or credentials',
         'form.previewSchedule': 'Preview next runs',
         'form.previewScheduleTitle': 'Next 5 scheduled runs:',
@@ -507,6 +507,10 @@ window.__ModuleLoader__.load({
         'history.summaryCost': '预估成本: ${cost}',
         'history.errorLabel': '错误详情:',
         'history.outputLabel': '执行输出:',
+        'history.statusUncertain': '不确定',
+        'history.artifacts': '产物文件',
+        'history.resolveCompleted': '标记已完成', 'history.resolveFailed': '标记失败',
+        'history.statusUncertainHint': '服务重启中断 — 请确认结果',
         'form.titleLabel': '任务名称 *',
         'form.titlePlaceholder': '例如: 每周备份检查',
         'form.typeLabel': '执行类型 *',
@@ -618,11 +622,9 @@ window.__ModuleLoader__.load({
         'confirm.delete': '确定删除该任务吗？',
                 'form.requireApprovalLabel': '执行前需人工确认审批',
         'form.requireApprovalHint': '开启后，任务执行前将挂起并等待授权用户批准提议 (#318)。',
-        'actions.approve': '批准',
-        'actions.reject': '拒绝',
+        'actions.approve': '批准', 'actions.reject': '拒绝',
         'approval.waiting': '等待人工审批',
-        'approval.approved': '已批准',
-        'approval.rejected': '已拒绝',
+        'approval.approved': '已批准', 'approval.rejected': '已拒绝',
         'recipe.dependenciesMissing': '缺少必要集成服务或凭据',
         'list.loadErrorPrefix': '加载任务列表失败'
       }
@@ -890,11 +892,6 @@ window.__ModuleLoader__.load({
     const STYLE_HEAL_KEY = '__dshCronStyleHeal';
     const STYLE_HEAL_INTERVAL_MS = 2000;
 
-    /**
-     * Keep the stylesheet attached: watch <head> (and <html>, which catches a
-     * replaced <head>) and re-attach on demand, with a slow interval as the
-     * backstop. heal() is idempotent and writes nothing while healthy.
-     */
     function startStyleSelfHeal() {
       if (typeof document === 'undefined') return () => {};
       if (typeof window !== 'undefined' && typeof window[STYLE_HEAL_KEY] === 'function') {
@@ -997,7 +994,6 @@ window.__ModuleLoader__.load({
     const DELIVERY_SETTING_KEYS = DELIVERY_SETTING_FIELDS.map((f) => f.key);
     const TEMPLATE_SETTING_KEYS = ['template', 'channelTemplates'];
 
-    /** Collect every delivery key the settings endpoints may return. */
     function parseEnvText(text) {
       const env = {};
       for (const rawLine of String(text || '').split('\n')) {
@@ -1091,15 +1087,10 @@ window.__ModuleLoader__.load({
       if (status === 'skipped') return T_KEY(t, 'history.statusSkipped');
       if (status === 'missed') return T_KEY(t, 'history.statusMissed');
       if (status === 'timeout') return T_KEY(t, 'history.statusTimeout');
+      if (status === 'uncertain') return T_KEY(t, 'history.statusUncertain');
       return T_KEY(t, 'history.statusFailed');
     }
 
-    /**
-     * A config-declared task is owned by the profile config file (#50): the
-     * panel shows it, but editing, pausing or deleting it here would be undone
-     * at the next start, so the row keeps the source label instead of the
-     * actions that cannot stick.
-     */
     function isConfigManaged(task) {
       return Boolean(task) && task.managedBy === 'config';
     }
@@ -1107,10 +1098,6 @@ window.__ModuleLoader__.load({
       return (typeof t === 'function' ? t : translate)(key, vars);
     }
 
-    /**
-     * Issue #307: universal fetch with AbortController timeout (default 15s).
-     * Connects with caller signal if supplied and fails closed on timeouts.
-     */
     const fetchWithTimeout = async (url, options = {}, timeoutMs = 15000) => {
       const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
       const timer = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
@@ -1139,9 +1126,6 @@ window.__ModuleLoader__.load({
       }
     };
 
-    /**
-     * Issue #307: universal JSON fetch helper with timeout and aborted body protection.
-     */
     const fetchJsonWithTimeout = async (url, options = {}, timeoutMs = 15000) => {
       const res = await fetchWithTimeout(url, options, timeoutMs);
       let data = {};
@@ -1166,11 +1150,6 @@ window.__ModuleLoader__.load({
       return out;
     }
 
-    /**
-     * Shared delivery form used by both the task panel modal and the plugin
-     * settings card, so a new channel is added in exactly one place.
-     * Sections collapse via the canonical aria-expanded head contract.
-     */
     function renderDeliverySettings({ T, values, onChange, onChannelTemplate, sections, onToggleSection }) {
       const val = (key) => (values[key] === undefined || values[key] === null ? '' : String(values[key]));
       const field = (f) => React.createElement('div', { className: 'dsh-cron-form-group', key: f.key, style: { marginBottom: '10px' } },
@@ -1247,7 +1226,6 @@ window.__ModuleLoader__.load({
       ];
     }
 
-    /** Parse a KEY=VALUE textarea into the task env object (#38). */
     function CronScreen(props) {
       const { ctx, toggle, onClose } = props;
       const t = props.t || translate;
@@ -1460,7 +1438,6 @@ window.__ModuleLoader__.load({
         return () => window.removeEventListener('keydown', onKey);
       }, [manualModalOpen, settingsModalOpen, dshModalOpen, dropdownOpen, onClose]);
 
-      /** #40: facet filtering happens client-side over the loaded list. */
       const visibleTasks = React.useMemo(() => {        let list = tasks;
         if (filterType) list = list.filter((x) => (x.type || 'llm') === filterType);
         if (filterModel) list = list.filter((x) => String(x.model || '').split('/').pop() === filterModel);
@@ -1491,7 +1468,6 @@ window.__ModuleLoader__.load({
         setFilterChannel('');
       };
 
-      /** #34: scroll to and flash the task the sidebar list asked for. */
       React.useEffect(() => {
         if (!pendingTaskHighlight || tasks.length === 0) return;
         const id = pendingTaskHighlight;
@@ -1718,7 +1694,6 @@ window.__ModuleLoader__.load({
         }
       };
 
-      /** #41: duplicate a task; the server copies config, resets run state (#41). */
       const handleDryRun = async (taskId) => {
         try {
           const { res, data } = await fetchJsonWithTimeout('/dsh-cron/tasks/' + encodeURIComponent(taskId) + '/dry-run', { method: 'POST' });
@@ -1777,10 +1752,8 @@ window.__ModuleLoader__.load({
         }
       };
 
-      /** A task id must not shadow a collection route (#42 review finding). */
       const RESERVED_TASK_IDS = ['export', 'import'];
 
-      /** Import needs the script-confirm header when the file has code tasks. */
       const isCodeTaskForm = (x) => {
         if (!x || typeof x !== 'object') return false;
         if (CODE_FORM_TYPES.includes(x.type)) return true;
@@ -1797,7 +1770,6 @@ window.__ModuleLoader__.load({
         return headers;
       };
 
-      /** #42, #240: download the task configuration with honest disclosure and sanitized export choice. */
       const handleExport = async () => {
         setTransferBusy(true);
         try {
@@ -1827,7 +1799,6 @@ window.__ModuleLoader__.load({
         }
       };
 
-      /** #42: read the picked file, validate it server-side and show the plan. */
       const handleImportFile = async (e) => {
         const file = e.target.files && e.target.files[0];
         e.target.value = '';
@@ -1884,7 +1855,6 @@ window.__ModuleLoader__.load({
         }
       };
 
-      /** #49: tune an existing task in a dialogue instead of editing fields. */
       const handleTuneWithDsh = async (task) => {
         const lines = [
           `Tune the existing scheduled task "${task.title}" (id: ${task.id}).`,
@@ -2007,11 +1977,6 @@ window.__ModuleLoader__.load({
         }
       };
 
-      /**
-       * Update one delivery setting without dropping the rest of the object.
-       * `undefined` removes the key so the server default applies again; an
-       * empty string is kept so a text field can be cleared on purpose.
-       */
       const updateDelivery = (key, value) => {
         setSettingsDelivery((prev) => {
           const next = Object.assign({}, prev);
@@ -2021,7 +1986,6 @@ window.__ModuleLoader__.load({
         });
       };
 
-      /** Per-channel template overrides live in a nested map on the server. */
       const updateChannelTemplate = (channelId, value) => {
         setSettingsDelivery((prev) => {
           const templates = Object.assign({}, prev.channelTemplates || {});
@@ -2195,6 +2159,23 @@ window.__ModuleLoader__.load({
         }
       };
 
+      const handleResolveUncertain = async (taskId, runId, resolution) => {
+        try {
+          const { res, data } = await fetchJsonWithTimeout('/dsh-cron/tasks/' + encodeURIComponent(taskId) + '/resolve-uncertain', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ runId, resolution }),
+          });
+          if (data && data.ok) {
+            await loadTaskHistory(taskId);
+          } else {
+            alert(data?.error || 'Failed to resolve uncertain run');
+          }
+        } catch (e) {
+          alert(e.message || 'Error resolving uncertain run');
+        }
+      };
+
       const loadTaskHistory = async (taskId) => {
         setHistoryLoading(true);
         try {
@@ -2828,6 +2809,41 @@ window.__ModuleLoader__.load({
                           onClick: () => handleRetryDelivery(formId, run.id)
                         }, retryingDeliveryId === run.id ? T_KEY(t, 'history.retryingDelivery') : T_KEY(t, 'history.retryDelivery'))
                       ),
+                      run.artifacts && run.artifacts.length > 0 && React.createElement('div', {
+                        style: { display: 'flex', flexWrap: 'wrap', gap: '6px', marginTop: '6px', alignItems: 'center' }
+                      },
+                        React.createElement('span', { className: 'dsh-cron-hint', style: { fontSize: '11px' } }, '📦 ' + T_KEY(t, 'history.artifacts') + ':'),
+                        run.artifacts.map((art) => React.createElement('a', {
+                          key: art.name || art.id,
+                          href: '/dsh-cron/runs/' + encodeURIComponent(run.id) + '/artifacts/' + encodeURIComponent(art.name) + '/preview',
+                          target: '_blank',
+                          rel: 'noopener noreferrer',
+                          className: 'dsh-cron-btn-secondary',
+                          style: { padding: '2px 8px', fontSize: '11px', textDecoration: 'none' },
+                          title: art.name + ' (' + Math.round((art.size || 0) / 1024 * 10) / 10 + ' KB)'
+                        }, art.name))
+                      ),
+                      run.status === 'uncertain' && React.createElement('div', {
+                        className: 'dsh-cron-status-banner',
+                        'data-type': 'warning',
+                        style: { marginTop: '8px', display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: '8px' }
+                      },
+                        React.createElement('span', null, '⚠️ ' + T_KEY(t, 'history.statusUncertainHint')),
+                        React.createElement('div', { style: { display: 'flex', gap: '6px' } },
+                          React.createElement('button', {
+                            type: 'button',
+                            className: 'dsh-cron-btn-secondary',
+                            style: { padding: '2px 8px', fontSize: '11px' },
+                            onClick: () => handleResolveUncertain(formId, run.id, 'completed')
+                          }, '✓ ' + T_KEY(t, 'history.resolveCompleted')),
+                          React.createElement('button', {
+                            type: 'button',
+                            className: 'dsh-cron-btn-secondary',
+                            style: { padding: '2px 8px', fontSize: '11px' },
+                            onClick: () => handleResolveUncertain(formId, run.id, 'failed')
+                          }, '✕ ' + T_KEY(t, 'history.resolveFailed'))
+                        )
+                      ),
                       run.diagnosis && React.createElement('div', {
                         className: 'dsh-cron-status-banner',
                         'data-type': 'info',
@@ -3351,7 +3367,7 @@ window.__ModuleLoader__.load({
                     React.createElement('div', { className: 'dsh-cron-hint' }, T_KEY(t, 'form.silentRuleHint'))
                   )
                 ),
-                
+
                   React.createElement('div', {
                     style: {
                       marginTop: '16px',
@@ -3485,7 +3501,6 @@ window.__ModuleLoader__.load({
           )
         ),
 
-
         dryRunResult && React.createElement('div', { className: 'dsh-cron-modal-overlay', onClick: () => setDryRunResult(null) },
           React.createElement('div', {
             className: 'dsh-cron-modal',
@@ -4167,18 +4182,9 @@ window.__ModuleLoader__.load({
       return entry;
     }
 
-    /**
-     * Collapsible list of active jobs under the sidebar entry (#34).
-     *
-     * Vanilla DOM like the entry itself: the sidebar is not a React root here.
-     * Collapsed by default, state persisted, capped at a few rows with an
-     * "and N more" line so a busy schedule cannot push the rest of the sidebar
-     * off screen. Clicking a row opens the panel and highlights that task.
-     */
     const SIDEBAR_JOBS_KEY = 'dsh-cron-sidebar-open';
     const SIDEBAR_JOBS_MAX_ROWS = 5;
 
-    /** Sidebar job row: title plus next run time or the live running state. */
     function buildSidebarJobRow(state, task) {
       const row = document.createElement('button');
       row.type = 'button';
@@ -4274,7 +4280,6 @@ window.__ModuleLoader__.load({
       return root;
     }
 
-    /** Keep the section mounted under the sidebar entry across re-renders. */
     function placeSidebarJobs(state, label) {
       if (state.root !== undefined && state.root.isConnected) return;
       const entry = document.querySelector('[' + ENTRY_ATTR + ']');
@@ -4290,14 +4295,6 @@ window.__ModuleLoader__.load({
       applySidebarJobsOpen(state);
     }
 
-    /**
-     * Collapsible list of active jobs under the sidebar entry (#34).
-     *
-     * Vanilla DOM like the entry itself: the sidebar is not a React root here.
-     * Collapsed by default, state persisted, capped at a few rows with an
-     * "and N more" line so a busy schedule cannot push the rest of the sidebar
-     * off screen. Clicking a row opens the panel and highlights that task.
-     */
     function mountSidebarJobs(toggle, label, openTaskSignal) {
       if (typeof document === 'undefined') return () => {};
       const state = { toggle, openTaskSignal, root: undefined, listEl: undefined, headEl: undefined, open: false };
@@ -4437,12 +4434,6 @@ window.__ModuleLoader__.load({
       };
     }
 
-    /**
-     * Register a card into a DSH mount point. Mount points are populated via
-     * ctx.slots.inject(mount, cb) — a direct slots.register does not throw but
-     * also never appears in the target surface (settings plugins tab, header),
-     * so the inject contract is mandatory (#85).
-     */
     function registerIntoMount(ctx, mountName, entry, component) {
       if (!ctx || !ctx.slots || typeof ctx.slots.inject !== 'function') return false;
       try {

package/lib/durable-journal.js

@@ -0,0 +1,188 @@
+import { createHash, randomUUID } from 'node:crypto';
+
+/**
+ * States for durable task execution lifecycle (#317)
+ */
+export const JOURNAL_STATES = {
+  QUEUED: 'queued',
+  RUNNING: 'running',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+  CANCELLED: 'cancelled',
+  UNCERTAIN: 'uncertain',
+};
+
+export class DurableJournal {
+  constructor(store) {
+    this.store = store;
+  }
+
+  /**
+   * Generates a deterministic idempotency key for a task run
+   */
+  generateIdempotencyKey(taskId, scheduleTick) {
+    const raw = `${taskId}:${scheduleTick || Date.now()}`;
+    return 'idem_' + createHash('sha256').update(raw).digest('hex').slice(0, 24);
+  }
+
+  /**
+   * Checks whether a run with this idempotency key was already completed
+   */
+  isIdempotencyKeyExecuted(taskId, idempotencyKey) {
+    if (!idempotencyKey) return null;
+    const history = this.store.getHistory(taskId) || [];
+    return history.find(
+      (r) => r.idempotencyKey === idempotencyKey &&
+             (r.status === JOURNAL_STATES.COMPLETED || r.status === 'success')
+    ) || null;
+  }
+
+  /**
+   * Pre-allocates a durable run entry before execution starts (#317)
+   */
+  createRunRecord(taskId, { idempotencyKey, chainRunId, trigger = 'scheduler', scheduleTick } = {}) {
+    const runId = 'run_' + randomUUID().replace(/-/g, '').slice(0, 16);
+    const key = idempotencyKey || this.generateIdempotencyKey(taskId, scheduleTick);
+
+    const record = {
+      id: runId,
+      taskId,
+      at: Date.now(),
+      status: JOURNAL_STATES.QUEUED,
+      trigger,
+      idempotencyKey: key,
+      chainRunId: chainRunId || null,
+      stages: [
+        { name: 'queue', status: 'success', startedAt: Date.now(), finishedAt: Date.now() },
+        { name: 'preflight', status: 'pending' },
+        { name: 'execution', status: 'pending' },
+        { name: 'validation', status: 'pending' },
+        { name: 'delivery', status: 'pending' },
+      ],
+      stoppedReason: null,
+      createdAt: Date.now(),
+    };
+
+    // Record initial queued entry into history/store
+    this.store.recordRun(taskId, record);
+    return record;
+  }
+
+  /**
+   * Transitions a run record to a new state and updates history entry
+   */
+  transition(taskId, runId, toState, metadata = {}) {
+    const runs = this.store.history.get(taskId) || [];
+    const index = runs.findIndex((r) => r.id === runId);
+    if (index === -1) return null;
+
+    const existing = runs[index];
+    const updated = {
+      ...existing,
+      ...metadata,
+      status: toState,
+      updatedAt: Date.now(),
+    };
+
+    if (
+      toState === JOURNAL_STATES.COMPLETED ||
+      toState === JOURNAL_STATES.FAILED ||
+      toState === JOURNAL_STATES.CANCELLED ||
+      toState === JOURNAL_STATES.UNCERTAIN
+    ) {
+      updated.finishedAt = Date.now();
+      if (updated.startedAt && !updated.durationMs) {
+        updated.durationMs = updated.finishedAt - updated.startedAt;
+      }
+    }
+
+    runs[index] = updated;
+    this.store.history.set(taskId, runs);
+    this.store.scheduleSave(50);
+    return updated;
+  }
+
+  /**
+   * Recovers uncompleted / in-flight runs on daemon restart (#317)
+   */
+  recoverPendingRuns(scheduler) {
+    const tasks = this.store.list();
+    const recovered = { uncertain: [], requeued: [] };
+
+    for (const task of tasks) {
+      const history = this.store.history.get(task.id) || [];
+      let historyChanged = false;
+
+      for (let i = 0; i < history.length; i++) {
+        const run = history[i];
+        if (run.status === JOURNAL_STATES.RUNNING) {
+          // Crash during execution -> transition to UNCERTAIN to prevent blind rerun
+          history[i] = {
+            ...run,
+            status: JOURNAL_STATES.UNCERTAIN,
+            stoppedReason: 'interrupted_by_restart',
+            uncertainAt: Date.now(),
+          };
+          historyChanged = true;
+          recovered.uncertain.push({ taskId: task.id, runId: run.id });
+        } else if (run.status === JOURNAL_STATES.QUEUED) {
+          // Queued run that didn't start yet: if task is still active and recent (<1 hour), re-enqueue
+          const ageMs = Date.now() - (run.createdAt || run.at);
+          if (task.status === 'active' && ageMs < 3600000 && scheduler && typeof scheduler.runTask === 'function') {
+            scheduler.queue = scheduler.queue || [];
+            if (!scheduler.queue.includes(task.id)) {
+              scheduler.queue.push(task.id);
+              recovered.requeued.push({ taskId: task.id, runId: run.id });
+            }
+          } else {
+            // Expired or cancelled queued run
+            history[i] = {
+              ...run,
+              status: JOURNAL_STATES.CANCELLED,
+              stoppedReason: 'Queued run expired or cancelled across restart',
+            };
+            historyChanged = true;
+          }
+        }
+      }
+
+      if (historyChanged) {
+        this.store.scheduleSave(50);
+      }
+    }
+
+    return recovered;
+  }
+
+  /**
+   * Manually resolves an uncertain run record (#317)
+   */
+  resolveUncertain(taskId, runId, { decision, note, resolvedBy = 'user' } = {}) {
+    const runs = this.store.history.get(taskId) || [];
+    const index = runs.findIndex((r) => r.id === runId);
+    if (index === -1) return { ok: false, error: 'Run not found' };
+
+    const run = runs[index];
+    if (run.status !== JOURNAL_STATES.UNCERTAIN) {
+      return { ok: false, error: `Run is in status "${run.status}", not uncertain` };
+    }
+
+    let nextStatus = JOURNAL_STATES.FAILED;
+    if (decision === 'completed' || decision === 'mark_completed') nextStatus = JOURNAL_STATES.COMPLETED;
+    else if (decision === 'failed' || decision === 'mark_failed') nextStatus = JOURNAL_STATES.FAILED;
+    else if (decision === 'cancel' || decision === 'cancelled') nextStatus = JOURNAL_STATES.CANCELLED;
+
+    const resolved = {
+      ...run,
+      status: nextStatus,
+      stoppedReason: `Uncertain run resolved by ${resolvedBy}: ${note || decision}`,
+      resolvedBy,
+      resolvedAt: Date.now(),
+    };
+
+    runs[index] = resolved;
+    this.store.history.set(taskId, runs);
+    this.store.scheduleSave(50);
+    return { ok: true, run: resolved };
+  }
+}

package/lib/routes.js

@@ -44,6 +44,21 @@ export function registerRoutes(ctx, { store, scheduler, recommendations }) {
     handler: createCronApiHandler(store, scheduler, null)
   }), 'dsh-cron: /schedule[...]');
 
+
+  // Chain retry from failed step (#319)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/chains',
+    handler: (req, res) => handleChainRoutes(store, scheduler, req, res)
+  }), 'dsh-cron: /chains[...]');
+
+  // Run artifacts listing, download and safe preview (#321)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-cron/runs',
+    handler: (req, res) => handleRunArtifactRoutes(store, req, res)
+  }), 'dsh-cron: /runs[...]');
+
   // GET /dsh-cron/metrics (#53) — Prometheus text exposition
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
@@ -198,3 +213,72 @@ export function registerRoutes(ctx, { store, scheduler, recommendations }) {
   }), 'dsh-cron: /kanban/test');
 }
 
+
+/**
+ * Handler for chain step retries (#319)
+ */
+export async function handleChainRoutes(store, scheduler, req, res) {
+  if (req.method === 'POST' && rejectCrossOrigin(req, res)) return;
+  const url = new URL(req.url, 'http://localhost');
+  const m = url.pathname.match(/^\/dsh-cron\/chains\/([^\/]+)\/retry-from\/([^\/]+)$/);
+  if (!m) {
+    sendJson(res, 404, { ok: false, error: 'Route not found' });
+    return;
+  }
+  if (req.method !== 'POST') {
+    sendJson(res, 405, { ok: false, error: 'Method not allowed' });
+    return;
+  }
+  const [, chainRunId, stepTaskId] = m;
+  const result = await store.chainCheckpointManager.retryChainFromStep(scheduler, chainRunId, stepTaskId);
+  if (!result.ok) {
+    sendJson(res, 400, result);
+    return;
+  }
+  sendJson(res, 200, result);
+}
+
+/**
+ * Handler for run artifacts (#321)
+ */
+export async function handleRunArtifactRoutes(store, req, res) {
+  const url = new URL(req.url, 'http://localhost');
+  const m = url.pathname.match(/^\/dsh-cron\/runs\/([^\/]+)\/artifacts(?:\/([^\/]+)(?:\/(preview))?)?$/);
+  if (!m) {
+    sendJson(res, 404, { ok: false, error: 'Route not found' });
+    return;
+  }
+  if (req.method !== 'GET') {
+    sendJson(res, 405, { ok: false, error: 'Method not allowed' });
+    return;
+  }
+  const [, runId, artifactId, action] = m;
+  if (!artifactId) {
+    const artifacts = store.getArtifactsForRun(runId);
+    sendJson(res, 200, { ok: true, runId, artifacts });
+    return;
+  }
+  const artifacts = store.getArtifactsForRun(runId);
+  const record = artifacts.find((a) => a.id === artifactId);
+  if (!record) {
+    sendJson(res, 404, { ok: false, error: 'Artifact record not found' });
+    return;
+  }
+  if (action === 'preview') {
+    const preview = store.artifactManager.generatePreview(artifactId, record.name);
+    sendJson(res, preview.ok ? 200 : 404, preview);
+    return;
+  }
+  const buf = store.artifactManager.readArtifact(artifactId, record.name);
+  if (!buf) {
+    sendJson(res, 404, { ok: false, error: 'Artifact file missing from disk (expired or removed)' });
+    return;
+  }
+  res.writeHead(200, {
+    'Content-Type': record.mimeType || 'application/octet-stream',
+    'Content-Disposition': `attachment; filename="${encodeURIComponent(record.name)}"`,
+    'Content-Length': buf.length,
+    'X-Content-Type-Options': 'nosniff',
+  });
+  res.end(buf);
+}

package/lib/scheduler-execution.js

@@ -310,6 +310,23 @@ export async function executeTask(scheduler, taskId, options = {}) {
       model: outcome.model || task.model || '',
     };
   }
+  // 0. Idempotency Check (#317): deduplicate runs with an already completed idempotency key
+  if (options.idempotencyKey && scheduler.store.durableJournal) {
+    const existing = scheduler.store.durableJournal.isIdempotencyKeyExecuted(taskId, options.idempotencyKey);
+    if (existing) {
+      logger.info(`[dsh-cron] Idempotency key "${options.idempotencyKey}" already executed for task "${taskId}", returning cached run`);
+      return {
+        ok: existing.status === 'completed' || existing.status === 'success',
+        idempotentReplay: true,
+        runId: existing.id,
+        status: existing.status,
+        output: existing.output,
+        costUsd: existing.costUsd,
+        durationMs: existing.durationMs,
+      };
+    }
+  }
+
 
   // 1. Approval Gate (#318): Human-in-the-loop check before executing actions requiring approval
   if (task.requireApproval && !options.approvedBy) {
@@ -699,6 +716,46 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     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);
+  // Durable journal & Idempotency (#317)
+  runInfo.idempotencyKey = options.idempotencyKey || currentRun?.idempotencyKey || null;
+
+  // Artifacts capture (#321)
+  if (Array.isArray(outcome.artifacts) && scheduler.store.artifactManager) {
+    for (const art of outcome.artifacts) {
+      if (art && art.name && (art.content || art.data)) {
+        try {
+          scheduler.store.artifactManager.saveArtifact(runInfo.runId, taskId, art.name, art.content || art.data);
+        } catch (artErr) {
+          logger.warn(`[dsh-cron] failed to save artifact ${art.name}:`, artErr.message);
+        }
+      }
+    }
+  }
+  if (scheduler.store.getArtifactsForRun) {
+    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);
+  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 || '' },
+        output: outcome.output || outcome.error || '',
+        durationMs: executionMs,
+      });
+    }
+  }
+
+  // Update Durable Journal (#317)
+  if (scheduler.store.durableJournal) {
+    const journalState = outcome.status === 'success' ? 'completed' : (outcome.status === 'uncertain' ? 'uncertain' : 'failed');
+    scheduler.store.durableJournal.transition(taskId, runInfo.runId, journalState, runInfo);
+  }
+
 
   try {
     scheduler.store.recordRun(taskId, runInfo);
@@ -795,6 +852,7 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
       if (nextTask) {
         logger.info(`[dsh-cron] triggering chained task "${nextTask.title}" (${targetId}) from "${task.title}" (depth ${currentDepth + 1})`);
         scheduler.runNow(targetId, {
+          chainRunId,
           chainDepth: currentDepth + 1,
           prevOutput: outcome.output || outcome.error || '',
           prevTaskId: task.id,

package/lib/scheduler.js

@@ -361,6 +361,26 @@ export class TaskScheduler {
   start() {
     this.isStopped = false;
     this.generation = (this.generation || 0) + 1;
+
+    // Recovery & cleanup on restart (#317, #321)
+    if (this.store && this.store.durableJournal) {
+      try {
+        const recovered = this.store.durableJournal.recoverPendingRuns(this);
+        if (recovered.uncertain.length > 0) {
+          logger.warn(`[dsh-cron] Recovered ${recovered.uncertain.length} in-flight run(s) interrupted by restart -> status marked uncertain`);
+        }
+      } catch (recErr) {
+        logger.error('[dsh-cron] restart recovery failed:', recErr.message);
+      }
+    }
+    if (this.store && this.store.artifactManager) {
+      try {
+        this.store.artifactManager.cleanupArtifacts(this.store);
+      } catch (cleanErr) {
+        logger.warn('[dsh-cron] artifact cleanup failed:', cleanErr.message);
+      }
+    }
+
     const tasks = this.store.list();
     const now = Date.now();
     for (const task of tasks) {

package/lib/store.js

@@ -1,3 +1,6 @@
+import { DurableJournal } from './durable-journal.js';
+import { ChainCheckpointManager } from './chain-checkpoints.js';
+import { ArtifactManager } from './artifacts.js';
 import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 import fs from 'node:fs';
@@ -36,6 +39,12 @@ export class TaskStore {
     this.tasks = new Map();
     this.history = new Map();
     this.settings = {};
+    this.chainCheckpoints = {};
+    this.artifacts = {};
+    const storeDir = path.dirname(this.filePath);
+    this.durableJournal = new DurableJournal(this);
+    this.chainCheckpointManager = new ChainCheckpointManager(this);
+    this.artifactManager = new ArtifactManager(path.join(storeDir, "artifacts"));
     this._lastBackupTime = 0;
     this._saveTimer = null;
     this._savePromise = Promise.resolve();
@@ -85,6 +94,12 @@ export class TaskStore {
       if (data.settings && typeof data.settings === 'object') {
         this.settings = data.settings;
       }
+      if (data.chainCheckpoints && typeof data.chainCheckpoints === 'object') {
+        this.chainCheckpoints = data.chainCheckpoints;
+      }
+      if (data.artifacts && typeof data.artifacts === 'object') {
+        this.artifacts = data.artifacts;
+      }
     };
 
     if (fs.existsSync(this.filePath)) {
@@ -189,6 +204,8 @@ export class TaskStore {
       tasks: tasksSnapshot,
       history: historySnapshot,
       settings: this.settings ? { ...this.settings } : {},
+      chainCheckpoints: this.chainCheckpoints ? { ...this.chainCheckpoints } : {},
+      artifacts: this.artifacts ? { ...this.artifacts } : {},
     };
   }
 
@@ -347,7 +364,10 @@ export class TaskStore {
         yield ']';
         await new Promise((r) => setImmediate(r));
       }
-      yield '}}';
+      yield '}';
+      yield ',"chainCheckpoints":' + JSON.stringify(data.chainCheckpoints || {});
+      yield ',"artifacts":' + JSON.stringify(data.artifacts || {});
+      yield '}';
     }
 
     try {
@@ -407,6 +427,32 @@ export class TaskStore {
     }
   }
 
+  getRun(runId) {
+    if (!runId) return null;
+    for (const [taskId, runs] of this.history.entries()) {
+      if (Array.isArray(runs)) {
+        const found = runs.find((r) => r.id === runId);
+        if (found) return { ...found, taskId };
+      }
+    }
+    return null;
+  }
+
+  recordArtifact(runIdOrRecord, maybeRecord) {
+    const runId = maybeRecord ? runIdOrRecord : (runIdOrRecord && runIdOrRecord.runId);
+    const artifactRecord = maybeRecord ? maybeRecord : runIdOrRecord;
+    if (!runId || !artifactRecord) return;
+    this.artifacts = this.artifacts || {};
+    this.artifacts[runId] = this.artifacts[runId] || [];
+    this.artifacts[runId].push(artifactRecord);
+    this.scheduleSave(50);
+  }
+
+  getArtifactsForRun(runId) {
+    if (!runId || !this.artifacts) return [];
+    return this.artifacts[runId] || [];
+  }
+
   getSettings() {
     const defaults = getDshDefaultTelegramCredentials();
     const base = { ...this.settings };
@@ -706,6 +752,9 @@ export class TaskStore {
         },
         delivery: runInfo.delivery || null,
         validation: runInfo.validation || null,
+        idempotencyKey: runInfo.idempotencyKey || null,
+        chainRunId: runInfo.chainRunId || null,
+        artifacts: runInfo.artifacts || null,
         sessionId: runInfo.sessionId || null,
         // #45: which model produced the run, and whether it only finished thanks
         // to the configured fallback.

package/package.json

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