codeharness 0.29.0 → 0.29.2

package/dist/index.js

@@ -40,7 +40,7 @@ import {
   validateDockerfile,
   warn,
   writeState
-} from "./chunk-PTHST5Z7.js";
+} from "./chunk-3ZSXMCZV.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -1896,7 +1896,7 @@ var AgentResolveError = class extends Error {
   }
 };
 var TEMPLATES_DIR = resolve2(getPackageRoot(), "templates/agents");
-var DEFAULT_MODEL = "claude-sonnet-4-6-20250514";
+var DEFAULT_MODEL = "claude-sonnet-4-6";
 var SAFE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
 function validateName(name) {
   if (!name || !SAFE_NAME_RE.test(name)) {
@@ -3357,7 +3357,12 @@ ${coverageDedup}`;
     ...task.plugins ?? definition.plugins ? { plugins: task.plugins ?? definition.plugins } : {},
     ...task.max_budget_usd != null ? { timeout: task.max_budget_usd } : {}
   };
-  info(`[${taskName}] ${storyKey} \u2014 dispatching via ${driverName} (model: ${model})`);
+  const emit = config.onEvent;
+  if (emit) {
+    emit({ type: "dispatch-start", taskName, storyKey, driverName, model });
+  } else {
+    info(`[${taskName}] ${storyKey} \u2014 dispatching via ${driverName} (model: ${model})...`);
+  }
   let output = "";
   let resultSessionId = "";
   let cost = 0;
@@ -3368,6 +3373,9 @@ ${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;
       }
@@ -3407,6 +3415,13 @@ ${coverageDedup}`;
       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 (errorEvent) {
     const categoryToCode = {
       RATE_LIMIT: "RATE_LIMIT",
@@ -3976,6 +3991,11 @@ async function executeWorkflow(config) {
       } 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)) {
@@ -4008,6 +4028,11 @@ async function executeWorkflow(config) {
         } 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)) {
@@ -4857,6 +4882,1145 @@ var LanePool = class {
   }
 };
 
+// src/lib/ink-renderer.tsx
+import { render as inkRender } from "ink";
+
+// src/lib/ink-components.tsx
+import { Text as Text8, Box as Box8 } from "ink";
+
+// src/lib/ink-activity-components.tsx
+import { Text, Box } from "ink";
+import { Spinner } from "@inkjs/ui";
+import { jsx, jsxs } from "react/jsx-runtime";
+var MESSAGE_STYLE = {
+  ok: { prefix: "[OK]", color: "green" },
+  warn: { prefix: "[WARN]", color: "yellow" },
+  fail: { prefix: "[FAIL]", color: "red" }
+};
+function StoryMessageLine({ msg }) {
+  const style = MESSAGE_STYLE[msg.type];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: style.color, bold: true, children: style.prefix }),
+      /* @__PURE__ */ jsx(Text, { children: ` Story ${msg.key}: ${msg.message}` })
+    ] }),
+    msg.details?.map((d, j) => /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \u2514 ${d}` }, j))
+  ] });
+}
+function CompletedTool({ entry }) {
+  const argsSummary = entry.args.length > 60 ? entry.args.slice(0, 60) + "\u2026" : entry.args;
+  return /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", children: [
+    /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2713 " }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[" }),
+    /* @__PURE__ */ jsx(Text, { children: entry.name }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "] " }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: argsSummary }),
+    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);
+  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 ActiveTool({ name, driverName }) {
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u26A1 " }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[" }),
+    /* @__PURE__ */ jsx(Text, { bold: true, children: name }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "] " }),
+    driverName && /* @__PURE__ */ jsx(Text, { dimColor: true, children: `(${driverName}) ` }),
+    /* @__PURE__ */ jsx(Spinner, { label: "" })
+  ] });
+}
+function LastThought({ text }) {
+  return /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", children: [
+    /* @__PURE__ */ jsx(Text, { children: "\u{1F4AD} " }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: text })
+  ] });
+}
+function RetryNotice({ info: info3 }) {
+  return /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+    "\u23F3 API retry ",
+    info3.attempt,
+    " (waiting ",
+    info3.delay,
+    "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";
+
+// src/lib/ink-workflow.tsx
+import { Text as Text2, Box as Box2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var termWidth = () => Math.min(process.stdout.columns || 60, 80);
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function isLoopBlock2(step) {
+  return typeof step === "object" && step !== null && "loop" in step;
+}
+function formatCost(costUsd) {
+  if (costUsd == null) return "...";
+  return `$${costUsd.toFixed(2)}`;
+}
+function formatElapsed2(ms) {
+  if (ms == null) return "...";
+  const seconds = Math.round(ms / 1e3);
+  if (seconds >= 60) {
+    return `${Math.floor(seconds / 60)}m`;
+  }
+  return `${seconds}s`;
+}
+function TaskNode({ name, status, spinnerFrame }) {
+  const s = status ?? "pending";
+  switch (s) {
+    case "done":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+        name,
+        " \u2713"
+      ] });
+    case "active": {
+      const frame = SPINNER_FRAMES[(spinnerFrame ?? 0) % SPINNER_FRAMES.length];
+      return /* @__PURE__ */ jsxs2(Text2, { color: "cyan", children: [
+        frame,
+        " ",
+        name
+      ] });
+    }
+    case "failed":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+        name,
+        " \u2717"
+      ] });
+    case "pending":
+    default:
+      return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: name });
+  }
+}
+function loopIteration(tasks, taskStates) {
+  const anyStarted = tasks.some((t) => {
+    const s = taskStates[t];
+    return s !== void 0 && s !== "pending";
+  });
+  return anyStarted ? 1 : 0;
+}
+function collectTaskNames(flow) {
+  const names = [];
+  for (const step of flow) {
+    if (isLoopBlock2(step)) {
+      names.push(...step.loop);
+    } else {
+      names.push(step);
+    }
+  }
+  return names;
+}
+function hasMetaData(taskMeta) {
+  if (!taskMeta) return false;
+  return Object.keys(taskMeta).length > 0;
+}
+function WorkflowGraph({ flow, currentTask, taskStates, taskMeta }) {
+  if (flow.length === 0 || Object.keys(taskStates).length === 0) {
+    return null;
+  }
+  const meta = taskMeta ?? {};
+  const showMeta = hasMetaData(taskMeta);
+  const spinnerFrame = Math.floor(Date.now() / 80);
+  const elements = [];
+  for (let i = 0; i < flow.length; i++) {
+    const step = flow[i];
+    if (i > 0) {
+      elements.push(/* @__PURE__ */ jsx2(Text2, { children: " \u2192 " }, `arrow-${i}`));
+    }
+    if (isLoopBlock2(step)) {
+      const iteration = loopIteration(step.loop, taskStates);
+      const loopNodes = [];
+      for (let j = 0; j < step.loop.length; j++) {
+        if (j > 0) {
+          loopNodes.push(/* @__PURE__ */ jsx2(Text2, { children: " \u2192 " }, `loop-arrow-${i}-${j}`));
+        }
+        loopNodes.push(
+          /* @__PURE__ */ jsx2(TaskNode, { name: step.loop[j], status: taskStates[step.loop[j]], spinnerFrame }, `loop-task-${i}-${j}`)
+        );
+      }
+      elements.push(
+        /* @__PURE__ */ jsxs2(Text2, { children: [
+          /* @__PURE__ */ jsxs2(Text2, { children: [
+            "loop(",
+            iteration,
+            ")[ "
+          ] }),
+          loopNodes,
+          /* @__PURE__ */ jsx2(Text2, { children: " ]" })
+        ] }, `loop-${i}`)
+      );
+    } else {
+      elements.push(
+        /* @__PURE__ */ jsx2(TaskNode, { name: step, status: taskStates[step], spinnerFrame }, `task-${i}`)
+      );
+    }
+  }
+  let driverRow = null;
+  let costRow = null;
+  if (showMeta) {
+    const taskNames = collectTaskNames(flow);
+    const driverParts = [];
+    const costParts = [];
+    let hasAnyCost = false;
+    for (const name of taskNames) {
+      const m = meta[name];
+      const driver = m?.driver ?? "";
+      driverParts.push(driver);
+      const state = taskStates[name];
+      if (state === "done") {
+        const costStr = formatCost(m?.costUsd);
+        const timeStr = formatElapsed2(m?.elapsedMs);
+        costParts.push(`${costStr} / ${timeStr}`);
+        hasAnyCost = true;
+      } else {
+        costParts.push("");
+      }
+    }
+    const hasSomeDriver = driverParts.some((d) => d.length > 0);
+    if (hasSomeDriver) {
+      const driverLabels = [];
+      for (let idx = 0; idx < taskNames.length; idx++) {
+        if (idx > 0) {
+          driverLabels.push(/* @__PURE__ */ jsx2(Text2, { children: "   " }, `drv-sep-${idx}`));
+        }
+        driverLabels.push(
+          /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: driverParts[idx] || " " }, `drv-${idx}`)
+        );
+      }
+      driverRow = /* @__PURE__ */ jsxs2(Text2, { children: [
+        "  ",
+        driverLabels
+      ] });
+    }
+    if (hasAnyCost) {
+      const costLabels = [];
+      for (let idx = 0; idx < taskNames.length; idx++) {
+        if (idx > 0) {
+          costLabels.push(/* @__PURE__ */ jsx2(Text2, { children: "   " }, `cost-sep-${idx}`));
+        }
+        costLabels.push(
+          /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: costParts[idx] || " " }, `cost-${idx}`)
+        );
+      }
+      costRow = /* @__PURE__ */ jsxs2(Text2, { children: [
+        "  ",
+        costLabels
+      ] });
+    }
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Text2, { children: "\u2501".repeat(termWidth()) }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      "  ",
+      elements
+    ] }),
+    driverRow,
+    costRow,
+    /* @__PURE__ */ jsx2(Text2, { children: "\u2501".repeat(termWidth()) })
+  ] });
+}
+
+// src/lib/ink-lane-container.tsx
+import { Text as Text4, Box as Box4 } from "ink";
+
+// src/lib/ink-lane.tsx
+import { Text as Text3, Box as Box3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function formatLaneCost(cost) {
+  if (cost == null) return "--";
+  return `$${cost.toFixed(2)}`;
+}
+function formatLaneElapsed(ms) {
+  if (ms == null) return "--";
+  const totalSeconds = Math.round(ms / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  if (minutes >= 60) {
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h ${remainingMinutes}m`;
+  }
+  if (minutes >= 1) {
+    return `${minutes}m`;
+  }
+  return `${totalSeconds}s`;
+}
+function StoryProgressBar({ entries }) {
+  if (entries.length === 0) return null;
+  const items = [];
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (i > 0) items.push(/* @__PURE__ */ jsx3(Text3, { children: " " }, `sp-${i}`));
+    switch (entry.status) {
+      case "done":
+        items.push(/* @__PURE__ */ jsx3(Text3, { color: "green", children: `\u2713 ${entry.key}` }, `s-${i}`));
+        break;
+      case "in-progress":
+        items.push(/* @__PURE__ */ jsx3(Text3, { color: "yellow", children: `\u25C6 ${entry.key}` }, `s-${i}`));
+        break;
+      case "pending":
+        items.push(/* @__PURE__ */ jsx3(Text3, { dimColor: true, children: `\u25CB ${entry.key}` }, `s-${i}`));
+        break;
+    }
+  }
+  return /* @__PURE__ */ jsxs3(Text3, { children: [
+    " ",
+    items
+  ] });
+}
+function Lane(props) {
+  const {
+    epicId,
+    epicTitle,
+    currentStory,
+    phase,
+    acProgress,
+    storyProgressEntries,
+    driver,
+    cost,
+    elapsedTime,
+    laneIndex
+  } = props;
+  const laneLabel = laneIndex != null ? `Lane ${laneIndex}: ` : "";
+  const titleLine = `${laneLabel}Epic ${epicId} \u2014 ${epicTitle}`;
+  const storyParts = [];
+  if (currentStory) storyParts.push(currentStory);
+  if (phase) storyParts.push(`\u25C6 ${phase}`);
+  if (acProgress) storyParts.push(`(AC ${acProgress})`);
+  const storyLine = storyParts.length > 0 ? ` ${storyParts.join(" ")}` : null;
+  const driverLine = ` ${driver ?? "unknown"} | ${formatLaneCost(cost)} / ${formatLaneElapsed(elapsedTime)}`;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: titleLine }),
+    storyLine && /* @__PURE__ */ jsx3(Text3, { children: storyLine }),
+    /* @__PURE__ */ jsx3(StoryProgressBar, { entries: storyProgressEntries }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: driverLine })
+  ] });
+}
+
+// src/lib/ink-lane-container.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function getLayoutMode(terminalWidth) {
+  if (terminalWidth >= 120) return "side-by-side";
+  if (terminalWidth >= 80) return "stacked";
+  return "single";
+}
+function truncate(str, maxLen) {
+  if (maxLen < 4) return str.slice(0, maxLen);
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+function CollapsedLanes({ lanes }) {
+  if (lanes.length === 0) return null;
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: lanes.map((lane) => {
+    const storyPart = lane.currentStory ?? "--";
+    const phasePart = lane.phase ?? "--";
+    const costPart = formatLaneCost(lane.cost);
+    const timePart = formatLaneElapsed(lane.elapsedTime);
+    const line = `Lane ${lane.laneIndex}: ${lane.epicTitle} \u2502 ${storyPart} \u25C6 ${phasePart} \u2502 ${costPart} / ${timePart}`;
+    return /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: line }, `collapsed-${lane.laneIndex}`);
+  }) });
+}
+function LaneContainer({ lanes, terminalWidth }) {
+  if (lanes.length === 0) return null;
+  const mode = getLayoutMode(terminalWidth);
+  let fullLanes;
+  let collapsedLaneData;
+  if (mode === "single") {
+    let mostRecentIndex = 0;
+    let mostRecentTime = -Infinity;
+    for (let i = 0; i < lanes.length; i++) {
+      const t = lanes[i].lastActivityTime ?? 0;
+      if (t >= mostRecentTime) {
+        mostRecentTime = t;
+        mostRecentIndex = i;
+      }
+    }
+    fullLanes = [lanes[mostRecentIndex]];
+    collapsedLaneData = lanes.filter((_, i) => i !== mostRecentIndex).map((lane, i) => {
+      const originalIndex = i >= mostRecentIndex ? i + 2 : i + 1;
+      return {
+        laneIndex: originalIndex,
+        epicTitle: truncate(lane.epicTitle, 30),
+        currentStory: lane.currentStory,
+        phase: lane.phase,
+        cost: lane.cost,
+        elapsedTime: lane.elapsedTime
+      };
+    });
+  } else {
+    fullLanes = lanes.slice(0, 2);
+    collapsedLaneData = lanes.slice(2).map((lane, i) => ({
+      laneIndex: i + 3,
+      epicTitle: truncate(lane.epicTitle, 30),
+      currentStory: lane.currentStory,
+      phase: lane.phase,
+      cost: lane.cost,
+      elapsedTime: lane.elapsedTime
+    }));
+  }
+  const laneWidth = mode === "side-by-side" ? Math.floor(terminalWidth / 2) - 1 : terminalWidth;
+  const fullLaneElements = [];
+  for (let i = 0; i < fullLanes.length; i++) {
+    const lane = fullLanes[i];
+    const laneIndex = mode === "single" ? void 0 : i + 1;
+    if (i > 0 && mode !== "side-by-side") {
+      fullLaneElements.push(/* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u2500".repeat(Math.min(terminalWidth, 60)) }, `sep-${i}`));
+    }
+    fullLaneElements.push(
+      /* @__PURE__ */ jsx4(Box4, { width: mode === "side-by-side" ? laneWidth : void 0, flexDirection: "column", children: /* @__PURE__ */ jsx4(
+        Lane,
+        {
+          epicId: lane.epicId,
+          epicTitle: lane.epicTitle,
+          currentStory: lane.currentStory,
+          phase: lane.phase,
+          acProgress: lane.acProgress,
+          storyProgressEntries: lane.storyProgressEntries,
+          driver: lane.driver,
+          cost: lane.cost,
+          elapsedTime: lane.elapsedTime,
+          laneIndex
+        }
+      ) }, `lane-${lane.epicId}`)
+    );
+  }
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    mode === "side-by-side" ? /* @__PURE__ */ jsx4(Box4, { flexDirection: "row", children: fullLaneElements }) : /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: fullLaneElements }),
+    /* @__PURE__ */ jsx4(CollapsedLanes, { lanes: collapsedLaneData })
+  ] });
+}
+
+// src/lib/ink-summary-bar.tsx
+import { Text as Text5, Box as Box5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function formatConflictText(count) {
+  return count === 1 ? "1 conflict" : `${count} conflicts`;
+}
+function formatCost2(cost) {
+  return `$${cost.toFixed(2)}`;
+}
+function SummaryBar({ doneStories, mergingEpic, pendingEpics, completedLanes }) {
+  const doneSection = doneStories.length > 0 ? doneStories.map((s) => `${s} \u2713`).join("  ") : "\u2014";
+  let mergingNode;
+  if (!mergingEpic) {
+    mergingNode = /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2014" });
+  } else if (mergingEpic.status === "resolving") {
+    const conflictText = mergingEpic.conflictCount != null ? ` (resolving ${formatConflictText(mergingEpic.conflictCount)})` : "";
+    mergingNode = /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: `${mergingEpic.epicId} \u2192 main${conflictText} \u25CC` });
+  } else if (mergingEpic.status === "in-progress") {
+    mergingNode = /* @__PURE__ */ jsx5(Text5, { children: `${mergingEpic.epicId} \u2192 main \u25CC` });
+  } else {
+    mergingNode = /* @__PURE__ */ jsx5(Text5, { color: "green", children: `${mergingEpic.epicId} \u2192 main \u2713` });
+  }
+  const pendingSection = pendingEpics.length > 0 ? pendingEpics.join(", ") : "\u2014";
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "green", children: `Done: ${doneSection}` }),
+      /* @__PURE__ */ jsx5(Text5, { children: " \u2502 " }),
+      /* @__PURE__ */ jsx5(Text5, { children: "Merging: " }),
+      mergingNode,
+      /* @__PURE__ */ jsx5(Text5, { children: " \u2502 " }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: `Pending: ${pendingSection}` })
+    ] }),
+    completedLanes && completedLanes.length > 0 && completedLanes.map((lane) => /* @__PURE__ */ jsx5(Text5, { color: "green", children: `[OK] Lane ${lane.laneIndex}: Epic ${lane.epicId} complete (${lane.storyCount} stories, ${formatCost2(lane.cost)}, ${lane.elapsed})` }, `lane-complete-${lane.laneIndex}`))
+  ] });
+}
+
+// src/lib/ink-merge-status.tsx
+import { Text as Text6, Box as Box6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function MergeStatus({ mergeState }) {
+  if (!mergeState) return null;
+  const lines = [];
+  if (mergeState.outcome === "clean") {
+    const count = mergeState.conflictCount ?? 0;
+    lines.push(
+      /* @__PURE__ */ jsx6(Text6, { color: "green", children: `[OK] Merge ${mergeState.epicId} \u2192 main: clean (${count} conflicts)` }, "merge-clean")
+    );
+  } else if (mergeState.outcome === "resolved") {
+    const count = mergeState.conflictCount ?? mergeState.conflicts?.length ?? 0;
+    const suffix = count === 1 ? "" : "s";
+    lines.push(
+      /* @__PURE__ */ jsx6(Text6, { color: "green", children: `[OK] Merge ${mergeState.epicId} \u2192 main: ${count} conflict${suffix} auto-resolved` }, "merge-resolved")
+    );
+    if (mergeState.conflicts && mergeState.conflicts.length > 0) {
+      for (let i = 0; i < mergeState.conflicts.length; i++) {
+        lines.push(
+          /* @__PURE__ */ jsxs6(Text6, { children: [
+            "     \u2514 ",
+            mergeState.conflicts[i]
+          ] }, `conflict-${i}`)
+        );
+      }
+    }
+  } else if (mergeState.outcome === "escalated") {
+    lines.push(
+      /* @__PURE__ */ jsx6(Text6, { color: "red", children: `[FAIL] Merge ${mergeState.epicId} \u2192 main: ${mergeState.reason ?? "unknown error"}` }, "merge-escalated")
+    );
+    if (mergeState.conflicts && mergeState.conflicts.length > 0) {
+      for (let i = 0; i < mergeState.conflicts.length; i++) {
+        lines.push(
+          /* @__PURE__ */ jsxs6(Text6, { children: [
+            "       \u2514 ",
+            mergeState.conflicts[i]
+          ] }, `esc-conflict-${i}`)
+        );
+      }
+    }
+    lines.push(
+      /* @__PURE__ */ jsx6(Text6, { color: "red", children: "       \u2192 Manual resolution required" }, "manual")
+    );
+    if (mergeState.worktreePath) {
+      lines.push(
+        /* @__PURE__ */ jsx6(Text6, { color: "red", children: `       \u2192 Worktree preserved: ${mergeState.worktreePath}` }, "worktree")
+      );
+    }
+  } else if (mergeState.outcome === "in-progress") {
+    lines.push(
+      /* @__PURE__ */ jsx6(Text6, { children: `Merging ${mergeState.epicId} \u2192 main \u25CC` }, "merge-inprog")
+    );
+  }
+  if (mergeState.testResults) {
+    const t = mergeState.testResults;
+    const hasFailed = t.failed > 0;
+    const prefix = hasFailed ? "[FAIL]" : "[OK]";
+    const color = hasFailed ? "red" : "green";
+    let testLine = `${prefix} Tests: ${t.passed}/${t.total} passed (${t.durationSecs}s)`;
+    if (t.coverage != null) {
+      testLine += ` ${t.coverage}% coverage`;
+    }
+    lines.push(
+      /* @__PURE__ */ jsx6(Text6, { color, children: testLine }, "tests")
+    );
+  }
+  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", children: lines });
+}
+
+// src/lib/ink-app.tsx
+import { Fragment, jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+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 }) {
+  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) {
+      onCycleLane();
+    }
+  }, { isActive: typeof process.stdin.setRawMode === "function" });
+  const activeLaneCount = state.laneCount ?? 0;
+  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: [
+      /* @__PURE__ */ jsx7(Separator, {}),
+      /* @__PURE__ */ jsx7(SummaryBar, { ...state.summaryBar })
+    ] }),
+    laneCount > 1 && state.mergeState && /* @__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 })
+    ] })
+  ] });
+}
+
+// src/lib/ink-components.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function Separator() {
+  const width = process.stdout.columns || 60;
+  return /* @__PURE__ */ jsx8(Text8, { children: "\u2501".repeat(width) });
+}
+function shortKey(key) {
+  const m = key.match(/^(\d+-\d+)/);
+  return m ? m[1] : key;
+}
+function formatCost3(cost) {
+  return `$${cost.toFixed(2)}`;
+}
+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`);
+  }
+  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 })
+  ] });
+}
+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 });
+}
+
+// src/lib/ink-renderer.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var noopHandle = {
+  update(_event, _driverName, _laneId) {
+  },
+  updateSprintState() {
+  },
+  updateStories() {
+  },
+  addMessage() {
+  },
+  updateWorkflowState() {
+  },
+  processLaneEvent() {
+  },
+  updateMergeState() {
+  },
+  cleanup() {
+  }
+};
+var MAX_COMPLETED_TOOLS = 50;
+function startRenderer(options) {
+  if (options?.quiet || !process.stdout.isTTY && !options?._forceTTY) {
+    return noopHandle;
+  }
+  let state = {
+    sprintInfo: options?.sprintState ?? null,
+    stories: [],
+    messages: [],
+    completedTools: [],
+    activeTool: null,
+    activeToolArgs: "",
+    lastThought: null,
+    retryInfo: null,
+    workflowFlow: [],
+    currentTaskName: null,
+    taskStates: {},
+    taskMeta: {},
+    activeDriverName: null,
+    driverCosts: {},
+    activeLaneId: null,
+    laneCount: 0
+  };
+  const laneStates = /* @__PURE__ */ new Map();
+  let pinnedLane = false;
+  let currentStoryCosts = {};
+  let lastStoryKey = state.sprintInfo?.storyKey ?? null;
+  const pendingStoryCosts = /* @__PURE__ */ new Map();
+  let cleaned = false;
+  const inkInstance = inkRender(/* @__PURE__ */ jsx9(App, { state, onCycleLane: () => cycleLane() }), {
+    exitOnCtrlC: false,
+    patchConsole: !options?._forceTTY,
+    maxFps: 15
+  });
+  function rerender() {
+    if (!cleaned) {
+      state = { ...state };
+      inkInstance.rerender(/* @__PURE__ */ jsx9(App, { state, onCycleLane: () => cycleLane() }));
+    }
+  }
+  function onSigint() {
+    cleanupFull();
+    process.kill(process.pid, "SIGINT");
+  }
+  function onSigterm() {
+    cleanupFull();
+    process.kill(process.pid, "SIGTERM");
+  }
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigterm);
+  function promoteActiveTool(clearActive, targetState) {
+    const s = targetState ?? state;
+    if (!s.activeTool) return;
+    const entry = {
+      name: s.activeTool.name,
+      args: s.activeToolArgs,
+      driver: s.activeDriverName ?? void 0
+    };
+    const updated = [...s.completedTools, entry];
+    s.completedTools = updated.length > MAX_COMPLETED_TOOLS ? updated.slice(updated.length - MAX_COMPLETED_TOOLS) : updated;
+    if (clearActive) {
+      s.activeTool = null;
+      s.activeToolArgs = "";
+      s.activeDriverName = null;
+    }
+  }
+  function copyLaneToDisplay(laneId) {
+    const ls = laneStates.get(laneId);
+    if (!ls) return;
+    state.completedTools = [...ls.completedTools];
+    state.activeTool = ls.activeTool ? { ...ls.activeTool } : null;
+    state.activeToolArgs = ls.activeToolArgs;
+    state.lastThought = ls.lastThought;
+    state.retryInfo = ls.retryInfo ? { ...ls.retryInfo } : null;
+    state.activeDriverName = ls.activeDriverName;
+    state.activeLaneId = laneId;
+  }
+  function getOrCreateLaneState(laneId) {
+    let ls = laneStates.get(laneId);
+    if (!ls) {
+      ls = {
+        completedTools: [],
+        activeTool: null,
+        activeToolArgs: "",
+        lastThought: null,
+        retryInfo: null,
+        activeDriverName: null,
+        status: "active",
+        lastActivityTime: Date.now()
+      };
+      laneStates.set(laneId, ls);
+    }
+    return ls;
+  }
+  function getActiveLaneIds() {
+    const ids = [];
+    for (const [id, ls] of laneStates) {
+      if (ls.status === "active") ids.push(id);
+    }
+    return ids;
+  }
+  function update(event, driverName, laneId) {
+    if (cleaned) return;
+    if (laneId) {
+      const ls = getOrCreateLaneState(laneId);
+      ls.lastActivityTime = Date.now();
+      switch (event.type) {
+        case "tool-start":
+          promoteActiveTool(false, ls);
+          ls.activeTool = { name: event.name };
+          ls.activeToolArgs = "";
+          ls.activeDriverName = driverName ?? null;
+          ls.lastThought = null;
+          ls.retryInfo = null;
+          break;
+        case "tool-input":
+          ls.activeToolArgs += event.partial;
+          return;
+        case "tool-complete":
+          if (ls.activeTool) {
+            if (["Agent", "Skill"].includes(ls.activeTool.name)) break;
+            promoteActiveTool(true, ls);
+          }
+          break;
+        case "text":
+          ls.lastThought = event.text;
+          ls.retryInfo = null;
+          break;
+        case "retry":
+          ls.retryInfo = { attempt: event.attempt, delay: event.delay };
+          break;
+        case "result":
+          if (event.cost > 0 && state.sprintInfo) {
+            state.sprintInfo = {
+              ...state.sprintInfo,
+              totalCost: (state.sprintInfo.totalCost ?? 0) + event.cost
+            };
+          }
+          if (event.cost > 0 && driverName) {
+            state.driverCosts = {
+              ...state.driverCosts,
+              [driverName]: (state.driverCosts[driverName] ?? 0) + event.cost
+            };
+            currentStoryCosts = {
+              ...currentStoryCosts,
+              [driverName]: (currentStoryCosts[driverName] ?? 0) + event.cost
+            };
+          }
+          break;
+      }
+      if (!pinnedLane && state.activeLaneId !== laneId) {
+        state.activeLaneId = laneId;
+      }
+      if (pinnedLane && state.activeLaneId !== laneId) {
+        pinnedLane = false;
+      }
+      if (state.activeLaneId === laneId) {
+        copyLaneToDisplay(laneId);
+      }
+      state.laneCount = laneStates.size;
+      rerender();
+      return;
+    }
+    switch (event.type) {
+      case "tool-start":
+        promoteActiveTool(false);
+        state.activeTool = { name: event.name };
+        state.activeToolArgs = "";
+        state.activeDriverName = driverName ?? null;
+        state.lastThought = null;
+        state.retryInfo = null;
+        break;
+      case "tool-input":
+        state.activeToolArgs += event.partial;
+        return;
+      // Skip rerender
+      case "tool-complete":
+        if (state.activeTool) {
+          if (["Agent", "Skill"].includes(state.activeTool.name)) break;
+          promoteActiveTool(true);
+        }
+        break;
+      case "text":
+        state.lastThought = event.text;
+        state.retryInfo = null;
+        break;
+      case "retry":
+        state.retryInfo = { attempt: event.attempt, delay: event.delay };
+        break;
+      case "result":
+        if (event.cost > 0 && state.sprintInfo) {
+          state.sprintInfo = {
+            ...state.sprintInfo,
+            totalCost: (state.sprintInfo.totalCost ?? 0) + event.cost
+          };
+        }
+        if (event.cost > 0 && driverName) {
+          state.driverCosts = {
+            ...state.driverCosts,
+            [driverName]: (state.driverCosts[driverName] ?? 0) + event.cost
+          };
+          currentStoryCosts = {
+            ...currentStoryCosts,
+            [driverName]: (currentStoryCosts[driverName] ?? 0) + event.cost
+          };
+        }
+        break;
+    }
+    rerender();
+  }
+  function processLaneEvent(event) {
+    if (cleaned) return;
+    switch (event.type) {
+      case "lane-started": {
+        const ls = getOrCreateLaneState(event.epicId);
+        ls.status = "active";
+        ls.lastActivityTime = Date.now();
+        if (state.activeLaneId == null) {
+          state.activeLaneId = event.epicId;
+          copyLaneToDisplay(event.epicId);
+        }
+        state.laneCount = laneStates.size;
+        break;
+      }
+      case "lane-completed": {
+        const ls = laneStates.get(event.epicId);
+        if (ls) {
+          ls.status = "completed";
+        }
+        if (state.summaryBar) {
+          const epicId = event.epicId;
+          const newDone = [...state.summaryBar.doneStories];
+          if (!newDone.includes(epicId)) newDone.push(epicId);
+          const newPending = state.summaryBar.pendingEpics.filter((e) => e !== epicId);
+          state.summaryBar = {
+            ...state.summaryBar,
+            doneStories: newDone,
+            pendingEpics: newPending
+          };
+        }
+        state.laneCount = laneStates.size;
+        break;
+      }
+      case "lane-failed": {
+        const ls = laneStates.get(event.epicId);
+        if (ls) {
+          ls.status = "failed";
+        } else {
+          const newLs = getOrCreateLaneState(event.epicId);
+          newLs.status = "failed";
+        }
+        if (state.activeLaneId === event.epicId) {
+          const activeIds = getActiveLaneIds();
+          if (activeIds.length > 0) {
+            state.activeLaneId = activeIds[0];
+            copyLaneToDisplay(activeIds[0]);
+          }
+        }
+        state.laneCount = laneStates.size;
+        break;
+      }
+      case "epic-queued": {
+        if (state.summaryBar) {
+          if (!state.summaryBar.pendingEpics.includes(event.epicId)) {
+            state.summaryBar = {
+              ...state.summaryBar,
+              pendingEpics: [...state.summaryBar.pendingEpics, event.epicId]
+            };
+          }
+        }
+        break;
+      }
+    }
+    rerender();
+  }
+  function updateMergeState(mergeState) {
+    if (cleaned) return;
+    state.mergeState = mergeState;
+    if (state.summaryBar && !mergeState) {
+      state.summaryBar = { ...state.summaryBar, mergingEpic: null };
+    }
+    if (state.summaryBar && mergeState) {
+      const mergingStatus = mergeState.outcome === "clean" || mergeState.outcome === "resolved" ? "complete" : mergeState.outcome === "escalated" ? "complete" : "in-progress";
+      state.summaryBar = {
+        ...state.summaryBar,
+        mergingEpic: {
+          epicId: mergeState.epicId,
+          status: mergingStatus,
+          conflictCount: mergeState.conflictCount
+        }
+      };
+    }
+    rerender();
+  }
+  function cycleLane() {
+    if (cleaned) return;
+    const activeIds = getActiveLaneIds();
+    if (activeIds.length <= 1) return;
+    const currentIndex = state.activeLaneId ? activeIds.indexOf(state.activeLaneId) : -1;
+    const nextIndex = (currentIndex + 1) % activeIds.length;
+    state.activeLaneId = activeIds[nextIndex];
+    copyLaneToDisplay(activeIds[nextIndex]);
+    pinnedLane = true;
+    rerender();
+  }
+  function cleanupFull() {
+    if (cleaned) return;
+    cleaned = true;
+    try {
+      inkInstance.unmount();
+    } catch {
+    }
+    try {
+      inkInstance.cleanup();
+    } catch {
+    }
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigterm);
+  }
+  function updateSprintState(sprintState) {
+    if (cleaned) return;
+    if (sprintState && state.sprintInfo) {
+      state.sprintInfo = {
+        ...sprintState,
+        totalCost: sprintState.totalCost ?? state.sprintInfo.totalCost,
+        acProgress: sprintState.acProgress ?? state.sprintInfo.acProgress,
+        currentCommand: sprintState.currentCommand ?? state.sprintInfo.currentCommand
+      };
+    } else {
+      state.sprintInfo = sprintState ?? null;
+    }
+    const newKey = state.sprintInfo?.storyKey ?? null;
+    if (newKey && lastStoryKey && newKey !== lastStoryKey) {
+      if (Object.keys(currentStoryCosts).length > 0) {
+        pendingStoryCosts.set(lastStoryKey, { ...currentStoryCosts });
+      }
+      currentStoryCosts = {};
+      lastStoryKey = newKey;
+    } else if (newKey && !lastStoryKey) {
+      lastStoryKey = newKey;
+    }
+    rerender();
+  }
+  function updateStories(stories) {
+    if (cleaned) return;
+    const currentKey = state.sprintInfo?.storyKey ?? null;
+    const hasCurrentCosts = Object.keys(currentStoryCosts).length > 0;
+    const updatedStories = stories.map((s) => {
+      if (s.status !== "done" || s.costByDriver) return s;
+      const pending = pendingStoryCosts.get(s.key);
+      if (pending) {
+        pendingStoryCosts.delete(s.key);
+        return { ...s, costByDriver: pending };
+      }
+      if (hasCurrentCosts && s.key === (lastStoryKey ?? currentKey)) {
+        const snap = { ...currentStoryCosts };
+        currentStoryCosts = {};
+        return { ...s, costByDriver: snap };
+      }
+      return s;
+    });
+    if (currentKey && currentKey !== lastStoryKey) {
+      if (lastStoryKey && Object.keys(currentStoryCosts).length > 0) {
+        pendingStoryCosts.set(lastStoryKey, { ...currentStoryCosts });
+      }
+      currentStoryCosts = {};
+      lastStoryKey = currentKey;
+    } else if (currentKey && !lastStoryKey) {
+      lastStoryKey = currentKey;
+    }
+    state.stories = updatedStories;
+    rerender();
+  }
+  function addMessage(msg) {
+    if (cleaned) return;
+    state.messages = [...state.messages, msg];
+    rerender();
+  }
+  function updateWorkflowState(flow, currentTask, taskStates, taskMeta) {
+    if (cleaned) return;
+    state.workflowFlow = flow;
+    state.currentTaskName = currentTask;
+    state.taskStates = { ...taskStates };
+    state.taskMeta = taskMeta ? { ...taskMeta } : state.taskMeta;
+    rerender();
+  }
+  return {
+    update,
+    updateSprintState,
+    updateStories,
+    addMessage,
+    updateWorkflowState,
+    processLaneEvent,
+    updateMergeState,
+    cleanup: cleanupFull,
+    _getState: () => state,
+    _getLaneStates: () => laneStates,
+    _cycleLane: () => cycleLane()
+  };
+}
+
 // src/commands/run.ts
 function resolvePluginDir() {
   return join15(process.cwd(), ".claude");
@@ -4996,6 +6160,80 @@ function registerRunCommand(program) {
         info("Resuming after circuit breaker \u2014 previous findings preserved", outputOpts);
       }
     }
+    const renderer = startRenderer({
+      quiet: !!options.quiet || isJson,
+      sprintState: {
+        storyKey: "",
+        phase: "executing",
+        done: counts.done,
+        total: counts.total,
+        totalCost: 0
+      }
+    });
+    let totalCostUsd = 0;
+    let storiesDone = counts.done;
+    const taskStates = {};
+    const taskMeta = {};
+    for (const [tn, task] of Object.entries(parsedWorkflow.tasks)) {
+      taskStates[tn] = "pending";
+      taskMeta[tn] = { driver: task.driver ?? "claude-code" };
+    }
+    const storyEntries = [];
+    for (const [key, status] of Object.entries(statuses)) {
+      if (key.startsWith("epic-")) continue;
+      if (status === "done") storyEntries.push({ key, status: "done" });
+      else if (status === "in-progress") storyEntries.push({ key, status: "in-progress" });
+      else if (status === "backlog" || status === "ready-for-dev") storyEntries.push({ key, status: "pending" });
+      else if (status === "failed") storyEntries.push({ key, status: "failed" });
+    }
+    renderer.updateStories(storyEntries);
+    const onEvent = (event) => {
+      if (event.type === "stream-event" && event.streamEvent) {
+        renderer.update(event.streamEvent, event.driverName);
+      }
+      if (event.type === "dispatch-start") {
+        renderer.updateSprintState({
+          storyKey: event.storyKey,
+          phase: event.taskName,
+          done: storiesDone,
+          total: counts.total,
+          totalCost: totalCostUsd
+        });
+        taskStates[event.taskName] = "active";
+        renderer.updateWorkflowState(parsedWorkflow.flow, event.taskName, { ...taskStates }, { ...taskMeta });
+        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;
+        taskStates[event.taskName] = "done";
+        taskMeta[event.taskName] = {
+          ...taskMeta[event.taskName],
+          costUsd: (taskMeta[event.taskName]?.costUsd ?? 0) + (event.costUsd ?? 0),
+          elapsedMs: (taskMeta[event.taskName]?.elapsedMs ?? 0) + (event.elapsedMs ?? 0)
+        };
+        renderer.updateWorkflowState(parsedWorkflow.flow, event.taskName, { ...taskStates }, { ...taskMeta });
+        renderer.updateSprintState({
+          storyKey: event.storyKey,
+          phase: event.taskName,
+          done: storiesDone,
+          total: counts.total,
+          totalCost: totalCostUsd
+        });
+      }
+      if (event.type === "dispatch-error") {
+        taskStates[event.taskName] = "failed";
+        renderer.updateWorkflowState(parsedWorkflow.flow, event.taskName, { ...taskStates }, { ...taskMeta });
+        renderer.addMessage({
+          type: "fail",
+          key: event.storyKey,
+          message: `[${event.taskName}] ${event.error?.message ?? "unknown error"}`
+        });
+      }
+    };
     const config = {
       workflow: parsedWorkflow,
       agents,
@@ -5003,7 +6241,8 @@ function registerRunCommand(program) {
       issuesPath: join15(projectDir, ".codeharness", "issues.yaml"),
       runId: `run-${Date.now()}`,
       projectDir,
-      maxIterations
+      maxIterations,
+      onEvent
     };
     const execution = parsedWorkflow.execution;
     const isParallel = execution?.epic_strategy === "parallel";
@@ -5081,6 +6320,7 @@ function registerRunCommand(program) {
     } else {
       try {
         const result = await executeWorkflow(config);
+        renderer.cleanup();
         if (result.success) {
           ok(`Workflow completed \u2014 ${result.storiesProcessed} stories processed, ${result.tasksCompleted} tasks completed in ${formatElapsed(result.durationMs)}`, outputOpts);
         } else {
@@ -5091,6 +6331,7 @@ function registerRunCommand(program) {
           process.exitCode = 1;
         }
       } catch (err) {
+        renderer.cleanup();
         const msg = err instanceof Error ? err.message : String(err);
         fail(`Workflow engine error: ${msg}`, outputOpts);
         process.exitCode = 1;
@@ -9177,7 +10418,7 @@ async function handleDockerCheck(isJson) {
     }
   }
 }
-function formatElapsed2(ms) {
+function formatElapsed3(ms) {
   const s = Math.floor(ms / 1e3);
   const h = Math.floor(s / 3600);
   const m = Math.floor(s % 3600 / 60);
@@ -9197,7 +10438,7 @@ function printWorkflowState() {
   console.log(`  Tasks completed: ${state.tasks_completed.length}`);
   if (state.phase === "executing" && state.started) {
     const elapsed = Date.now() - Date.parse(state.started);
-    console.log(`  Elapsed: ${formatElapsed2(elapsed)}`);
+    console.log(`  Elapsed: ${formatElapsed3(elapsed)}`);
   }
   if (state.evaluator_scores.length > 0) {
     const latest = state.evaluator_scores[state.evaluator_scores.length - 1];
@@ -9222,7 +10463,7 @@ function getWorkflowStateData() {
   };
   if (state.phase === "executing" && state.started) {
     data.elapsed_ms = Date.now() - Date.parse(state.started);
-    data.elapsed = formatElapsed2(data.elapsed_ms);
+    data.elapsed = formatElapsed3(data.elapsed_ms);
   }
   return data;
 }
@@ -9874,7 +11115,7 @@ function registerTeardownCommand(program) {
     } else if (otlpMode === "remote-routed") {
       if (!options.keepDocker) {
         try {
-          const { stopCollectorOnly: stopCollectorOnly2 } = await import("./docker-32GRDQOK.js");
+          const { stopCollectorOnly: stopCollectorOnly2 } = await import("./docker-QJGQIPTO.js");
           stopCollectorOnly2();
           result.docker.stopped = true;
           if (!isJson) {
@@ -9906,7 +11147,7 @@ function registerTeardownCommand(program) {
         info("Shared stack: kept running (other projects may use it)");
       }
     } else if (isLegacyStack) {
-      const { isStackRunning: isStackRunning2, stopStack } = await import("./docker-32GRDQOK.js");
+      const { isStackRunning: isStackRunning2, stopStack } = await import("./docker-QJGQIPTO.js");
       let stackRunning = false;
       try {
         stackRunning = isStackRunning2(composeFile);
@@ -12784,7 +14025,7 @@ function registerDriversCommand(program) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.29.0" : "0.0.0-dev";
+var VERSION = true ? "0.29.2" : "0.0.0-dev";
 function createProgram() {
   const program = new Command();
   program.name("codeharness").description("Makes autonomous coding agents produce software that actually works").version(VERSION).option("--json", "Output in machine-readable JSON format");