@goodandready/dsh-cron 0.3.12 → 0.3.14

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,7 @@
+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';
 import { evaluateAdaptiveRun, calculateNextAdaptiveState } from './adaptive.js';
 import { approvalManager } from './approval.js';
@@ -137,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 {
@@ -441,14 +464,42 @@ export async function applySilentRuleToRun(task, runInfo, { askModel, readSettin
 /**
  * Run the model-assisted steps for a finished run.
  */
-export async function applyModelAssists(task, runInfo, options) {
+export async function applyModelAssists(task, runInfo, options = {}) {
   const inspection = await inspectFailureRun(task, runInfo, options);
   if (inspection.inspected) {
     runInfo.diagnosis = inspection.diagnosis;
     runInfo.suggestion = inspection.suggestion;
     runInfo.confidence = inspection.confidence;
+    runInfo.doctorReport = inspection.doctorReport || {
+      category: inspection.category || 'runtime_error',
+      cause: inspection.diagnosis,
+      suggestedFix: inspection.suggestion,
+      confidence: inspection.confidence,
+      diff: inspection.diff || '',
+      timestamp: Date.now(),
+      applied: false,
+      autoHealed: false,
+    };
     logger.info(`[dsh-cron] task "${task.title}" failure diagnosed (${inspection.confidence}): ${inspection.diagnosis}`);
-  } else if (inspection.error && task.inspectOnFailure) {
+
+    // Safe Auto-Heal Check (#353)
+    if (shouldAutoHeal(task, runInfo.doctorReport)) {
+      try {
+        const healResult = await applyDoctorFix(task, runInfo.doctorReport, {
+          store: options.store,
+          user: 'scheduler:auto-heal',
+          isAutoHeal: true,
+        });
+        if (healResult.ok) {
+          logger.info(`[dsh-cron] task "${task.title}" auto-healed successfully with doctor fix!`);
+          runInfo.autoHealed = true;
+          if (runInfo.doctorReport) runInfo.doctorReport.autoHealed = true;
+        }
+      } catch (autoHealErr) {
+        logger.warn(`[dsh-cron] failed to auto-heal task "${task.title}":`, autoHealErr.message);
+      }
+    }
+  } else if (inspection.error && (task.inspectOnFailure || task.autoDiagnose || task.autoHeal)) {
     logger.warn(`[dsh-cron] failure inspection for "${task.title}" not applied: ${inspection.error}`);
   }
 
@@ -742,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 = {
@@ -769,8 +838,14 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     runInfo.artifacts = scheduler.store.getArtifactsForRun(runInfo.runId);
   }
 
-  // Chain Checkpoints (#319, #328)
-  const chainedTargets = parseChainTargets(outcome.status === 'success' ? task.onSuccess : task.onFailure);
+  // Chain Checkpoints & Decision Nodes (#319, #328, #352)
+  const branchResult = resolveBranchTargets(task, outcome, runInfo);
+  if (branchResult && branchResult.decision) {
+    runInfo.branchDecision = branchResult.decision;
+  }
+  const chainedTargets = branchResult
+    ? branchResult.targets
+    : parseChainTargets(outcome.status === 'success' ? task.onSuccess : task.onFailure);
   let hasDependents = false;
   if (scheduler.store?.tasks) {
     for (const t of Object.values(scheduler.store.tasks)) {
@@ -888,10 +963,27 @@ export async function handleCompleteRun(scheduler, task, taskId, currentRun, out
     }
   }
 
-  // 2. Task Chaining (#137, #328 Fan-Out / Fan-In)
-  const targets = parseChainTargets(isSuccess ? task.onSuccess : (isFailure ? task.onFailure : null));
+  // 2. Task Chaining & Decision Nodes (#137, #328, #352 Fan-Out / Fan-In)
+  const targets = branchResult
+    ? branchResult.targets
+    : parseChainTargets(isSuccess ? task.onSuccess : (isFailure ? task.onFailure : null));
   const currentDepth = options.chainDepth || 0;
 
+  if (branchResult && branchResult.decision) {
+    logger.info(`[dsh-cron] decision node in "${task.title}": routed to ${targets.join(', ') || 'none'} (${branchResult.decision.isElse ? 'fallback else' : (branchResult.decision.matched ? `rule #${branchResult.decision.matchedIndex + 1}` : 'unmatched')})`);
+    if (chainRunId && scheduler.store.chainCheckpointManager && Array.isArray(task.branchRules)) {
+      for (const rule of task.branchRules) {
+        if (rule && rule.targetTask && !targets.includes(rule.targetTask)) {
+          scheduler.store.chainCheckpointManager.recordStepSnapshot(chainRunId, rule.targetTask, {
+            status: 'skipped',
+            skippedReason: 'condition not met',
+            durationMs: 0,
+          });
+        }
+      }
+    }
+  }
+
   if (currentDepth < 4) {
     // 2.1 Trigger explicit targets (Fan-Out)
     for (const targetId of targets) {

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,
+    },
+  };
+}