codeharness 0.29.4 → 0.30.1

package/dist/{chunk-KVKEUNEB.js → chunk-QLY7NJIB.js}

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

package/dist/{docker-PYH5XATT.js → docker-P65B7Z3S.js}

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

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   validateDockerfile,
   warn,
   writeState
-} from "./chunk-KVKEUNEB.js";
+} from "./chunk-QLY7NJIB.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -3882,75 +3882,165 @@ async function executeWorkflow(config) {
   let halted = false;
   let lastOutputContract = null;
   let accumulatedCostUsd = 0;
-  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 (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 (loopResult.halted) {
+      if (typeof s === "string") preTasks.push(s);
+    }
+    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;
       }
-      if (state.phase === "max-iterations" || state.phase === "circuit-breaker") {
-        halted = true;
+      processedStories.add(item.key);
+      for (const taskName of preTasks) {
+        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;
+        }
       }
-      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;
+    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 nullResult = await executeNullTask(
-            task,
-            taskName,
-            PER_RUN_SENTINEL,
-            state,
-            config,
-            lastOutputContract ?? void 0,
-            accumulatedCostUsd
-          );
-          state = nullResult.updatedState;
-          lastOutputContract = nullResult.contract;
+          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 = isEngineError(err) ? err : handleDispatchError(err, taskName, PER_RUN_SENTINEL);
+          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);
+            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 (isTaskCompleted(state, taskName, item.key)) {
-            warn(`workflow-engine: skipping completed task ${taskName} for ${item.key}`);
+        }
+        if (loopResult.halted) {
+          halted = true;
+        }
+        if (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 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,
-              item.key,
+              PER_RUN_SENTINEL,
               state,
               config,
               lastOutputContract ?? void 0,
@@ -3960,71 +4050,56 @@ async function executeWorkflow(config) {
             lastOutputContract = nullResult.contract;
             tasksCompleted++;
           } catch (err) {
-            const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, item.key);
+            const engineError = isEngineError(err) ? err : handleDispatchError(err, taskName, PER_RUN_SENTINEL);
             errors.push(engineError);
-            state = recordErrorInState(state, taskName, item.key, 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;
-        }
+      const definition = config.agents[task.agent];
+      if (!definition) {
+        warn(`workflow-engine: agent "${task.agent}" not found for task "${taskName}", skipping`);
+        continue;
       }
-    } else {
-      for (const item of workItems) {
-        if (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 (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,
-            item.key,
+            PER_RUN_SENTINEL,
             definition,
             state,
             config,
@@ -4037,24 +4112,65 @@ async function executeWorkflow(config) {
           accumulatedCostUsd += dispatchResult.contract?.cost_usd ?? 0;
           tasksCompleted++;
         } catch (err) {
-          const engineError = handleDispatchError(err, taskName, item.key);
+          const engineError = handleDispatchError(err, taskName, PER_RUN_SENTINEL);
           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, storyKey: PER_RUN_SENTINEL, error: { code: engineError.code, message: engineError.message } });
           } else {
-            warn(`[${taskName}] ${item.key} \u2014 ERROR: [${engineError.code}] ${engineError.message}`);
+            warn(`[${taskName}] ${PER_RUN_SENTINEL} \u2014 ERROR: [${engineError.code}] ${engineError.message}`);
           }
-          state = recordErrorInState(state, taskName, item.key, engineError);
+          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) {
+            halted = true;
             break;
           }
-          continue;
+          processedStories.add(item.key);
+          if (isTaskCompleted(state, taskName, item.key)) {
+            warn(`workflow-engine: skipping completed task ${taskName} for ${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;
+            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;
+            }
+            continue;
+          }
         }
       }
     }
-  }
   if (state.phase === "interrupted") {
   } else if (errors.length === 0 && state.phase !== "max-iterations" && state.phase !== "circuit-breaker") {
     state = { ...state, phase: "completed" };
@@ -4930,15 +5046,29 @@ function CompletedTool({ entry }) {
     entry.driver && /* @__PURE__ */ jsx(Text, { dimColor: true, children: ` (${entry.driver})` })
   ] });
 }
-var VISIBLE_COMPLETED_TOOLS = 5;
-function CompletedTools({ tools }) {
-  const visible = tools.slice(-VISIBLE_COMPLETED_TOOLS);
+var DEFAULT_VISIBLE_TOOLS = 5;
+function CompletedTools({ tools, maxVisible }) {
+  const limit = maxVisible ?? DEFAULT_VISIBLE_TOOLS;
+  const visible = tools.slice(-limit);
   const hidden = tools.length - visible.length;
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
     hidden > 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \u2026 ${hidden} earlier tools` }),
     visible.map((entry, i) => /* @__PURE__ */ jsx(CompletedTool, { entry }, i))
   ] });
 }
+function ActivitySection({ completedTools, activeTool, activeDriverName, lastThought, retryInfo, availableHeight }) {
+  let reserved = 0;
+  if (activeTool) reserved++;
+  if (lastThought) reserved++;
+  if (retryInfo) reserved++;
+  const toolsHeight = Math.max(1, availableHeight - reserved - 1);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [
+    /* @__PURE__ */ jsx(CompletedTools, { tools: completedTools, maxVisible: toolsHeight }),
+    activeTool && /* @__PURE__ */ jsx(ActiveTool, { name: activeTool.name, driverName: activeDriverName }),
+    lastThought && /* @__PURE__ */ jsx(LastThought, { text: lastThought }),
+    retryInfo && /* @__PURE__ */ jsx(RetryNotice, { info: retryInfo })
+  ] });
+}
 function ActiveTool({ name, driverName }) {
   return /* @__PURE__ */ jsxs(Box, { children: [
     /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u26A1 " }),
@@ -4964,13 +5094,6 @@ function RetryNotice({ info: info3 }) {
     "ms)"
   ] });
 }
-function DriverCostSummary({ driverCosts }) {
-  if (!driverCosts) return null;
-  const entries = Object.entries(driverCosts).sort(([a], [b]) => a.localeCompare(b));
-  if (entries.length === 0) return null;
-  const parts = entries.map(([driver, cost]) => `${driver} $${cost.toFixed(2)}`).join(", ");
-  return /* @__PURE__ */ jsx(Text, { dimColor: true, children: `Cost: ${parts}` });
-}
 
 // src/lib/ink-app.tsx
 import { Box as Box7, Static, Text as Text7, useInput } from "ink";
@@ -5430,39 +5553,49 @@ function LaneActivityHeader({ activeLaneId, laneCount }) {
   if (laneCount <= 1 || !activeLaneId) return null;
   return /* @__PURE__ */ jsx7(Text7, { children: /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: `[Lane ${activeLaneId} \u25B8]` }) });
 }
-function App({ state, onCycleLane }) {
+function App({ state, onCycleLane, onQuit }) {
   const lanes = state.lanes;
   const laneCount = lanes?.length ?? 0;
   const terminalWidth = process.stdout.columns || 80;
-  useInput((_input, key) => {
-    if (key.ctrl && _input === "l" && onCycleLane && laneCount > 1) {
+  useInput((input, key) => {
+    if (key.ctrl && input === "l" && onCycleLane && laneCount > 1) {
       onCycleLane();
     }
+    if (input === "q" && onQuit) {
+      onQuit();
+    }
   }, { isActive: typeof process.stdin.setRawMode === "function" });
   const activeLaneCount = state.laneCount ?? 0;
+  const termRows = process.stdout.rows || 24;
+  const fixedHeight = 10;
+  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) }),
     /* @__PURE__ */ jsx7(Header, { info: state.sprintInfo, laneCount: laneCount > 1 ? laneCount : void 0 }),
-    laneCount > 1 ? /* @__PURE__ */ jsx7(LaneContainer, { lanes, terminalWidth }) : /* @__PURE__ */ jsxs7(Fragment, { children: [
-      /* @__PURE__ */ jsx7(WorkflowGraph, { flow: state.workflowFlow, currentTask: state.currentTaskName, taskStates: state.taskStates, taskMeta: state.taskMeta }),
-      /* @__PURE__ */ jsx7(StoryBreakdown, { stories: state.stories, sprintInfo: state.sprintInfo }),
-      /* @__PURE__ */ jsx7(DriverCostSummary, { driverCosts: state.driverCosts })
-    ] }),
-    laneCount > 1 && state.summaryBar && /* @__PURE__ */ jsxs7(Fragment, { children: [
+    laneCount > 1 ? /* @__PURE__ */ jsxs7(Fragment, { children: [
+      /* @__PURE__ */ jsx7(LaneContainer, { lanes, terminalWidth }),
+      state.summaryBar && /* @__PURE__ */ jsxs7(Fragment, { children: [
+        /* @__PURE__ */ jsx7(Separator, {}),
+        /* @__PURE__ */ jsx7(SummaryBar, { ...state.summaryBar })
+      ] }),
+      state.mergeState && /* @__PURE__ */ jsxs7(Fragment, { children: [
+        /* @__PURE__ */ jsx7(Separator, {}),
+        /* @__PURE__ */ jsx7(MergeStatus, { mergeState: state.mergeState })
+      ] }),
       /* @__PURE__ */ jsx7(Separator, {}),
-      /* @__PURE__ */ jsx7(SummaryBar, { ...state.summaryBar })
-    ] }),
-    laneCount > 1 && state.mergeState && /* @__PURE__ */ jsxs7(Fragment, { children: [
+      /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", paddingLeft: 1, children: [
+        /* @__PURE__ */ jsx7(LaneActivityHeader, { activeLaneId: state.activeLaneId ?? null, laneCount: activeLaneCount }),
+        /* @__PURE__ */ jsx7(ActivitySection, { completedTools: state.completedTools, activeTool: state.activeTool, activeDriverName: state.activeDriverName, lastThought: state.lastThought, retryInfo: state.retryInfo, availableHeight })
+      ] })
+    ] }) : /* @__PURE__ */ jsxs7(Fragment, { children: [
       /* @__PURE__ */ jsx7(Separator, {}),
-      /* @__PURE__ */ jsx7(MergeStatus, { mergeState: state.mergeState })
-    ] }),
-    (state.stories.length > 0 || laneCount > 1 && (state.summaryBar || state.mergeState)) && /* @__PURE__ */ jsx7(Separator, {}),
-    /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", paddingLeft: 1, children: [
-      /* @__PURE__ */ jsx7(LaneActivityHeader, { activeLaneId: state.activeLaneId ?? null, laneCount: activeLaneCount }),
-      /* @__PURE__ */ jsx7(CompletedTools, { tools: state.completedTools }),
-      state.activeTool && /* @__PURE__ */ jsx7(ActiveTool, { name: state.activeTool.name, driverName: state.activeDriverName }),
-      state.lastThought && /* @__PURE__ */ jsx7(LastThought, { text: state.lastThought }),
-      state.retryInfo && /* @__PURE__ */ jsx7(RetryNotice, { info: state.retryInfo })
+      /* @__PURE__ */ jsx7(ProgressBar, { done: state.sprintInfo?.done ?? 0, total: state.sprintInfo?.total ?? 0 }),
+      /* @__PURE__ */ jsx7(EpicInfo, { info: state.sprintInfo }),
+      /* @__PURE__ */ jsx7(StoryContext, { entries: state.storyContext ?? [] }),
+      /* @__PURE__ */ jsx7(Separator, {}),
+      /* @__PURE__ */ jsx7(WorkflowGraph, { flow: state.workflowFlow, currentTask: state.currentTaskName, taskStates: state.taskStates }),
+      /* @__PURE__ */ jsx7(Separator, {}),
+      /* @__PURE__ */ jsx7(ActivitySection, { completedTools: state.completedTools, activeTool: state.activeTool, activeDriverName: state.activeDriverName, lastThought: state.lastThought, retryInfo: state.retryInfo, availableHeight })
     ] })
   ] });
 }
@@ -5483,133 +5616,48 @@ function formatCost3(cost) {
 function Header({ info: info3, laneCount }) {
   if (!info3) return null;
   const parts = ["codeharness run"];
-  if (laneCount != null && laneCount > 1) {
-    parts.push(`${laneCount} lanes`);
-  }
-  if (info3.iterationCount != null) {
-    parts.push(`iteration ${info3.iterationCount}`);
-  }
-  if (info3.elapsed) {
-    parts.push(`${info3.elapsed} elapsed`);
-  }
+  if (laneCount != null && laneCount > 1) parts.push(`${laneCount} lanes`);
+  if (info3.elapsed) parts.push(`${info3.elapsed} elapsed`);
   const displayCost = laneCount != null && laneCount > 1 && info3.laneTotalCost != null ? info3.laneTotalCost : info3.totalCost;
-  if (displayCost != null) {
-    parts.push(`${formatCost3(displayCost)} spent`);
-  }
-  const headerLine = parts.join(" | ");
-  let phaseLine = "";
-  if (info3.phase) {
-    phaseLine = `Phase: ${info3.phase}`;
-    if (info3.acProgress) {
-      phaseLine += ` \u2192 AC ${info3.acProgress}`;
-    }
-    if (info3.currentCommand) {
-      phaseLine += ` (${info3.currentCommand})`;
-    }
-  }
-  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx8(Text8, { children: headerLine }),
-    /* @__PURE__ */ jsx8(Separator, {}),
-    /* @__PURE__ */ jsx8(Text8, { children: `Story: ${info3.storyKey || "(waiting)"}` }),
-    phaseLine && /* @__PURE__ */ jsx8(Text8, { children: phaseLine })
+  if (displayCost != null) parts.push(`${formatCost3(displayCost)} spent`);
+  const left = parts.join(" | ");
+  const right = "[q to quit]";
+  const width = process.stdout.columns || 80;
+  const pad = Math.max(0, width - left.length - right.length);
+  return /* @__PURE__ */ jsxs8(Text8, { children: [
+    left,
+    " ".repeat(pad),
+    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: right })
   ] });
 }
-function StoryBreakdown({ stories, sprintInfo }) {
-  if (stories.length === 0) return null;
-  const done = [];
-  const inProgress = [];
-  const pending = [];
-  const failed = [];
-  const blocked = [];
-  for (const s of stories) {
-    switch (s.status) {
-      case "done":
-        done.push(s);
-        break;
-      case "in-progress":
-        inProgress.push(s);
-        break;
-      case "pending":
-        pending.push(s);
-        break;
-      case "failed":
-        failed.push(s);
-        break;
-      case "blocked":
-        blocked.push(s);
-        break;
-    }
-  }
-  const lines = [];
-  if (done.length > 0) {
-    const doneItems = done.map((s) => {
-      let item = `${shortKey(s.key)} \u2713`;
-      if (s.costByDriver && Object.keys(s.costByDriver).length > 0) {
-        const costParts = Object.keys(s.costByDriver).sort().map(
-          (driver) => `${driver} ${formatCost3(s.costByDriver[driver])}`
-        );
-        item += ` ${costParts.join(", ")}`;
-      }
-      return item;
-    }).join("  ");
-    lines.push(
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        /* @__PURE__ */ jsx8(Text8, { color: "green", children: "Done: " }),
-        /* @__PURE__ */ jsx8(Text8, { color: "green", children: doneItems })
-      ] }, "done")
-    );
-  }
-  if (inProgress.length > 0) {
-    for (const s of inProgress) {
-      let thisText = `${shortKey(s.key)} \u25C6`;
-      if (sprintInfo && sprintInfo.storyKey && shortKey(s.key) === shortKey(sprintInfo.storyKey)) {
-        if (sprintInfo.phase) thisText += ` ${sprintInfo.phase}`;
-        if (sprintInfo.acProgress) thisText += ` (${sprintInfo.acProgress} ACs)`;
-      }
-      lines.push(
-        /* @__PURE__ */ jsxs8(Text8, { children: [
-          /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: "This: " }),
-          /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: thisText })
-        ] }, `this-${s.key}`)
-      );
-    }
-  }
-  if (pending.length > 0) {
-    lines.push(
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        /* @__PURE__ */ jsx8(Text8, { children: "Next: " }),
-        /* @__PURE__ */ jsx8(Text8, { children: shortKey(pending[0].key) }),
-        pending.length > 1 && /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: ` (+${pending.length - 1} more)` })
-      ] }, "next")
-    );
-  }
-  if (blocked.length > 0) {
-    const blockedItems = blocked.map((s) => {
-      let item = `${shortKey(s.key)} \u2715`;
-      if (s.retryCount != null && s.maxRetries != null) item += ` (${s.retryCount}/${s.maxRetries})`;
-      return item;
-    }).join("  ");
-    lines.push(
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "Blocked: " }),
-        /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: blockedItems })
-      ] }, "blocked")
-    );
-  }
-  if (failed.length > 0) {
-    const failedItems = failed.map((s) => {
-      let item = `${shortKey(s.key)} \u2717`;
-      if (s.retryCount != null && s.maxRetries != null) item += ` (${s.retryCount}/${s.maxRetries})`;
-      return item;
-    }).join("  ");
-    lines.push(
-      /* @__PURE__ */ jsxs8(Text8, { children: [
-        /* @__PURE__ */ jsx8(Text8, { color: "red", children: "Failed: " }),
-        /* @__PURE__ */ jsx8(Text8, { color: "red", children: failedItems })
-      ] }, "failed")
-    );
-  }
-  return /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", children: lines });
+function ProgressBar({ done, total }) {
+  const width = Math.max(10, (process.stdout.columns || 80) - 30);
+  const pct = total > 0 ? done / total : 0;
+  const filled = Math.round(width * pct);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+  const pctStr = total > 0 ? `${Math.round(pct * 100)}%` : "0%";
+  return /* @__PURE__ */ jsxs8(Text8, { children: [
+    "Progress: ",
+    /* @__PURE__ */ jsx8(Text8, { color: "green", children: bar }),
+    ` ${done}/${total} stories (${pctStr})`
+  ] });
+}
+function EpicInfo({ info: info3 }) {
+  if (!info3?.epicId) return null;
+  const title = info3.epicTitle ?? `Epic ${info3.epicId}`;
+  const progress = info3.epicStoriesTotal ? ` \u2014 ${info3.epicStoriesDone ?? 0}/${info3.epicStoriesTotal} stories done` : "";
+  return /* @__PURE__ */ jsxs8(Text8, { children: [
+    /* @__PURE__ */ jsx8(Text8, { bold: true, children: `Epic ${info3.epicId}: ${title}` }),
+    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: progress })
+  ] });
+}
+function StoryContext({ entries }) {
+  if (entries.length === 0) return null;
+  return /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", children: entries.map((e, i) => {
+    if (e.role === "prev") return /* @__PURE__ */ jsx8(Text8, { children: /* @__PURE__ */ jsx8(Text8, { color: "green", children: `  Prev: ${shortKey(e.key)} \u2713` }) }, i);
+    if (e.role === "current") return /* @__PURE__ */ jsx8(Text8, { children: /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: `  This: ${shortKey(e.key)} \u25C6 ${e.task ?? ""}` }) }, i);
+    return /* @__PURE__ */ jsx8(Text8, { children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: `  Next: ${shortKey(e.key)}` }) }, i);
+  }) });
 }
 
 // src/lib/ink-renderer.tsx
@@ -5652,6 +5700,7 @@ function startRenderer(options) {
     taskMeta: {},
     activeDriverName: null,
     driverCosts: {},
+    storyContext: [],
     activeLaneId: null,
     laneCount: 0
   };
@@ -5661,7 +5710,8 @@ function startRenderer(options) {
   let lastStoryKey = state.sprintInfo?.storyKey ?? null;
   const pendingStoryCosts = /* @__PURE__ */ new Map();
   let cleaned = false;
-  const inkInstance = inkRender(/* @__PURE__ */ jsx9(App, { state, onCycleLane: () => cycleLane() }), {
+  const onQuit = options?.onQuit;
+  const inkInstance = inkRender(/* @__PURE__ */ jsx9(App, { state, onCycleLane: () => cycleLane(), onQuit: onQuit ? () => onQuit() : void 0 }), {
     exitOnCtrlC: false,
     patchConsole: !options?._forceTTY,
     maxFps: 15
@@ -5669,7 +5719,7 @@ function startRenderer(options) {
   function rerender() {
     if (!cleaned) {
       state = { ...state };
-      inkInstance.rerender(/* @__PURE__ */ jsx9(App, { state, onCycleLane: () => cycleLane() }));
+      inkInstance.rerender(/* @__PURE__ */ jsx9(App, { state, onCycleLane: () => cycleLane(), onQuit: onQuit ? () => onQuit() : void 0 }));
     }
   }
   const heartbeat = setInterval(() => {
@@ -6005,6 +6055,24 @@ function startRenderer(options) {
       lastStoryKey = currentKey;
     }
     state.stories = updatedStories;
+    const ctx = [];
+    const currentStory = currentKey ?? "";
+    const currentTask = state.currentTaskName ?? "";
+    let foundCurrent = false;
+    let prevKey = null;
+    for (const s of updatedStories) {
+      if (s.key === currentStory) {
+        if (prevKey) ctx.push({ key: prevKey, role: "prev" });
+        ctx.push({ key: s.key, role: "current", task: currentTask });
+        foundCurrent = true;
+      } else if (foundCurrent && s.status === "pending") {
+        ctx.push({ key: s.key, role: "next" });
+        break;
+      } else if (s.status === "done") {
+        prevKey = s.key;
+      }
+    }
+    state.storyContext = ctx;
     rerender();
   }
   function addMessage(msg) {
@@ -6175,17 +6243,8 @@ function registerRunCommand(program) {
       }
     }
     const abortController = new AbortController();
-    const renderer = startRenderer({
-      quiet: !!options.quiet || isJson,
-      sprintState: {
-        storyKey: "",
-        phase: "executing",
-        done: counts.done,
-        total: counts.total,
-        totalCost: 0
-      }
-    });
     let interrupted = false;
+    let renderer;
     const onInterrupt = () => {
       if (interrupted) {
         process.exit(1);
@@ -6195,6 +6254,17 @@ function registerRunCommand(program) {
       abortController.abort();
       info("Interrupted \u2014 waiting for current task to finish...", outputOpts);
     };
+    renderer = startRenderer({
+      quiet: !!options.quiet || isJson,
+      sprintState: {
+        storyKey: "",
+        phase: "executing",
+        done: counts.done,
+        total: counts.total,
+        totalCost: 0
+      },
+      onQuit: () => onInterrupt()
+    });
     process.on("SIGINT", onInterrupt);
     process.on("SIGTERM", onInterrupt);
     const sessionStartMs = Date.now();
@@ -6204,15 +6274,28 @@ function registerRunCommand(program) {
     let currentTaskName = "";
     const headerRefresh = setInterval(() => {
       if (interrupted) return;
+      const epicId = currentStoryKey ? extractEpicId2(currentStoryKey) : "";
+      const epic = epicId ? epicData[epicId] : void 0;
       renderer.updateSprintState({
         storyKey: currentStoryKey,
         phase: currentTaskName,
         done: storiesDone,
         total: counts.total,
         totalCost: totalCostUsd,
-        elapsed: formatElapsed(Date.now() - sessionStartMs)
+        elapsed: formatElapsed(Date.now() - sessionStartMs),
+        epicId: epicId || void 0,
+        epicStoriesDone: epic?.storiesDone,
+        epicStoriesTotal: epic?.storiesTotal
       });
     }, 2e3);
+    const epicData = {};
+    const sprintStateResult = getSprintState2();
+    if (sprintStateResult.success) {
+      for (const [epicKey, epic] of Object.entries(sprintStateResult.data.epics ?? {})) {
+        const epicId = epicKey.replace("epic-", "");
+        epicData[epicId] = { storiesDone: epic.storiesDone ?? 0, storiesTotal: epic.storiesTotal ?? 0 };
+      }
+    }
     const taskStates = {};
     const taskMeta = {};
     for (const [tn, task] of Object.entries(parsedWorkflow.tasks)) {
@@ -6235,13 +6318,18 @@ function registerRunCommand(program) {
       if (event.type === "dispatch-start") {
         currentStoryKey = event.storyKey;
         currentTaskName = event.taskName;
+        const epicId = extractEpicId2(event.storyKey);
+        const epic = epicData[epicId];
         renderer.updateSprintState({
           storyKey: event.storyKey,
           phase: event.taskName,
           done: storiesDone,
           total: counts.total,
           totalCost: totalCostUsd,
-          elapsed: formatElapsed(Date.now() - sessionStartMs)
+          elapsed: formatElapsed(Date.now() - sessionStartMs),
+          epicId,
+          epicStoriesDone: epic?.storiesDone ?? 0,
+          epicStoriesTotal: epic?.storiesTotal ?? 0
         });
         taskStates[event.taskName] = "active";
         renderer.updateWorkflowState(parsedWorkflow.flow, event.taskName, { ...taskStates }, { ...taskMeta });
@@ -6286,6 +6374,7 @@ function registerRunCommand(program) {
       runId: `run-${Date.now()}`,
       projectDir,
       abortSignal: abortController.signal,
+      storyPipeline: true,
       maxIterations,
       onEvent
     };
@@ -11167,7 +11256,7 @@ function registerTeardownCommand(program) {
     } else if (otlpMode === "remote-routed") {
       if (!options.keepDocker) {
         try {
-          const { stopCollectorOnly: stopCollectorOnly2 } = await import("./docker-PYH5XATT.js");
+          const { stopCollectorOnly: stopCollectorOnly2 } = await import("./docker-P65B7Z3S.js");
           stopCollectorOnly2();
           result.docker.stopped = true;
           if (!isJson) {
@@ -11199,7 +11288,7 @@ function registerTeardownCommand(program) {
         info("Shared stack: kept running (other projects may use it)");
       }
     } else if (isLegacyStack) {
-      const { isStackRunning: isStackRunning2, stopStack } = await import("./docker-PYH5XATT.js");
+      const { isStackRunning: isStackRunning2, stopStack } = await import("./docker-P65B7Z3S.js");
       let stackRunning = false;
       try {
         stackRunning = isStackRunning2(composeFile);
@@ -14095,7 +14184,7 @@ function registerDriversCommand(program) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.29.4" : "0.0.0-dev";
+var VERSION = true ? "0.30.1" : "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.29.4",
+  "version": "0.30.1",
   "type": "module",
   "description": "CLI for codeharness — makes autonomous coding agents produce software that actually works",
   "bin": {