codeharness 0.35.7 → 0.36.3

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   validateDockerfile,
   warn,
   writeState
-} from "./chunk-WNIM6AUG.js";
+} from "./chunk-2FHBRGG7.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -149,7 +149,7 @@ function registerBridgeCommand(program) {
 
 // src/commands/run.ts
 import { existsSync as existsSync17 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/modules/sprint/state.ts
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync, existsSync as existsSync5, unlinkSync } from "fs";
@@ -2506,10 +2506,10 @@ function resolveWorkflow(options) {
   return validateAndResolve(merged);
 }
 
-// src/lib/workflow-engine.ts
+// src/lib/workflow-machine.ts
+import { setup, assign, fromPromise as fromPromise2, 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";
+import { join as join13 } from "path";
 
 // src/lib/agent-dispatch.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
@@ -2550,24 +2550,213 @@ function checkCapabilityConflicts(workflow) {
   return warnings;
 }
 
-// src/lib/agents/model-resolver.ts
-function resolveModel(task, agent, driver) {
-  const taskModel = task.model?.trim() || void 0;
-  const agentModel = agent.model?.trim() || void 0;
-  if (taskModel) {
-    return taskModel;
+// src/lib/verdict-parser.ts
+import Ajv2 from "ajv";
+
+// src/schemas/verdict.schema.json
+var verdict_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://codeharness.dev/schemas/verdict.schema.json",
+  title: "EvaluatorVerdict",
+  description: "Schema for evaluator verdict output (AD5)",
+  type: "object",
+  required: ["verdict", "score", "findings"],
+  additionalProperties: true,
+  properties: {
+    verdict: {
+      type: "string",
+      enum: ["pass", "fail"]
+    },
+    score: {
+      type: "object",
+      required: ["passed", "failed", "unknown", "total"],
+      additionalProperties: true,
+      properties: {
+        passed: {
+          type: "integer",
+          minimum: 0
+        },
+        failed: {
+          type: "integer",
+          minimum: 0
+        },
+        unknown: {
+          type: "integer",
+          minimum: 0
+        },
+        total: {
+          type: "integer",
+          minimum: 0
+        }
+      }
+    },
+    findings: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["ac", "description", "status", "evidence"],
+        additionalProperties: true,
+        properties: {
+          ac: {
+            type: "integer"
+          },
+          description: {
+            type: "string"
+          },
+          status: {
+            type: "string",
+            enum: ["pass", "fail", "unknown"]
+          },
+          evidence: {
+            type: "object",
+            required: ["commands_run", "output_observed", "reasoning"],
+            additionalProperties: true,
+            properties: {
+              commands_run: {
+                type: "array",
+                items: {
+                  type: "string"
+                }
+              },
+              output_observed: {
+                type: "string"
+              },
+              reasoning: {
+                type: "string"
+              }
+            }
+          }
+        }
+      }
+    },
+    evaluator_trace_id: {
+      type: "string"
+    },
+    duration_seconds: {
+      type: "number"
+    }
   }
-  if (agentModel) {
-    return agentModel;
+};
+
+// src/lib/verdict-parser.ts
+var VerdictParseError = class _VerdictParseError extends Error {
+  retryable;
+  rawOutput;
+  validationErrors;
+  constructor(message, retryable, rawOutput, validationErrors) {
+    super(message);
+    Object.setPrototypeOf(this, _VerdictParseError.prototype);
+    this.name = "VerdictParseError";
+    this.retryable = retryable;
+    this.rawOutput = rawOutput;
+    this.validationErrors = validationErrors;
   }
-  if (!driver.defaultModel?.trim()) {
-    throw new Error(
-      "Driver has no default model: driver.defaultModel must be a non-empty string"
+};
+var ajv2 = new Ajv2({ allErrors: true });
+var validateSchema = ajv2.compile(verdict_schema_default);
+function validateVerdict(data) {
+  const valid = validateSchema(data);
+  if (valid) {
+    const verdict = JSON.parse(JSON.stringify(data));
+    return { valid: true, verdict };
+  }
+  const errors = (validateSchema.errors ?? []).map((err) => {
+    const path = err.instancePath || "/";
+    return `${path}: ${err.message ?? "unknown error"}`;
+  });
+  return { valid: false, errors };
+}
+function parseVerdict(output) {
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    throw new VerdictParseError(
+      "Failed to parse verdict: invalid JSON",
+      true,
+      output
     );
   }
-  return driver.defaultModel;
+  const result = validateVerdict(parsed);
+  if (!result.valid) {
+    throw new VerdictParseError(
+      `Failed to parse verdict: schema validation failed`,
+      true,
+      output,
+      result.errors
+    );
+  }
+  const verdict = result.verdict;
+  let passDowngraded = false;
+  for (const finding of verdict.findings) {
+    if (finding.status === "pass" && (!finding.evidence.commands_run || finding.evidence.commands_run.length === 0)) {
+      finding.status = "unknown";
+      finding.evidence.reasoning += " [Downgraded from PASS: no commands_run evidence provided]";
+      passDowngraded = true;
+    }
+  }
+  if (passDowngraded) {
+    let passed = 0;
+    let failed = 0;
+    let unknown = 0;
+    for (const finding of verdict.findings) {
+      if (finding.status === "pass") passed++;
+      else if (finding.status === "fail") failed++;
+      else unknown++;
+    }
+    verdict.score = {
+      passed,
+      failed,
+      unknown,
+      total: verdict.findings.length
+    };
+    if (passed === 0) {
+      verdict.verdict = "fail";
+    }
+  }
+  return verdict;
+}
+function parseVerdictTag(output) {
+  const match = /<verdict>(pass|fail)<\/verdict>/i.exec(output);
+  if (!match) return null;
+  const verdict = match[1].toLowerCase();
+  const issuesMatch = /<issues>([\s\S]*?)<\/issues>/i.exec(output);
+  return {
+    verdict,
+    ...issuesMatch ? { issues: issuesMatch[1].trim() } : {}
+  };
+}
+function extractTag(output, tag) {
+  const pattern = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, "i");
+  const match = pattern.exec(output);
+  return match ? match[1].trim() : null;
+}
+
+// src/lib/circuit-breaker.ts
+function evaluateProgress(scores) {
+  if (scores.length < 2) {
+    return { halt: false };
+  }
+  const scoreHistory = scores.map((s) => s.passed);
+  const latest = scoreHistory[scoreHistory.length - 1];
+  const previous = scoreHistory[scoreHistory.length - 2];
+  if (latest > previous) {
+    return { halt: false };
+  }
+  const latestScore = scores[scores.length - 1];
+  const failCount = latestScore.total - latestScore.passed;
+  const remainingFailures = Array.from({ length: failCount }, (_, i) => i + 1);
+  return {
+    halt: true,
+    reason: "score-stagnation",
+    remainingFailures,
+    scoreHistory
+  };
 }
 
+// src/lib/workflow-machine.ts
+import { parse as parse5 } from "yaml";
+
 // 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";
@@ -2668,6 +2857,28 @@ function isValidWorkflowState(value) {
   return true;
 }
 
+// src/lib/workflow-actors.ts
+import { fromPromise } from "xstate";
+import { join as join12 } from "path";
+
+// src/lib/agents/model-resolver.ts
+function resolveModel(task, agent, driver) {
+  const taskModel = task.model?.trim() || void 0;
+  const agentModel = agent.model?.trim() || void 0;
+  if (taskModel) {
+    return taskModel;
+  }
+  if (agentModel) {
+    return agentModel;
+  }
+  if (!driver.defaultModel?.trim()) {
+    throw new Error(
+      "Driver has no default model: driver.defaultModel must be a non-empty string"
+    );
+  }
+  return driver.defaultModel;
+}
+
 // 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";
@@ -2901,210 +3112,6 @@ function getLastSessionId(state, taskName, storyKey) {
   return void 0;
 }
 
-// src/lib/verdict-parser.ts
-import Ajv2 from "ajv";
-
-// src/schemas/verdict.schema.json
-var verdict_schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://codeharness.dev/schemas/verdict.schema.json",
-  title: "EvaluatorVerdict",
-  description: "Schema for evaluator verdict output (AD5)",
-  type: "object",
-  required: ["verdict", "score", "findings"],
-  additionalProperties: true,
-  properties: {
-    verdict: {
-      type: "string",
-      enum: ["pass", "fail"]
-    },
-    score: {
-      type: "object",
-      required: ["passed", "failed", "unknown", "total"],
-      additionalProperties: true,
-      properties: {
-        passed: {
-          type: "integer",
-          minimum: 0
-        },
-        failed: {
-          type: "integer",
-          minimum: 0
-        },
-        unknown: {
-          type: "integer",
-          minimum: 0
-        },
-        total: {
-          type: "integer",
-          minimum: 0
-        }
-      }
-    },
-    findings: {
-      type: "array",
-      items: {
-        type: "object",
-        required: ["ac", "description", "status", "evidence"],
-        additionalProperties: true,
-        properties: {
-          ac: {
-            type: "integer"
-          },
-          description: {
-            type: "string"
-          },
-          status: {
-            type: "string",
-            enum: ["pass", "fail", "unknown"]
-          },
-          evidence: {
-            type: "object",
-            required: ["commands_run", "output_observed", "reasoning"],
-            additionalProperties: true,
-            properties: {
-              commands_run: {
-                type: "array",
-                items: {
-                  type: "string"
-                }
-              },
-              output_observed: {
-                type: "string"
-              },
-              reasoning: {
-                type: "string"
-              }
-            }
-          }
-        }
-      }
-    },
-    evaluator_trace_id: {
-      type: "string"
-    },
-    duration_seconds: {
-      type: "number"
-    }
-  }
-};
-
-// src/lib/verdict-parser.ts
-var VerdictParseError = class _VerdictParseError extends Error {
-  retryable;
-  rawOutput;
-  validationErrors;
-  constructor(message, retryable, rawOutput, validationErrors) {
-    super(message);
-    Object.setPrototypeOf(this, _VerdictParseError.prototype);
-    this.name = "VerdictParseError";
-    this.retryable = retryable;
-    this.rawOutput = rawOutput;
-    this.validationErrors = validationErrors;
-  }
-};
-var ajv2 = new Ajv2({ allErrors: true });
-var validateSchema = ajv2.compile(verdict_schema_default);
-function validateVerdict(data) {
-  const valid = validateSchema(data);
-  if (valid) {
-    const verdict = JSON.parse(JSON.stringify(data));
-    return { valid: true, verdict };
-  }
-  const errors = (validateSchema.errors ?? []).map((err) => {
-    const path = err.instancePath || "/";
-    return `${path}: ${err.message ?? "unknown error"}`;
-  });
-  return { valid: false, errors };
-}
-function parseVerdict(output) {
-  let parsed;
-  try {
-    parsed = JSON.parse(output);
-  } catch {
-    throw new VerdictParseError(
-      "Failed to parse verdict: invalid JSON",
-      true,
-      output
-    );
-  }
-  const result = validateVerdict(parsed);
-  if (!result.valid) {
-    throw new VerdictParseError(
-      `Failed to parse verdict: schema validation failed`,
-      true,
-      output,
-      result.errors
-    );
-  }
-  const verdict = result.verdict;
-  let passDowngraded = false;
-  for (const finding of verdict.findings) {
-    if (finding.status === "pass" && (!finding.evidence.commands_run || finding.evidence.commands_run.length === 0)) {
-      finding.status = "unknown";
-      finding.evidence.reasoning += " [Downgraded from PASS: no commands_run evidence provided]";
-      passDowngraded = true;
-    }
-  }
-  if (passDowngraded) {
-    let passed = 0;
-    let failed = 0;
-    let unknown = 0;
-    for (const finding of verdict.findings) {
-      if (finding.status === "pass") passed++;
-      else if (finding.status === "fail") failed++;
-      else unknown++;
-    }
-    verdict.score = {
-      passed,
-      failed,
-      unknown,
-      total: verdict.findings.length
-    };
-    if (passed === 0) {
-      verdict.verdict = "fail";
-    }
-  }
-  return verdict;
-}
-function parseVerdictTag(output) {
-  const match = /<verdict>(pass|fail)<\/verdict>/i.exec(output);
-  if (!match) return null;
-  const verdict = match[1].toLowerCase();
-  const issuesMatch = /<issues>([\s\S]*?)<\/issues>/i.exec(output);
-  return {
-    verdict,
-    ...issuesMatch ? { issues: issuesMatch[1].trim() } : {}
-  };
-}
-function extractTag(output, tag) {
-  const pattern = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, "i");
-  const match = pattern.exec(output);
-  return match ? match[1].trim() : null;
-}
-
-// src/lib/circuit-breaker.ts
-function evaluateProgress(scores) {
-  if (scores.length < 2) {
-    return { halt: false };
-  }
-  const scoreHistory = scores.map((s) => s.passed);
-  const latest = scoreHistory[scoreHistory.length - 1];
-  const previous = scoreHistory[scoreHistory.length - 2];
-  if (latest > previous) {
-    return { halt: false };
-  }
-  const latestScore = scores[scores.length - 1];
-  const failCount = latestScore.total - latestScore.passed;
-  const remainingFailures = Array.from({ length: failCount }, (_, i) => i + 1);
-  return {
-    halt: true,
-    reason: "score-stagnation",
-    remainingFailures,
-    scoreHistory
-  };
-}
-
 // src/lib/telemetry-writer.ts
 import { appendFileSync, existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync12 } from "fs";
 import { join as join11 } from "path";
@@ -3164,10 +3171,27 @@ 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__";
-var HALT_ERROR_CODES = /* @__PURE__ */ new Set(["RATE_LIMIT", "NETWORK", "SDK_INIT"]);
-var DEFAULT_MAX_ITERATIONS = 5;
+// src/lib/workflow-actors.ts
+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}. Run ONLY these commands: 1) \`npx vitest run\` (unit tests), 2) \`npm run lint\` (linter). Do NOT run \`npm test\` (BATS integration tests) \u2014 those require the installed CLI binary and Docker, which are not available in the sandbox. If vitest and lint both pass, include <verdict>pass</verdict>. If either fails, include <verdict>fail</verdict> with the actual error output. Only report failures from YOUR test run, not from previous sessions.`,
+  "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.`
+};
+var FILE_WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "Write",
+  "Edit",
+  "write_to_file",
+  "edit_file",
+  "write",
+  "edit",
+  "WriteFile",
+  "EditFile"
+]);
 function buildCoverageDeduplicationContext(contract, projectDir) {
   if (!contract?.testResults) return null;
   const { coverage } = contract.testResults;
@@ -3181,170 +3205,36 @@ function buildCoverageDeduplicationContext(contract, projectDir) {
     return null;
   }
 }
-function propagateVerifyFlags(taskName, contract, projectDir) {
-  if (taskName !== "implement") return;
-  if (!contract?.testResults) return;
-  const { failed, coverage } = contract.testResults;
-  try {
-    const { state, body } = readStateWithBody(projectDir);
-    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}`);
-  }
-}
-function isTaskCompleted(state, taskName, storyKey) {
-  return state.tasks_completed.some(
-    (cp) => cp.task_name === taskName && cp.story_key === storyKey && !cp.error
-  );
-}
-function isLoopTaskCompleted(state, taskName, storyKey, iteration) {
-  const count = state.tasks_completed.filter(
-    (cp) => cp.task_name === taskName && cp.story_key === storyKey && !cp.error
-  ).length;
-  return count >= iteration;
-}
-function loadWorkItems(sprintStatusPath, issuesPath2) {
-  const items = [];
-  if (existsSync15(sprintStatusPath)) {
-    let raw;
-    try {
-      raw = readFileSync13(sprintStatusPath, "utf-8");
-    } catch {
-      warn(`workflow-engine: 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}`);
-      return items;
-    }
-    if (parsed && typeof parsed === "object") {
-      const data = parsed;
-      const devStatus = data.development_status;
-      if (devStatus && typeof devStatus === "object") {
-        for (const [key, status] of Object.entries(devStatus)) {
-          if (key.startsWith("epic-")) continue;
-          if (key.endsWith("-retrospective")) continue;
-          if (status === "backlog" || status === "ready-for-dev" || status === "in-progress") {
-            items.push({ key, source: "sprint" });
-          }
-        }
-      }
-    }
-  }
-  if (issuesPath2 && existsSync15(issuesPath2)) {
-    let raw;
-    try {
-      raw = readFileSync13(issuesPath2, "utf-8");
-    } catch {
-      warn(`workflow-engine: 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}`);
-      return items;
-    }
-    if (parsed && typeof parsed === "object") {
-      const data = parsed;
-      const issuesList = data.issues;
-      if (Array.isArray(issuesList)) {
-        for (const issue of issuesList) {
-          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"
-              });
-            }
-          }
-        }
-      }
-    }
-  }
-  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;
-}
-async function executeNullTask(task, taskName, storyKey, state, config, previousOutputContract, accumulatedCostUsd) {
+async function nullTaskCore(input) {
+  const { task: _task, taskName, storyKey, config, workflowState, previousContract, accumulatedCostUsd } = input;
   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;
+    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 = state.started ? new Date(state.started).getTime() : startMs;
+  const workflowStartMs = workflowState.started ? new Date(workflowState.started).getTime() : startMs;
   const ctx = {
     storyKey,
     taskName,
-    cost: accumulatedCostUsd ?? 0,
+    cost: accumulatedCostUsd,
     durationMs: startMs - workflowStartMs,
-    outputContract: previousOutputContract ?? null,
+    outputContract: previousContract,
     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;
+  } catch (err) {
+    throw { taskName, storyKey, code: "NULL_TASK_HANDLER_ERROR", message: `Null task handler "${taskName}" threw: ${err instanceof Error ? err.message : String(err)}` };
   }
-  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;
+    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()
-  };
-  let updatedState = {
-    ...state,
-    tasks_completed: [...state.tasks_completed, checkpoint]
-  };
+  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,
@@ -3360,18 +3250,34 @@ async function executeNullTask(task, taskName, storyKey, state, config, previous
     acceptanceCriteria: []
   };
   writeWorkflowState(updatedState, projectDir);
-  return { updatedState, output: result.output ?? "", contract };
+  return { output: result.output ?? "", cost: 0, changedFiles: [], sessionId: "", contract, updatedState };
+}
+function propagateVerifyFlags(taskName, contract, projectDir) {
+  if (taskName !== "implement") return;
+  if (!contract?.testResults) return;
+  const { failed, coverage } = contract.testResults;
+  try {
+    const { state, body } = readStateWithBody(projectDir);
+    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-actors: flag propagation failed for ${taskName}: ${msg}`);
+  }
 }
-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 } = 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 +3290,19 @@ 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.`
-  };
   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 +3310,10 @@ ${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 } : {}
   };
   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 +3324,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 +3346,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,26 +3367,14 @@ ${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 {
-    const checkpoint = {
-      task_name: taskName,
-      story_key: storyKey,
-      completed_at: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    updatedState = {
-      ...updatedState,
-      tasks_completed: [...updatedState.tasks_completed, checkpoint]
-    };
+    const checkpoint = { task_name: taskName, story_key: storyKey, completed_at: (/* @__PURE__ */ new Date()).toISOString() };
+    updatedState = { ...updatedState, tasks_completed: [...updatedState.tasks_completed, checkpoint] };
   }
   updatedState = recordTraceId(traceId, updatedState);
   const durationMs = Date.now() - startMs;
@@ -3541,32 +3396,109 @@ ${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-actors: failed to write output contract for ${taskName}/${storyKey}: ${msg}`);
     contract = null;
   }
   writeWorkflowState(updatedState, projectDir);
-  return { updatedState, output, contract };
+  propagateVerifyFlags(taskName, contract, projectDir);
+  return { output, cost, changedFiles, sessionId: resultSessionId, contract, updatedState };
 }
-function buildRetryPrompt(storyKey, findings) {
-  const failedFindings = findings.filter(
-    (f) => f.status === "fail" || f.status === "unknown"
+var dispatchActor = fromPromise(async ({ input }) => dispatchTaskCore(input));
+var nullTaskDispatchActor = fromPromise(async ({ input }) => {
+  return nullTaskCore(input);
+});
+
+// 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;
+function isTaskCompleted(state, taskName, storyKey) {
+  return state.tasks_completed.some(
+    (cp) => cp.task_name === taskName && cp.story_key === storyKey && !cp.error
   );
-  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}`;
+}
+function isLoopTaskCompleted(state, taskName, storyKey, iteration) {
+  const count = state.tasks_completed.filter(
+    (cp) => cp.task_name === taskName && cp.story_key === storyKey && !cp.error
+  ).length;
+  return count >= iteration;
+}
+function loadWorkItems(sprintStatusPath, issuesPath2) {
+  const items = [];
+  if (existsSync15(sprintStatusPath)) {
+    let raw;
+    try {
+      raw = readFileSync13(sprintStatusPath, "utf-8");
+    } catch {
+      warn(`workflow-machine: could not read sprint-status.yaml at ${sprintStatusPath}`);
+      return items;
     }
+    let parsed;
+    try {
+      parsed = parse5(raw);
+    } catch {
+      warn(`workflow-machine: invalid YAML in sprint-status.yaml at ${sprintStatusPath}`);
+      return items;
+    }
+    if (parsed && typeof parsed === "object") {
+      const data = parsed;
+      const devStatus = data.development_status;
+      if (devStatus && typeof devStatus === "object") {
+        for (const [key, status] of Object.entries(devStatus)) {
+          if (key.startsWith("epic-")) continue;
+          if (key.endsWith("-retrospective")) continue;
+          if (status === "backlog" || status === "ready-for-dev" || status === "in-progress") {
+            items.push({ key, source: "sprint" });
+          }
+        }
+      }
+    }
+  }
+  if (issuesPath2 && existsSync15(issuesPath2)) {
+    let raw;
+    try {
+      raw = readFileSync13(issuesPath2, "utf-8");
+    } catch {
+      warn(`workflow-machine: could not read issues.yaml at ${issuesPath2}`);
+      return items;
+    }
+    let parsed;
+    try {
+      parsed = parse5(raw);
+    } catch {
+      warn(`workflow-machine: invalid YAML in issues.yaml at ${issuesPath2}`);
+      return items;
+    }
+    if (parsed && typeof parsed === "object") {
+      const data = parsed;
+      const issuesList = data.issues;
+      if (Array.isArray(issuesList)) {
+        for (const issue of issuesList) {
+          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" });
+            }
+          }
+        }
+      }
+    }
+  }
+  return items;
+}
+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:
 
-${formattedFindings}
+${formatted}
 
 Focus on fixing the failed criteria above.`;
 }
@@ -3575,40 +3507,23 @@ function buildAllUnknownVerdict(workItems, reasoning) {
     ac: index + 1,
     description: `AC #${index + 1}`,
     status: "unknown",
-    evidence: {
-      commands_run: [],
-      output_observed: "",
-      reasoning
-    }
+    evidence: { commands_run: [], output_observed: "", reasoning }
   }));
-  return {
-    verdict: "fail",
-    score: {
-      passed: 0,
-      failed: 0,
-      unknown: findings.length,
-      total: findings.length
-    },
-    findings
-  };
+  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 executeLoopBlock(loopBlock, state, config, workItems, initialContract, storyFlowTasks) {
+function isLoopBlock(step) {
+  return typeof step === "object" && step !== null && "loop" in step;
+}
+var loopIterationActor = fromPromise2(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];
@@ -3617,266 +3532,201 @@ async function executeLoopBlock(loopBlock, state, config, workItems, initialCont
     }
     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));
+  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 = isEngineError(err) ? err : handleDispatchError(err, taskName, item.key);
+          errors.push(engineError);
+          currentState = recordErrorInState(currentState, taskName, item.key, engineError);
+          writeWorkflowState(currentState, projectDir);
+        }
       }
-      return isLoopTaskCompleted(currentState, tn, PER_RUN_SENTINEL, currentState.iteration);
-    });
-    if (currentState.iteration === 0 || allCurrentIterationDone) {
-      currentState = {
-        ...currentState,
-        iteration: nextIteration
-      };
-      writeWorkflowState(currentState, projectDir);
+      continue;
+    }
+    const definition = config.agents[task.agent];
+    if (!definition) {
+      warn(`workflow-machine: agent "${task.agent}" not found for task "${taskName}", skipping`);
+      continue;
     }
-    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`);
+    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;
       }
-      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);
+      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");
+              }
             }
           }
-        } else {
-          if (isLoopTaskCompleted(currentState, taskName, PER_RUN_SENTINEL, currentState.iteration)) {
-            warn(`workflow-engine: skipping completed task ${taskName} for ${PER_RUN_SENTINEL}`);
-            continue;
+          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: [] };
           }
-          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);
+          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] };
           }
-        }
-        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);
+          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);
-            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);
-        } catch (err) {
-          const engineError = handleDispatchError(err, taskName, PER_RUN_SENTINEL);
-          errors.push(engineError);
-          currentState = recordErrorInState(currentState, taskName, PER_RUN_SENTINEL, engineError);
-          writeWorkflowState(currentState, projectDir);
-          lastVerdict = null;
-          if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) {
-            haltedInLoop = true;
-            break;
-          }
-          continue;
+        }
+      } 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) {
-      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 };
-    }
-    if (currentState.circuit_breaker.triggered) {
-      currentState = { ...currentState, phase: "circuit-breaker" };
-      writeWorkflowState(currentState, projectDir);
-      return { state: currentState, errors, tasksCompleted, halted: false, lastContract: lastOutputContract };
-    }
-  }
+    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 +3734,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 +3751,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 = join13(projectDir, ".codeharness", "verify-guides");
+  const guideFiles = [];
+  try {
+    mkdirSync6(guidesDir, { recursive: true });
+  } catch {
+    return guideFiles;
+  }
+  for (const item of epicItems) {
+    try {
+      const contractPath = join13(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 = join13(guidesDir, `${item.key}-guide.md`);
+          writeFileSync8(guidePath, docs, "utf-8");
+          guideFiles.push(guidePath);
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const deployContractPath = join13(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 = join13(guidesDir, "deploy-info.md");
+        writeFileSync8(deployPath, report, "utf-8");
+        guideFiles.push(deployPath);
+      }
+    }
+  } catch {
+  }
+  return guideFiles;
+}
+function cleanupGuideFiles(projectDir) {
+  const guidesDir = join13(projectDir, ".codeharness", "verify-guides");
+  try {
+    rmSync2(guidesDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+var storyFlowActor = fromPromise2(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 = fromPromise2(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 = fromPromise2(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 +4131,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 +4162,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 +4176,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,32 +4184,20 @@ 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
 import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync16, readFileSync as readFileSync14, statSync } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/lib/cross-worktree-validator.ts
 import { exec } from "child_process";
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync7 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { promisify } from "util";
 var execAsync = promisify(exec);
 var MAX_BUFFER = 10 * 1024 * 1024;
@@ -4267,9 +4231,9 @@ function writeMergeTelemetry(opts, result) {
       testResults: result.testResults,
       errors: result.valid ? [] : ["Test suite failed after merge"]
     };
-    const dir = join13(opts.cwd, TELEMETRY_DIR2);
+    const dir = join14(opts.cwd, TELEMETRY_DIR2);
     mkdirSync7(dir, { recursive: true });
-    appendFileSync2(join13(dir, TELEMETRY_FILE2), JSON.stringify(entry) + "\n");
+    appendFileSync2(join14(dir, TELEMETRY_FILE2), JSON.stringify(entry) + "\n");
   } catch {
   }
 }
@@ -4750,7 +4714,7 @@ var WorktreeManager = class {
    * Check if a worktree is orphaned (no active codeharness process).
    */
   isOrphaned(wt) {
-    const laneStatePath = join14(wt.path, ".codeharness", "lane-state.json");
+    const laneStatePath = join15(wt.path, ".codeharness", "lane-state.json");
     if (!existsSync16(laneStatePath)) {
       return true;
     }
@@ -6103,7 +6067,7 @@ function startRenderer(options) {
 
 // src/commands/run.ts
 function resolvePluginDir() {
-  return join15(process.cwd(), ".claude");
+  return join16(process.cwd(), ".claude");
 }
 function extractEpicId2(storyKey) {
   const match = storyKey.match(/^(\d+)-/);
@@ -6195,8 +6159,8 @@ function registerRunCommand(program) {
         process.exitCode = 1;
         return;
       }
-      const projectWorkflowPath = join15(projectDir, ".codeharness", "workflows", "default.yaml");
-      const templateWorkflowPath = join15(projectDir, "templates", "workflows", "default.yaml");
+      const projectWorkflowPath = join16(projectDir, ".codeharness", "workflows", "default.yaml");
+      const templateWorkflowPath = join16(projectDir, "templates", "workflows", "default.yaml");
       const workflowPath = existsSync17(projectWorkflowPath) ? projectWorkflowPath : templateWorkflowPath;
       try {
         parsedWorkflow = parseWorkflow(workflowPath);
@@ -6417,16 +6381,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,12 +6401,25 @@ 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,
       agents,
-      sprintStatusPath: join15(projectDir, "_bmad-output", "implementation-artifacts", "sprint-status.yaml"),
-      issuesPath: join15(projectDir, ".codeharness", "issues.yaml"),
+      sprintStatusPath: join16(projectDir, "_bmad-output", "implementation-artifacts", "sprint-status.yaml"),
+      issuesPath: join16(projectDir, ".codeharness", "issues.yaml"),
       runId: `run-${Date.now()}`,
       projectDir,
       abortSignal: abortController.signal,
@@ -6498,7 +6465,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 +6501,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);
@@ -6564,7 +6531,7 @@ function registerRunCommand(program) {
 
 // src/commands/verify.ts
 import { existsSync as existsSync28, readFileSync as readFileSync25 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 
 // src/modules/verify/index.ts
 import { readFileSync as readFileSync24 } from "fs";
@@ -6801,11 +6768,11 @@ function validateProofQuality(proofPath) {
 // src/modules/verify/orchestrator.ts
 import { execFileSync } from "child_process";
 import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync10 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // src/lib/doc-health/types.ts
 import { readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".py"]);
 function getExtension(filename) {
   const dot = filename.lastIndexOf(".");
@@ -6826,7 +6793,7 @@ function getNewestSourceMtime(dir) {
     const dirName = current.split("/").pop() ?? "";
     if (dirName === "node_modules" || dirName === ".git") return;
     for (const entry of entries) {
-      const fullPath = join16(current, entry);
+      const fullPath = join17(current, entry);
       let stat;
       try {
         stat = statSync2(fullPath);
@@ -6858,7 +6825,7 @@ import {
   readdirSync as readdirSync5,
   statSync as statSync4
 } from "fs";
-import { join as join18, relative as relative2 } from "path";
+import { join as join19, relative as relative2 } from "path";
 
 // src/lib/doc-health/staleness.ts
 import { execSync as execSync3 } from "child_process";
@@ -6868,7 +6835,7 @@ import {
   readdirSync as readdirSync4,
   statSync as statSync3
 } from "fs";
-import { join as join17, relative } from "path";
+import { join as join18, relative } from "path";
 var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".js", ".py"]);
 var DO_NOT_EDIT_HEADER = "<!-- DO NOT EDIT MANUALLY";
 function getSourceFilesInModule(modulePath) {
@@ -6883,7 +6850,7 @@ function getSourceFilesInModule(modulePath) {
     const dirName = current.split("/").pop() ?? "";
     if (dirName === "node_modules" || dirName === ".git" || dirName === "__tests__" || dirName === "dist" || dirName === "coverage" || dirName.startsWith(".") && current !== modulePath) return;
     for (const entry of entries) {
-      const fullPath = join17(current, entry);
+      const fullPath = join18(current, entry);
       let stat;
       try {
         stat = statSync3(fullPath);
@@ -6929,10 +6896,10 @@ function checkAgentsMdCompleteness(agentsPath, modulePath) {
 }
 function checkAgentsMdForModule(modulePath, dir) {
   const root = dir ?? process.cwd();
-  const fullModulePath = join17(root, modulePath);
-  let agentsPath = join17(fullModulePath, "AGENTS.md");
+  const fullModulePath = join18(root, modulePath);
+  let agentsPath = join18(fullModulePath, "AGENTS.md");
   if (!existsSync19(agentsPath)) {
-    agentsPath = join17(root, "AGENTS.md");
+    agentsPath = join18(root, "AGENTS.md");
   }
   if (!existsSync19(agentsPath)) {
     return {
@@ -6997,14 +6964,14 @@ function checkStoryDocFreshness(storyId, dir) {
   for (const mod of modulesToCheck) {
     const result = checkAgentsMdForModule(mod, root);
     documents.push(result);
-    const moduleAgentsPath = join17(root, mod, "AGENTS.md");
-    const actualAgentsPath = existsSync19(moduleAgentsPath) ? moduleAgentsPath : join17(root, "AGENTS.md");
+    const moduleAgentsPath = join18(root, mod, "AGENTS.md");
+    const actualAgentsPath = existsSync19(moduleAgentsPath) ? moduleAgentsPath : join18(root, "AGENTS.md");
     if (existsSync19(actualAgentsPath)) {
       checkAgentsMdLineCountInternal(actualAgentsPath, result.path, documents);
     }
   }
   if (modulesToCheck.length === 0) {
-    const rootAgentsPath = join17(root, "AGENTS.md");
+    const rootAgentsPath = join18(root, "AGENTS.md");
     if (existsSync19(rootAgentsPath)) {
       documents.push({
         path: "AGENTS.md",
@@ -7079,7 +7046,7 @@ function findModules(dir, threshold) {
     let sourceCount = 0;
     const subdirs = [];
     for (const entry of entries) {
-      const fullPath = join18(current, entry);
+      const fullPath = join19(current, entry);
       let stat;
       try {
         stat = statSync4(fullPath);
@@ -7113,7 +7080,7 @@ function scanDocHealth(dir) {
   const root = dir ?? process.cwd();
   const documents = [];
   const modules = findModules(root);
-  const rootAgentsPath = join18(root, "AGENTS.md");
+  const rootAgentsPath = join19(root, "AGENTS.md");
   if (existsSync20(rootAgentsPath)) {
     if (modules.length > 0) {
       const docMtime = statSync4(rootAgentsPath).mtime;
@@ -7121,8 +7088,8 @@ function scanDocHealth(dir) {
       let staleModule = "";
       let newestCode = null;
       for (const mod of modules) {
-        const fullModPath = join18(root, mod);
-        const modAgentsPath = join18(fullModPath, "AGENTS.md");
+        const fullModPath = join19(root, mod);
+        const modAgentsPath = join19(fullModPath, "AGENTS.md");
         if (existsSync20(modAgentsPath)) continue;
         const { missing } = checkAgentsMdCompleteness(rootAgentsPath, fullModPath);
         if (missing.length > 0 && staleModule === "") {
@@ -7171,7 +7138,7 @@ function scanDocHealth(dir) {
     });
   }
   for (const mod of modules) {
-    const modAgentsPath = join18(root, mod, "AGENTS.md");
+    const modAgentsPath = join19(root, mod, "AGENTS.md");
     if (existsSync20(modAgentsPath)) {
       const result = checkAgentsMdForModule(mod, root);
       if (result.path !== "AGENTS.md") {
@@ -7180,7 +7147,7 @@ function scanDocHealth(dir) {
       }
     }
   }
-  const indexPath = join18(root, "docs", "index.md");
+  const indexPath = join19(root, "docs", "index.md");
   if (existsSync20(indexPath)) {
     const content = readFileSync17(indexPath, "utf-8");
     const hasAbsolutePaths = /https?:\/\/|file:\/\//i.test(content);
@@ -7192,11 +7159,11 @@ function scanDocHealth(dir) {
       reason: hasAbsolutePaths ? "Contains absolute URLs (may violate NFR25)" : "Uses relative paths"
     });
   }
-  const activeDir = join18(root, "docs", "exec-plans", "active");
+  const activeDir = join19(root, "docs", "exec-plans", "active");
   if (existsSync20(activeDir)) {
     const files = readdirSync5(activeDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const filePath = join18(activeDir, file);
+      const filePath = join19(activeDir, file);
       documents.push({
         path: `docs/exec-plans/active/${file}`,
         grade: "fresh",
@@ -7207,11 +7174,11 @@ function scanDocHealth(dir) {
     }
   }
   for (const subdir of ["quality", "generated"]) {
-    const dirPath = join18(root, "docs", subdir);
+    const dirPath = join19(root, "docs", subdir);
     if (!existsSync20(dirPath)) continue;
     const files = readdirSync5(dirPath).filter((f) => !f.startsWith("."));
     for (const file of files) {
-      const filePath = join18(dirPath, file);
+      const filePath = join19(dirPath, file);
       let stat;
       try {
         stat = statSync4(filePath);
@@ -7267,7 +7234,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync9
 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function printDocHealthOutput(report) {
   for (const doc of report.documents) {
     switch (doc.grade) {
@@ -7288,7 +7255,7 @@ function printDocHealthOutput(report) {
 }
 function completeExecPlan(storyId, dir) {
   const root = dir ?? process.cwd();
-  const activePath = join19(root, "docs", "exec-plans", "active", `${storyId}.md`);
+  const activePath = join20(root, "docs", "exec-plans", "active", `${storyId}.md`);
   if (!existsSync21(activePath)) {
     return null;
   }
@@ -7300,9 +7267,9 @@ function completeExecPlan(storyId, dir) {
     `$1
 Completed: ${timestamp}`
   );
-  const completedDir = join19(root, "docs", "exec-plans", "completed");
+  const completedDir = join20(root, "docs", "exec-plans", "completed");
   mkdirSync8(completedDir, { recursive: true });
-  const completedPath = join19(completedDir, `${storyId}.md`);
+  const completedPath = join20(completedDir, `${storyId}.md`);
   writeFileSync9(completedPath, content, "utf-8");
   try {
     unlinkSync2(activePath);
@@ -7344,9 +7311,9 @@ function checkPreconditions(dir, storyId) {
 }
 function createProofDocument(storyId, _storyTitle, _acs, dir) {
   const root = dir ?? process.cwd();
-  const verificationDir = join20(root, "verification");
+  const verificationDir = join21(root, "verification");
   mkdirSync9(verificationDir, { recursive: true });
-  const proofPath = join20(verificationDir, `${storyId}-proof.md`);
+  const proofPath = join21(verificationDir, `${storyId}-proof.md`);
   writeFileSync10(proofPath, `# ${storyId} \u2014 Proof
 
 Pending: blind evaluator (Epic 6)
@@ -7518,7 +7485,7 @@ function parseObservabilityGaps(proofContent) {
 
 // src/modules/observability/analyzer.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var DEFAULT_RULES_DIR = "patches/observability/";
 var ADDITIONAL_RULES_DIRS = ["patches/error-handling/"];
 var DEFAULT_TIMEOUT = 6e4;
@@ -7553,8 +7520,8 @@ function analyze(projectDir, config) {
   }
   const rulesDir = config?.rulesDir ?? DEFAULT_RULES_DIR;
   const timeout = config?.timeout ?? DEFAULT_TIMEOUT;
-  const fullRulesDir = join21(projectDir, rulesDir);
-  const additionalDirs = (config?.additionalRulesDirs ?? ADDITIONAL_RULES_DIRS).map((d) => join21(projectDir, d));
+  const fullRulesDir = join22(projectDir, rulesDir);
+  const additionalDirs = (config?.additionalRulesDirs ?? ADDITIONAL_RULES_DIRS).map((d) => join22(projectDir, d));
   const rawResult = runSemgrep(projectDir, fullRulesDir, timeout, additionalDirs);
   if (!rawResult.success) {
     return fail2(rawResult.error);
@@ -7643,7 +7610,7 @@ function normalizeSeverity(severity) {
 
 // src/modules/observability/coverage.ts
 import { readFileSync as readFileSync20, writeFileSync as writeFileSync11, renameSync as renameSync3, existsSync as existsSync24 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var STATE_FILE2 = "sprint-state.json";
 var DEFAULT_STATIC_TARGET = 80;
 function defaultCoverageState() {
@@ -7659,7 +7626,7 @@ function defaultCoverageState() {
   };
 }
 function readStateFile(projectDir) {
-  const fp = join22(projectDir, STATE_FILE2);
+  const fp = join23(projectDir, STATE_FILE2);
   if (!existsSync24(fp)) {
     return ok2({});
   }
@@ -7732,7 +7699,7 @@ function parseGapArray(raw) {
 
 // src/modules/observability/runtime-coverage.ts
 import { readFileSync as readFileSync21, writeFileSync as writeFileSync12, renameSync as renameSync4, existsSync as existsSync25 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // src/modules/observability/coverage-gate.ts
 var DEFAULT_STATIC_TARGET2 = 80;
@@ -7775,7 +7742,7 @@ function checkObservabilityCoverageGate(projectDir, overrides) {
 // src/modules/observability/runtime-validator.ts
 import { execSync as execSync4 } from "child_process";
 import { readdirSync as readdirSync6, statSync as statSync5 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 var DEFAULT_CONFIG = {
   testCommand: "npm test",
   otlpEndpoint: "http://localhost:4318",
@@ -7902,11 +7869,11 @@ function mapEventsToModules(events, projectDir, modules) {
   });
 }
 function discoverModules(projectDir) {
-  const srcDir = join24(projectDir, "src");
+  const srcDir = join25(projectDir, "src");
   try {
     return readdirSync6(srcDir).filter((name) => {
       try {
-        return statSync5(join24(srcDir, name)).isDirectory();
+        return statSync5(join25(srcDir, name)).isDirectory();
       } catch {
         return false;
       }
@@ -8574,7 +8541,7 @@ function getACById(id) {
 // src/modules/verify/validation-runner.ts
 import { execSync as execSync5 } from "child_process";
 import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync10 } from "fs";
-import { join as join25, dirname as dirname3 } from "path";
+import { join as join26, dirname as dirname3 } from "path";
 var MAX_VALIDATION_ATTEMPTS = 10;
 var AC_COMMAND_TIMEOUT_MS = 3e4;
 var VAL_KEY_PREFIX = "val-";
@@ -8683,7 +8650,7 @@ function executeValidationAC(ac) {
 function createFixStory(ac, error) {
   try {
     const storyKey = `val-fix-${ac.id}`;
-    const storyPath = join25(
+    const storyPath = join26(
       process.cwd(),
       "_bmad-output",
       "implementation-artifacts",
@@ -9054,11 +9021,11 @@ function runValidationCycle() {
 // src/modules/verify/env.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import { existsSync as existsSync27, mkdirSync as mkdirSync11, readdirSync as readdirSync7, readFileSync as readFileSync23, writeFileSync as writeFileSync14, cpSync, rmSync as rmSync3, statSync as statSync6 } from "fs";
-import { join as join27, basename as basename2 } from "path";
+import { join as join28, basename as basename2 } from "path";
 import { createHash } from "crypto";
 
 // src/modules/verify/dockerfile-generator.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function generateVerifyDockerfile(projectDir) {
   const detections = detectStacks(projectDir);
   const sections = [];
@@ -9078,7 +9045,7 @@ function generateVerifyDockerfile(projectDir) {
   for (const detection of detections) {
     const provider = getStackProvider(detection.stack);
     if (!provider) continue;
-    const resolvedDir = detection.dir === "." ? projectDir : join26(projectDir, detection.dir);
+    const resolvedDir = detection.dir === "." ? projectDir : join27(projectDir, detection.dir);
     const section = provider.getVerifyDockerfileSection(resolvedDir);
     if (section) {
       sections.push(section);
@@ -9107,7 +9074,7 @@ function isValidStoryKey(storyKey) {
   return /^[a-zA-Z0-9_-]+$/.test(storyKey);
 }
 function computeDistHash(projectDir) {
-  const distDir = join27(projectDir, "dist");
+  const distDir = join28(projectDir, "dist");
   if (!existsSync27(distDir)) return null;
   const hash = createHash("sha256");
   const files = collectFiles(distDir).sort();
@@ -9120,7 +9087,7 @@ function computeDistHash(projectDir) {
 function collectFiles(dir) {
   const results = [];
   for (const entry of readdirSync7(dir, { withFileTypes: true })) {
-    const fullPath = join27(dir, entry.name);
+    const fullPath = join28(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...collectFiles(fullPath));
     } else {
@@ -9156,7 +9123,7 @@ function detectProjectType(projectDir) {
   const rootDetection = allStacks.find((s) => s.dir === ".");
   const stack = rootDetection ? rootDetection.stack : null;
   if (stack && STACK_TO_PROJECT_TYPE[stack]) return STACK_TO_PROJECT_TYPE[stack];
-  if (existsSync27(join27(projectDir, ".claude-plugin", "plugin.json"))) return "plugin";
+  if (existsSync27(join28(projectDir, ".claude-plugin", "plugin.json"))) return "plugin";
   return "generic";
 }
 function buildVerifyImage(options = {}) {
@@ -9200,18 +9167,18 @@ function buildNodeImage(projectDir) {
   const lastLine = packOutput.split("\n").pop()?.trim();
   if (!lastLine) throw new Error("npm pack produced no output \u2014 cannot determine tarball filename.");
   const tarballName = basename2(lastLine);
-  const tarballPath = join27("/tmp", tarballName);
-  const buildContext = join27("/tmp", `codeharness-verify-build-${Date.now()}`);
+  const tarballPath = join28("/tmp", tarballName);
+  const buildContext = join28("/tmp", `codeharness-verify-build-${Date.now()}`);
   mkdirSync11(buildContext, { recursive: true });
   try {
-    cpSync(tarballPath, join27(buildContext, tarballName));
+    cpSync(tarballPath, join28(buildContext, tarballName));
     const dockerfile = generateVerifyDockerfile(projectDir) + `
 # Install project from tarball
 ARG TARBALL=package.tgz
 COPY \${TARBALL} /tmp/\${TARBALL}
 RUN npm install -g /tmp/\${TARBALL} && rm /tmp/\${TARBALL}
 `;
-    writeFileSync14(join27(buildContext, "Dockerfile"), dockerfile);
+    writeFileSync14(join28(buildContext, "Dockerfile"), dockerfile);
     execFileSync5("docker", ["build", "-t", IMAGE_TAG, "--build-arg", `TARBALL=${tarballName}`, "."], {
       cwd: buildContext,
       stdio: "pipe",
@@ -9223,22 +9190,22 @@ RUN npm install -g /tmp/\${TARBALL} && rm /tmp/\${TARBALL}
   }
 }
 function buildPythonImage(projectDir) {
-  const distDir = join27(projectDir, "dist");
+  const distDir = join28(projectDir, "dist");
   const distFiles = readdirSync7(distDir).filter((f) => f.endsWith(".tar.gz") || f.endsWith(".whl"));
   if (distFiles.length === 0) {
     throw new Error("No distribution files found in dist/. Run your build command first (e.g., python -m build).");
   }
   const distFile = distFiles.filter((f) => f.endsWith(".tar.gz"))[0] ?? distFiles[0];
-  const buildContext = join27("/tmp", `codeharness-verify-build-${Date.now()}`);
+  const buildContext = join28("/tmp", `codeharness-verify-build-${Date.now()}`);
   mkdirSync11(buildContext, { recursive: true });
   try {
-    cpSync(join27(distDir, distFile), join27(buildContext, distFile));
+    cpSync(join28(distDir, distFile), join28(buildContext, distFile));
     const dockerfile = generateVerifyDockerfile(projectDir) + `
 # Install project from distribution
 COPY ${distFile} /tmp/${distFile}
 RUN pip install --break-system-packages /tmp/${distFile} && rm /tmp/${distFile}
 `;
-    writeFileSync14(join27(buildContext, "Dockerfile"), dockerfile);
+    writeFileSync14(join28(buildContext, "Dockerfile"), dockerfile);
     execFileSync5("docker", ["build", "-t", IMAGE_TAG, "."], {
       cwd: buildContext,
       stdio: "pipe",
@@ -9253,19 +9220,19 @@ function prepareVerifyWorkspace(storyKey, projectDir) {
   if (!isValidStoryKey(storyKey)) {
     throw new Error(`Invalid story key: ${storyKey}. Keys must contain only alphanumeric characters, hyphens, and underscores.`);
   }
-  const storyFile = join27(root, STORY_DIR, `${storyKey}.md`);
+  const storyFile = join28(root, STORY_DIR, `${storyKey}.md`);
   if (!existsSync27(storyFile)) throw new Error(`Story file not found: ${storyFile}`);
   const workspace = `${TEMP_PREFIX}${storyKey}`;
   if (existsSync27(workspace)) rmSync3(workspace, { recursive: true, force: true });
   mkdirSync11(workspace, { recursive: true });
-  cpSync(storyFile, join27(workspace, "story.md"));
-  const readmePath = join27(root, "README.md");
-  if (existsSync27(readmePath)) cpSync(readmePath, join27(workspace, "README.md"));
-  const docsDir = join27(root, "docs");
+  cpSync(storyFile, join28(workspace, "story.md"));
+  const readmePath = join28(root, "README.md");
+  if (existsSync27(readmePath)) cpSync(readmePath, join28(workspace, "README.md"));
+  const docsDir = join28(root, "docs");
   if (existsSync27(docsDir) && statSync6(docsDir).isDirectory()) {
-    cpSync(docsDir, join27(workspace, "docs"), { recursive: true });
+    cpSync(docsDir, join28(workspace, "docs"), { recursive: true });
   }
-  mkdirSync11(join27(workspace, "verification"), { recursive: true });
+  mkdirSync11(join28(workspace, "verification"), { recursive: true });
   return workspace;
 }
 function checkVerifyEnv() {
@@ -9318,18 +9285,18 @@ function cleanupVerifyEnv(storyKey) {
   }
 }
 function buildPluginImage(projectDir) {
-  const buildContext = join27("/tmp", `codeharness-verify-build-${Date.now()}`);
+  const buildContext = join28("/tmp", `codeharness-verify-build-${Date.now()}`);
   mkdirSync11(buildContext, { recursive: true });
   try {
-    const pluginDir = join27(projectDir, ".claude-plugin");
-    cpSync(pluginDir, join27(buildContext, ".claude-plugin"), { recursive: true });
+    const pluginDir = join28(projectDir, ".claude-plugin");
+    cpSync(pluginDir, join28(buildContext, ".claude-plugin"), { recursive: true });
     for (const dir of ["commands", "hooks", "knowledge", "skills"]) {
-      const src = join27(projectDir, dir);
+      const src = join28(projectDir, dir);
       if (existsSync27(src) && statSync6(src).isDirectory()) {
-        cpSync(src, join27(buildContext, dir), { recursive: true });
+        cpSync(src, join28(buildContext, dir), { recursive: true });
       }
     }
-    writeFileSync14(join27(buildContext, "Dockerfile"), generateVerifyDockerfile(projectDir));
+    writeFileSync14(join28(buildContext, "Dockerfile"), generateVerifyDockerfile(projectDir));
     execFileSync5("docker", ["build", "-t", IMAGE_TAG, "."], {
       cwd: buildContext,
       stdio: "pipe",
@@ -9340,10 +9307,10 @@ function buildPluginImage(projectDir) {
   }
 }
 function buildSimpleImage(projectDir, timeout = 12e4) {
-  const buildContext = join27("/tmp", `codeharness-verify-build-${Date.now()}`);
+  const buildContext = join28("/tmp", `codeharness-verify-build-${Date.now()}`);
   mkdirSync11(buildContext, { recursive: true });
   try {
-    writeFileSync14(join27(buildContext, "Dockerfile"), generateVerifyDockerfile(projectDir));
+    writeFileSync14(join28(buildContext, "Dockerfile"), generateVerifyDockerfile(projectDir));
     execFileSync5("docker", ["build", "-t", IMAGE_TAG, "."], {
       cwd: buildContext,
       stdio: "pipe",
@@ -9425,7 +9392,7 @@ function verifyRetro(opts, isJson, root) {
     return;
   }
   const retroFile = `epic-${epicNum}-retrospective.md`;
-  const retroPath = join28(root, STORY_DIR2, retroFile);
+  const retroPath = join29(root, STORY_DIR2, retroFile);
   if (!existsSync28(retroPath)) {
     if (isJson) {
       jsonOutput({ status: "fail", epic: epicNum, retroFile, message: `${retroFile} not found` });
@@ -9443,7 +9410,7 @@ function verifyRetro(opts, isJson, root) {
     warn(`Failed to update sprint status: ${message}`);
   }
   if (isJson) {
-    jsonOutput({ status: "ok", epic: epicNum, retroFile: join28(STORY_DIR2, retroFile) });
+    jsonOutput({ status: "ok", epic: epicNum, retroFile: join29(STORY_DIR2, retroFile) });
   } else {
     ok(`Epic ${epicNum} retrospective: marked done`);
   }
@@ -9454,7 +9421,7 @@ function verifyStory(storyId, isJson, root) {
     process.exitCode = 1;
     return;
   }
-  const readmePath = join28(root, "README.md");
+  const readmePath = join29(root, "README.md");
   if (!existsSync28(readmePath)) {
     if (isJson) {
       jsonOutput({ status: "fail", message: "No README.md found \u2014 verification requires user documentation" });
@@ -9464,7 +9431,7 @@ function verifyStory(storyId, isJson, root) {
     process.exitCode = 1;
     return;
   }
-  const storyFilePath = join28(root, STORY_DIR2, `${storyId}.md`);
+  const storyFilePath = join29(root, STORY_DIR2, `${storyId}.md`);
   if (!existsSync28(storyFilePath)) {
     fail(`Story file not found: ${storyFilePath}`, { json: isJson });
     process.exitCode = 1;
@@ -9505,7 +9472,7 @@ function verifyStory(storyId, isJson, root) {
     return;
   }
   const storyTitle = extractStoryTitle(storyFilePath);
-  const expectedProofPath = join28(root, "verification", `${storyId}-proof.md`);
+  const expectedProofPath = join29(root, "verification", `${storyId}-proof.md`);
   const proofPath = existsSync28(expectedProofPath) ? expectedProofPath : createProofDocument(storyId, storyTitle, acs, root);
   const proofQuality = validateProofQuality(proofPath);
   if (!proofQuality.passed) {
@@ -9677,11 +9644,11 @@ function resolveEndpoints(state) {
 
 // src/lib/onboard-checks.ts
 import { existsSync as existsSync32 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 
 // src/lib/coverage/parser.ts
 import { existsSync as existsSync29, readFileSync as readFileSync26 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 function parseTestCounts(output) {
   const vitestMatch = /Tests\s+(\d+)\s+passed(?:\s*\|\s*(\d+)\s+failed)?/i.exec(output);
   if (vitestMatch) {
@@ -9745,7 +9712,7 @@ function parseVitestCoverage(dir) {
   }
 }
 function parsePythonCoverage(dir) {
-  const reportPath = join29(dir, "coverage.json");
+  const reportPath = join30(dir, "coverage.json");
   if (!existsSync29(reportPath)) {
     warn("Coverage report not found at coverage.json");
     return 0;
@@ -9759,7 +9726,7 @@ function parsePythonCoverage(dir) {
   }
 }
 function parseTarpaulinCoverage(dir) {
-  const reportPath = join29(dir, "coverage", "tarpaulin-report.json");
+  const reportPath = join30(dir, "coverage", "tarpaulin-report.json");
   if (!existsSync29(reportPath)) {
     warn("Tarpaulin report not found at coverage/tarpaulin-report.json");
     return 0;
@@ -9774,8 +9741,8 @@ function parseTarpaulinCoverage(dir) {
 }
 function findCoverageSummary(dir) {
   const candidates = [
-    join29(dir, "coverage", "coverage-summary.json"),
-    join29(dir, "src", "coverage", "coverage-summary.json")
+    join30(dir, "coverage", "coverage-summary.json"),
+    join30(dir, "src", "coverage", "coverage-summary.json")
   ];
   for (const p of candidates) {
     if (existsSync29(p)) return p;
@@ -9786,7 +9753,7 @@ function findCoverageSummary(dir) {
 // src/lib/coverage/runner.ts
 import { execSync as execSync7 } from "child_process";
 import { existsSync as existsSync30, readFileSync as readFileSync27 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 function detectCoverageTool(dir) {
   const baseDir = dir ?? process.cwd();
   const stateHint = getStateToolHint(baseDir);
@@ -9819,7 +9786,7 @@ function detectRustCoverageTool(dir) {
     warn("cargo-tarpaulin not installed \u2014 coverage detection unavailable");
     return { tool: "unknown", runCommand: "", reportFormat: "" };
   }
-  const cargoPath = join30(dir, "Cargo.toml");
+  const cargoPath = join31(dir, "Cargo.toml");
   let isWorkspace = false;
   try {
     const cargoContent = readFileSync27(cargoPath, "utf-8");
@@ -9842,8 +9809,8 @@ function getStateToolHint(dir) {
   }
 }
 function detectNodeCoverageTool(dir, stateHint) {
-  const hasVitestConfig = existsSync30(join30(dir, "vitest.config.ts")) || existsSync30(join30(dir, "vitest.config.js"));
-  const pkgPath = join30(dir, "package.json");
+  const hasVitestConfig = existsSync30(join31(dir, "vitest.config.ts")) || existsSync30(join31(dir, "vitest.config.js"));
+  const pkgPath = join31(dir, "package.json");
   let hasVitestCoverageV8 = false;
   let hasVitestCoverageIstanbul = false;
   let hasC8 = false;
@@ -9904,7 +9871,7 @@ function getNodeTestCommand(scripts, runner) {
   return "npm test";
 }
 function detectPythonCoverageTool(dir) {
-  const reqPath = join30(dir, "requirements.txt");
+  const reqPath = join31(dir, "requirements.txt");
   if (existsSync30(reqPath)) {
     try {
       const content = readFileSync27(reqPath, "utf-8");
@@ -9918,7 +9885,7 @@ function detectPythonCoverageTool(dir) {
     } catch {
     }
   }
-  const pyprojectPath = join30(dir, "pyproject.toml");
+  const pyprojectPath = join31(dir, "pyproject.toml");
   if (existsSync30(pyprojectPath)) {
     try {
       const content = readFileSync27(pyprojectPath, "utf-8");
@@ -10751,7 +10718,7 @@ function registerStatusCommand(program) {
 
 // src/modules/audit/dimensions.ts
 import { existsSync as existsSync33, readdirSync as readdirSync8 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 function gap(dimension, description, suggestedFix) {
   return { dimension, description, suggestedFix };
 }
@@ -10863,15 +10830,15 @@ function checkDocumentation(projectDir) {
 function checkVerification(projectDir) {
   try {
     const gaps = [];
-    const sprintPath = join32(projectDir, "_bmad-output", "implementation-artifacts", "sprint-status.yaml");
+    const sprintPath = join33(projectDir, "_bmad-output", "implementation-artifacts", "sprint-status.yaml");
     if (!existsSync33(sprintPath)) return dimOk("verification", "warn", "no sprint data", [gap("verification", "No sprint-status.yaml found", "Run sprint planning to create sprint status")]);
-    const vDir = join32(projectDir, "verification");
+    const vDir = join33(projectDir, "verification");
     let proofCount = 0, totalChecked = 0;
     if (existsSync33(vDir)) {
       for (const file of readdirSafe(vDir)) {
         if (!file.endsWith("-proof.md")) continue;
         totalChecked++;
-        const r = parseProof(join32(vDir, file));
+        const r = parseProof(join33(vDir, file));
         if (isOk(r) && r.data.passed) {
           proofCount++;
         } else {
@@ -10949,7 +10916,7 @@ function formatAuditJson(result) {
 
 // src/modules/audit/fix-generator.ts
 import { existsSync as existsSync34, writeFileSync as writeFileSync15, mkdirSync as mkdirSync12 } from "fs";
-import { join as join33, dirname as dirname5 } from "path";
+import { join as join34, dirname as dirname5 } from "path";
 function buildStoryKey(gap2, index) {
   const safeDimension = gap2.dimension.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
   return `audit-fix-${safeDimension}-${index}`;
@@ -10981,7 +10948,7 @@ function generateFixStories(auditResult) {
     const stories = [];
     let created = 0;
     let skipped = 0;
-    const artifactsDir = join33(
+    const artifactsDir = join34(
       process.cwd(),
       "_bmad-output",
       "implementation-artifacts"
@@ -10990,7 +10957,7 @@ function generateFixStories(auditResult) {
       for (let i = 0; i < dimension.gaps.length; i++) {
         const gap2 = dimension.gaps[i];
         const key = buildStoryKey(gap2, i + 1);
-        const filePath = join33(artifactsDir, `${key}.md`);
+        const filePath = join34(artifactsDir, `${key}.md`);
         if (existsSync34(filePath)) {
           stories.push({
             key,
@@ -11181,7 +11148,7 @@ function registerOnboardCommand(program) {
 
 // src/commands/teardown.ts
 import { existsSync as existsSync35, unlinkSync as unlinkSync3, readFileSync as readFileSync29, writeFileSync as writeFileSync16, rmSync as rmSync4 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 function buildDefaultResult() {
   return {
     status: "ok",
@@ -11227,7 +11194,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-Z6B3GBST.js");
           stopCollectorOnly2();
           result.docker.stopped = true;
           if (!isJson) {
@@ -11259,7 +11226,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-Z6B3GBST.js");
       let stackRunning = false;
       try {
         stackRunning = isStackRunning2(composeFile);
@@ -11284,7 +11251,7 @@ function registerTeardownCommand(program) {
           info("Docker stack: not running, skipping");
         }
       }
-      const composeFilePath = join34(projectDir, composeFile);
+      const composeFilePath = join35(projectDir, composeFile);
       if (existsSync35(composeFilePath)) {
         unlinkSync3(composeFilePath);
         result.removed.push(composeFile);
@@ -11292,7 +11259,7 @@ function registerTeardownCommand(program) {
           ok(`Removed: ${composeFile}`);
         }
       }
-      const otelConfigPath = join34(projectDir, "otel-collector-config.yaml");
+      const otelConfigPath = join35(projectDir, "otel-collector-config.yaml");
       if (existsSync35(otelConfigPath)) {
         unlinkSync3(otelConfigPath);
         result.removed.push("otel-collector-config.yaml");
@@ -11312,7 +11279,7 @@ function registerTeardownCommand(program) {
     }
     const stacks = state.stacks ?? (state.stack ? [state.stack] : []);
     if (state.otlp?.enabled && stacks.includes("nodejs")) {
-      const pkgPath = join34(projectDir, "package.json");
+      const pkgPath = join35(projectDir, "package.json");
       if (existsSync35(pkgPath)) {
         try {
           const raw = readFileSync29(pkgPath, "utf-8");
@@ -11355,7 +11322,7 @@ function registerTeardownCommand(program) {
         }
       }
     }
-    const harnessDir = join34(projectDir, ".harness");
+    const harnessDir = join35(projectDir, ".harness");
     if (existsSync35(harnessDir)) {
       rmSync4(harnessDir, { recursive: true, force: true });
       result.removed.push(".harness/");
@@ -12046,7 +12013,7 @@ function registerQueryCommand(program) {
 
 // src/commands/retro-import.ts
 import { existsSync as existsSync37, readFileSync as readFileSync31 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 
 // src/lib/retro-parser.ts
 var KNOWN_TOOLS = ["showboat", "ralph", "beads", "bmad"];
@@ -12164,7 +12131,7 @@ function isDuplicate(newItem, existingTitles, threshold = 0.8) {
 
 // src/lib/issue-tracker.ts
 import { existsSync as existsSync36, readFileSync as readFileSync30, writeFileSync as writeFileSync17, mkdirSync as mkdirSync13 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import { parse as parse6, stringify as stringify3 } from "yaml";
 var VALID_PRIORITIES = /* @__PURE__ */ new Set([
   "low",
@@ -12172,9 +12139,9 @@ var VALID_PRIORITIES = /* @__PURE__ */ new Set([
   "high",
   "critical"
 ]);
-var ISSUES_REL_PATH = join35(".codeharness", "issues.yaml");
+var ISSUES_REL_PATH = join36(".codeharness", "issues.yaml");
 function issuesPath(dir) {
-  return join35(dir, ISSUES_REL_PATH);
+  return join36(dir, ISSUES_REL_PATH);
 }
 function readIssues(dir = process.cwd()) {
   const filePath = issuesPath(dir);
@@ -12190,7 +12157,7 @@ function readIssues(dir = process.cwd()) {
 }
 function writeIssues(data, dir = process.cwd()) {
   const filePath = issuesPath(dir);
-  const dirPath = join35(dir, ".codeharness");
+  const dirPath = join36(dir, ".codeharness");
   if (!existsSync36(dirPath)) {
     mkdirSync13(dirPath, { recursive: true });
   }
@@ -12351,7 +12318,7 @@ function registerRetroImportCommand(program) {
       return;
     }
     const retroFile = `epic-${epicNum}-retrospective.md`;
-    const retroPath = join36(root, STORY_DIR3, retroFile);
+    const retroPath = join37(root, STORY_DIR3, retroFile);
     if (!existsSync37(retroPath)) {
       fail(`Retro file not found: ${retroFile}`, { json: isJson });
       process.exitCode = 1;
@@ -12852,7 +12819,7 @@ function registerValidateStateCommand(program) {
 
 // src/commands/validate-schema.ts
 import { readdirSync as readdirSync9, existsSync as existsSync38 } from "fs";
-import { join as join37, resolve as resolve6 } from "path";
+import { join as join38, resolve as resolve6 } from "path";
 function renderSchemaResult(result, isJson) {
   if (isJson) {
     jsonOutput(result);
@@ -12872,7 +12839,7 @@ function renderSchemaResult(result, isJson) {
   process.exitCode = result.status === "pass" ? 0 : 1;
 }
 function runSchemaValidation(projectDir) {
-  const workflowsDir = join37(projectDir, ".codeharness", "workflows");
+  const workflowsDir = join38(projectDir, ".codeharness", "workflows");
   if (!existsSync38(workflowsDir)) {
     return {
       status: "fail",
@@ -13181,7 +13148,7 @@ function registerAuditCommand(program) {
 
 // src/commands/stats.ts
 import { existsSync as existsSync39, readdirSync as readdirSync10, readFileSync as readFileSync32, writeFileSync as writeFileSync18 } from "fs";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 var RATES = {
   input: 15,
   output: 75,
@@ -13266,10 +13233,10 @@ function parseLogFile(filePath, report) {
   }
 }
 function generateReport3(projectDir, logsDir) {
-  const ralphLogs = join38(projectDir, "ralph", "logs");
-  const sessionLogs = join38(projectDir, "session-logs");
+  const ralphLogs = join39(projectDir, "ralph", "logs");
+  const sessionLogs = join39(projectDir, "session-logs");
   const resolvedLogsDir = logsDir ?? (existsSync39(ralphLogs) ? ralphLogs : sessionLogs);
-  const logFiles = readdirSync10(resolvedLogsDir).filter((f) => f.endsWith(".log")).sort().map((f) => join38(resolvedLogsDir, f));
+  const logFiles = readdirSync10(resolvedLogsDir).filter((f) => f.endsWith(".log")).sort().map((f) => join39(resolvedLogsDir, f));
   const report = {
     byPhase: /* @__PURE__ */ new Map(),
     byStory: /* @__PURE__ */ new Map(),
@@ -13370,10 +13337,10 @@ function registerStatsCommand(program) {
     const projectDir = process.cwd();
     let logsDir;
     if (options.logsDir) {
-      logsDir = join38(projectDir, options.logsDir);
+      logsDir = join39(projectDir, options.logsDir);
     } else {
-      const ralphLogs = join38(projectDir, "ralph", "logs");
-      const sessionLogs = join38(projectDir, "session-logs");
+      const ralphLogs = join39(projectDir, "ralph", "logs");
+      const sessionLogs = join39(projectDir, "session-logs");
       logsDir = existsSync39(ralphLogs) ? ralphLogs : sessionLogs;
     }
     if (!existsSync39(logsDir)) {
@@ -13389,7 +13356,7 @@ function registerStatsCommand(program) {
     const formatted = formatReport2(report);
     console.log(formatted);
     if (options.save) {
-      const outPath = join38(projectDir, "_bmad-output", "implementation-artifacts", "cost-report.md");
+      const outPath = join39(projectDir, "_bmad-output", "implementation-artifacts", "cost-report.md");
       writeFileSync18(outPath, formatted, "utf-8");
       ok(`Report saved to ${outPath}`);
     }
@@ -14246,7 +14213,7 @@ function registerDriversCommand(program) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.35.7" : "0.0.0-dev";
+var VERSION = true ? "0.36.3" : "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");