@goodandready/dsh-cron 0.3.13 → 0.3.15

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.
@@ -193,7 +205,7 @@ Every task picks its own runtime; non-LLM runtimes need no model and consume no
 * **SSH** (`ssh`) — execute a command on a remote host through a `dsh-remote-workspace` profile (`sshProfileId`) or standalone host/key fields.
 * **Docker** (`docker`) — run the command in a container image (`dockerImage`).
 * **Environment variables** — a per-task `env` map (KEY VALUE per line in the UI) applied to external runtimes; secrets do not belong here.
-* **Workspaces and worktrees** — bind a task to a harness workspace (`workspaceId`) and, for code-modifying agent tasks, run it in an isolated git worktree (`worktree`, `keepWorktree`).
+* **Workspaces and worktrees** — bind a task to a harness workspace (`workspaceId`, resolved through host `workspaceRegistry`) or path, and run code-modifying agent tasks in an isolated git worktree (`worktree`, `keepWorktree`).
 
 ### 7. Cost Control: Fallback Model & Burn Guard
 * **Fallback Model** — A task can run on the cheap model by default and still finish on the strong one: set `fallbackModel` (and optionally `fallbackProvider`) and a failed run — `error` or `timeout` — is retried **once** on that model before the ordinary retry backoff applies. History records which model produced the result and whether the fallback was used, usage and cost of both attempts are summed, and the `{model}` template variable renders the model that finished the run. Only agent-mediated tasks (`llm`, `skill`, `workflow`) can use a fallback.

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` запускается, если ни одно из правил не совпало.
@@ -193,7 +205,7 @@ cron({
 * **SSH** (`ssh`) — выполнение команды на удалённом хосте через профиль `dsh-remote-workspace` (`sshProfileId`) или отдельные поля host/key.
 * **Docker** (`docker`) — выполнение команды в контейнере образа (`dockerImage`).
 * **Переменные окружения** — карта `env` на задачу (в UI — строки KEY VALUE) для внешних рантаймов; секретам здесь не место.
-* **Workspace и worktree** — привязка задачи к workspace харнесса (`workspaceId`) и, для изменяющих код агентских задач, запуск в изолированном git worktree (`worktree`, `keepWorktree`).
+* **Workspace и worktree** — привязка задачи к workspace харнесса (`workspaceId`, разрешаемому через службу `workspaceRegistry`) или пути, и запуск в изолированном git worktree (`worktree`, `keepWorktree`).
 
 ### 7. Экономия: fallback-модель и защита бюджета (Burn Guard)
 * **Fallback-модель** — задача может идти на дешёвой модели по умолчанию и всё же завершиться на сильной: задайте `fallbackModel` (и при необходимости `fallbackProvider`), и сбойный запуск (`error` или `timeout`) один раз повторится на этой модели, прежде чем включится обычный retry с задержкой. В истории видно, какая модель произвела результат и был ли использован fallback; расход и стоимость обеих попыток суммируются; переменная шаблона `{model}` подставляет модель, завершившую запуск. Fallback доступен только агентским типам (`llm`, `skill`, `workflow`).

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`。
@@ -193,7 +205,7 @@ cron({
 * **SSH**（`ssh`）—— 通过 `dsh-remote-workspace` 配置（`sshProfileId`）或独立 host/key 字段在远程主机执行命令。
 * **Docker**（`docker`）—— 在镜像容器（`dockerImage`）中执行命令。
 * **环境变量** —— 按任务的 `env` 映射（界面中每行 KEY VALUE）应用于外部运行时；请勿在此存放密钥。
-* **工作区与 worktree** —— 将任务绑定到 Harness 工作区（`workspaceId`）；对会修改代码的智能体任务，可在隔离的 git worktree 中运行（`worktree`、`keepWorktree`）。
+* **工作区与 worktree** —— 将任务绑定到 Harness 工作区（`workspaceId`，通过宿主 `workspaceRegistry` 服务解析）或直接路径；对会修改代码的智能体任务，可在隔离的 git worktree 中运行（`worktree`、`keepWorktree`）。
 
 ### 7. 成本控制：回退模型与支出保护（Burn Guard）
 * **回退模型** —— 任务可以默认使用便宜模型，失败时改用更强模型完成：设置 `fallbackModel`（可选 `fallbackProvider`），失败（`error` 或 `timeout`）的运行会在该模型上重试一次，之后才进入常规重试退避。历史记录会标明最终产出结果的模型以及是否使用了回退，两次尝试的用量与成本都会累计，模板变量 `{model}` 渲染完成运行的模型。回退仅适用于智能体类型（`llm`、`skill`、`workflow`）。

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/index.js

@@ -95,7 +95,7 @@ export {
 };
 
 export const name = '@goodandready/dsh-cron';
-export const inject = ['tools', 'webServer', 'llm', 'agents', 'agentDefaultModel', 'credentials'];
+export const inject = ['tools', 'webServer', 'llm', 'agents', 'agentDefaultModel', 'credentials', 'workspaceRegistry'];
 
 import { executeCreateTask } from './task-create.js';
 import {

package/lib/runner-worktree.js

@@ -1,6 +1,8 @@
 import { logger } from './logger.js';
 import { bestEffort } from './best-effort.js';
 
+import fs from 'node:fs';
+
 /**
  * Resolve the working directory for a task: explicit cwd, a bound
  * workspace id resolved through the harness, or the process cwd (#31).
@@ -8,17 +10,45 @@ import { bestEffort } from './best-effort.js';
 export function resolveCwd(task, ctx = null) {
   if (task.cwd) return String(task.cwd);
   if (task.workspaceId) {
-    if (ctx && typeof ctx.get === 'function') {
+    const rawId = String(task.workspaceId).trim();
+    if (ctx) {
       const resolved = bestEffort('resolve-workspace-path', () => {
-        const workspaces = ctx.get('workspaces');
-        if (workspaces && typeof workspaces.get === 'function') {
-          const ws = workspaces.get(task.workspaceId);
-          return ws && ws.path ? String(ws.path) : null;
+        // Issue #363 / GH #12: host workspace service is 'workspaceRegistry' in DeepSeek Harness
+        const registry =
+          (typeof ctx.get === 'function' ? ctx.get('workspaceRegistry') : null) ||
+          ctx.workspaceRegistry ||
+          (typeof ctx.get === 'function' ? ctx.get('workspaces') : null) ||
+          ctx.workspaces;
+
+        if (registry) {
+          // 1. Direct get(id) lookup on WorkspaceRegistry
+          if (typeof registry.get === 'function') {
+            const ws = registry.get(rawId);
+            if (ws && ws.path) return String(ws.path);
+          }
+          // 2. List lookup if ID, title, or Path was provided ("Workspace id or path")
+          if (typeof registry.list === 'function') {
+            const list = registry.list();
+            if (Array.isArray(list)) {
+              const matched = list.find((w) => w && (w.id === rawId || w.path === rawId || w.title === rawId));
+              if (matched && matched.path) return String(matched.path);
+            }
+          }
         }
         return null;
       });
       if (resolved) return resolved;
     }
+
+    // 3. Fallback: if task.workspaceId directly points to an existing directory path on disk
+    try {
+      if (fs.existsSync(rawId) && fs.statSync(rawId).isDirectory()) {
+        return rawId;
+      }
+    } catch (_fsErr) {
+      // ignore filesystem stat error
+    }
+
     // Issue #231: fail-closed if workspaceId was specified but cannot be resolved
     throw new Error(`Workspace "${task.workspaceId}" requested by task could not be resolved`);
   }

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.15",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",