codeharness 0.35.7 → 0.36.2

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   validateDockerfile,
   warn,
   writeState
-} from "./chunk-WNIM6AUG.js";
+} from "./chunk-374J3J3A.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -2506,10 +2506,10 @@ function resolveWorkflow(options) {
   return validateAndResolve(merged);
 }
 
-// src/lib/workflow-engine.ts
+// src/lib/workflow-machine.ts
+import { setup, assign, fromPromise, createActor } from "xstate";
 import { readFileSync as readFileSync13, existsSync as existsSync15, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "fs";
 import { join as join12 } from "path";
-import { parse as parse5 } from "yaml";
 
 // src/lib/agent-dispatch.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
@@ -2568,109 +2568,9 @@ function resolveModel(task, agent, driver) {
   return driver.defaultModel;
 }
 
-// src/lib/workflow-state.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync2, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
-import { join as join8 } from "path";
-import { parse as parse4, stringify } from "yaml";
-var STATE_DIR = ".codeharness";
-var STATE_FILE = "workflow-state.yaml";
-function getDefaultWorkflowState() {
-  return {
-    workflow_name: "",
-    started: "",
-    iteration: 0,
-    phase: "idle",
-    tasks_completed: [],
-    evaluator_scores: [],
-    circuit_breaker: {
-      triggered: false,
-      reason: null,
-      score_history: []
-    },
-    trace_ids: []
-  };
-}
-function writeWorkflowState(state, dir) {
-  const baseDir = dir ?? process.cwd();
-  const stateDir = join8(baseDir, STATE_DIR);
-  mkdirSync2(stateDir, { recursive: true });
-  const yamlContent = stringify(state, { nullStr: "null" });
-  writeFileSync6(join8(stateDir, STATE_FILE), yamlContent, "utf-8");
-}
-function readWorkflowState(dir) {
-  const baseDir = dir ?? process.cwd();
-  const filePath = join8(baseDir, STATE_DIR, STATE_FILE);
-  if (!existsSync11(filePath)) {
-    return getDefaultWorkflowState();
-  }
-  let raw;
-  try {
-    raw = readFileSync10(filePath, "utf-8");
-  } catch {
-    warn("workflow-state.yaml could not be read \u2014 returning default state");
-    return getDefaultWorkflowState();
-  }
-  let parsed;
-  try {
-    parsed = parse4(raw);
-  } catch {
-    warn("workflow-state.yaml contains invalid YAML \u2014 returning default state");
-    return getDefaultWorkflowState();
-  }
-  if (!isValidWorkflowState(parsed)) {
-    warn("workflow-state.yaml has invalid shape \u2014 returning default state");
-    return getDefaultWorkflowState();
-  }
-  return parsed;
-}
-function isValidWorkflowState(value) {
-  if (!value || typeof value !== "object") return false;
-  const s = value;
-  if (typeof s.workflow_name !== "string") return false;
-  if (typeof s.started !== "string") return false;
-  if (typeof s.iteration !== "number") return false;
-  if (typeof s.phase !== "string") return false;
-  if (!Array.isArray(s.tasks_completed)) return false;
-  if (!Array.isArray(s.evaluator_scores)) return false;
-  if (!s.circuit_breaker || typeof s.circuit_breaker !== "object") return false;
-  if (s.trace_ids !== void 0) {
-    if (!Array.isArray(s.trace_ids)) return false;
-    for (const id of s.trace_ids) {
-      if (typeof id !== "string") return false;
-    }
-  }
-  for (const t of s.tasks_completed) {
-    if (!t || typeof t !== "object") return false;
-    const tc = t;
-    if (typeof tc.task_name !== "string") return false;
-    if (typeof tc.story_key !== "string") return false;
-    if (typeof tc.completed_at !== "string") return false;
-    if (tc.session_id !== void 0 && typeof tc.session_id !== "string") return false;
-    if (tc.error !== void 0 && typeof tc.error !== "boolean") return false;
-  }
-  for (const e of s.evaluator_scores) {
-    if (!e || typeof e !== "object") return false;
-    const es = e;
-    if (typeof es.iteration !== "number") return false;
-    if (typeof es.passed !== "number") return false;
-    if (typeof es.failed !== "number") return false;
-    if (typeof es.unknown !== "number") return false;
-    if (typeof es.total !== "number") return false;
-    if (typeof es.timestamp !== "string") return false;
-  }
-  const cb = s.circuit_breaker;
-  if (typeof cb.triggered !== "boolean") return false;
-  if (cb.reason !== null && typeof cb.reason !== "string") return false;
-  if (!Array.isArray(cb.score_history)) return false;
-  for (const score of cb.score_history) {
-    if (typeof score !== "number") return false;
-  }
-  return true;
-}
-
 // src/lib/agents/output-contract.ts
-import { writeFileSync as writeFileSync7, readFileSync as readFileSync11, renameSync as renameSync2, mkdirSync as mkdirSync3, existsSync as existsSync12 } from "fs";
-import { join as join9, resolve as resolve4 } from "path";
+import { writeFileSync as writeFileSync6, readFileSync as readFileSync10, renameSync as renameSync2, mkdirSync as mkdirSync2, existsSync as existsSync11 } from "fs";
+import { join as join8, resolve as resolve4 } from "path";
 function assertSafeComponent(value, label) {
   if (!value || value.trim().length === 0) {
     throw new Error(`${label} must be a non-empty string`);
@@ -2682,7 +2582,7 @@ function assertSafeComponent(value, label) {
 function contractFilePath(taskName, storyId, contractDir) {
   assertSafeComponent(taskName, "taskName");
   assertSafeComponent(storyId, "storyId");
-  const filePath = join9(contractDir, `${taskName}-${storyId}.json`);
+  const filePath = join8(contractDir, `${taskName}-${storyId}.json`);
   const resolvedDir = resolve4(contractDir);
   const resolvedFile = resolve4(filePath);
   if (!resolvedFile.startsWith(resolvedDir)) {
@@ -2694,8 +2594,8 @@ function writeOutputContract(contract, contractDir) {
   const finalPath = contractFilePath(contract.taskName, contract.storyId, contractDir);
   const tmpPath2 = finalPath + ".tmp";
   try {
-    mkdirSync3(contractDir, { recursive: true });
-    writeFileSync7(tmpPath2, JSON.stringify(contract, null, 2) + "\n", "utf-8");
+    mkdirSync2(contractDir, { recursive: true });
+    writeFileSync6(tmpPath2, JSON.stringify(contract, null, 2) + "\n", "utf-8");
     renameSync2(tmpPath2, finalPath);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -2773,8 +2673,8 @@ ${context}`;
 }
 
 // src/lib/source-isolation.ts
-import { mkdirSync as mkdirSync4, copyFileSync, existsSync as existsSync13, rmSync } from "fs";
-import { join as join10, basename } from "path";
+import { mkdirSync as mkdirSync3, copyFileSync, existsSync as existsSync12, rmSync } from "fs";
+import { join as join9, basename } from "path";
 function sanitizeRunId(runId) {
   let sanitized = runId.replace(/[^a-zA-Z0-9._-]/g, "_");
   sanitized = sanitized.replace(/^\.+/, "");
@@ -2784,7 +2684,7 @@ function sanitizeRunId(runId) {
   return sanitized;
 }
 function deduplicateFilename(dir, name) {
-  if (!existsSync13(join10(dir, name))) {
+  if (!existsSync12(join9(dir, name))) {
     return name;
   }
   const dotIdx = name.lastIndexOf(".");
@@ -2795,26 +2695,26 @@ function deduplicateFilename(dir, name) {
   do {
     candidate = `${stem}-${counter}${ext}`;
     counter++;
-  } while (existsSync13(join10(dir, candidate)));
+  } while (existsSync12(join9(dir, candidate)));
   return candidate;
 }
 async function createIsolatedWorkspace(options) {
   const safeRunId = sanitizeRunId(options.runId);
   const dir = `/tmp/codeharness-verify-${safeRunId}`;
-  const storyFilesDir = join10(dir, "story-files");
-  const verdictDir = join10(dir, "verdict");
-  if (existsSync13(dir)) {
+  const storyFilesDir = join9(dir, "story-files");
+  const verdictDir = join9(dir, "verdict");
+  if (existsSync12(dir)) {
     rmSync(dir, { recursive: true, force: true });
   }
-  mkdirSync4(storyFilesDir, { recursive: true });
-  mkdirSync4(verdictDir, { recursive: true });
+  mkdirSync3(storyFilesDir, { recursive: true });
+  mkdirSync3(verdictDir, { recursive: true });
   for (const filePath of options.storyFiles) {
-    if (!existsSync13(filePath)) {
+    if (!existsSync12(filePath)) {
       warn(`Source isolation: story file not found, skipping: ${filePath}`);
       continue;
     }
     const name = deduplicateFilename(storyFilesDir, basename(filePath));
-    const dest = join10(storyFilesDir, name);
+    const dest = join9(storyFilesDir, name);
     copyFileSync(filePath, dest);
   }
   const workspace = {
@@ -2825,7 +2725,7 @@ async function createIsolatedWorkspace(options) {
       return { cwd: dir };
     },
     async cleanup() {
-      if (existsSync13(dir)) {
+      if (existsSync12(dir)) {
         rmSync(dir, { recursive: true, force: true });
       }
     }
@@ -3106,8 +3006,8 @@ function evaluateProgress(scores) {
 }
 
 // src/lib/telemetry-writer.ts
-import { appendFileSync, existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync12 } from "fs";
-import { join as join11 } from "path";
+import { appendFileSync, existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync11 } from "fs";
+import { join as join10 } from "path";
 var TELEMETRY_DIR = ".codeharness";
 var TELEMETRY_FILE = "telemetry.jsonl";
 function extractEpicId(storyKey) {
@@ -3140,9 +3040,9 @@ async function writeTelemetryEntry(ctx) {
     } : null,
     errors: []
   };
-  const dir = join11(ctx.projectDir, TELEMETRY_DIR);
-  mkdirSync5(dir, { recursive: true });
-  appendFileSync(join11(dir, TELEMETRY_FILE), JSON.stringify(entry) + "\n");
+  const dir = join10(ctx.projectDir, TELEMETRY_DIR);
+  mkdirSync4(dir, { recursive: true });
+  appendFileSync(join10(dir, TELEMETRY_FILE), JSON.stringify(entry) + "\n");
   return { success: true, output: `telemetry: entry written for ${ctx.storyKey}` };
 }
 
@@ -3159,15 +3059,138 @@ function listNullTasks() {
 }
 registerNullTask("telemetry", writeTelemetryEntry);
 
+// src/lib/workflow-machine.ts
+import { parse as parse5 } from "yaml";
+
 // src/lib/evaluator.ts
 function formatCoverageContextMessage(coverage, target) {
   return `Coverage already verified by engine: ${coverage}% (target: ${target}%). No re-run needed.`;
 }
 
-// src/lib/workflow-engine.ts
-var PER_RUN_SENTINEL = "__run__";
+// src/lib/workflow-state.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
+import { join as join11 } from "path";
+import { parse as parse4, stringify } from "yaml";
+var STATE_DIR = ".codeharness";
+var STATE_FILE = "workflow-state.yaml";
+function getDefaultWorkflowState() {
+  return {
+    workflow_name: "",
+    started: "",
+    iteration: 0,
+    phase: "idle",
+    tasks_completed: [],
+    evaluator_scores: [],
+    circuit_breaker: {
+      triggered: false,
+      reason: null,
+      score_history: []
+    },
+    trace_ids: []
+  };
+}
+function writeWorkflowState(state, dir) {
+  const baseDir = dir ?? process.cwd();
+  const stateDir = join11(baseDir, STATE_DIR);
+  mkdirSync5(stateDir, { recursive: true });
+  const yamlContent = stringify(state, { nullStr: "null" });
+  writeFileSync7(join11(stateDir, STATE_FILE), yamlContent, "utf-8");
+}
+function readWorkflowState(dir) {
+  const baseDir = dir ?? process.cwd();
+  const filePath = join11(baseDir, STATE_DIR, STATE_FILE);
+  if (!existsSync14(filePath)) {
+    return getDefaultWorkflowState();
+  }
+  let raw;
+  try {
+    raw = readFileSync12(filePath, "utf-8");
+  } catch {
+    warn("workflow-state.yaml could not be read \u2014 returning default state");
+    return getDefaultWorkflowState();
+  }
+  let parsed;
+  try {
+    parsed = parse4(raw);
+  } catch {
+    warn("workflow-state.yaml contains invalid YAML \u2014 returning default state");
+    return getDefaultWorkflowState();
+  }
+  if (!isValidWorkflowState(parsed)) {
+    warn("workflow-state.yaml has invalid shape \u2014 returning default state");
+    return getDefaultWorkflowState();
+  }
+  return parsed;
+}
+function isValidWorkflowState(value) {
+  if (!value || typeof value !== "object") return false;
+  const s = value;
+  if (typeof s.workflow_name !== "string") return false;
+  if (typeof s.started !== "string") return false;
+  if (typeof s.iteration !== "number") return false;
+  if (typeof s.phase !== "string") return false;
+  if (!Array.isArray(s.tasks_completed)) return false;
+  if (!Array.isArray(s.evaluator_scores)) return false;
+  if (!s.circuit_breaker || typeof s.circuit_breaker !== "object") return false;
+  if (s.trace_ids !== void 0) {
+    if (!Array.isArray(s.trace_ids)) return false;
+    for (const id of s.trace_ids) {
+      if (typeof id !== "string") return false;
+    }
+  }
+  for (const t of s.tasks_completed) {
+    if (!t || typeof t !== "object") return false;
+    const tc = t;
+    if (typeof tc.task_name !== "string") return false;
+    if (typeof tc.story_key !== "string") return false;
+    if (typeof tc.completed_at !== "string") return false;
+    if (tc.session_id !== void 0 && typeof tc.session_id !== "string") return false;
+    if (tc.error !== void 0 && typeof tc.error !== "boolean") return false;
+  }
+  for (const e of s.evaluator_scores) {
+    if (!e || typeof e !== "object") return false;
+    const es = e;
+    if (typeof es.iteration !== "number") return false;
+    if (typeof es.passed !== "number") return false;
+    if (typeof es.failed !== "number") return false;
+    if (typeof es.unknown !== "number") return false;
+    if (typeof es.total !== "number") return false;
+    if (typeof es.timestamp !== "string") return false;
+  }
+  const cb = s.circuit_breaker;
+  if (typeof cb.triggered !== "boolean") return false;
+  if (cb.reason !== null && typeof cb.reason !== "string") return false;
+  if (!Array.isArray(cb.score_history)) return false;
+  for (const score of cb.score_history) {
+    if (typeof score !== "number") return false;
+  }
+  return true;
+}
+
+// src/lib/workflow-machine.ts
 var HALT_ERROR_CODES = /* @__PURE__ */ new Set(["RATE_LIMIT", "NETWORK", "SDK_INIT"]);
 var DEFAULT_MAX_ITERATIONS = 5;
+var HEALTH_CHECK_TIMEOUT_MS = 5e3;
+var FILE_WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "Write",
+  "Edit",
+  "write_to_file",
+  "edit_file",
+  "write",
+  "edit",
+  "WriteFile",
+  "EditFile"
+]);
+var TASK_PROMPTS = {
+  "create-story": (key) => `Create the story spec for ${key}. Read the epic definitions and architecture docs. Write a complete story file with acceptance criteria, tasks, and dev notes. CRITICAL: Every AC must be testable by a blind QA agent using ONLY a user guide + browser/API/CLI access. No AC should reference source code, internal data structures, or implementation details like O(1) complexity. Each AC must describe observable behavior that can be verified through UI interaction (agent-browser), API calls (curl), CLI commands (docker exec), or log inspection (docker logs). Wrap output in <story-spec>...</story-spec> tags.`,
+  "implement": (key) => `Implement story ${key}`,
+  "check": (key) => `Run automated checks for story ${key}. Execute the project's test suite, linter, and coverage tool. Include <verdict>pass</verdict> or <verdict>fail</verdict> in your response.`,
+  "review": (key) => `Review the implementation of story ${key}. Check for correctness, security issues, architecture violations, and AC coverage. Include <verdict>pass</verdict> or <verdict>fail</verdict> in your response. If fail, include <issues>...</issues>.`,
+  "document": (key) => `Write user documentation for story ${key}. Describe what was built and how to use it from a user's perspective. No source code. Wrap documentation in <user-docs>...</user-docs> tags.`,
+  "deploy": () => `Provision the Docker environment for this project. Check for docker-compose.yml, start containers, verify health. Wrap report in <deploy-report>...</deploy-report> tags with status, containers, URLs, credentials, health.`,
+  "verify": () => `Verify the epic's stories using the user docs and deploy info in ./story-files/. For each AC, derive verification steps, run commands, observe output. Include <verdict>pass</verdict> or <verdict>fail</verdict>. Include <evidence ac="N" status="pass|fail|unknown">...</evidence> per AC. Include <quality-scores>...</quality-scores>.`,
+  "retro": () => `Run a retrospective for this epic. Analyze what worked, what failed, patterns, and action items for next epic.`
+};
 function buildCoverageDeduplicationContext(contract, projectDir) {
   if (!contract?.testResults) return null;
   const { coverage } = contract.testResults;
@@ -3187,16 +3210,14 @@ function propagateVerifyFlags(taskName, contract, projectDir) {
   const { failed, coverage } = contract.testResults;
   try {
     const { state, body } = readStateWithBody(projectDir);
-    if (failed === 0) {
-      state.session_flags.tests_passed = true;
-    }
+    if (failed === 0) state.session_flags.tests_passed = true;
     if (coverage !== null && coverage !== void 0 && coverage >= state.coverage.target) {
       state.session_flags.coverage_met = true;
     }
     writeState(state, projectDir, body);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    warn(`workflow-engine: flag propagation failed for ${taskName}: ${msg}`);
+    warn(`workflow-machine: flag propagation failed for ${taskName}: ${msg}`);
   }
 }
 function isTaskCompleted(state, taskName, storyKey) {
@@ -3217,14 +3238,14 @@ function loadWorkItems(sprintStatusPath, issuesPath2) {
     try {
       raw = readFileSync13(sprintStatusPath, "utf-8");
     } catch {
-      warn(`workflow-engine: could not read sprint-status.yaml at ${sprintStatusPath}`);
+      warn(`workflow-machine: could not read sprint-status.yaml at ${sprintStatusPath}`);
       return items;
     }
     let parsed;
     try {
       parsed = parse5(raw);
     } catch {
-      warn(`workflow-engine: invalid YAML in sprint-status.yaml at ${sprintStatusPath}`);
+      warn(`workflow-machine: invalid YAML in sprint-status.yaml at ${sprintStatusPath}`);
       return items;
     }
     if (parsed && typeof parsed === "object") {
@@ -3246,14 +3267,14 @@ function loadWorkItems(sprintStatusPath, issuesPath2) {
     try {
       raw = readFileSync13(issuesPath2, "utf-8");
     } catch {
-      warn(`workflow-engine: could not read issues.yaml at ${issuesPath2}`);
+      warn(`workflow-machine: could not read issues.yaml at ${issuesPath2}`);
       return items;
     }
     let parsed;
     try {
       parsed = parse5(raw);
     } catch {
-      warn(`workflow-engine: invalid YAML in issues.yaml at ${issuesPath2}`);
+      warn(`workflow-machine: invalid YAML in issues.yaml at ${issuesPath2}`);
       return items;
     }
     if (parsed && typeof parsed === "object") {
@@ -3264,11 +3285,7 @@ function loadWorkItems(sprintStatusPath, issuesPath2) {
           if (issue && typeof issue === "object") {
             const status = issue.status;
             if (status === "backlog" || status === "ready-for-dev" || status === "in-progress") {
-              items.push({
-                key: issue.id,
-                title: issue.title,
-                source: "issues"
-              });
+              items.push({ key: issue.id, title: issue.title, source: "issues" });
             }
           }
         }
@@ -3277,101 +3294,45 @@ function loadWorkItems(sprintStatusPath, issuesPath2) {
   }
   return items;
 }
-var FILE_WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "Write",
-  "Edit",
-  "write_to_file",
-  "edit_file",
-  "write",
-  "edit",
-  "WriteFile",
-  "EditFile"
-]);
-function isLoopBlock(step) {
-  return typeof step === "object" && step !== null && "loop" in step;
+function buildRetryPrompt(storyKey, findings) {
+  const failedFindings = findings.filter((f) => f.status === "fail" || f.status === "unknown");
+  if (failedFindings.length === 0) return `Implement story ${storyKey}`;
+  const formatted = failedFindings.map((f) => {
+    let entry = `AC #${f.ac} (${f.status.toUpperCase()}): ${f.description}`;
+    if (f.evidence?.reasoning) entry += `
+  Evidence: ${f.evidence.reasoning}`;
+    return entry;
+  }).join("\n\n");
+  return `Retry story ${storyKey}. Previous evaluator findings:
+
+${formatted}
+
+Focus on fixing the failed criteria above.`;
 }
-async function executeNullTask(task, taskName, storyKey, state, config, previousOutputContract, accumulatedCostUsd) {
-  const projectDir = config.projectDir ?? process.cwd();
-  const handler = getNullTask(taskName);
-  if (!handler) {
-    const registered = listNullTasks();
-    const registeredList = registered.length > 0 ? registered.join(", ") : "(none)";
-    const error = {
-      taskName,
-      storyKey,
-      code: "NULL_TASK_NOT_FOUND",
-      message: `No null task handler registered for "${taskName}". Registered handlers: ${registeredList}`
-    };
-    throw error;
-  }
-  const startMs = Date.now();
-  const workflowStartMs = state.started ? new Date(state.started).getTime() : startMs;
-  const ctx = {
-    storyKey,
-    taskName,
-    cost: accumulatedCostUsd ?? 0,
-    durationMs: startMs - workflowStartMs,
-    outputContract: previousOutputContract ?? null,
-    projectDir
-  };
-  let result;
-  try {
-    result = await handler(ctx);
-  } catch (handlerErr) {
-    const error = {
-      taskName,
-      storyKey,
-      code: "NULL_TASK_HANDLER_ERROR",
-      message: `Null task handler "${taskName}" threw: ${handlerErr instanceof Error ? handlerErr.message : String(handlerErr)}`
-    };
-    throw error;
-  }
-  const durationMs = Date.now() - startMs;
-  if (!result.success) {
-    const error = {
-      taskName,
-      storyKey,
-      code: "NULL_TASK_FAILED",
-      message: `Null task handler "${taskName}" returned success=false${result.output ? `: ${result.output}` : ""}`
-    };
-    throw error;
-  }
-  const checkpoint = {
-    task_name: taskName,
-    story_key: storyKey,
-    completed_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  let updatedState = {
-    ...state,
-    tasks_completed: [...state.tasks_completed, checkpoint]
-  };
-  const contract = {
-    version: 1,
-    taskName,
-    storyId: storyKey,
-    driver: "engine",
-    model: "null",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    cost_usd: 0,
-    duration_ms: durationMs,
-    changedFiles: [],
-    testResults: null,
-    output: result.output ?? "",
-    acceptanceCriteria: []
-  };
-  writeWorkflowState(updatedState, projectDir);
-  return { updatedState, output: result.output ?? "", contract };
+function buildAllUnknownVerdict(workItems, reasoning) {
+  const findings = workItems.map((_, index) => ({
+    ac: index + 1,
+    description: `AC #${index + 1}`,
+    status: "unknown",
+    evidence: { commands_run: [], output_observed: "", reasoning }
+  }));
+  return { verdict: "fail", score: { passed: 0, failed: 0, unknown: findings.length, total: findings.length }, findings };
+}
+function getFailedItems(verdict, allItems) {
+  if (!verdict) return allItems;
+  if (verdict.verdict === "pass") return [];
+  return allItems;
 }
-async function dispatchTaskWithResult(task, taskName, storyKey, definition, state, config, customPrompt, previousOutputContract, storyFiles) {
+async function dispatchTaskCore(input) {
+  const { task, taskName, storyKey, definition, config, workflowState, previousContract, onStreamEvent, storyFiles, customPrompt, accumulatedCostUsd } = input;
   const projectDir = config.projectDir ?? process.cwd();
-  const traceId = generateTraceId(config.runId, state.iteration, taskName);
+  const traceId = generateTraceId(config.runId, workflowState.iteration, taskName);
   const tracePrompt = formatTracePrompt(traceId);
   const sessionKey = { taskName, storyKey };
-  const sessionId = resolveSessionId(task.session, sessionKey, state);
+  const sessionId = resolveSessionId(task.session, sessionKey, workflowState);
   const driverName = task.driver ?? "claude-code";
   const driver = getDriver(driverName);
-  const agentAsModelSource = { model: definition.model };
-  const model = resolveModel(task, agentAsModelSource, driver);
+  const model = resolveModel(task, { model: definition.model }, driver);
   let cwd;
   let workspace = null;
   if (task.source_access === false) {
@@ -3384,37 +3345,20 @@ async function dispatchTaskWithResult(task, taskName, storyKey, definition, stat
   } else {
     cwd = projectDir;
   }
-  const isEpicSentinel = storyKey.startsWith("__epic_") || storyKey === PER_RUN_SENTINEL;
-  const TASK_PROMPTS = {
-    "create-story": (key) => `Create the story spec for ${key}. Read the epic definitions and architecture docs. Write a complete story file with acceptance criteria, tasks, and dev notes. CRITICAL: Every AC must be testable by a blind QA agent using ONLY a user guide + browser/API/CLI access. No AC should reference source code, internal data structures, or implementation details like O(1) complexity. Each AC must describe observable behavior that can be verified through UI interaction (agent-browser), API calls (curl), CLI commands (docker exec), or log inspection (docker logs). Wrap output in <story-spec>...</story-spec> tags.`,
-    "implement": (key) => `Implement story ${key}`,
-    "check": (key) => `Run automated checks for story ${key}. Execute the project's test suite, linter, and coverage tool. Include <verdict>pass</verdict> or <verdict>fail</verdict> in your response.`,
-    "review": (key) => `Review the implementation of story ${key}. Check for correctness, security issues, architecture violations, and AC coverage. Include <verdict>pass</verdict> or <verdict>fail</verdict> in your response. If fail, include <issues>...</issues>.`,
-    "document": (key) => `Write user documentation for story ${key}. Describe what was built and how to use it from a user's perspective. No source code. Wrap documentation in <user-docs>...</user-docs> tags.`,
-    "deploy": () => `Provision the Docker environment for this project. Check for docker-compose.yml, start containers, verify health. Wrap report in <deploy-report>...</deploy-report> tags with status, containers, URLs, credentials, health.`,
-    "verify": () => `Verify the epic's stories using the user docs and deploy info in ./story-files/. For each AC, derive verification steps, run commands, observe output. Include <verdict>pass</verdict> or <verdict>fail</verdict>. Include <evidence ac="N" status="pass|fail|unknown">...</evidence> per AC. Include <quality-scores>...</quality-scores>.`,
-    "retro": () => `Run a retrospective for this epic. Analyze what worked, what failed, patterns, and action items for next epic.`
-  };
+  const isEpicSentinel = storyKey.startsWith("__epic_") || storyKey === "__run__";
   let basePrompt;
   if (customPrompt) {
     basePrompt = customPrompt;
-  } else if (isEpicSentinel && TASK_PROMPTS[taskName]) {
-    basePrompt = TASK_PROMPTS[taskName](storyKey);
   } else if (TASK_PROMPTS[taskName]) {
     basePrompt = TASK_PROMPTS[taskName](storyKey);
   } else {
     basePrompt = `Execute task "${taskName}" for story ${storyKey}`;
   }
-  let prompt = buildPromptWithContractContext(basePrompt, previousOutputContract ?? null);
-  const coverageDedup = buildCoverageDeduplicationContext(
-    previousOutputContract ?? null,
-    projectDir
-  );
-  if (coverageDedup) {
-    prompt = `${prompt}
+  let prompt = buildPromptWithContractContext(basePrompt, previousContract);
+  const coverageDedup = buildCoverageDeduplicationContext(previousContract, projectDir);
+  if (coverageDedup) prompt = `${prompt}
 
 ${coverageDedup}`;
-  }
   const dispatchOpts = {
     prompt,
     model,
@@ -3422,15 +3366,11 @@ ${coverageDedup}`;
     sourceAccess: task.source_access !== false,
     ...sessionId ? { sessionId } : {},
     ...tracePrompt ? { appendSystemPrompt: tracePrompt } : {},
-    ...task.plugins ?? definition.plugins ? { plugins: task.plugins ?? definition.plugins } : {},
-    ...task.max_budget_usd != null ? { timeout: task.max_budget_usd } : {}
+    ...task.plugins ?? definition.plugins ? { plugins: task.plugins ?? definition.plugins } : {}
+    // Note: max_budget_usd is not mapped to timeout — they have different semantics
   };
   const emit = config.onEvent;
-  if (emit) {
-    emit({ type: "dispatch-start", taskName, storyKey, driverName, model });
-  } else {
-    info(`[${taskName}] ${storyKey} \u2014 dispatching via ${driverName} (model: ${model})...`);
-  }
+  if (emit) emit({ type: "dispatch-start", taskName, storyKey, driverName, model });
   let output = "";
   let resultSessionId = "";
   let cost = 0;
@@ -3441,28 +3381,21 @@ ${coverageDedup}`;
   const startMs = Date.now();
   try {
     for await (const event of driver.dispatch(dispatchOpts)) {
-      if (emit) {
-        emit({ type: "stream-event", taskName, storyKey, driverName, streamEvent: event });
-      }
-      if (event.type === "text") {
-        output += event.text;
-      }
+      if (onStreamEvent) onStreamEvent(event, driverName);
+      if (emit) emit({ type: "stream-event", taskName, storyKey, driverName, streamEvent: event });
+      if (event.type === "text") output += event.text;
       if (event.type === "tool-start") {
-        const toolStart = event;
-        activeToolName = toolStart.name;
+        const ts = event;
+        activeToolName = ts.name;
         activeToolInput = "";
       }
-      if (event.type === "tool-input") {
-        activeToolInput += event.partial;
-      }
+      if (event.type === "tool-input") activeToolInput += event.partial;
       if (event.type === "tool-complete") {
         if (activeToolName && FILE_WRITE_TOOL_NAMES.has(activeToolName)) {
           try {
             const parsed = JSON.parse(activeToolInput);
             const filePath = parsed.file_path ?? parsed.path ?? parsed.filePath;
-            if (filePath && typeof filePath === "string") {
-              changedFiles.push(filePath);
-            }
+            if (filePath && typeof filePath === "string") changedFiles.push(filePath);
           } catch {
           }
         }
@@ -3470,26 +3403,17 @@ ${coverageDedup}`;
         activeToolInput = "";
       }
       if (event.type === "result") {
-        const resultEvt = event;
-        resultSessionId = resultEvt.sessionId;
-        cost = resultEvt.cost;
-        if (resultEvt.error) {
-          errorEvent = { error: resultEvt.error, errorCategory: resultEvt.errorCategory };
-        }
+        const r = event;
+        resultSessionId = r.sessionId;
+        cost = r.cost;
+        if (r.error) errorEvent = { error: r.error, errorCategory: r.errorCategory };
       }
     }
   } finally {
-    if (workspace) {
-      await workspace.cleanup();
-    }
+    if (workspace) await workspace.cleanup();
   }
   const elapsedMs = Date.now() - startMs;
-  if (emit) {
-    emit({ type: "dispatch-end", taskName, storyKey, driverName, elapsedMs, costUsd: cost });
-  } else {
-    const elapsed = (elapsedMs / 1e3).toFixed(1);
-    info(`[${taskName}] ${storyKey} \u2014 done (${elapsed}s, cost: $${cost.toFixed(4)})`);
-  }
+  if (emit) emit({ type: "dispatch-end", taskName, storyKey, driverName, elapsedMs, costUsd: cost });
   if (errorEvent) {
     const categoryToCode = {
       RATE_LIMIT: "RATE_LIMIT",
@@ -3500,14 +3424,9 @@ ${coverageDedup}`;
       UNKNOWN: "UNKNOWN"
     };
     const code = categoryToCode[errorEvent.errorCategory ?? "UNKNOWN"] ?? "UNKNOWN";
-    throw new DispatchError(
-      errorEvent.error,
-      code,
-      definition.name,
-      errorEvent
-    );
+    throw new DispatchError(errorEvent.error, code, definition.name, errorEvent);
   }
-  let updatedState = state;
+  let updatedState = workflowState;
   if (resultSessionId) {
     updatedState = recordSessionId(sessionKey, resultSessionId, updatedState);
   } else {
@@ -3516,10 +3435,7 @@ ${coverageDedup}`;
       story_key: storyKey,
       completed_at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    updatedState = {
-      ...updatedState,
-      tasks_completed: [...updatedState.tasks_completed, checkpoint]
-    };
+    updatedState = { ...updatedState, tasks_completed: [...updatedState.tasks_completed, checkpoint] };
   }
   updatedState = recordTraceId(traceId, updatedState);
   const durationMs = Date.now() - startMs;
@@ -3541,342 +3457,278 @@ ${coverageDedup}`;
     };
     writeOutputContract(contract, join12(projectDir, ".codeharness", "contracts"));
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    warn(`workflow-engine: failed to write output contract for ${taskName}/${storyKey}: ${message}`);
+    const msg = err instanceof Error ? err.message : String(err);
+    warn(`workflow-machine: failed to write output contract for ${taskName}/${storyKey}: ${msg}`);
     contract = null;
   }
   writeWorkflowState(updatedState, projectDir);
-  return { updatedState, output, contract };
-}
-function buildRetryPrompt(storyKey, findings) {
-  const failedFindings = findings.filter(
-    (f) => f.status === "fail" || f.status === "unknown"
-  );
-  if (failedFindings.length === 0) {
-    return `Implement story ${storyKey}`;
-  }
-  const formattedFindings = failedFindings.map((f) => {
-    const status = f.status.toUpperCase();
-    let entry = `AC #${f.ac} (${status}): ${f.description}`;
-    if (f.evidence?.reasoning) {
-      entry += `
-  Evidence: ${f.evidence.reasoning}`;
-    }
-    return entry;
-  }).join("\n\n");
-  return `Retry story ${storyKey}. Previous evaluator findings:
-
-${formattedFindings}
-
-Focus on fixing the failed criteria above.`;
+  propagateVerifyFlags(taskName, contract, projectDir);
+  return { output, cost, changedFiles, sessionId: resultSessionId, contract, updatedState };
 }
-function buildAllUnknownVerdict(workItems, reasoning) {
-  const findings = workItems.map((_, index) => ({
-    ac: index + 1,
-    description: `AC #${index + 1}`,
-    status: "unknown",
-    evidence: {
-      commands_run: [],
-      output_observed: "",
-      reasoning
-    }
-  }));
-  return {
-    verdict: "fail",
-    score: {
-      passed: 0,
-      failed: 0,
-      unknown: findings.length,
-      total: findings.length
-    },
-    findings
+async function nullTaskCore(input) {
+  const { task, taskName, storyKey, config, workflowState, previousContract, accumulatedCostUsd } = input;
+  const projectDir = config.projectDir ?? process.cwd();
+  const handler = getNullTask(taskName);
+  if (!handler) {
+    const registered = listNullTasks();
+    throw { taskName, storyKey, code: "NULL_TASK_NOT_FOUND", message: `No null task handler registered for "${taskName}". Registered: ${registered.join(", ") || "(none)"}` };
+  }
+  const startMs = Date.now();
+  const workflowStartMs = workflowState.started ? new Date(workflowState.started).getTime() : startMs;
+  const ctx = {
+    storyKey,
+    taskName,
+    cost: accumulatedCostUsd,
+    durationMs: startMs - workflowStartMs,
+    outputContract: previousContract,
+    projectDir
+  };
+  let result;
+  try {
+    result = await handler(ctx);
+  } catch (err) {
+    throw { taskName, storyKey, code: "NULL_TASK_HANDLER_ERROR", message: `Null task handler "${taskName}" threw: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  if (!result.success) {
+    throw { taskName, storyKey, code: "NULL_TASK_FAILED", message: `Null task handler "${taskName}" returned success=false${result.output ? `: ${result.output}` : ""}` };
+  }
+  const checkpoint = { task_name: taskName, story_key: storyKey, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+  const updatedState = { ...workflowState, tasks_completed: [...workflowState.tasks_completed, checkpoint] };
+  const durationMs = Date.now() - startMs;
+  const contract = {
+    version: 1,
+    taskName,
+    storyId: storyKey,
+    driver: "engine",
+    model: "null",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    cost_usd: 0,
+    duration_ms: durationMs,
+    changedFiles: [],
+    testResults: null,
+    output: result.output ?? "",
+    acceptanceCriteria: []
   };
+  writeWorkflowState(updatedState, projectDir);
+  return { output: result.output ?? "", cost: 0, changedFiles: [], sessionId: "", contract, updatedState };
 }
-function getFailedItems(verdict, allItems) {
-  if (!verdict) return allItems;
-  if (verdict.verdict === "pass") return [];
-  return allItems;
+function isLoopBlock(step) {
+  return typeof step === "object" && step !== null && "loop" in step;
 }
-async function executeLoopBlock(loopBlock, state, config, workItems, initialContract, storyFlowTasks) {
+var dispatchActor = fromPromise(async ({ input }) => {
+  return dispatchTaskCore(input);
+});
+var nullTaskDispatchActor = fromPromise(async ({ input }) => {
+  return nullTaskCore(input);
+});
+var loopIterationActor = fromPromise(async ({ input }) => {
+  const { loopBlock, config, workItems, storyFlowTasks, onStreamEvent, maxIterations } = input;
+  let { currentState, errors, tasksCompleted, lastContract, lastVerdict, accumulatedCostUsd } = input;
   const projectDir = config.projectDir ?? process.cwd();
-  const maxIterations = config.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-  const errors = [];
-  let tasksCompleted = 0;
-  let currentState = state;
-  let lastVerdict = null;
-  let lastOutputContract = initialContract ?? null;
-  let accumulatedCostUsd = 0;
-  if (loopBlock.loop.length === 0) {
-    return { state: currentState, errors, tasksCompleted, halted: false, lastContract: lastOutputContract };
-  }
+  const RUN_SENTINEL = "__run__";
   const lastAgentTaskInLoop = (() => {
     for (let i = loopBlock.loop.length - 1; i >= 0; i--) {
       const tn = loopBlock.loop[i];
       const t = config.workflow.tasks[tn];
       if (t && t.agent !== null) return tn;
-    }
-    return loopBlock.loop[loopBlock.loop.length - 1];
-  })();
-  while (true) {
-    const nextIteration = currentState.iteration + 1;
-    const allCurrentIterationDone = currentState.iteration > 0 && loopBlock.loop.every((tn) => {
-      const t = config.workflow.tasks[tn];
-      if (!t) return true;
-      if (storyFlowTasks?.has(tn)) {
-        return workItems.every((item) => isLoopTaskCompleted(currentState, tn, item.key, currentState.iteration));
-      }
-      return isLoopTaskCompleted(currentState, tn, PER_RUN_SENTINEL, currentState.iteration);
-    });
-    if (currentState.iteration === 0 || allCurrentIterationDone) {
-      currentState = {
-        ...currentState,
-        iteration: nextIteration
-      };
-      writeWorkflowState(currentState, projectDir);
-    }
-    let haltedInLoop = false;
-    for (const taskName of loopBlock.loop) {
-      const task = config.workflow.tasks[taskName];
-      if (!task) {
-        warn(`workflow-engine: task "${taskName}" not found in workflow tasks, skipping`);
-        continue;
-      }
-      if (task.agent === null) {
-        if (storyFlowTasks?.has(taskName)) {
-          const itemsToProcess = lastVerdict ? getFailedItems(lastVerdict, workItems) : workItems;
-          for (const item of itemsToProcess) {
-            if (isLoopTaskCompleted(currentState, taskName, item.key, currentState.iteration)) {
-              warn(`workflow-engine: skipping completed task ${taskName} for ${item.key}`);
-              continue;
-            }
-            try {
-              const nullResult = await executeNullTask(
-                task,
-                taskName,
-                item.key,
-                currentState,
-                config,
-                lastOutputContract ?? void 0,
-                accumulatedCostUsd
-              );
-              currentState = nullResult.updatedState;
-              lastOutputContract = nullResult.contract;
-              tasksCompleted++;
-            } catch (err) {
-              const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, item.key);
-              errors.push(engineError);
-              currentState = recordErrorInState(currentState, taskName, item.key, engineError);
-              writeWorkflowState(currentState, projectDir);
-            }
-          }
-        } else {
-          if (isLoopTaskCompleted(currentState, taskName, PER_RUN_SENTINEL, currentState.iteration)) {
-            warn(`workflow-engine: skipping completed task ${taskName} for ${PER_RUN_SENTINEL}`);
-            continue;
-          }
-          try {
-            const nullResult = await executeNullTask(
-              task,
-              taskName,
-              PER_RUN_SENTINEL,
-              currentState,
-              config,
-              lastOutputContract ?? void 0,
-              accumulatedCostUsd
-            );
-            currentState = nullResult.updatedState;
-            lastOutputContract = nullResult.contract;
-            tasksCompleted++;
-          } catch (err) {
-            const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, PER_RUN_SENTINEL);
-            errors.push(engineError);
-            currentState = recordErrorInState(currentState, taskName, PER_RUN_SENTINEL, engineError);
-            writeWorkflowState(currentState, projectDir);
-          }
-        }
-        continue;
-      }
-      const definition = config.agents[task.agent];
-      if (!definition) {
-        warn(`workflow-engine: agent "${task.agent}" not found for task "${taskName}", skipping`);
-        continue;
-      }
-      if (storyFlowTasks?.has(taskName)) {
-        const itemsToRetry = lastVerdict ? getFailedItems(lastVerdict, workItems) : workItems;
-        for (const item of itemsToRetry) {
-          if (isLoopTaskCompleted(currentState, taskName, item.key, currentState.iteration)) {
-            warn(`workflow-engine: skipping completed task ${taskName} for ${item.key}`);
-            continue;
-          }
-          const prompt = lastVerdict ? buildRetryPrompt(item.key, lastVerdict.findings) : void 0;
-          try {
-            const dispatchResult = await dispatchTaskWithResult(
-              task,
-              taskName,
-              item.key,
-              definition,
-              currentState,
-              config,
-              prompt,
-              lastOutputContract ?? void 0
-            );
-            currentState = dispatchResult.updatedState;
-            lastOutputContract = dispatchResult.contract;
-            propagateVerifyFlags(taskName, dispatchResult.contract, projectDir);
-            accumulatedCostUsd += dispatchResult.contract?.cost_usd ?? 0;
-            tasksCompleted++;
-          } catch (err) {
-            const engineError = handleDispatchError(err, taskName, item.key);
-            errors.push(engineError);
-            currentState = recordErrorInState(currentState, taskName, item.key, engineError);
-            writeWorkflowState(currentState, projectDir);
-            if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) {
-              haltedInLoop = true;
-              break;
-            }
-            continue;
-          }
-        }
-        if (haltedInLoop) break;
-      } else {
-        if (isLoopTaskCompleted(currentState, taskName, PER_RUN_SENTINEL, currentState.iteration)) {
-          warn(`workflow-engine: skipping completed task ${taskName} for ${PER_RUN_SENTINEL}`);
-          continue;
-        }
-        try {
-          const dispatchResult = await dispatchTaskWithResult(
-            task,
-            taskName,
-            PER_RUN_SENTINEL,
-            definition,
-            currentState,
-            config,
-            void 0,
-            lastOutputContract ?? void 0
-          );
-          currentState = dispatchResult.updatedState;
-          lastOutputContract = dispatchResult.contract;
-          propagateVerifyFlags(taskName, dispatchResult.contract, projectDir);
-          accumulatedCostUsd += dispatchResult.contract?.cost_usd ?? 0;
-          tasksCompleted++;
-          const isLastTaskInLoop = taskName === lastAgentTaskInLoop;
-          if (isLastTaskInLoop) {
-            let verdict = null;
-            try {
-              verdict = parseVerdict(dispatchResult.output);
-            } catch (parseErr) {
-              if (parseErr instanceof VerdictParseError && parseErr.retryable) {
-                warn(`workflow-engine: verdict parse failed, retrying evaluator for ${taskName}`);
-                try {
-                  const retryResult = await dispatchTaskWithResult(
-                    task,
-                    taskName,
-                    PER_RUN_SENTINEL,
-                    definition,
-                    currentState,
-                    config,
-                    void 0,
-                    lastOutputContract ?? void 0
-                  );
-                  currentState = retryResult.updatedState;
-                  lastOutputContract = retryResult.contract;
-                  propagateVerifyFlags(taskName, retryResult.contract, projectDir);
-                  tasksCompleted++;
-                  verdict = parseVerdict(retryResult.output);
-                } catch {
-                  verdict = buildAllUnknownVerdict(
-                    workItems,
-                    "Evaluator failed to produce valid JSON after retry"
-                  );
-                }
-              }
-            }
-            if (!verdict) {
-              const tagged = parseVerdictTag(dispatchResult.output);
-              if (tagged) {
-                verdict = {
-                  verdict: tagged.verdict,
-                  score: { passed: tagged.verdict === "pass" ? 1 : 0, failed: tagged.verdict === "fail" ? 1 : 0, unknown: 0, total: 1 },
-                  findings: []
-                };
-              }
-            }
-            lastVerdict = verdict;
-            if (verdict) {
-              const score = {
-                iteration: currentState.iteration,
-                passed: verdict.score.passed,
-                failed: verdict.score.failed,
-                unknown: verdict.score.unknown,
-                total: verdict.score.total,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              };
-              currentState = {
-                ...currentState,
-                evaluator_scores: [...currentState.evaluator_scores, score]
-              };
-            } else {
-              const totalItems = workItems.length;
-              const score = {
-                iteration: currentState.iteration,
-                passed: 0,
-                failed: 0,
-                unknown: totalItems,
-                total: totalItems,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              };
-              currentState = {
-                ...currentState,
-                evaluator_scores: [...currentState.evaluator_scores, score]
-              };
-            }
-            const cbDecision = evaluateProgress(currentState.evaluator_scores);
-            if (cbDecision.halt) {
-              currentState = {
-                ...currentState,
-                circuit_breaker: {
-                  triggered: true,
-                  reason: cbDecision.reason,
-                  score_history: cbDecision.scoreHistory
-                }
-              };
-              writeWorkflowState(currentState, projectDir);
-            }
-          }
-          writeWorkflowState(currentState, projectDir);
+    }
+    return loopBlock.loop[loopBlock.loop.length - 1];
+  })();
+  const nextIteration = currentState.iteration + 1;
+  const allCurrentIterationDone = currentState.iteration > 0 && loopBlock.loop.every((tn) => {
+    const t = config.workflow.tasks[tn];
+    if (!t) return true;
+    if (storyFlowTasks?.has(tn)) return workItems.every((item) => isLoopTaskCompleted(currentState, tn, item.key, currentState.iteration));
+    return isLoopTaskCompleted(currentState, tn, RUN_SENTINEL, currentState.iteration);
+  });
+  if (currentState.iteration === 0 || allCurrentIterationDone) {
+    currentState = { ...currentState, iteration: nextIteration };
+    writeWorkflowState(currentState, projectDir);
+  }
+  let haltedInLoop = false;
+  for (const taskName of loopBlock.loop) {
+    const task = config.workflow.tasks[taskName];
+    if (!task) {
+      warn(`workflow-machine: task "${taskName}" not found in workflow tasks, skipping`);
+      continue;
+    }
+    if (task.agent === null) {
+      const items2 = storyFlowTasks?.has(taskName) ? lastVerdict ? getFailedItems(lastVerdict, workItems) : workItems : [{ key: RUN_SENTINEL, source: "sprint" }];
+      for (const item of items2) {
+        if (isLoopTaskCompleted(currentState, taskName, item.key, currentState.iteration)) {
+          warn(`workflow-machine: skipping completed task ${taskName} for ${item.key}`);
+          continue;
+        }
+        try {
+          const nr = await nullTaskCore({ task, taskName, storyKey: item.key, config, workflowState: currentState, previousContract: lastContract, accumulatedCostUsd });
+          currentState = nr.updatedState;
+          lastContract = nr.contract;
+          tasksCompleted++;
         } catch (err) {
-          const engineError = handleDispatchError(err, taskName, PER_RUN_SENTINEL);
+          const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, item.key);
           errors.push(engineError);
-          currentState = recordErrorInState(currentState, taskName, PER_RUN_SENTINEL, engineError);
+          currentState = recordErrorInState(currentState, taskName, item.key, engineError);
           writeWorkflowState(currentState, projectDir);
-          lastVerdict = null;
-          if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) {
-            haltedInLoop = true;
-            break;
-          }
-          continue;
         }
       }
+      continue;
     }
-    if (haltedInLoop) {
-      return { state: currentState, errors, tasksCompleted, halted: true, lastContract: lastOutputContract };
-    }
-    if (lastVerdict?.verdict === "pass") {
-      return { state: currentState, errors, tasksCompleted, halted: false, lastContract: lastOutputContract };
-    }
-    if (currentState.iteration >= maxIterations) {
-      currentState = { ...currentState, phase: "max-iterations" };
-      writeWorkflowState(currentState, projectDir);
-      return { state: currentState, errors, tasksCompleted, halted: false, lastContract: lastOutputContract };
+    const definition = config.agents[task.agent];
+    if (!definition) {
+      warn(`workflow-machine: agent "${task.agent}" not found for task "${taskName}", skipping`);
+      continue;
     }
-    if (currentState.circuit_breaker.triggered) {
-      currentState = { ...currentState, phase: "circuit-breaker" };
-      writeWorkflowState(currentState, projectDir);
-      return { state: currentState, errors, tasksCompleted, halted: false, lastContract: lastOutputContract };
+    const items = storyFlowTasks?.has(taskName) ? lastVerdict ? getFailedItems(lastVerdict, workItems) : workItems : [{ key: RUN_SENTINEL, source: "sprint" }];
+    for (const item of items) {
+      if (isLoopTaskCompleted(currentState, taskName, item.key, currentState.iteration)) {
+        warn(`workflow-machine: skipping completed task ${taskName} for ${item.key}`);
+        continue;
+      }
+      const prompt = lastVerdict ? buildRetryPrompt(item.key, lastVerdict.findings) : void 0;
+      try {
+        const dr = await dispatchTaskCore({ task, taskName, storyKey: item.key, definition, config, workflowState: currentState, previousContract: lastContract, onStreamEvent, customPrompt: prompt });
+        currentState = dr.updatedState;
+        lastContract = dr.contract;
+        accumulatedCostUsd += dr.contract?.cost_usd ?? 0;
+        tasksCompleted++;
+        if (taskName === lastAgentTaskInLoop && !storyFlowTasks?.has(taskName)) {
+          let verdict = null;
+          try {
+            verdict = parseVerdict(dr.output);
+          } catch (parseErr) {
+            if (parseErr instanceof VerdictParseError && parseErr.retryable) {
+              try {
+                const retryResult = await dispatchTaskCore({ task, taskName, storyKey: item.key, definition, config, workflowState: currentState, previousContract: lastContract, onStreamEvent });
+                currentState = retryResult.updatedState;
+                lastContract = retryResult.contract;
+                tasksCompleted++;
+                verdict = parseVerdict(retryResult.output);
+              } catch {
+                verdict = buildAllUnknownVerdict(workItems, "Evaluator failed after retry");
+              }
+            }
+          }
+          if (!verdict) {
+            const tagged = parseVerdictTag(dr.output);
+            if (tagged) verdict = { verdict: tagged.verdict, score: { passed: tagged.verdict === "pass" ? 1 : 0, failed: tagged.verdict === "fail" ? 1 : 0, unknown: 0, total: 1 }, findings: [] };
+          }
+          lastVerdict = verdict;
+          if (verdict) {
+            const score = { iteration: currentState.iteration, passed: verdict.score.passed, failed: verdict.score.failed, unknown: verdict.score.unknown, total: verdict.score.total, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+            currentState = { ...currentState, evaluator_scores: [...currentState.evaluator_scores, score] };
+          }
+          const cbDecision = evaluateProgress(currentState.evaluator_scores);
+          if (cbDecision.halt) {
+            currentState = { ...currentState, circuit_breaker: { triggered: true, reason: cbDecision.reason, score_history: cbDecision.scoreHistory } };
+            writeWorkflowState(currentState, projectDir);
+          }
+          writeWorkflowState(currentState, projectDir);
+        }
+      } catch (err) {
+        const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, item.key);
+        errors.push(engineError);
+        currentState = recordErrorInState(currentState, taskName, item.key, engineError);
+        writeWorkflowState(currentState, projectDir);
+        if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) {
+          haltedInLoop = true;
+          break;
+        }
+      }
     }
-  }
+    if (haltedInLoop) break;
+  }
+  return { ...input, currentState, errors, tasksCompleted, halted: haltedInLoop, lastContract, lastVerdict, accumulatedCostUsd };
+});
+var loopMachine = setup({
+  types: {},
+  actors: { loopIterationActor },
+  guards: {
+    halted: ({ context }) => context.halted,
+    verdictPass: ({ context }) => context.lastVerdict?.verdict === "pass",
+    maxIterations: ({ context }) => context.currentState.iteration >= context.maxIterations,
+    circuitBreaker: ({ context }) => context.currentState.circuit_breaker.triggered
+  }
+}).createMachine({
+  id: "loopBlock",
+  context: ({ input }) => input,
+  initial: "checkEmpty",
+  states: {
+    checkEmpty: {
+      always: [
+        { guard: ({ context }) => context.loopBlock.loop.length === 0, target: "done" },
+        { target: "iterating" }
+      ]
+    },
+    iterating: {
+      invoke: {
+        src: "loopIterationActor",
+        input: ({ context }) => context,
+        onDone: {
+          target: "checkTermination",
+          actions: assign(({ event }) => event.output)
+        },
+        onError: { target: "halted" }
+      }
+    },
+    checkTermination: {
+      always: [
+        { guard: "halted", target: "halted" },
+        { guard: "verdictPass", target: "done" },
+        { guard: "maxIterations", target: "maxIterationsReached" },
+        { guard: "circuitBreaker", target: "circuitBreakerTriggered" },
+        { target: "iterating" }
+      ]
+    },
+    done: { type: "final" },
+    halted: { type: "final" },
+    maxIterationsReached: {
+      type: "final",
+      entry: [
+        assign(({ context }) => ({ ...context, currentState: { ...context.currentState, phase: "max-iterations" } })),
+        ({ context }) => {
+          const projectDir = context.config.projectDir ?? process.cwd();
+          writeWorkflowState(context.currentState, projectDir);
+        }
+      ]
+    },
+    circuitBreakerTriggered: {
+      type: "final",
+      entry: [
+        assign(({ context }) => ({ ...context, currentState: { ...context.currentState, phase: "circuit-breaker" } })),
+        ({ context }) => {
+          const projectDir = context.config.projectDir ?? process.cwd();
+          writeWorkflowState(context.currentState, projectDir);
+        }
+      ]
+    }
+  }
+});
+async function executeLoopBlock(loopBlock, state, config, workItems, initialContract, storyFlowTasks, onStreamEvent) {
+  const input = {
+    loopBlock,
+    config,
+    workItems,
+    storyFlowTasks,
+    onStreamEvent,
+    maxIterations: config.maxIterations ?? DEFAULT_MAX_ITERATIONS,
+    currentState: state,
+    errors: [],
+    tasksCompleted: 0,
+    halted: false,
+    lastContract: initialContract ?? null,
+    lastVerdict: null,
+    accumulatedCostUsd: 0
+  };
+  const actor = createActor(loopMachine, { input });
+  return new Promise((resolve7) => {
+    actor.subscribe({ complete: () => {
+      const snap = actor.getSnapshot();
+      const ctx = snap.context;
+      resolve7({ state: ctx.currentState, errors: ctx.errors, tasksCompleted: ctx.tasksCompleted, halted: ctx.halted, lastContract: ctx.lastContract });
+    } });
+    actor.start();
+  });
 }
-var HEALTH_CHECK_TIMEOUT_MS = 5e3;
 async function checkDriverHealth(workflow, timeoutMs) {
   const driverNames = /* @__PURE__ */ new Set();
   for (const task of Object.values(workflow.tasks)) {
@@ -3884,9 +3736,7 @@ async function checkDriverHealth(workflow, timeoutMs) {
     driverNames.add(task.driver ?? "claude-code");
   }
   const drivers = /* @__PURE__ */ new Map();
-  for (const name of driverNames) {
-    drivers.set(name, getDriver(name));
-  }
+  for (const name of driverNames) drivers.set(name, getDriver(name));
   const responded = /* @__PURE__ */ new Set();
   const healthChecks = Promise.all(
     [...drivers.entries()].map(async ([name, driver]) => {
@@ -3903,78 +3753,378 @@ async function checkDriverHealth(workflow, timeoutMs) {
   const result = await Promise.race([healthChecks, timeoutPromise]);
   if (result === "timeout") {
     const pending = [...driverNames].filter((n) => !responded.has(n));
-    const names = pending.length > 0 ? pending.join(", ") : [...driverNames].join(", ");
-    throw new Error(
-      `Driver health check timed out after ${effectiveTimeout}ms. Drivers that did not respond: ${names}`
-    );
+    throw new Error(`Driver health check timed out after ${effectiveTimeout}ms. Drivers: ${(pending.length > 0 ? pending : [...driverNames]).join(", ")}`);
   }
   clearTimeout(timer);
   const failures = result.filter((r) => !r.health.available);
   if (failures.length > 0) {
-    const details = failures.map((f) => `${f.name}: ${f.health.error ?? "unavailable"}`).join("; ");
-    throw new Error(`Driver health check failed: ${details}`);
+    throw new Error(`Driver health check failed: ${failures.map((f) => `${f.name}: ${f.health.error ?? "unavailable"}`).join("; ")}`);
   }
 }
-async function executeWorkflow(config) {
-  const startMs = Date.now();
+function collectGuideFiles(epicItems, epicSentinel, projectDir) {
+  const guidesDir = join12(projectDir, ".codeharness", "verify-guides");
+  const guideFiles = [];
+  try {
+    mkdirSync6(guidesDir, { recursive: true });
+  } catch {
+    return guideFiles;
+  }
+  for (const item of epicItems) {
+    try {
+      const contractPath = join12(projectDir, ".codeharness", "contracts", `document-${item.key}.json`);
+      if (existsSync15(contractPath)) {
+        const contractData = JSON.parse(readFileSync13(contractPath, "utf-8"));
+        const docs = contractData.output ? extractTag(contractData.output, "user-docs") ?? contractData.output : null;
+        if (docs) {
+          const guidePath = join12(guidesDir, `${item.key}-guide.md`);
+          writeFileSync8(guidePath, docs, "utf-8");
+          guideFiles.push(guidePath);
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const deployContractPath = join12(projectDir, ".codeharness", "contracts", `deploy-${epicSentinel}.json`);
+    if (existsSync15(deployContractPath)) {
+      const deployData = JSON.parse(readFileSync13(deployContractPath, "utf-8"));
+      const report = deployData.output ? extractTag(deployData.output, "deploy-report") ?? deployData.output : null;
+      if (report) {
+        const deployPath = join12(guidesDir, "deploy-info.md");
+        writeFileSync8(deployPath, report, "utf-8");
+        guideFiles.push(deployPath);
+      }
+    }
+  } catch {
+  }
+  return guideFiles;
+}
+function cleanupGuideFiles(projectDir) {
+  const guidesDir = join12(projectDir, ".codeharness", "verify-guides");
+  try {
+    rmSync2(guidesDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+var storyFlowActor = fromPromise(async ({ input }) => {
+  const { item, config, storyFlowTasks } = input;
+  let { workflowState: state, lastContract, accumulatedCostUsd } = input;
   const projectDir = config.projectDir ?? process.cwd();
   const errors = [];
   let tasksCompleted = 0;
-  const processedStories = /* @__PURE__ */ new Set();
+  let halted = false;
+  for (const storyStep of config.workflow.storyFlow) {
+    if (halted || config.abortSignal?.aborted) {
+      halted = true;
+      break;
+    }
+    if (isLoopBlock(storyStep)) {
+      const loopResult = await executeLoopBlock(storyStep, state, config, [item], lastContract, storyFlowTasks);
+      state = loopResult.state;
+      errors.push(...loopResult.errors);
+      tasksCompleted += loopResult.tasksCompleted;
+      lastContract = loopResult.lastContract;
+      if (loopResult.halted || state.phase === "max-iterations" || state.phase === "circuit-breaker") {
+        halted = true;
+        break;
+      }
+      continue;
+    }
+    if (typeof storyStep !== "string") continue;
+    const taskName = storyStep;
+    const task = config.workflow.tasks[taskName];
+    if (!task) {
+      warn(`workflow-machine: task "${taskName}" not found in workflow tasks, skipping`);
+      continue;
+    }
+    if (task.agent === null) {
+      if (isTaskCompleted(state, taskName, item.key)) continue;
+      try {
+        const nr = await nullTaskCore({ task, taskName, storyKey: item.key, config, workflowState: state, previousContract: lastContract, accumulatedCostUsd });
+        state = nr.updatedState;
+        lastContract = nr.contract;
+        tasksCompleted++;
+      } catch (err) {
+        const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, item.key);
+        errors.push(engineError);
+        state = recordErrorInState(state, taskName, item.key, engineError);
+        writeWorkflowState(state, projectDir);
+        break;
+      }
+      continue;
+    }
+    const definition = config.agents[task.agent];
+    if (!definition) {
+      warn(`workflow-machine: agent "${task.agent}" not found for task "${taskName}", skipping`);
+      continue;
+    }
+    if (isTaskCompleted(state, taskName, item.key)) continue;
+    try {
+      const dr = await dispatchTaskCore({ task, taskName, storyKey: item.key, definition, config, workflowState: state, previousContract: lastContract });
+      state = dr.updatedState;
+      lastContract = dr.contract;
+      accumulatedCostUsd += dr.contract?.cost_usd ?? 0;
+      tasksCompleted++;
+    } catch (err) {
+      const engineError = handleDispatchError(err, taskName, item.key);
+      errors.push(engineError);
+      if (config.onEvent) config.onEvent({ type: "dispatch-error", taskName, storyKey: item.key, error: { code: engineError.code, message: engineError.message } });
+      state = recordErrorInState(state, taskName, item.key, engineError);
+      writeWorkflowState(state, projectDir);
+      if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) halted = true;
+      break;
+    }
+  }
+  if (!halted && config.onEvent) {
+    config.onEvent({ type: "story-done", taskName: "story_flow", storyKey: item.key });
+  }
+  return { workflowState: state, errors, tasksCompleted, lastContract, accumulatedCostUsd, halted };
+});
+var epicStepActor = fromPromise(async ({ input }) => {
+  const { epicId, epicItems, config, storyFlowTasks } = input;
+  let { workflowState: state, errors, tasksCompleted, storiesProcessed, lastContract, accumulatedCostUsd, halted, currentStepIndex } = input;
+  const projectDir = config.projectDir ?? process.cwd();
+  const step = config.workflow.epicFlow[currentStepIndex];
+  if (!step || halted || config.abortSignal?.aborted) {
+    if (config.abortSignal?.aborted) {
+      state = { ...state, phase: "interrupted" };
+      writeWorkflowState(state, projectDir);
+    }
+    return { ...input, workflowState: state, errors, tasksCompleted, storiesProcessed, lastContract, accumulatedCostUsd, halted: true, currentStepIndex };
+  }
+  if (step === "story_flow") {
+    for (const item of epicItems) {
+      if (halted || config.abortSignal?.aborted) {
+        halted = true;
+        break;
+      }
+      storiesProcessed.add(item.key);
+      const storyResult = await new Promise((resolve7, reject) => {
+        const a = createActor(storyFlowActor, { input: { item, config, workflowState: state, lastContract, accumulatedCostUsd, storyFlowTasks } });
+        a.subscribe({ complete: () => resolve7(a.getSnapshot().output), error: reject });
+        a.start();
+      });
+      state = storyResult.workflowState;
+      errors.push(...storyResult.errors);
+      tasksCompleted += storyResult.tasksCompleted;
+      lastContract = storyResult.lastContract;
+      accumulatedCostUsd = storyResult.accumulatedCostUsd;
+      if (storyResult.halted) {
+        halted = true;
+        break;
+      }
+    }
+    return { ...input, workflowState: state, errors, tasksCompleted, storiesProcessed, lastContract, accumulatedCostUsd, halted, currentStepIndex: currentStepIndex + 1 };
+  }
+  if (isLoopBlock(step)) {
+    const loopResult = await executeLoopBlock(step, state, config, epicItems, lastContract, storyFlowTasks);
+    state = loopResult.state;
+    errors.push(...loopResult.errors);
+    tasksCompleted += loopResult.tasksCompleted;
+    lastContract = loopResult.lastContract;
+    for (const item of epicItems) storiesProcessed.add(item.key);
+    if (loopResult.halted || state.phase === "max-iterations" || state.phase === "circuit-breaker") halted = true;
+    return { ...input, workflowState: state, errors, tasksCompleted, storiesProcessed, lastContract, accumulatedCostUsd, halted, currentStepIndex: currentStepIndex + 1 };
+  }
+  const taskName = step;
+  const task = config.workflow.tasks[taskName];
+  if (!task) {
+    warn(`workflow-machine: task "${taskName}" not found in workflow tasks, skipping`);
+    return { ...input, currentStepIndex: currentStepIndex + 1 };
+  }
+  const epicSentinel = `__epic_${epicId}__`;
+  if (task.agent === null) {
+    if (!isTaskCompleted(state, taskName, epicSentinel)) {
+      try {
+        const nr = await nullTaskCore({ task, taskName, storyKey: epicSentinel, config, workflowState: state, previousContract: lastContract, accumulatedCostUsd });
+        state = nr.updatedState;
+        lastContract = nr.contract;
+        tasksCompleted++;
+      } catch (err) {
+        const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, epicSentinel);
+        errors.push(engineError);
+        state = recordErrorInState(state, taskName, epicSentinel, engineError);
+        writeWorkflowState(state, projectDir);
+      }
+    }
+    return { ...input, workflowState: state, errors, tasksCompleted, storiesProcessed, lastContract, accumulatedCostUsd, halted, currentStepIndex: currentStepIndex + 1 };
+  }
+  const definition = config.agents[task.agent];
+  if (!definition) {
+    warn(`workflow-machine: agent "${task.agent}" not found for task "${taskName}", skipping`);
+    return { ...input, currentStepIndex: currentStepIndex + 1 };
+  }
+  if (isTaskCompleted(state, taskName, epicSentinel)) {
+    return { ...input, currentStepIndex: currentStepIndex + 1 };
+  }
+  let guideFiles = [];
+  if (task.source_access === false) guideFiles = collectGuideFiles(epicItems, epicSentinel, projectDir);
+  try {
+    const dr = await dispatchTaskCore({ task, taskName, storyKey: epicSentinel, definition, config, workflowState: state, previousContract: lastContract, storyFiles: guideFiles });
+    state = dr.updatedState;
+    lastContract = dr.contract;
+    accumulatedCostUsd += dr.contract?.cost_usd ?? 0;
+    tasksCompleted++;
+  } catch (err) {
+    const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, epicSentinel);
+    errors.push(engineError);
+    if (config.onEvent) config.onEvent({ type: "dispatch-error", taskName, storyKey: epicSentinel, error: { code: engineError.code, message: engineError.message } });
+    state = recordErrorInState(state, taskName, epicSentinel, engineError);
+    writeWorkflowState(state, projectDir);
+    if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) halted = true;
+  } finally {
+    if (guideFiles.length > 0) cleanupGuideFiles(projectDir);
+  }
+  return { ...input, workflowState: state, errors, tasksCompleted, storiesProcessed, lastContract, accumulatedCostUsd, halted, currentStepIndex: currentStepIndex + 1 };
+});
+var epicMachine = setup({
+  types: {},
+  actors: { epicStepActor },
+  guards: {
+    epicDone: ({ context }) => context.halted || context.currentStepIndex >= context.config.workflow.epicFlow.length
+  }
+}).createMachine({
+  id: "epic",
+  context: ({ input }) => input,
+  initial: "processingStep",
+  states: {
+    processingStep: {
+      invoke: {
+        src: "epicStepActor",
+        input: ({ context }) => context,
+        onDone: {
+          target: "checkNext",
+          actions: assign(({ event }) => event.output)
+        },
+        onError: {
+          target: "done",
+          actions: assign(({ context, event }) => {
+            const msg = event.error instanceof Error ? event.error.message : String(event.error);
+            return { ...context, errors: [...context.errors, { taskName: "__epic_actor__", storyKey: context.epicId, code: "ACTOR_ERROR", message: msg }], halted: true };
+          })
+        }
+      }
+    },
+    checkNext: {
+      always: [
+        { guard: "epicDone", target: "done" },
+        { target: "processingStep" }
+      ]
+    },
+    done: { type: "final" }
+  }
+});
+var runEpicActor = fromPromise(async ({ input }) => {
+  const { config, storyFlowTasks, epicEntries, currentEpicIndex } = input;
+  let { workflowState: state, errors, tasksCompleted, storiesProcessed, lastContract, accumulatedCostUsd, halted } = input;
+  if (currentEpicIndex >= epicEntries.length || halted || config.abortSignal?.aborted) {
+    if (config.abortSignal?.aborted) {
+      const projectDir = config.projectDir ?? process.cwd();
+      state = { ...state, phase: "interrupted" };
+      writeWorkflowState(state, projectDir);
+    }
+    return { ...input, workflowState: state, halted: true };
+  }
+  const [epicId, epicItems] = epicEntries[currentEpicIndex];
+  if (config.onEvent) {
+    config.onEvent({ type: "dispatch-start", taskName: "story_flow", storyKey: `__epic_${epicId}__` });
+  }
+  const epicInput = {
+    epicId,
+    epicItems,
+    config,
+    storyFlowTasks,
+    currentStoryIndex: 0,
+    workflowState: state,
+    errors: [],
+    tasksCompleted: 0,
+    storiesProcessed: /* @__PURE__ */ new Set(),
+    lastContract,
+    accumulatedCostUsd,
+    halted: false,
+    currentStepIndex: 0
+  };
+  const epicResult = await new Promise((resolve7) => {
+    const actor = createActor(epicMachine, { input: epicInput });
+    actor.subscribe({ complete: () => resolve7(actor.getSnapshot().context) });
+    actor.start();
+  });
+  state = epicResult.workflowState;
+  errors.push(...epicResult.errors);
+  tasksCompleted += epicResult.tasksCompleted;
+  for (const key of epicResult.storiesProcessed) storiesProcessed.add(key);
+  lastContract = epicResult.lastContract;
+  accumulatedCostUsd = epicResult.accumulatedCostUsd;
+  halted = epicResult.halted;
+  return { ...input, workflowState: state, errors, tasksCompleted, storiesProcessed, lastContract, accumulatedCostUsd, halted, currentEpicIndex: currentEpicIndex + 1 };
+});
+var runMachine = setup({
+  types: {},
+  actors: { runEpicActor },
+  guards: {
+    allEpicsDone: ({ context }) => context.halted || context.currentEpicIndex >= context.epicEntries.length
+  }
+}).createMachine({
+  id: "run",
+  context: ({ input }) => input,
+  initial: "processingEpic",
+  states: {
+    processingEpic: {
+      invoke: {
+        src: "runEpicActor",
+        input: ({ context }) => context,
+        onDone: {
+          target: "checkNext",
+          actions: assign(({ event }) => event.output)
+        },
+        onError: {
+          target: "allDone",
+          actions: assign(({ context, event }) => {
+            const msg = event.error instanceof Error ? event.error.message : String(event.error);
+            return { ...context, errors: [...context.errors, { taskName: "__run_actor__", storyKey: "__run__", code: "ACTOR_ERROR", message: msg }], halted: true };
+          })
+        }
+      }
+    },
+    checkNext: {
+      always: [
+        { guard: "allEpicsDone", target: "allDone" },
+        { target: "processingEpic" }
+      ]
+    },
+    allDone: { type: "final" }
+  }
+});
+async function runWorkflowActor(config) {
+  const startMs = Date.now();
+  const projectDir = config.projectDir ?? process.cwd();
   let state = readWorkflowState(projectDir);
   if (state.phase === "completed") {
-    return {
-      success: true,
-      tasksCompleted: 0,
-      storiesProcessed: 0,
-      errors: [],
-      durationMs: 0
-    };
+    return { success: true, tasksCompleted: 0, storiesProcessed: 0, errors: [], durationMs: 0 };
   }
   if (state.phase === "error" || state.phase === "failed") {
     const errorCount = state.tasks_completed.filter((t) => t.error).length;
-    if (!config.onEvent) info(`Resuming from ${state.phase} state \u2014 ${errorCount} previous error(s), retrying failed tasks`);
+    if (!config.onEvent) info(`Resuming from ${state.phase} state \u2014 ${errorCount} previous error(s)`);
   }
-  state = {
-    ...state,
-    phase: "executing",
-    started: state.started || (/* @__PURE__ */ new Date()).toISOString(),
-    workflow_name: config.workflow.storyFlow.filter((s) => typeof s === "string").join(" -> ")
-  };
+  state = { ...state, phase: "executing", started: state.started || (/* @__PURE__ */ new Date()).toISOString(), workflow_name: config.workflow.storyFlow.filter((s) => typeof s === "string").join(" -> ") };
   writeWorkflowState(state, projectDir);
   try {
     await checkDriverHealth(config.workflow);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     state = { ...state, phase: "failed" };
-    const engineError = {
-      taskName: "__health_check__",
-      storyKey: "__health_check__",
-      code: "HEALTH_CHECK",
-      message
-    };
-    errors.push(engineError);
+    const errors2 = [{ taskName: "__health_check__", storyKey: "__health_check__", code: "HEALTH_CHECK", message }];
     writeWorkflowState(state, projectDir);
-    return {
-      success: false,
-      tasksCompleted: 0,
-      storiesProcessed: 0,
-      errors,
-      durationMs: Date.now() - startMs
-    };
+    return { success: false, tasksCompleted: 0, storiesProcessed: 0, errors: errors2, durationMs: Date.now() - startMs };
   }
   const capWarnings = checkCapabilityConflicts(config.workflow);
-  for (const cw of capWarnings) {
-    warn(cw.message);
-  }
+  for (const cw of capWarnings) warn(cw.message);
   const workItems = loadWorkItems(config.sprintStatusPath, config.issuesPath);
   const storyFlowTasks = /* @__PURE__ */ new Set();
   for (const step of config.workflow.storyFlow) {
     if (typeof step === "string") storyFlowTasks.add(step);
     if (typeof step === "object" && "loop" in step) {
-      for (const loopTask of step.loop) {
-        storyFlowTasks.add(loopTask);
-      }
+      for (const lt of step.loop) storyFlowTasks.add(lt);
     }
   }
   const epicGroups = /* @__PURE__ */ new Map();
@@ -3983,196 +4133,28 @@ async function executeWorkflow(config) {
     if (!epicGroups.has(epicId)) epicGroups.set(epicId, []);
     epicGroups.get(epicId).push(item);
   }
-  let halted = false;
-  let lastOutputContract = null;
-  let accumulatedCostUsd = 0;
-  for (const [epicId, epicItems] of epicGroups) {
-    if (halted) break;
-    if (config.abortSignal?.aborted) {
-      if (!config.onEvent) info("Execution interrupted \u2014 saving state");
-      state = { ...state, phase: "interrupted" };
-      writeWorkflowState(state, projectDir);
-      halted = true;
-      break;
-    }
-    if (config.onEvent) {
-      config.onEvent({ type: "dispatch-start", taskName: "story_flow", storyKey: `__epic_${epicId}__` });
-    } else {
-      info(`[epic-${epicId}] Starting epic with ${epicItems.length} stories`);
-    }
-    for (const step of config.workflow.epicFlow) {
-      if (halted) break;
-      if (config.abortSignal?.aborted) {
-        state = { ...state, phase: "interrupted" };
-        writeWorkflowState(state, projectDir);
-        halted = true;
-        break;
-      }
-      if (step === "story_flow") {
-        for (const item of epicItems) {
-          if (halted || config.abortSignal?.aborted) {
-            if (config.abortSignal?.aborted) {
-              state = { ...state, phase: "interrupted" };
-              writeWorkflowState(state, projectDir);
-            }
-            halted = true;
-            break;
-          }
-          processedStories.add(item.key);
-          for (const storyStep of config.workflow.storyFlow) {
-            if (halted || config.abortSignal?.aborted) {
-              halted = true;
-              break;
-            }
-            if (isLoopBlock(storyStep)) {
-              const loopResult = await executeLoopBlock(
-                storyStep,
-                state,
-                config,
-                [item],
-                lastOutputContract,
-                storyFlowTasks
-              );
-              state = loopResult.state;
-              errors.push(...loopResult.errors);
-              tasksCompleted += loopResult.tasksCompleted;
-              lastOutputContract = loopResult.lastContract;
-              if (loopResult.halted || state.phase === "max-iterations" || state.phase === "circuit-breaker") {
-                halted = true;
-                break;
-              }
-              continue;
-            }
-            if (typeof storyStep !== "string") continue;
-            const taskName2 = storyStep;
-            const task2 = config.workflow.tasks[taskName2];
-            if (!task2) {
-              warn(`workflow-engine: task "${taskName2}" not found, skipping`);
-              continue;
-            }
-            if (task2.agent === null) continue;
-            const definition2 = config.agents[task2.agent];
-            if (!definition2) {
-              warn(`workflow-engine: agent "${task2.agent}" not found for "${taskName2}"`);
-              continue;
-            }
-            if (isTaskCompleted(state, taskName2, item.key)) continue;
-            try {
-              const dr = await dispatchTaskWithResult(task2, taskName2, item.key, definition2, state, config, void 0, lastOutputContract ?? void 0);
-              state = dr.updatedState;
-              lastOutputContract = dr.contract;
-              propagateVerifyFlags(taskName2, dr.contract, projectDir);
-              accumulatedCostUsd += dr.contract?.cost_usd ?? 0;
-              tasksCompleted++;
-            } catch (err) {
-              const engineError = handleDispatchError(err, taskName2, item.key);
-              errors.push(engineError);
-              if (config.onEvent) {
-                config.onEvent({ type: "dispatch-error", taskName: taskName2, storyKey: item.key, error: { code: engineError.code, message: engineError.message } });
-              } else {
-                warn(`[${taskName2}] ${item.key} \u2014 ERROR: [${engineError.code}] ${engineError.message}`);
-              }
-              state = recordErrorInState(state, taskName2, item.key, engineError);
-              writeWorkflowState(state, projectDir);
-              if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) {
-                halted = true;
-              }
-              break;
-            }
-          }
-        }
-        continue;
-      }
-      if (isLoopBlock(step)) {
-        const loopResult = await executeLoopBlock(step, state, config, epicItems, lastOutputContract, storyFlowTasks);
-        state = loopResult.state;
-        errors.push(...loopResult.errors);
-        tasksCompleted += loopResult.tasksCompleted;
-        lastOutputContract = loopResult.lastContract;
-        for (const item of epicItems) processedStories.add(item.key);
-        if (loopResult.halted || state.phase === "max-iterations" || state.phase === "circuit-breaker") {
-          halted = true;
-        }
-        continue;
-      }
-      const taskName = step;
-      const task = config.workflow.tasks[taskName];
-      if (!task) {
-        warn(`workflow-engine: task "${taskName}" not found, skipping`);
-        continue;
-      }
-      if (task.agent === null) continue;
-      const definition = config.agents[task.agent];
-      if (!definition) {
-        warn(`workflow-engine: agent "${task.agent}" not found for "${taskName}"`);
-        continue;
-      }
-      const epicSentinel = `__epic_${epicId}__`;
-      if (isTaskCompleted(state, taskName, epicSentinel)) continue;
-      let guideFiles = [];
-      if (task.source_access === false) {
-        const guidesDir = join12(projectDir, ".codeharness", "verify-guides");
-        try {
-          mkdirSync6(guidesDir, { recursive: true });
-          for (const item of epicItems) {
-            const contractPath = join12(projectDir, ".codeharness", "contracts", `document-${item.key}.json`);
-            if (existsSync15(contractPath)) {
-              const contractData = JSON.parse(readFileSync13(contractPath, "utf-8"));
-              const docs = contractData.output ? extractTag(contractData.output, "user-docs") ?? contractData.output : null;
-              if (docs) {
-                const guidePath = join12(guidesDir, `${item.key}-guide.md`);
-                writeFileSync8(guidePath, docs, "utf-8");
-                guideFiles.push(guidePath);
-              }
-            }
-          }
-          const deployContractPath = join12(projectDir, ".codeharness", "contracts", `deploy-${epicSentinel}.json`);
-          if (existsSync15(deployContractPath)) {
-            const deployData = JSON.parse(readFileSync13(deployContractPath, "utf-8"));
-            const report = deployData.output ? extractTag(deployData.output, "deploy-report") ?? deployData.output : null;
-            if (report) {
-              const deployPath = join12(guidesDir, "deploy-info.md");
-              writeFileSync8(deployPath, report, "utf-8");
-              guideFiles.push(deployPath);
-            }
-          }
-        } catch {
-        }
-      }
-      try {
-        const dr = await dispatchTaskWithResult(task, taskName, epicSentinel, definition, state, config, void 0, lastOutputContract ?? void 0, guideFiles);
-        state = dr.updatedState;
-        lastOutputContract = dr.contract;
-        propagateVerifyFlags(taskName, dr.contract, projectDir);
-        accumulatedCostUsd += dr.contract?.cost_usd ?? 0;
-        tasksCompleted++;
-      } catch (err) {
-        const engineError = handleDispatchError(err, taskName, epicSentinel);
-        errors.push(engineError);
-        if (config.onEvent) {
-          config.onEvent({ type: "dispatch-error", taskName, storyKey: epicSentinel, error: { code: engineError.code, message: engineError.message } });
-        } else {
-          warn(`[${taskName}] epic-${epicId} \u2014 ERROR: [${engineError.code}] ${engineError.message}`);
-        }
-        state = recordErrorInState(state, taskName, epicSentinel, engineError);
-        writeWorkflowState(state, projectDir);
-        if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) {
-          halted = true;
-        }
-      } finally {
-        if (guideFiles.length > 0) {
-          const guidesDir = join12(projectDir, ".codeharness", "verify-guides");
-          try {
-            rmSync2(guidesDir, { recursive: true, force: true });
-          } catch {
-          }
-        }
-      }
-    }
-    if (!halted) {
-      if (!config.onEvent) info(`[epic-${epicId}] Epic completed`);
-    }
-  }
+  const runInput = {
+    config,
+    storyFlowTasks,
+    epicEntries: [...epicGroups.entries()],
+    currentEpicIndex: 0,
+    workflowState: state,
+    errors: [],
+    tasksCompleted: 0,
+    storiesProcessed: /* @__PURE__ */ new Set(),
+    lastContract: null,
+    accumulatedCostUsd: 0,
+    halted: false
+  };
+  const finalContext = await new Promise((resolve7) => {
+    const actor = createActor(runMachine, { input: runInput });
+    actor.subscribe({ complete: () => resolve7(actor.getSnapshot().context) });
+    actor.start();
+  });
+  state = finalContext.workflowState;
+  const errors = finalContext.errors;
+  const tasksCompleted = finalContext.tasksCompleted;
+  const storiesProcessed = finalContext.storiesProcessed;
   if (state.phase === "interrupted") {
   } else if (errors.length === 0 && state.phase !== "max-iterations" && state.phase !== "circuit-breaker") {
     state = { ...state, phase: "completed" };
@@ -4182,7 +4164,7 @@ async function executeWorkflow(config) {
   return {
     success: errors.length === 0 && !loopTerminated && state.phase !== "interrupted",
     tasksCompleted,
-    storiesProcessed: processedStories.size,
+    storiesProcessed: storiesProcessed.size,
     errors,
     durationMs: Date.now() - startMs
   };
@@ -4196,11 +4178,7 @@ function recordErrorInState(state, taskName, storyKey, error) {
     error_message: error.message,
     error_code: error.code
   };
-  return {
-    ...state,
-    phase: "error",
-    tasks_completed: [...state.tasks_completed, errorCheckpoint]
-  };
+  return { ...state, phase: "error", tasks_completed: [...state.tasks_completed, errorCheckpoint] };
 }
 function isEngineError(err) {
   if (!err || typeof err !== "object") return false;
@@ -4208,21 +4186,9 @@ function isEngineError(err) {
   return typeof e.taskName === "string" && typeof e.storyKey === "string" && typeof e.code === "string" && typeof e.message === "string";
 }
 function handleDispatchError(err, taskName, storyKey) {
-  if (err instanceof DispatchError) {
-    return {
-      taskName,
-      storyKey,
-      code: err.code,
-      message: err.message
-    };
-  }
+  if (err instanceof DispatchError) return { taskName, storyKey, code: err.code, message: err.message };
   const message = err instanceof Error ? err.message : String(err);
-  return {
-    taskName,
-    storyKey,
-    code: "UNKNOWN",
-    message
-  };
+  return { taskName, storyKey, code: "UNKNOWN", message };
 }
 
 // src/lib/worktree-manager.ts
@@ -6417,16 +6383,6 @@ function registerRunCommand(program) {
             key: event.storyKey.replace("__epic_", "Epic ").replace("__", ""),
             message: `verification complete (cost: $${(event.costUsd ?? 0).toFixed(2)})`
           });
-          const epicId = event.storyKey.replace("__epic_", "").replace("__", "");
-          for (let i = 0; i < storyEntries.length; i++) {
-            const se = storyEntries[i];
-            if (se.status === "in-progress" && se.key.startsWith(`${epicId}-`)) {
-              storiesDone++;
-              updateStoryStatus2(se.key, "done");
-              storyEntries[i] = { ...se, status: "done" };
-            }
-          }
-          renderer.updateStories([...storyEntries]);
         }
       }
       if (event.type === "dispatch-error") {
@@ -6447,6 +6403,19 @@ function registerRunCommand(program) {
           renderer.updateStories([...storyEntries]);
         }
       }
+      if (event.type === "story-done") {
+        storiesDone++;
+        updateStoryStatus2(event.storyKey, "done");
+        const idx = storyEntries.findIndex((s) => s.key === event.storyKey);
+        if (idx >= 0) {
+          storyEntries[idx] = { ...storyEntries[idx], status: "done" };
+          renderer.updateStories([...storyEntries]);
+        }
+        const epicId = extractEpicId2(event.storyKey);
+        if (epicData[epicId]) {
+          epicData[epicId].storiesDone = (epicData[epicId].storiesDone ?? 0) + 1;
+        }
+      }
     };
     const config = {
       workflow: parsedWorkflow,
@@ -6498,7 +6467,7 @@ function registerRunCommand(program) {
             ...config,
             projectDir: worktreePath
           };
-          return executeWorkflow(epicConfig);
+          return runWorkflowActor(epicConfig);
         };
         const poolResult = await pool.startPool(epics, executeFn);
         const remainingWorktrees = worktreeManager.listWorktrees();
@@ -6534,7 +6503,7 @@ function registerRunCommand(program) {
       }
     } else {
       try {
-        const result = await executeWorkflow(config);
+        const result = await runWorkflowActor(config);
         clearInterval(headerRefresh);
         process.removeListener("SIGINT", onInterrupt);
         process.removeListener("SIGTERM", onInterrupt);
@@ -11227,7 +11196,7 @@ function registerTeardownCommand(program) {
     } else if (otlpMode === "remote-routed") {
       if (!options.keepDocker) {
         try {
-          const { stopCollectorOnly: stopCollectorOnly2 } = await import("./docker-MXONF2RK.js");
+          const { stopCollectorOnly: stopCollectorOnly2 } = await import("./docker-SV6TB753.js");
           stopCollectorOnly2();
           result.docker.stopped = true;
           if (!isJson) {
@@ -11259,7 +11228,7 @@ function registerTeardownCommand(program) {
         info("Shared stack: kept running (other projects may use it)");
       }
     } else if (isLegacyStack) {
-      const { isStackRunning: isStackRunning2, stopStack } = await import("./docker-MXONF2RK.js");
+      const { isStackRunning: isStackRunning2, stopStack } = await import("./docker-SV6TB753.js");
       let stackRunning = false;
       try {
         stackRunning = isStackRunning2(composeFile);
@@ -14246,7 +14215,7 @@ function registerDriversCommand(program) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.35.7" : "0.0.0-dev";
+var VERSION = true ? "0.36.2" : "0.0.0-dev";
 function createProgram() {
   const program = new Command();
   program.name("codeharness").description("Makes autonomous coding agents produce software that actually works").version(VERSION).option("--json", "Output in machine-readable JSON format");