@goodandready/dsh-cron 0.3.13 → 0.3.14

package/README.md

@@ -90,6 +90,18 @@ graph TD
 
 ## ✨ Features & Capabilities
 
+### 🐝 Swarm Delegation & Parallel Multi-Agent Execution (#350)
+- **Controlled Worker Pool**: Configure `concurrencyLimit` (1..10, default 3) to execute independent subtasks in parallel without overloading system resources.
+- **Fault-Tolerant Decomposition**: Subtask failures are isolated; the swarm aggregates all successful results and flags partial errors gracefully.
+- **Automated Synthesis**: Aggregates worker outputs into a structured Markdown digest or delegates synthesis to a designated synthesizer model.
+- **Swarm Metrics & History**: Run history records total, succeeded, failed counts, and duration alongside detailed per-worker execution logs.
+
+### 🔍 Git Diff & Interactive Patch Review (#351)
+- **Automatic Diff Capture**: Tasks running in Git worktrees capture modified files, stat summary, and unified diffs (up to 256 KiB) automatically.
+- **1-Click Discard**: Revert uncommitted working directory changes safely with a single click (`git reset --hard HEAD && git clean -fd`).
+- **1-Click Apply**: Re-apply previously captured diffs directly to the repository (`git apply --whitespace=fix`).
+- **Interactive Run Preview**: Color-coded diff inspector embedded directly into the execution history drawer.
+
 ### 🔀 Decision Nodes & Conditional IF/ELSE Branching (#352)
 - **Conditional Routing**: Tasks can define `branchRules` evaluating execution outcomes (`exitCode`, `output`, `output.json.<path>`, `status`) with operators (`equals`, `notequals`, `contains`, `gt`, `gte`, `lt`, `lte`, `regex`, `exists`).
 - **Fallback Else**: Optional `elseTask` triggers when no branch condition matches.

package/README.ru.md

@@ -90,6 +90,18 @@ graph TD
 
 ## ✨ Возможности
 
+### 🐝 Роевая декомпозиция задач и мультиагентный запуск (Swarm Delegation) (#350)
+- **Управляемый пул воркеров**: Настройка `concurrencyLimit` (1..10, по умолчанию 3) для параллельного выполнения независимых подзадач без перегрузки системы.
+- **Отказоустойчивая декомпозиция**: Ошибки отдельных воркеров изолированы; рой объединяет успешные результаты и корректно фиксирует частичные сбои.
+- **Автоматический синтез**: Сведение результатов всех воркеров в структурированный Markdown-дайджест или через выделенную модель-синтезатор.
+- **Метрики и история роя**: Сохранение количества успешных/сбойных задач, времени выполнения и детальных логов каждого воркера.
+
+### 🔍 Просмотр Git Diff и интерактивное подтверждение патчей (#351)
+- **Автоматический захват диффов**: Задачи в Git-каталогах автоматически сохраняют список файлов, сводку изменений и унифицированный diff (до 256 КиБ).
+- **1-Click Discard**: Безопасный откат незакоммиченных изменений в один клик (`git reset --hard HEAD && git clean -fd`).
+- **1-Click Apply**: Повторное наложение сохранённого патча на рабочий каталог (`git apply --whitespace=fix`).
+- **Интерактивный просмотр**: Цветовая подсветка строк diff в карточке истории запусков.
+
 ### 🔀 Решающие узлы и условные развилки IF/ELSE (#352)
 - **Маршрутизация по условию**: Задачи могут задавать `branchRules` для проверки результата (`exitCode`, `output`, `output.json.<path>`, `status`) через операторы (`equals`, `notequals`, `contains`, `gt`, `gte`, `lt`, `lte`, `regex`, `exists`).
 - **Ветка Else**: Резервная задача `elseTask` запускается, если ни одно из правил не совпало.

package/README.zh.md

@@ -90,6 +90,18 @@ graph TD
 
 ## ✨ 功能与能力
 
+### 🐝 群蚁协同委托与多智能体并行执行 (Swarm Delegation) (#350)
+- **受控工作池**：配置并发限制 `concurrencyLimit`（1..10，默认 3），在不耗尽系统资源的前提下并行处理独立子任务。
+- **高容错分解**：单个子任务异常完全隔离，群体自动聚合所有成功输出，并在存在异常时清晰上报。
+- **智能结果汇编**：支持将所有工作节点的执行输出聚合成结构化 Markdown 报告或交由综合模型提炼总结。
+- **群体指标与历史**：运行历史完整记录成功/失败统计、耗时及每个子节点的执行快照与日志。
+
+### 🔍 Git Diff 变更查看与交互式补丁审查 (#351)
+- **自动 Diff 捕获**：在 Git 工作区执行的任务会自动捕获变更文件列表、状态统计及完整 Unified Diff（最高 256 KiB）。
+- **一键丢弃 (Discard)**：一键清空工作区未提交改动，安全重置仓库状态（`git reset --hard HEAD && git clean -fd`）。
+- **一键应用 (Apply)**：将保存的 Diff 补丁直接重新注入并应用到工作区（`git apply --whitespace=fix`）。
+- **交互式审阅面板**：在运行详情抽屉中直接查看带有色彩区分的高亮 Diff 变更对比。
+
 ### 🔀 决策节点与条件分支 IF/ELSE (#352)
 - **条件路由**：任务可配置 `branchRules`（评估 `exitCode`、`output`、`output.json.<path>` 等字段），支持 `equals`、`notequals`、`contains`、`gt`、`lt`、`regex` 等操作符。
 - **回退分支**：若无匹配规则，自动执行 `elseTask`。

package/lib/api.js

@@ -1,3 +1,4 @@
+import { captureGitDiff, discardGitChanges, applyGitDiff } from './git-diff.js';
 import { applyDoctorFix, revertDoctorFix, diagnoseFailure } from './doctor.js';
 import { handleTaskWebhookRoute } from './api-task-webhook.js';
 import { rollbackPromptVersion, sanitizePromptHistory } from './prompt-evolver.js';
@@ -346,6 +347,24 @@ async function handleTaskItem({ store, scheduler, req, res, url, id, action, sub
       sendJson(res, 200, { ok: true, history: store.getHistory(id, limit) });
       return;
     }
+    if (action === 'git-diff') {
+      const task = store.get(id);
+      if (!task) {
+        sendJson(res, 404, NOT_FOUND);
+        return;
+      }
+      const runs = store.getHistory(id, 10);
+      const runId = url.searchParams.get('runId') || subAction;
+      const targetRun = runId ? runs.find((r) => r.id === runId) : runs[0];
+      const diffData = targetRun?.gitDiff || null;
+      sendJson(res, 200, {
+        ok: true,
+        taskId: id,
+        runId: targetRun?.id || null,
+        gitDiff: diffData,
+      });
+      return;
+    }
     if (action === 'doctor') {
       const task = store.get(id);
       if (!task) {
@@ -399,6 +418,50 @@ async function handleTaskItem({ store, scheduler, req, res, url, id, action, sub
 
 /** Task actions that are plain POSTs. Returns true when one matched. */
 async function handleItemPost({ store, scheduler, req, res, url, id, action, subAction }) {
+  if (action === 'git-diff' && (subAction === 'discard' || subAction === 'revert')) {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const targetDir = task.cwd;
+    if (!targetDir) {
+      sendJson(res, 400, { ok: false, error: 'Task does not define a working directory (cwd)' });
+      return true;
+    }
+    const result = await discardGitChanges(targetDir);
+    sendJson(res, result.ok ? 200 : 500, result);
+    return true;
+  }
+
+  if (action === 'git-diff' && subAction === 'apply') {
+    const task = store.get(id);
+    if (!task) {
+      sendJson(res, 404, NOT_FOUND);
+      return true;
+    }
+    const body = await readBody(req, res);
+    const bodyData = (body && body.body) || {};
+    let patch = bodyData.diff || bodyData.patch;
+    if (!patch) {
+      const runs = store.getHistory(id, 5);
+      const targetRun = runs.find((r) => r.gitDiff?.diff);
+      patch = targetRun?.gitDiff?.diff;
+    }
+    if (!patch) {
+      sendJson(res, 400, { ok: false, error: 'No diff patch provided or found in run history' });
+      return true;
+    }
+    const targetDir = task.cwd;
+    if (!targetDir) {
+      sendJson(res, 400, { ok: false, error: 'Task does not define a working directory (cwd)' });
+      return true;
+    }
+    const result = await applyGitDiff(targetDir, patch);
+    sendJson(res, result.ok ? 200 : 500, result);
+    return true;
+  }
+
   if ((action === 'doctor' && subAction === 'apply') || action === 'doctor-apply') {
     const task = store.get(id);
     if (!task) {

package/lib/client.js

@@ -3557,6 +3557,85 @@ onClick: () => openEditModal(selectedTaskMeta, { prompt: run.suggestion })
 }, T_KEY(t, 'history.applySuggestion'))
 )
 ),
+run.subtaskRuns && Array.isArray(run.subtaskRuns) && run.subtaskRuns.length > 0 && h('div', {
+style: { marginTop: '8px', padding: '8px', background: 'var(--dsw-alias-bg-layer-2)', borderRadius: '6px', fontSize: '12px' }
+},
+h('div', { style: { fontWeight: '600', marginBottom: '4px' } }, '🐝 ' + T_KEY(t, 'history.swarmBadge') + ' (' + run.subtaskRuns.filter(r => r.status === 'success').length + '/' + run.subtaskRuns.length + ')'),
+h('div', { style: { display: 'flex', flexDirection: 'column', gap: '4px' } },
+run.subtaskRuns.map((st, sidx) => h('div', {
+key: sidx,
+style: { display: 'flex', justifyContent: 'space-between', padding: '2px 6px', background: 'var(--dsw-alias-bg-layer-3)', borderRadius: '4px' }
+},
+h('span', null, (st.status === 'success' ? '✅ ' : '❌ ') + st.title),
+h('span', { style: { color: 'var(--dsw-alias-label-tertiary)', fontSize: '11px' } }, (st.durationMs || 0) + 'ms')
+))
+)
+),
+run.gitDiff && run.gitDiff.hasChanges && h('div', {
+className: 'dsh-cron-status-banner',
+style: { marginTop: '8px', display: 'flex', flexDirection: 'column', gap: '6px' }
+},
+h('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center' } },
+h('strong', null, '📝 ' + T_KEY(t, 'history.gitDiff')),
+h('span', { style: { fontSize: '11px', color: 'var(--dsw-alias-label-secondary)' } }, run.gitDiff.stat || '')
+),
+run.gitDiff.diff && h('div', {
+style: {
+background: 'var(--dsw-alias-bg-layer-2)',
+border: '1px solid var(--dsw-alias-border-l2)',
+borderRadius: '4px',
+padding: '6px',
+fontFamily: 'monospace',
+fontSize: '11px',
+maxHeight: '140px',
+overflowY: 'auto',
+whiteSpace: 'pre'
+}
+}, run.gitDiff.diff),
+h('div', { style: { display: 'flex', gap: '8px', marginTop: '4px' } },
+h('button', {
+type: 'button',
+className: 'dsh-cron-btn-secondary',
+style: { padding: '2px 8px', fontSize: '12px' },
+onClick: async () => {
+if (!confirm('Discard all uncommitted changes in task directory?')) return;
+const c = typeof AbortController !== 'undefined' ? new AbortController() : null;
+const tId = c ? setTimeout(() => c.abort(), 15000) : null;
+try {
+const res = await fetch('/dsh-cron/tasks/' + encodeURIComponent(formId) + '/git-diff/discard', {
+method: 'POST',
+signal: c ? c.signal : undefined
+});
+const d = await res.json();
+if (d.ok) { alert('Working directory reset successfully.'); if (formId) loadTaskHistory(formId); }
+else alert(d.error || 'Failed to discard changes');
+} catch (e) { alert(e.message); }
+finally { if (tId) clearTimeout(tId); }
+}
+}, '🗑️ ' + T_KEY(t, 'history.discardDiff')),
+h('button', {
+type: 'button',
+className: 'dsh-cron-btn-primary',
+style: { padding: '2px 8px', fontSize: '12px' },
+onClick: async () => {
+const c = typeof AbortController !== 'undefined' ? new AbortController() : null;
+const tId = c ? setTimeout(() => c.abort(), 15000) : null;
+try {
+const res = await fetch('/dsh-cron/tasks/' + encodeURIComponent(formId) + '/git-diff/apply', {
+method: 'POST',
+headers: { 'Content-Type': 'application/json' },
+signal: c ? c.signal : undefined,
+body: JSON.stringify({ diff: run.gitDiff.diff })
+});
+const d = await res.json();
+if (d.ok) { alert('Patch applied successfully.'); if (formId) loadTaskHistory(formId); }
+else alert(d.error || 'Failed to apply patch');
+} catch (e) { alert(e.message); }
+finally { if (tId) clearTimeout(tId); }
+}
+}, '✅ ' + T_KEY(t, 'history.applyDiff'))
+)
+),
 run.silentSkip && h('div', {
 className: 'dsh-cron-hint',
 style: { display: 'flex', gap: '6px', alignItems: 'center' }

package/lib/git-diff.js

@@ -0,0 +1,226 @@
+/**
+ * Git Diff and Patch Review Engine (#351)
+ *
+ * Provides safe collection, parsing, inspection, and manipulation of Git diffs
+ * generated during task execution (e.g. scripts modifying workspace or worktree).
+ */
+
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const execFileAsync = promisify(execFile);
+
+export const MAX_DIFF_SIZE = 256 * 1024; // 256 KiB safety ceiling
+
+/**
+ * Checks if a given directory is inside a git working tree.
+ *
+ * @param {string} cwd
+ * @returns {Promise<boolean>}
+ */
+export async function isGitRepository(cwd) {
+  if (!cwd) return false;
+  try {
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], {
+      cwd,
+      timeout: 3000,
+    });
+    return stdout.trim() === 'true';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Parses git status --porcelain output into structured file items.
+ *
+ * @param {string} porcelainOutput
+ * @returns {Array<Object>}
+ */
+export function parsePorcelainStatus(porcelainOutput) {
+  if (!porcelainOutput || typeof porcelainOutput !== 'string') return [];
+  const lines = porcelainOutput.split('\n').map((l) => l.trimEnd()).filter(Boolean);
+  const files = [];
+
+  for (const line of lines) {
+    if (line.length < 3) continue;
+    const x = line[0];
+    const y = line[1];
+    const filePath = line.slice(3).trim();
+
+    let status = 'modified';
+    if (x === 'A' || y === 'A' || (x === '?' && y === '?')) status = 'added';
+    else if (x === 'D' || y === 'D') status = 'deleted';
+    else if (x === 'R' || y === 'R') status = 'renamed';
+
+    files.push({
+      path: filePath,
+      rawCode: `${x}${y}`.trim(),
+      status,
+    });
+  }
+
+  return files;
+}
+
+/**
+ * Parses git diff --stat output into structured totals.
+ *
+ * @param {string} statOutput
+ * @returns {{ filesCount: number, insertions: number, deletions: number }}
+ */
+export function parseGitStatSummary(statOutput) {
+  if (!statOutput || typeof statOutput !== 'string') {
+    return { filesCount: 0, insertions: 0, deletions: 0 };
+  }
+
+  const match = statOutput.match(/(\d+)\s+files?\s+changed(?:,\s+(\d+)\s+insertions?\(\+\))?(?:,\s+(\d+)\s+deletions?\(-\))?/i);
+  if (!match) {
+    return { filesCount: 0, insertions: 0, deletions: 0 };
+  }
+
+  return {
+    filesCount: Number(match[1] || 0),
+    insertions: Number(match[2] || 0),
+    deletions: Number(match[3] || 0),
+  };
+}
+
+/**
+ * Captures the current Git diff in the specified directory.
+ *
+ * @param {string} cwd Target repository directory
+ * @param {Object} [options]
+ * @param {number} [options.maxSize=262144] Maximum diff size before truncation
+ * @returns {Promise<Object>} { hasChanges: boolean, stat: string, diff: string, files: Array, summary: Object, truncated: boolean }
+ */
+export async function captureGitDiff(cwd, { maxSize = MAX_DIFF_SIZE } = {}) {
+  if (!cwd) {
+    return { hasChanges: false, error: 'No working directory specified' };
+  }
+
+  const isRepo = await isGitRepository(cwd);
+  if (!isRepo) {
+    return { hasChanges: false, isRepo: false };
+  }
+
+  try {
+    // 1. Check if there are any changes
+    const { stdout: statusOut } = await execFileAsync('git', ['status', '--porcelain'], { cwd, timeout: 5000 });
+    const cleanStatus = statusOut.trim();
+    if (!cleanStatus) {
+      return { hasChanges: false, stat: '', diff: '', files: [], summary: { filesCount: 0, insertions: 0, deletions: 0 } };
+    }
+
+    const files = parsePorcelainStatus(cleanStatus);
+
+    // 2. Fetch diff stat
+    let stat = '';
+    try {
+      const { stdout: statOut } = await execFileAsync('git', ['diff', '--stat', 'HEAD'], { cwd, timeout: 5000 });
+      stat = statOut.trim();
+    } catch {
+      // Fallback without HEAD (e.g. unborn branch)
+      try {
+        const { stdout: statOut } = await execFileAsync('git', ['diff', '--stat'], { cwd, timeout: 5000 });
+        stat = statOut.trim();
+      } catch {
+        stat = `${files.length} file(s) changed`;
+      }
+    }
+
+    const summary = parseGitStatSummary(stat);
+    if (summary.filesCount === 0 && files.length > 0) {
+      summary.filesCount = files.length;
+    }
+
+    // 3. Fetch full unified diff
+    let rawDiff = '';
+    try {
+      const { stdout: diffOut } = await execFileAsync('git', ['diff', 'HEAD'], { cwd, timeout: 8000, maxBuffer: 10 * 1024 * 1024 });
+      rawDiff = diffOut;
+    } catch {
+      try {
+        const { stdout: diffOut } = await execFileAsync('git', ['diff'], { cwd, timeout: 8000, maxBuffer: 10 * 1024 * 1024 });
+        rawDiff = diffOut;
+      } catch (err) {
+        rawDiff = `[Diff unavailable: ${err.message}]`;
+      }
+    }
+
+    let truncated = false;
+    let diff = rawDiff;
+    if (Buffer.byteLength(diff, 'utf8') > maxSize) {
+      diff = diff.slice(0, maxSize) + '\n\n[... Diff truncated: exceeds 256 KiB limit ...]';
+      truncated = true;
+    }
+
+    return {
+      hasChanges: true,
+      isRepo: true,
+      stat,
+      diff,
+      files,
+      summary,
+      truncated,
+    };
+  } catch (err) {
+    return {
+      hasChanges: false,
+      error: err.message || String(err),
+    };
+  }
+}
+
+/**
+ * Discards all uncommitted changes (tracked and untracked) in the target git directory.
+ *
+ * @param {string} cwd Target repository directory
+ * @returns {Promise<{ ok: boolean, error?: string }>}
+ */
+export async function discardGitChanges(cwd) {
+  if (!cwd) return { ok: false, error: 'No working directory specified' };
+  const isRepo = await isGitRepository(cwd);
+  if (!isRepo) return { ok: false, error: 'Not a git repository' };
+
+  try {
+    // Reset tracked modifications
+    await execFileAsync('git', ['reset', '--hard', 'HEAD'], { cwd, timeout: 10000 });
+    // Clean untracked files and directories
+    await execFileAsync('git', ['clean', '-fd'], { cwd, timeout: 10000 });
+    return { ok: true, discarded: true };
+  } catch (err) {
+    return { ok: false, error: err.message || String(err) };
+  }
+}
+
+/**
+ * Applies a git patch string to the target repository directory.
+ *
+ * @param {string} cwd Target repository directory
+ * @param {string} patchContent Unified diff / patch text
+ * @returns {Promise<{ ok: boolean, error?: string }>}
+ */
+export async function applyGitDiff(cwd, patchContent) {
+  if (!cwd || !patchContent) return { ok: false, error: 'Missing directory or patch content' };
+  const isRepo = await isGitRepository(cwd);
+  if (!isRepo) return { ok: false, error: 'Not a git repository' };
+
+  const tmpPath = path.join(os.tmpdir(), `dsh-cron-patch-${Date.now()}-${Math.random().toString(36).slice(2)}.diff`);
+  try {
+    await fs.writeFile(tmpPath, patchContent, 'utf8');
+    await execFileAsync('git', ['apply', '--whitespace=fix', tmpPath], { cwd, timeout: 10000 });
+    return { ok: true, applied: true };
+  } catch (err) {
+    return { ok: false, error: `Failed to apply git diff: ${err.message || err}` };
+  } finally {
+    try {
+      await fs.unlink(tmpPath);
+    } catch (_e) {
+      /* ignore temp file cleanup error */
+    }
+  }
+}

package/lib/scheduler-execution.js

@@ -1,3 +1,5 @@
+import { executeSwarmTask } from './swarm.js';
+import { captureGitDiff } from './git-diff.js';
 import { resolveBranchTargets } from './branching.js';
 import { shouldAutoHeal, applyDoctorFix } from './doctor.js';
 import { recordPromptRunOutcome } from './prompt-evolver.js';
@@ -139,6 +141,25 @@ export async function executeOnce(scheduler, task, signal, options = {}) {
     model: task.model || '',
     fallback: false,
   };
+  if (task.type === 'swarm') {
+    try {
+      const swarmRes = await executeSwarmTask(task, {
+        executeFn: (subtask) => scheduler.executeFn(subtask, { signal, ...options }),
+        askModel: scheduler.askModel,
+        signal,
+        logger,
+      });
+      result.output = swarmRes.output || '';
+      result.status = swarmRes.status;
+      result.subtaskRuns = swarmRes.subtaskRuns || [];
+      result.swarmStats = swarmRes.stats;
+      return result;
+    } catch (err) {
+      result.error = err.message || String(err);
+      result.status = 'error';
+      return result;
+    }
+  }
   if (typeof scheduler.executeFn !== 'function') return result;
   const executableTask = resolveTaskForExecution(task, options);
   try {
@@ -772,6 +793,24 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     },
   ];
 
+  if (outcome.subtaskRuns) {
+    runInfo.subtaskRuns = outcome.subtaskRuns;
+    runInfo.swarmStats = outcome.swarmStats;
+  }
+
+  // Capture git diff if task runs in a worktree or custom git cwd (#351)
+  const diffDir = task.worktree ? (runInfo.worktreePath || task.cwd) : task.cwd;
+  if (diffDir) {
+    try {
+      const diffResult = await captureGitDiff(diffDir);
+      if (diffResult && diffResult.hasChanges) {
+        runInfo.gitDiff = diffResult;
+      }
+    } catch {
+      // Non-fatal if diff capture fails
+    }
+  }
+
   runInfo.stages = stages;
   runInfo.delivery = deliveryResult;
   runInfo.cost = {

package/lib/store.js

@@ -776,6 +776,10 @@ export class TaskStore {
         selfHealing: runInfo.selfHealing || null,
         autoDiagnosis: runInfo.autoDiagnosis ? String(runInfo.autoDiagnosis).slice(0, 1000) : '',
         confidence: runInfo.confidence || '',
+        doctorReport: runInfo.doctorReport || null,
+        subtaskRuns: Array.isArray(runInfo.subtaskRuns) ? runInfo.subtaskRuns : null,
+        swarmStats: runInfo.swarmStats || null,
+        gitDiff: runInfo.gitDiff || null,
       },
       ...prevRuns,
     ];

package/lib/swarm.js

@@ -0,0 +1,303 @@
+/**
+ * Swarm Delegation Engine (#350)
+ *
+ * Provides parallel multi-agent task execution and swarm decomposition:
+ * - Dynamic or static subtask orchestration
+ * - Controlled concurrency worker pool (concurrencyLimit)
+ * - Fault-tolerant execution (single worker failure does not crash the swarm)
+ * - Result aggregation and synthesis
+ */
+
+import { parseJsonAnswer } from './llm-ask.js';
+
+export const DEFAULT_SWARM_CONCURRENCY = 3;
+export const MAX_SWARM_CONCURRENCY = 10;
+
+/**
+ * Sanitizes and normalizes swarm configuration.
+ *
+ * @param {Object} [swarmConfig]
+ * @returns {Object}
+ */
+export function sanitizeSwarmConfig(swarmConfig) {
+  if (!swarmConfig || typeof swarmConfig !== 'object') {
+    return {
+      concurrencyLimit: DEFAULT_SWARM_CONCURRENCY,
+      subtasks: [],
+      orchestrator: null,
+      synthesizer: null,
+    };
+  }
+
+  const concurrencyRaw = Number(swarmConfig.concurrencyLimit || swarmConfig.concurrency || DEFAULT_SWARM_CONCURRENCY);
+  const concurrencyLimit = Math.min(Math.max(1, Number.isNaN(concurrencyRaw) ? DEFAULT_SWARM_CONCURRENCY : concurrencyRaw), MAX_SWARM_CONCURRENCY);
+
+  let subtasks = [];
+  if (Array.isArray(swarmConfig.subtasks)) {
+    subtasks = swarmConfig.subtasks.map((st, idx) => ({
+      id: String(st.id || `subtask_${idx + 1}`).trim(),
+      title: String(st.title || st.id || `Worker ${idx + 1}`).trim(),
+      prompt: String(st.prompt || '').trim(),
+      model: st.model ? String(st.model).trim() : undefined,
+      type: st.type ? String(st.type).trim() : 'llm',
+      cwd: st.cwd ? String(st.cwd).trim() : undefined,
+      env: st.env && typeof st.env === 'object' ? st.env : undefined,
+    })).filter((st) => Boolean(st.prompt));
+  }
+
+  let orchestrator = null;
+  if (swarmConfig.orchestrator && typeof swarmConfig.orchestrator === 'object') {
+    orchestrator = {
+      prompt: swarmConfig.orchestrator.prompt ? String(swarmConfig.orchestrator.prompt).trim() : '',
+      model: swarmConfig.orchestrator.model ? String(swarmConfig.orchestrator.model).trim() : undefined,
+    };
+  }
+
+  let synthesizer = null;
+  if (swarmConfig.synthesizer && typeof swarmConfig.synthesizer === 'object') {
+    synthesizer = {
+      prompt: swarmConfig.synthesizer.prompt ? String(swarmConfig.synthesizer.prompt).trim() : '',
+      model: swarmConfig.synthesizer.model ? String(swarmConfig.synthesizer.model).trim() : undefined,
+      mode: ['summary', 'concat', 'json'].includes(swarmConfig.synthesizer.mode) ? swarmConfig.synthesizer.mode : 'summary',
+    };
+  }
+
+  return {
+    concurrencyLimit,
+    subtasks,
+    orchestrator,
+    synthesizer,
+  };
+}
+
+/**
+ * Builds the orchestrator system prompt for dynamic task decomposition.
+ */
+const ORCHESTRATOR_SYSTEM_PROMPT = [
+  'You are a Swarm Task Orchestrator.',
+  'Your role is to decompose the user task into 2 to 8 independent parallel subtasks.',
+  'Respond strictly with a JSON object in this format:',
+  '{"subtasks": [{"id": "unique_id", "title": "short title", "prompt": "precise instructions for worker"}]}',
+  'Do not include markdown code fences outside JSON. Return only valid JSON.',
+].join(' ');
+
+/**
+ * Executes a list of subtasks using a concurrency-limited pool.
+ *
+ * @param {Array<Object>} subtasks
+ * @param {Function} workerExecutor async (subtask) => { output, error, exitCode }
+ * @param {Object} [options]
+ * @param {number} [options.concurrencyLimit=3]
+ * @param {AbortSignal} [options.signal]
+ * @returns {Promise<Array<Object>>} subtaskRuns
+ */
+export async function executeWorkerPool(subtasks, workerExecutor, { concurrencyLimit = DEFAULT_SWARM_CONCURRENCY, signal } = {}) {
+  if (!Array.isArray(subtasks) || subtasks.length === 0) {
+    return [];
+  }
+
+  const results = new Array(subtasks.length);
+  let currentIndex = 0;
+
+  async function worker() {
+    while (currentIndex < subtasks.length) {
+      if (signal?.aborted) {
+        throw new Error('Swarm execution aborted');
+      }
+
+      const idx = currentIndex++;
+      const st = subtasks[idx];
+      const start = Date.now();
+
+      try {
+        const res = await workerExecutor(st);
+        const durationMs = Date.now() - start;
+        results[idx] = {
+          id: st.id,
+          title: st.title || st.id,
+          status: (res && res.error) ? 'error' : 'success',
+          output: String((res && (res.output || res.result || res.stdout)) || ''),
+          error: res && res.error ? String(res.error) : null,
+          durationMs,
+        };
+      } catch (err) {
+        const durationMs = Date.now() - start;
+        results[idx] = {
+          id: st.id,
+          title: st.title || st.id,
+          status: 'error',
+          output: '',
+          error: err?.message || String(err),
+          durationMs,
+        };
+      }
+    }
+  }
+
+  const limit = Math.max(1, Math.min(concurrencyLimit, subtasks.length));
+  const workers = Array.from({ length: limit }, () => worker());
+  await Promise.all(workers);
+
+  return results;
+}
+
+/**
+ * Synthesizes the results of all subtask runs into a final unified report.
+ *
+ * @param {Object} params
+ * @param {Object} params.task
+ * @param {Array<Object>} params.subtaskRuns
+ * @param {Function} [params.askModel]
+ * @returns {Promise<string>}
+ */
+export async function synthesizeSwarmResults({ task, subtaskRuns, askModel }) {
+  const synthesizer = task.swarm?.synthesizer;
+
+  // If a model and prompt are configured, ask LLM to synthesize
+  if (synthesizer?.prompt && typeof askModel === 'function') {
+    try {
+      const summaryContext = subtaskRuns.map((r, i) => [
+        `### Worker ${i + 1}: ${r.title} [Status: ${r.status}]`,
+        r.error ? `Error: ${r.error}` : '',
+        r.output ? `Output:\n${r.output}` : '(no output)',
+      ].filter(Boolean).join('\n')).join('\n\n---\n\n');
+
+      const prompt = [
+        synthesizer.prompt,
+        '',
+        '## Worker Subtask Outputs:',
+        summaryContext,
+      ].join('\n');
+
+      const res = await askModel({
+        task,
+        prompt,
+        system: 'You synthesize multi-agent swarm execution results into a comprehensive, cohesive summary report.',
+        preferredModel: synthesizer.model || task.model,
+        maxTokens: 2000,
+      });
+
+      if (res && res.ok && res.text) {
+        return res.text.trim();
+      }
+    } catch {
+      // Fallback to structured joining on failure
+    }
+  }
+
+  // Default clean markdown synthesis
+  const header = `## 🐝 Swarm Execution Report: ${task.title || task.id}\n`;
+  const successfulCount = subtaskRuns.filter((r) => r.status === 'success').length;
+  const statsLine = `**Summary**: ${successfulCount} / ${subtaskRuns.length} subtasks completed successfully.\n\n`;
+
+  const body = subtaskRuns.map((r) => {
+    const icon = r.status === 'success' ? '✅' : '❌';
+    const lines = [
+      `### ${icon} ${r.title} (${r.durationMs}ms)`,
+      r.error ? `> ⚠️ **Error**: ${r.error}` : '',
+      r.output ? r.output.trim() : '*(No output produced)*',
+    ].filter(Boolean);
+    return lines.join('\n\n');
+  }).join('\n\n---\n\n');
+
+  return header + statsLine + body;
+}
+
+/**
+ * Main entry point for executing a swarm task.
+ *
+ * @param {Object} task
+ * @param {Object} options
+ * @param {Function} options.executeFn Worker execution handler: async (subtask) => result
+ * @param {Function} [options.askModel] Model querying function for dynamic decomposition/synthesis
+ * @param {AbortSignal} [options.signal]
+ * @param {Object} [options.logger]
+ * @returns {Promise<Object>} Execution result { ok, status, output, subtaskRuns, stats }
+ */
+export async function executeSwarmTask(task, { executeFn, askModel, signal, logger } = {}) {
+  const swarmConfig = sanitizeSwarmConfig(task.swarm);
+  let subtasks = [...swarmConfig.subtasks];
+
+  // 1. Dynamic decomposition via orchestrator prompt if subtasks not explicitly listed
+  if (subtasks.length === 0 && swarmConfig.orchestrator?.prompt && typeof askModel === 'function') {
+    try {
+      const decompRes = await askModel({
+        task,
+        prompt: swarmConfig.orchestrator.prompt,
+        system: ORCHESTRATOR_SYSTEM_PROMPT,
+        preferredModel: swarmConfig.orchestrator.model || task.model,
+        maxTokens: 1000,
+      });
+
+      if (decompRes && decompRes.ok && decompRes.text) {
+        const parsed = parseJsonAnswer(decompRes.text);
+        if (parsed && Array.isArray(parsed.subtasks)) {
+          subtasks = parsed.subtasks.map((st, i) => ({
+            id: String(st.id || `subtask_${i + 1}`).trim(),
+            title: String(st.title || st.id || `Worker ${i + 1}`).trim(),
+            prompt: String(st.prompt || '').trim(),
+            type: st.type || 'llm',
+            model: st.model || task.model,
+          })).filter((st) => Boolean(st.prompt));
+        }
+      }
+    } catch (err) {
+      if (logger) logger.warn(`[dsh-cron] Swarm dynamic decomposition failed: ${err.message}`);
+    }
+  }
+
+  // Fallback: if still no subtasks, construct single task from prompt
+  if (subtasks.length === 0) {
+    subtasks = [{
+      id: 'worker_1',
+      title: task.title || 'Swarm Primary Worker',
+      prompt: task.prompt || '',
+      type: 'llm',
+      model: task.model,
+    }];
+  }
+
+  const startAll = Date.now();
+
+  // 2. Execute workers concurrently
+  const defaultWorkerExecutor = async (st) => {
+    if (typeof executeFn === 'function') {
+      return executeFn({
+        ...task,
+        id: `${task.id}__${st.id}`,
+        title: `${task.title || task.id} -> ${st.title}`,
+        prompt: st.prompt,
+        type: st.type || task.type,
+        model: st.model || task.model,
+      });
+    }
+    return { output: `Worker ${st.title} completed`, status: 'success' };
+  };
+
+  const subtaskRuns = await executeWorkerPool(subtasks, defaultWorkerExecutor, {
+    concurrencyLimit: swarmConfig.concurrencyLimit,
+    signal,
+  });
+
+  const totalDurationMs = Date.now() - startAll;
+  const completedCount = subtaskRuns.filter((r) => r.status === 'success').length;
+  const failedCount = subtaskRuns.filter((r) => r.status === 'error').length;
+
+  // 3. Synthesize final report
+  const output = await synthesizeSwarmResults({ task, subtaskRuns, askModel });
+
+  const status = failedCount === 0 ? 'success' : (completedCount > 0 ? 'warning' : 'error');
+
+  return {
+    ok: status !== 'error',
+    status,
+    output,
+    subtaskRuns,
+    stats: {
+      total: subtasks.length,
+      completed: completedCount,
+      failed: failedCount,
+      totalDurationMs,
+    },
+  };
+}

package/lib/task-create.js

@@ -1,3 +1,4 @@
+import { sanitizeSwarmConfig } from './swarm.js';
 import { sanitizeBranchRules } from './branching.js';
 import { sanitizePromptHistory } from './prompt-evolver.js';
 import { sanitizeAdaptiveConfig } from './adaptive.js';
@@ -57,6 +58,7 @@ export function executeCreateTask(store, scheduler, args) {
     onSuccess: args.onSuccess ? String(args.onSuccess).trim() : '',
     onFailure: args.onFailure ? String(args.onFailure).trim() : '',
     branchRules: args.branchRules !== undefined ? sanitizeBranchRules(args.branchRules) : undefined,
+    swarm: args.swarm !== undefined ? sanitizeSwarmConfig(args.swarm) : undefined,
     elseTask: args.elseTask ? String(args.elseTask).trim() : undefined,
     autoHeal: args.autoHeal !== undefined ? Boolean(args.autoHeal) : undefined,
     selfHealing: args.selfHealing && typeof args.selfHealing === 'object' ? {

package/lib/task-patch.js

@@ -1,3 +1,4 @@
+import { sanitizeSwarmConfig } from './swarm.js';
 import { sanitizeBranchRules } from './branching.js';
 import { trackPromptEdit, sanitizePromptHistory } from './prompt-evolver.js';
 import { sanitizeAdaptiveConfig } from './adaptive.js';

package/lib/task-transfer.js

@@ -96,6 +96,8 @@ export const PATCHABLE_TASK_FIELDS = [
   'revisions',
   'previousPrompt',
   'previousScript',
+  'swarm',
+  'gitDiff',
 ];
 
 /** 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.13",
+  "version": "0.3.14",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",