codeharness 0.31.6 → 0.32.0

package/dist/{chunk-ZLOBOEIA.js → chunk-IZWRIAGV.js}

@@ -2895,7 +2895,7 @@ function generateDockerfileTemplate(projectDir, stackOrDetections) {
 }
 
 // src/modules/infra/init-project.ts
-var HARNESS_VERSION = true ? "0.31.6" : "0.0.0-dev";
+var HARNESS_VERSION = true ? "0.32.0" : "0.0.0-dev";
 function failResult(opts, error) {
   return {
     status: "fail",

package/dist/{docker-RHFGKHJV.js → docker-R4444RHQ.js}

@@ -16,7 +16,7 @@ import {
   stopCollectorOnly,
   stopSharedStack,
   stopStack
-} from "./chunk-ZLOBOEIA.js";
+} from "./chunk-IZWRIAGV.js";
 export {
   checkRemoteEndpoint,
   cleanupOrphanedContainers,

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   validateDockerfile,
   warn,
   writeState
-} from "./chunk-ZLOBOEIA.js";
+} from "./chunk-IZWRIAGV.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -1604,7 +1604,7 @@ var workflow_schema_default = {
   title: "Codeharness Workflow",
   description: "Schema for codeharness workflow YAML files",
   type: "object",
-  required: ["tasks"],
+  required: ["tasks", "story_flow", "epic_flow"],
   properties: {
     tasks: {
       type: "object",
@@ -1706,12 +1706,6 @@ var workflow_schema_default = {
           ],
           description: "Agent identifier for this task (null for engine-handled tasks)"
         },
-        scope: {
-          type: "string",
-          enum: ["per-story", "per-run", "per-epic"],
-          default: "per-story",
-          description: "Execution scope \u2014 per-story, per-run, or per-epic"
-        },
         session: {
           type: "string",
           enum: ["fresh", "continue"],
@@ -2121,7 +2115,7 @@ ${bullets}`);
 }
 
 // src/lib/hierarchical-flow.ts
-var BUILTIN_EPIC_FLOW_TASKS = /* @__PURE__ */ new Set(["merge", "validate"]);
+var BUILTIN_EPIC_FLOW_TASKS = /* @__PURE__ */ new Set(["merge", "validate", "story_flow"]);
 var EXECUTION_DEFAULTS = {
   max_parallel: 1,
   isolation: "none",
@@ -2134,18 +2128,25 @@ var VALID_MERGE_STRATEGY = /* @__PURE__ */ new Set(["rebase", "merge-commit"]);
 var VALID_EPIC_STRATEGY = /* @__PURE__ */ new Set(["parallel", "sequential"]);
 var VALID_STORY_STRATEGY = /* @__PURE__ */ new Set(["sequential", "parallel"]);
 function resolveHierarchicalFlow(parsed, resolvedTasks) {
-  const hasFlow = "flow" in parsed && parsed.flow !== void 0;
   const hasStoryFlow = "story_flow" in parsed && parsed.story_flow !== void 0;
-  if (hasFlow && hasStoryFlow) {
-    throw new HierarchicalFlowError(
-      'Workflow cannot have both "flow" and "story_flow" \u2014 use "story_flow" for hierarchical workflows or "flow" for legacy mode'
-    );
+  const hasEpicFlow = "epic_flow" in parsed && parsed.epic_flow !== void 0;
+  if (!hasStoryFlow) {
+    throw new HierarchicalFlowError('Workflow must define "story_flow"');
+  }
+  if (!hasEpicFlow) {
+    throw new HierarchicalFlowError('Workflow must define "epic_flow"');
   }
   const rawExecution = parsed.execution != null && typeof parsed.execution === "object" ? parsed.execution : {};
   const execution = resolveExecutionConfig(rawExecution);
-  const rawStoryFlow = hasStoryFlow ? parsed.story_flow : parsed.flow;
-  const storyFlow = normalizeFlowArray(rawStoryFlow);
+  const storyFlow = normalizeFlowArray(parsed.story_flow);
   const epicFlow = normalizeFlowArray(parsed.epic_flow);
+  const storyFlowRefs = epicFlow.filter((s) => s === "story_flow");
+  if (storyFlowRefs.length === 0) {
+    throw new HierarchicalFlowError('epic_flow must contain a "story_flow" reference');
+  }
+  if (storyFlowRefs.length > 1) {
+    throw new HierarchicalFlowError('epic_flow must contain exactly one "story_flow" reference');
+  }
   return {
     execution,
     storyFlow,
@@ -2286,23 +2287,20 @@ function validateAndResolve(parsed) {
     );
   }
   const data = parsed;
-  const hasFlow = "flow" in data && data.flow !== void 0;
   const hasStoryFlow = "story_flow" in data && data.story_flow !== void 0;
-  if (hasFlow && hasStoryFlow) {
-    throw new WorkflowParseError(
-      'Workflow cannot have both "flow" and "story_flow" \u2014 use "story_flow" for hierarchical workflows or "flow" for legacy mode',
-      [{ path: "/", message: 'Cannot have both "flow" and "story_flow"' }]
-    );
+  const hasEpicFlow = "epic_flow" in data && data.epic_flow !== void 0;
+  if (!hasStoryFlow) {
+    throw new WorkflowParseError('Workflow must define "story_flow"', [{ path: "/", message: 'Missing "story_flow"' }]);
   }
-  const effectiveStoryFlow = (hasStoryFlow ? data.story_flow : data.flow) ?? [];
+  if (!hasEpicFlow) {
+    throw new WorkflowParseError('Workflow must define "epic_flow"', [{ path: "/", message: 'Missing "epic_flow"' }]);
+  }
+  const effectiveStoryFlow = data.story_flow ?? [];
   const effectiveEpicFlow = data.epic_flow ?? [];
   const taskNames = new Set(Object.keys(data.tasks));
   const allErrors = [];
-  const storyFlowLabel = hasStoryFlow ? "story_flow" : "flow";
-  validateFlowReferences(effectiveStoryFlow, taskNames, storyFlowLabel, allErrors, false);
-  if (effectiveEpicFlow.length > 0) {
-    validateFlowReferences(effectiveEpicFlow, taskNames, "epic_flow", allErrors, true);
-  }
+  validateFlowReferences(effectiveStoryFlow, taskNames, "story_flow", allErrors, false);
+  validateFlowReferences(effectiveEpicFlow, taskNames, "epic_flow", allErrors, true);
   validateReferentialIntegrity(data, allErrors);
   if (allErrors.length > 0) {
     const details = allErrors.map((e) => e.message).join("; ");
@@ -2312,7 +2310,6 @@ function validateAndResolve(parsed) {
   for (const [taskName, task] of Object.entries(data.tasks)) {
     const resolved = {
       agent: task.agent,
-      scope: task.scope ?? "per-story",
       session: task.session ?? "fresh",
       source_access: task.source_access ?? true
     };
@@ -2348,13 +2345,13 @@ function validateAndResolve(parsed) {
     }
     throw err;
   }
-  const resolvedFlow = hierarchical.storyFlow;
   return {
     tasks: resolvedTasks,
-    flow: resolvedFlow,
-    execution: hierarchical.execution,
     storyFlow: hierarchical.storyFlow,
-    epicFlow: hierarchical.epicFlow
+    epicFlow: hierarchical.epicFlow,
+    execution: hierarchical.execution,
+    flow: hierarchical.storyFlow
+    // deprecated compat
   };
 }
 function validateFlowReferences(flow, taskNames, flowLabel, errors, allowBuiltins) {
@@ -3561,7 +3558,7 @@ function getFailedItems(verdict, allItems) {
   if (verdict.verdict === "pass") return [];
   return allItems;
 }
-async function executeLoopBlock(loopBlock, state, config, workItems, initialContract) {
+async function executeLoopBlock(loopBlock, state, config, workItems, initialContract, storyFlowTasks) {
   const projectDir = config.projectDir ?? process.cwd();
   const maxIterations = config.maxIterations ?? DEFAULT_MAX_ITERATIONS;
   const errors = [];
@@ -3578,7 +3575,7 @@ async function executeLoopBlock(loopBlock, state, config, workItems, initialCont
     const allCurrentIterationDone = currentState.iteration > 0 && loopBlock.loop.every((tn) => {
       const t = config.workflow.tasks[tn];
       if (!t) return true;
-      if (t.scope === "per-story") {
+      if (storyFlowTasks?.has(tn)) {
         return workItems.every((item) => isLoopTaskCompleted(currentState, tn, item.key, currentState.iteration));
       }
       return isLoopTaskCompleted(currentState, tn, PER_RUN_SENTINEL, currentState.iteration);
@@ -3598,7 +3595,7 @@ async function executeLoopBlock(loopBlock, state, config, workItems, initialCont
         continue;
       }
       if (task.agent === null) {
-        if (task.scope === "per-story") {
+        if (storyFlowTasks?.has(taskName)) {
           const itemsToProcess = lastVerdict ? getFailedItems(lastVerdict, workItems) : workItems;
           for (const item of itemsToProcess) {
             if (isLoopTaskCompleted(currentState, taskName, item.key, currentState.iteration)) {
@@ -3657,7 +3654,7 @@ async function executeLoopBlock(loopBlock, state, config, workItems, initialCont
         warn(`workflow-engine: agent "${task.agent}" not found for task "${taskName}", skipping`);
         continue;
       }
-      if (task.scope === "per-story") {
+      if (storyFlowTasks?.has(taskName)) {
         const itemsToRetry = lastVerdict ? getFailedItems(lastVerdict, workItems) : workItems;
         for (const item of itemsToRetry) {
           if (isLoopTaskCompleted(currentState, taskName, item.key, currentState.iteration)) {
@@ -3911,298 +3908,125 @@ async function executeWorkflow(config) {
     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);
+  }
   let halted = false;
   let lastOutputContract = null;
   let accumulatedCostUsd = 0;
-  if (config.storyPipeline) {
-    const preTasks = [];
-    let loopIdx = -1;
-    for (let i = 0; i < config.workflow.storyFlow.length; i++) {
-      const s = config.workflow.storyFlow[i];
-      if (isLoopBlock(s)) {
-        loopIdx = i;
-        break;
-      }
-      if (typeof s === "string") preTasks.push(s);
+  for (const step of config.workflow.epicFlow) {
+    if (halted) break;
+    if (config.abortSignal?.aborted) {
+      info("Execution interrupted \u2014 saving state");
+      state = { ...state, phase: "interrupted" };
+      writeWorkflowState(state, projectDir);
+      halted = true;
+      break;
     }
-    for (const item of workItems) {
-      if (halted || config.abortSignal?.aborted) {
-        if (config.abortSignal?.aborted) {
-          info("Execution interrupted \u2014 saving state");
-          state = { ...state, phase: "interrupted" };
-          writeWorkflowState(state, projectDir);
-        }
-        halted = true;
-        break;
-      }
-      processedStories.add(item.key);
-      for (const taskName of preTasks) {
+    if (step === "story_flow") {
+      for (const item of workItems) {
         if (halted || config.abortSignal?.aborted) {
-          halted = true;
-          break;
-        }
-        const task = config.workflow.tasks[taskName];
-        if (!task || task.agent === null) continue;
-        const definition = config.agents[task.agent];
-        if (!definition) {
-          warn(`workflow-engine: agent "${task.agent}" not found for "${taskName}"`);
-          continue;
-        }
-        if (isTaskCompleted(state, taskName, item.key)) continue;
-        try {
-          const dr = await dispatchTaskWithResult(task, taskName, item.key, definition, state, config, void 0, lastOutputContract ?? void 0);
-          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, item.key);
-          errors.push(engineError);
-          if (config.onEvent) {
-            config.onEvent({ type: "dispatch-error", taskName, storyKey: item.key, error: { code: engineError.code, message: engineError.message } });
-          } else {
-            warn(`[${taskName}] ${item.key} \u2014 ERROR: [${engineError.code}] ${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;
-        }
-      }
-    }
-    const remaining = loopIdx >= 0 ? config.workflow.storyFlow.slice(loopIdx) : [];
-    for (const step of remaining) {
-      if (halted || config.abortSignal?.aborted) {
-        halted = true;
-        break;
-      }
-      if (isLoopBlock(step)) {
-        const loopResult = await executeLoopBlock(step, state, config, workItems, lastOutputContract);
-        state = loopResult.state;
-        errors.push(...loopResult.errors);
-        tasksCompleted += loopResult.tasksCompleted;
-        lastOutputContract = loopResult.lastContract;
-        for (const item of workItems) 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) continue;
-      if (task.agent === null) continue;
-      const definition = config.agents[task.agent];
-      if (!definition) continue;
-      if (task.scope === "per-run" || task.scope === "per-epic") {
-        if (isTaskCompleted(state, taskName, PER_RUN_SENTINEL)) continue;
-        try {
-          const dr = await dispatchTaskWithResult(task, taskName, PER_RUN_SENTINEL, definition, state, config, void 0, lastOutputContract ?? void 0);
-          state = dr.updatedState;
-          lastOutputContract = dr.contract;
-          tasksCompleted++;
-        } catch (err) {
-          const engineError = handleDispatchError(err, taskName, PER_RUN_SENTINEL);
-          errors.push(engineError);
-          state = recordErrorInState(state, taskName, PER_RUN_SENTINEL, engineError);
-          writeWorkflowState(state, projectDir);
-        }
-      } else {
-        for (const item of workItems) {
-          if (halted || config.abortSignal?.aborted) break;
-          if (isTaskCompleted(state, taskName, item.key)) continue;
-          try {
-            const dr = await dispatchTaskWithResult(task, taskName, item.key, definition, state, config, void 0, lastOutputContract ?? void 0);
-            state = dr.updatedState;
-            lastOutputContract = dr.contract;
-            tasksCompleted++;
-          } catch (err) {
-            const engineError = handleDispatchError(err, taskName, item.key);
-            errors.push(engineError);
-            state = recordErrorInState(state, taskName, item.key, engineError);
+          if (config.abortSignal?.aborted) {
+            state = { ...state, phase: "interrupted" };
             writeWorkflowState(state, projectDir);
           }
-        }
-      }
-    }
-  }
-  if (!config.storyPipeline)
-    for (const step of config.workflow.storyFlow) {
-      if (halted) break;
-      if (config.abortSignal?.aborted) {
-        info("Execution interrupted \u2014 saving state");
-        state = { ...state, phase: "interrupted" };
-        writeWorkflowState(state, projectDir);
-        halted = true;
-        break;
-      }
-      if (isLoopBlock(step)) {
-        const loopResult = await executeLoopBlock(step, state, config, workItems, lastOutputContract);
-        state = loopResult.state;
-        errors.push(...loopResult.errors);
-        tasksCompleted += loopResult.tasksCompleted;
-        lastOutputContract = loopResult.lastContract;
-        for (const item of workItems) {
-          processedStories.add(item.key);
-        }
-        if (loopResult.halted) {
-          halted = true;
-        }
-        if (state.phase === "max-iterations" || state.phase === "circuit-breaker") {
           halted = true;
+          break;
         }
-        continue;
-      }
-      const taskName = step;
-      const task = config.workflow.tasks[taskName];
-      if (!task) {
-        warn(`workflow-engine: task "${taskName}" not found in workflow tasks, skipping`);
-        continue;
-      }
-      if (task.agent === null) {
-        if (task.scope === "per-run") {
-          if (isTaskCompleted(state, taskName, PER_RUN_SENTINEL)) {
-            warn(`workflow-engine: skipping completed task ${taskName} for ${PER_RUN_SENTINEL}`);
-            continue;
-          }
-          try {
-            const nullResult = await executeNullTask(
-              task,
-              taskName,
-              PER_RUN_SENTINEL,
-              state,
-              config,
-              lastOutputContract ?? void 0,
-              accumulatedCostUsd
-            );
-            state = nullResult.updatedState;
-            lastOutputContract = nullResult.contract;
-            tasksCompleted++;
-          } catch (err) {
-            const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, PER_RUN_SENTINEL);
-            errors.push(engineError);
-            state = recordErrorInState(state, taskName, PER_RUN_SENTINEL, engineError);
-            writeWorkflowState(state, projectDir);
-          }
-        } else {
-          for (const item of workItems) {
-            processedStories.add(item.key);
-            if (isTaskCompleted(state, taskName, item.key)) {
-              warn(`workflow-engine: skipping completed task ${taskName} for ${item.key}`);
-              continue;
-            }
-            try {
-              const nullResult = await executeNullTask(
-                task,
-                taskName,
-                item.key,
-                state,
-                config,
-                lastOutputContract ?? void 0,
-                accumulatedCostUsd
-              );
-              state = nullResult.updatedState;
-              lastOutputContract = nullResult.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);
-            }
-          }
-        }
-        continue;
-      }
-      const definition = config.agents[task.agent];
-      if (!definition) {
-        warn(`workflow-engine: agent "${task.agent}" not found for task "${taskName}", skipping`);
-        continue;
-      }
-      if (task.scope === "per-run") {
-        if (isTaskCompleted(state, taskName, PER_RUN_SENTINEL)) {
-          warn(`workflow-engine: skipping completed task ${taskName} for ${PER_RUN_SENTINEL}`);
-          continue;
-        }
-        try {
-          const dispatchResult = await dispatchTaskWithResult(
-            task,
-            taskName,
-            PER_RUN_SENTINEL,
-            definition,
-            state,
-            config,
-            void 0,
-            lastOutputContract ?? void 0
-          );
-          state = dispatchResult.updatedState;
-          lastOutputContract = dispatchResult.contract;
-          propagateVerifyFlags(taskName, dispatchResult.contract, projectDir);
-          accumulatedCostUsd += dispatchResult.contract?.cost_usd ?? 0;
-          tasksCompleted++;
-        } catch (err) {
-          const engineError = handleDispatchError(err, taskName, PER_RUN_SENTINEL);
-          errors.push(engineError);
-          if (config.onEvent) {
-            config.onEvent({ type: "dispatch-error", taskName, storyKey: PER_RUN_SENTINEL, error: { code: engineError.code, message: engineError.message } });
-          } else {
-            warn(`[${taskName}] ${PER_RUN_SENTINEL} \u2014 ERROR: [${engineError.code}] ${engineError.message}`);
-          }
-          state = recordErrorInState(state, taskName, PER_RUN_SENTINEL, engineError);
-          writeWorkflowState(state, projectDir);
-          if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) {
-            halted = true;
-          }
-        }
-      } else {
-        for (const item of workItems) {
-          if (config.abortSignal?.aborted) {
+        processedStories.add(item.key);
+        for (const storyStep of config.workflow.storyFlow) {
+          if (halted || config.abortSignal?.aborted) {
             halted = true;
             break;
           }
-          processedStories.add(item.key);
-          if (isTaskCompleted(state, taskName, item.key)) {
-            warn(`workflow-engine: skipping completed task ${taskName} for ${item.key}`);
+          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 dispatchResult = await dispatchTaskWithResult(
-              task,
-              taskName,
-              item.key,
-              definition,
-              state,
-              config,
-              void 0,
-              lastOutputContract ?? void 0
-            );
-            state = dispatchResult.updatedState;
-            lastOutputContract = dispatchResult.contract;
-            propagateVerifyFlags(taskName, dispatchResult.contract, projectDir);
-            accumulatedCostUsd += dispatchResult.contract?.cost_usd ?? 0;
+            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, taskName, item.key);
+            const engineError = handleDispatchError(err, taskName2, item.key);
             errors.push(engineError);
             if (config.onEvent) {
-              config.onEvent({ type: "dispatch-error", taskName, storyKey: item.key, error: { code: engineError.code, message: engineError.message } });
+              config.onEvent({ type: "dispatch-error", taskName: taskName2, storyKey: item.key, error: { code: engineError.code, message: engineError.message } });
             } else {
-              warn(`[${taskName}] ${item.key} \u2014 ERROR: [${engineError.code}] ${engineError.message}`);
+              warn(`[${taskName2}] ${item.key} \u2014 ERROR: [${engineError.code}] ${engineError.message}`);
             }
-            state = recordErrorInState(state, taskName, item.key, engineError);
+            state = recordErrorInState(state, taskName2, item.key, engineError);
             writeWorkflowState(state, projectDir);
             if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) {
               halted = true;
-              break;
             }
-            continue;
+            break;
           }
         }
       }
+      continue;
+    }
+    if (isLoopBlock(step)) {
+      const loopResult = await executeLoopBlock(step, state, config, workItems, lastOutputContract, storyFlowTasks);
+      state = loopResult.state;
+      errors.push(...loopResult.errors);
+      tasksCompleted += loopResult.tasksCompleted;
+      lastOutputContract = loopResult.lastContract;
+      for (const item of workItems) 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;
     }
+    if (isTaskCompleted(state, taskName, PER_RUN_SENTINEL)) continue;
+    try {
+      const dr = await dispatchTaskWithResult(task, taskName, PER_RUN_SENTINEL, definition, state, config, void 0, lastOutputContract ?? void 0);
+      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, PER_RUN_SENTINEL);
+      errors.push(engineError);
+      if (config.onEvent) {
+        config.onEvent({ type: "dispatch-error", taskName, storyKey: PER_RUN_SENTINEL, error: { code: engineError.code, message: engineError.message } });
+      } else {
+        warn(`[${taskName}] ${PER_RUN_SENTINEL} \u2014 ERROR: [${engineError.code}] ${engineError.message}`);
+      }
+      state = recordErrorInState(state, taskName, PER_RUN_SENTINEL, engineError);
+      writeWorkflowState(state, projectDir);
+      if (err instanceof DispatchError && HALT_ERROR_CODES.has(err.code)) {
+        halted = true;
+      }
+    }
+  }
   if (state.phase === "interrupted") {
   } else if (errors.length === 0 && state.phase !== "max-iterations" && state.phase !== "circuit-breaker") {
     state = { ...state, phase: "completed" };
@@ -5217,9 +5041,13 @@ function WorkflowGraph({ flow, currentTask, taskStates, taskMeta }) {
       if (isLoopBlock2(step)) break;
       if (typeof step === "string") {
         if (elements2.length > 0) elements2.push(/* @__PURE__ */ jsx2(Text2, { children: " \u2192 " }, `a-${step}`));
-        elements2.push(
-          /* @__PURE__ */ jsx2(TaskNode, { name: step, status: taskStates[step], spinnerFrame, driver: meta[step]?.driver }, `t-${step}`)
-        );
+        if (step === "story_flow") {
+          elements2.push(/* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "stories \u2713" }, "sf"));
+        } else {
+          elements2.push(
+            /* @__PURE__ */ jsx2(TaskNode, { name: step, status: taskStates[step], spinnerFrame, driver: meta[step]?.driver }, `t-${step}`)
+          );
+        }
       }
     }
     if (elements2.length > 0) elements2.push(/* @__PURE__ */ jsx2(Text2, { children: " \u2192 " }, "loop-arrow"));
@@ -5246,9 +5074,13 @@ function WorkflowGraph({ flow, currentTask, taskStates, taskMeta }) {
     if (elements.length > 0) {
       elements.push(/* @__PURE__ */ jsx2(Text2, { children: " \u2192 " }, `a-${step}`));
     }
-    elements.push(
-      /* @__PURE__ */ jsx2(TaskNode, { name: step, status: taskStates[step], spinnerFrame, driver: meta[step]?.driver }, `t-${step}`)
-    );
+    if (step === "story_flow") {
+      elements.push(/* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "stories \u2713" }, "sf"));
+    } else {
+      elements.push(
+        /* @__PURE__ */ jsx2(TaskNode, { name: step, status: taskStates[step], spinnerFrame, driver: meta[step]?.driver }, `t-${step}`)
+      );
+    }
   }
   return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsxs2(Text2, { children: [
     "  ",
@@ -5551,7 +5383,8 @@ function App({ state, onCycleLane, onQuit }) {
   }, { isActive: typeof process.stdin.setRawMode === "function" });
   const activeLaneCount = state.laneCount ?? 0;
   const termRows = process.stdout.rows || 24;
-  const fixedHeight = 10;
+  const staticLines = state.messages.length;
+  const fixedHeight = 10 + staticLines + 2;
   const availableHeight = Math.max(3, termRows - fixedHeight);
   return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
     /* @__PURE__ */ jsx7(Static, { items: state.messages, children: (msg, i) => /* @__PURE__ */ jsx7(StoryMessageLine, { msg }, i) }),
@@ -6287,32 +6120,25 @@ function registerRunCommand(program) {
         epicData[epicId] = { storiesDone: epic.storiesDone ?? 0, storiesTotal: epic.storiesTotal ?? 0 };
       }
     }
-    const preLoopTasks = /* @__PURE__ */ new Set();
-    const loopTasks = /* @__PURE__ */ new Set();
-    for (const step of parsedWorkflow.flow) {
-      if (typeof step === "string") {
-        preLoopTasks.add(step);
-      } else if (typeof step === "object" && "loop" in step) {
-        for (const lt of step.loop) loopTasks.add(lt);
-      }
+    const storyFlowTasks = /* @__PURE__ */ new Set();
+    for (const step of parsedWorkflow.storyFlow) {
+      if (typeof step === "string") storyFlowTasks.add(step);
     }
-    let pastLoop = false;
-    for (const step of parsedWorkflow.flow) {
+    const epicLoopTasks = /* @__PURE__ */ new Set();
+    for (const step of parsedWorkflow.epicFlow) {
       if (typeof step === "object" && "loop" in step) {
-        pastLoop = true;
-        continue;
+        for (const lt of step.loop) epicLoopTasks.add(lt);
       }
-      if (pastLoop && typeof step === "string") preLoopTasks.add(step);
     }
-    let inLoop = false;
+    let inEpicPhase = false;
     const taskStates = {};
     const taskMeta = {};
     for (const [tn, task] of Object.entries(parsedWorkflow.tasks)) {
       taskStates[tn] = "pending";
-      if (loopTasks.has(tn)) taskStates[`loop:${tn}`] = "pending";
+      if (epicLoopTasks.has(tn)) taskStates[`loop:${tn}`] = "pending";
       const driverLabel2 = task.model ?? task.driver ?? "claude-code";
       taskMeta[tn] = { driver: driverLabel2 };
-      if (loopTasks.has(tn)) taskMeta[`loop:${tn}`] = { driver: driverLabel2 };
+      if (epicLoopTasks.has(tn)) taskMeta[`loop:${tn}`] = { driver: driverLabel2 };
     }
     const storyEntries = [];
     for (const [key, status] of Object.entries(statuses)) {
@@ -6323,24 +6149,27 @@ function registerRunCommand(program) {
       else if (status === "failed") storyEntries.push({ key, status: "failed" });
     }
     renderer.updateStories(storyEntries);
-    renderer.updateWorkflowState(parsedWorkflow.flow, null, { ...taskStates }, { ...taskMeta });
+    renderer.updateWorkflowState(parsedWorkflow.storyFlow, null, { ...taskStates }, { ...taskMeta });
     const onEvent = (event) => {
       if (event.type === "stream-event" && event.streamEvent) {
         renderer.update(event.streamEvent, event.driverName);
       }
       if (event.type === "dispatch-start") {
-        if (event.storyKey !== currentStoryKey && preLoopTasks.has(event.taskName)) {
-          inLoop = false;
-          for (const tn of Object.keys(taskStates)) {
+        const isStoryTask = storyFlowTasks.has(event.taskName);
+        const isEpicTask = !isStoryTask;
+        if (isStoryTask && event.storyKey !== currentStoryKey) {
+          inEpicPhase = false;
+          for (const tn of storyFlowTasks) {
             taskStates[tn] = "pending";
           }
         }
+        if (isEpicTask && !inEpicPhase) {
+          inEpicPhase = true;
+        }
         currentStoryKey = event.storyKey;
         currentTaskName = event.taskName;
-        if (loopTasks.has(event.taskName) && taskStates[event.taskName] === "done") {
-          inLoop = true;
-        }
-        const stateKey = inLoop && loopTasks.has(event.taskName) ? `loop:${event.taskName}` : event.taskName;
+        const inLoop = inEpicPhase && epicLoopTasks.has(event.taskName) && taskStates[event.taskName] === "done";
+        const stateKey = inLoop ? `loop:${event.taskName}` : event.taskName;
         const epicId = extractEpicId2(event.storyKey);
         const epic = epicData[epicId];
         renderer.updateSprintState({
@@ -6355,33 +6184,29 @@ function registerRunCommand(program) {
           epicStoriesTotal: epic?.storiesTotal ?? 0
         });
         taskStates[stateKey] = "active";
-        renderer.updateWorkflowState(parsedWorkflow.flow, event.taskName, { ...taskStates }, { ...taskMeta });
-        updateStoryStatus2(event.storyKey, "in-progress");
-        const idx = storyEntries.findIndex((s) => s.key === event.storyKey);
-        if (idx >= 0 && storyEntries[idx].status === "pending") {
-          storyEntries[idx] = { ...storyEntries[idx], status: "in-progress" };
-          renderer.updateStories([...storyEntries]);
+        const displayFlow = inEpicPhase ? parsedWorkflow.epicFlow : parsedWorkflow.storyFlow;
+        renderer.updateWorkflowState(displayFlow, event.taskName, { ...taskStates }, { ...taskMeta });
+        if (isStoryTask) {
+          updateStoryStatus2(event.storyKey, "in-progress");
+          const idx = storyEntries.findIndex((s) => s.key === event.storyKey);
+          if (idx >= 0 && storyEntries[idx].status === "pending") {
+            storyEntries[idx] = { ...storyEntries[idx], status: "in-progress" };
+            renderer.updateStories([...storyEntries]);
+          }
         }
       }
       if (event.type === "dispatch-end") {
         totalCostUsd += event.costUsd ?? 0;
-        const stateKey = inLoop && loopTasks.has(event.taskName) ? `loop:${event.taskName}` : event.taskName;
+        const inLoop = inEpicPhase && epicLoopTasks.has(event.taskName) && taskStates[event.taskName] === "done";
+        const stateKey = inLoop ? `loop:${event.taskName}` : event.taskName;
         taskStates[stateKey] = "done";
         taskMeta[stateKey] = {
           ...taskMeta[stateKey],
           costUsd: (taskMeta[stateKey]?.costUsd ?? 0) + (event.costUsd ?? 0),
           elapsedMs: (taskMeta[stateKey]?.elapsedMs ?? 0) + (event.elapsedMs ?? 0)
         };
-        renderer.updateWorkflowState(parsedWorkflow.flow, event.taskName, { ...taskStates }, { ...taskMeta });
-        if (event.taskName === "verify") {
-          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 displayFlow = inEpicPhase ? parsedWorkflow.epicFlow : parsedWorkflow.storyFlow;
+        renderer.updateWorkflowState(displayFlow, event.taskName, { ...taskStates }, { ...taskMeta });
         renderer.updateSprintState({
           storyKey: event.storyKey,
           phase: event.taskName,
@@ -6389,11 +6214,25 @@ function registerRunCommand(program) {
           total: counts.total,
           totalCost: totalCostUsd
         });
+        if (storyFlowTasks.has(event.taskName)) {
+          const allStoryDone = [...storyFlowTasks].every((tn) => taskStates[tn] === "done");
+          if (allStoryDone) {
+            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]);
+            }
+          }
+        }
       }
       if (event.type === "dispatch-error") {
-        const stateKey = inLoop && loopTasks.has(event.taskName) ? `loop:${event.taskName}` : event.taskName;
+        const inLoop = inEpicPhase && epicLoopTasks.has(event.taskName);
+        const stateKey = inLoop ? `loop:${event.taskName}` : event.taskName;
         taskStates[stateKey] = "failed";
-        renderer.updateWorkflowState(parsedWorkflow.flow, event.taskName, { ...taskStates }, { ...taskMeta });
+        const displayFlow = inEpicPhase ? parsedWorkflow.epicFlow : parsedWorkflow.storyFlow;
+        renderer.updateWorkflowState(displayFlow, event.taskName, { ...taskStates }, { ...taskMeta });
         renderer.addMessage({
           type: "fail",
           key: event.storyKey,
@@ -6415,7 +6254,6 @@ function registerRunCommand(program) {
       runId: `run-${Date.now()}`,
       projectDir,
       abortSignal: abortController.signal,
-      storyPipeline: true,
       maxIterations,
       onEvent
     };
@@ -11297,7 +11135,7 @@ function registerTeardownCommand(program) {
     } else if (otlpMode === "remote-routed") {
       if (!options.keepDocker) {
         try {
-          const { stopCollectorOnly: stopCollectorOnly2 } = await import("./docker-RHFGKHJV.js");
+          const { stopCollectorOnly: stopCollectorOnly2 } = await import("./docker-R4444RHQ.js");
           stopCollectorOnly2();
           result.docker.stopped = true;
           if (!isJson) {
@@ -11329,7 +11167,7 @@ function registerTeardownCommand(program) {
         info("Shared stack: kept running (other projects may use it)");
       }
     } else if (isLegacyStack) {
-      const { isStackRunning: isStackRunning2, stopStack } = await import("./docker-RHFGKHJV.js");
+      const { isStackRunning: isStackRunning2, stopStack } = await import("./docker-R4444RHQ.js");
       let stackRunning = false;
       try {
         stackRunning = isStackRunning2(composeFile);
@@ -14316,7 +14154,7 @@ function registerDriversCommand(program) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.31.6" : "0.0.0-dev";
+var VERSION = true ? "0.32.0" : "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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeharness",
-  "version": "0.31.6",
+  "version": "0.32.0",
   "type": "module",
   "description": "CLI for codeharness — makes autonomous coding agents produce software that actually works",
   "bin": {

package/templates/workflows/default.yaml

@@ -1,52 +1,48 @@
 tasks:
   create-story:
     agent: story-creator
-    scope: per-story
     session: fresh
     source_access: true
     model: claude-opus-4-6
   implement:
     agent: dev
-    scope: per-story
     session: fresh
     source_access: true
     model: claude-sonnet-4-6
   check:
     agent: checker
-    scope: per-story
     session: fresh
     source_access: true
     driver: codex
   review:
     agent: reviewer
-    scope: per-story
     session: fresh
     source_access: true
     driver: codex
   verify:
     agent: evaluator
-    scope: per-story
     session: fresh
     source_access: false
     driver: codex
   retry:
     agent: dev
-    scope: per-story
     session: fresh
     source_access: true
     model: claude-sonnet-4-6
   retro:
     agent: retro
-    scope: per-epic
     session: fresh
     source_access: true
     model: claude-opus-4-6
 
-flow:
+story_flow:
   - create-story
   - implement
   - check
   - review
+
+epic_flow:
+  - story_flow
   - verify
   - loop:
       - retry