executant 1.8.0 → 1.10.0

package/dist/index.js

@@ -156,6 +156,15 @@ function loadWorkflow(filePath2) {
 ${detail}`);
   }
   const vars = doc.vars ?? {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const step of doc.steps) {
+    if (seen.has(step.name)) {
+      throw new Error(
+        `Duplicate step name "${step.name}" \u2014 step names must be unique within a workflow`
+      );
+    }
+    seen.add(step.name);
+  }
   return {
     goal: doc.goal,
     vars,
@@ -370,25 +379,12 @@ async function* runCommand(task) {
 // src/tasks/claude.ts
 import { execSync, spawn as spawn2 } from "node:child_process";
 import { zodToJsonSchema } from "zod-to-json-schema";
+var METHODOLOGY = loadPrompt("development-methodology");
 var DEFAULT_TOOLS = ["Read", "Edit", "Write", "Bash", "Glob", "Grep"];
-function resolveClaudePath() {
-  try {
-    return execSync("which claude", { env: process.env }).toString().trim();
-  } catch {
-    throw new Error(
-      "claude CLI not found. Ensure it is installed and in PATH.\n  brew install claude  OR  npm install -g @anthropic-ai/claude-code"
-    );
-  }
-}
-async function* runClaude(task) {
+function buildClaudeArgs(task) {
   const allowedTools = task.allowedTools ?? DEFAULT_TOOLS;
-  yield {
-    type: "log",
-    level: "info",
-    text: `claude -p "${task.prompt.slice(0, 60).replace(/\n/g, " ")}\u2026"`
-  };
   const permissionMode = task.permissionMode ?? "bypassPermissions";
-  const args = [
+  return [
     "--print",
     task.prompt,
     "--output-format",
@@ -402,6 +398,23 @@ async function* runClaude(task) {
     ...task.appendSystemPrompt ? ["--append-system-prompt", task.appendSystemPrompt] : [],
     ...task.jsonSchema ? ["--json-schema", JSON.stringify(task.jsonSchema)] : []
   ];
+}
+function resolveClaudePath() {
+  try {
+    return execSync("which claude", { env: process.env }).toString().trim();
+  } catch {
+    throw new Error(
+      "claude CLI not found. Ensure it is installed and in PATH.\n  brew install claude  OR  npm install -g @anthropic-ai/claude-code"
+    );
+  }
+}
+async function* runClaude(task) {
+  yield {
+    type: "log",
+    level: "info",
+    text: `claude -p "${task.prompt.slice(0, 60).replace(/\n/g, " ")}\u2026"`
+  };
+  const args = buildClaudeArgs(task);
   const claudeBin = resolveClaudePath();
   let proc;
   try {
@@ -410,7 +423,9 @@ async function* runClaude(task) {
       env: { ...process.env }
     });
   } catch (err) {
-    throw new Error(`Failed to spawn claude (${claudeBin}): ${getErrorMessage(err)}`);
+    throw new Error(
+      `Failed to spawn claude (${claudeBin}): ${getErrorMessage(err)}`
+    );
   }
   const cleanup = () => {
     try {
@@ -480,7 +495,10 @@ function isObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function getArray(obj, ...keys) {
-  const result = keys.reduce((cur, k) => isObject(cur) ? cur[k] : null, obj);
+  const result = keys.reduce(
+    (cur, k) => isObject(cur) ? cur[k] : null,
+    obj
+  );
   return Array.isArray(result) ? result : [];
 }
 function getString(obj, key) {
@@ -496,7 +514,9 @@ async function runClaudeStructured(task, schema) {
     else if (event.type === "output:text") lines.push(event.text);
   }
   if (structuredOutput === void 0 && process.env["NODE_ENV"] !== "test") {
-    console.warn("[executant] runClaudeStructured: no output:structured event \u2014 falling back to text parsing");
+    console.warn(
+      "[executant] runClaudeStructured: no output:structured event \u2014 falling back to text parsing"
+    );
   }
   const data = structuredOutput ?? JSON.parse(extractJsonObject(lines.join("").trim()));
   return schema.parse(data);
@@ -611,7 +631,11 @@ async function* runForEach(task) {
         };
       }
       try {
-        yield* runStep(substituted);
+        for await (const event of runStep(substituted)) {
+          if (event.type !== "step:iteration" && event.type !== "step:inner") {
+            yield event;
+          }
+        }
       } catch (err) {
         const error = err instanceof Error ? err : new Error(String(err));
         if (!substituted.continueOnError) {
@@ -863,7 +887,7 @@ init_update();
 
 // src/ui/App.tsx
 import { useEffect as useEffect2, useReducer, useState } from "react";
-import { Box as Box4, Text as Text4, useApp, useStdin } from "ink";
+import { Box as Box5, Text as Text5, useApp, useStdin } from "ink";
 
 // src/ui/KeyboardHandler.tsx
 import { useInput } from "ink";
@@ -931,45 +955,70 @@ function reducer(state, event) {
         status: "running",
         startTime: Date.now()
       });
-    case "step:complete":
+    case "step:complete": {
+      const prev = state.tasks[event.index]?.iterationHistory;
+      const iterationHistory = prev?.length ? prev.map(
+        (r) => r.status === "running" ? { ...r, status: "complete", endTime: Date.now() } : r
+      ) : void 0;
       return {
         ...updateTask(state, event.index, {
           status: "complete",
-          endTime: Date.now()
+          endTime: Date.now(),
+          ...iterationHistory ? { iterationHistory } : {}
         }),
         currentIndex: event.index + 1
       };
-    case "step:error":
+    }
+    case "step:error": {
+      const prev = state.tasks[event.index]?.iterationHistory;
+      const iterationHistory = prev?.length ? prev.map(
+        (r) => r.status === "running" ? { ...r, status: "error", endTime: Date.now() } : r
+      ) : void 0;
       return {
         ...updateTask(state, event.index, {
           status: "error",
           endTime: Date.now(),
-          error: event.error
+          error: event.error,
+          ...iterationHistory ? { iterationHistory } : {}
         }),
         currentIndex: event.index + 1
       };
+    }
     case "step:skip":
       return {
         ...updateTask(state, event.index, { status: "skipped" }),
         currentIndex: event.index + 1
       };
-    case "step:iteration":
-      return updateTask(state, event.index, {
-        iteration: {
-          current: event.iteration,
-          total: event.total,
-          item: event.item
-        },
-        inner: void 0
-      });
-    case "step:inner":
+    case "step:iteration": {
+      const prev = (state.tasks[event.index]?.iterationHistory ?? []).map(
+        (r) => r.status === "running" ? { ...r, status: "complete", endTime: Date.now() } : r
+      );
       return updateTask(state, event.index, {
-        inner: {
-          index: event.innerIndex,
-          total: event.innerTotal,
-          name: event.name
-        }
+        iterationHistory: [
+          ...prev,
+          {
+            item: event.item,
+            iteration: event.iteration,
+            total: event.total,
+            status: "running",
+            startTime: Date.now()
+          }
+        ]
       });
+    }
+    case "step:inner": {
+      const iterationHistory = (state.tasks[event.index]?.iterationHistory ?? []).map(
+        (r) => r.status === "running" ? {
+          ...r,
+          inner: {
+            index: event.innerIndex,
+            total: event.innerTotal,
+            name: event.name
+          }
+        } : r
+      );
+      return updateTask(state, event.index, { iterationHistory });
+    }
     case "output:text": {
       const idx = event.index;
       if (idx >= state.tasks.length) return state;
@@ -1024,20 +1073,6 @@ function appendLine(state, index, line) {
 // src/ui/TaskRow.tsx
 import { Box, Text } from "ink";
 
-// src/ui/utils.ts
-var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var EXIT_DELAY_MS = 300;
-function formatHeaderElapsed(start, end) {
-  const ms = (end ?? Date.now()) - start;
-  return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
-}
-function formatTaskElapsed(start, end, status) {
-  if (!start) return "";
-  const ms = (end ?? Date.now()) - start;
-  if (status === "running" || status === "complete" || status === "error") return `${(ms / 1e3).toFixed(1)}s`;
-  return "";
-}
-
 // src/ui/theme.ts
 import { createRequire } from "node:module";
 import { oklchToHex } from "@coston/design-tokens";
@@ -1066,6 +1101,32 @@ var theme = {
   // log pane border
 };
 
+// src/ui/utils.ts
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var STATUS_ICON = {
+  complete: "\u2713",
+  error: "\u2717",
+  skipped: "\u2298",
+  pending: "\xB7"
+};
+var STATUS_COLOR = {
+  complete: theme.success,
+  error: theme.error,
+  pending: theme.muted
+};
+var EXIT_DELAY_MS = 300;
+function formatHeaderElapsed(start, end) {
+  const ms = (end ?? Date.now()) - start;
+  return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+}
+function formatTaskElapsed(start, end, status) {
+  if (!start) return "";
+  const ms = (end ?? Date.now()) - start;
+  if (status === "running" || status === "complete" || status === "error")
+    return `${(ms / 1e3).toFixed(1)}s`;
+  return "";
+}
+
 // src/ui/TaskRow.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 function TaskRow({ taskState, isActive, index, tick }) {
@@ -1073,9 +1134,8 @@ function TaskRow({ taskState, isActive, index, tick }) {
   const icon = statusIcon(status, tick);
   const color = statusColor(status, isActive);
   const elapsed = formatTaskElapsed(startTime, endTime, status);
-  const iterInfo = taskState.iteration ? ` (${taskState.iteration.current}/${taskState.iteration.total}) ${taskState.iteration.item}` : "";
-  const innerInfo = taskState.inner ? ` \u2014 ${taskState.inner.name} [${taskState.inner.index + 1}/${taskState.inner.total}]` : "";
-  const label = `${index + 1}. ${task.name}${iterInfo}${innerInfo}`;
+  const iterInfo = formatIterCount(taskState.iterationHistory);
+  const label = `${index + 1}. ${task.name}${iterInfo}`;
   return /* @__PURE__ */ jsxs(Box, { children: [
     /* @__PURE__ */ jsxs(Text, { color, children: [
       icon,
@@ -1088,17 +1148,6 @@ function TaskRow({ taskState, isActive, index, tick }) {
     ] })
   ] });
 }
-var STATUS_ICON = {
-  complete: "\u2713",
-  error: "\u2717",
-  skipped: "\u2298",
-  pending: "\xB7"
-};
-var STATUS_COLOR = {
-  complete: theme.success,
-  error: theme.error,
-  pending: theme.muted
-};
 function statusIcon(status, tick) {
   return status === "running" ? SPINNER[tick % SPINNER.length] : STATUS_ICON[status] ?? "\xB7";
 }
@@ -1106,16 +1155,74 @@ function statusColor(status, isActive) {
   if (isActive && status === "running") return theme.primary;
   return STATUS_COLOR[status] ?? theme.foreground;
 }
+function formatIterCount(history) {
+  if (!history?.length) return "";
+  const total = history[0].total;
+  const running = history.find((r) => r.status === "running");
+  const current = running?.iteration ?? history.length;
+  return ` (${current}/${total})`;
+}
 
-// src/ui/LogPane.tsx
+// src/ui/IterationRow.tsx
 import { Box as Box2, Text as Text2 } from "ink";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function IterationRow({ record, tick }) {
+  const icon = record.status === "running" ? SPINNER[tick % SPINNER.length] : STATUS_ICON[record.status] ?? "\xB7";
+  const color = STATUS_COLOR[record.status] ?? theme.primary;
+  const innerText = record.inner ? ` \u2014 ${stripItem(record.inner.name, record.item)} [${record.inner.index + 1}/${record.inner.total}]` : "";
+  const ms = (record.endTime ?? Date.now()) - record.startTime;
+  const elapsed = `${(ms / 1e3).toFixed(1)}s`;
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "    " }),
+    /* @__PURE__ */ jsx2(Text2, { color, children: icon }),
+    /* @__PURE__ */ jsx2(Text2, { children: " " }),
+    /* @__PURE__ */ jsxs2(
+      Text2,
+      {
+        color: record.status === "running" ? theme.foreground : theme.muted,
+        children: [
+          record.item,
+          innerText
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "  ",
+      elapsed
+    ] })
+  ] });
+}
+function stripItem(name, item) {
+  if (!name.includes(item)) return name;
+  const stripped = name.replace(item, "").replace(/\s{2,}/g, " ").replace(/^[\s\-—–]+/, "").replace(/[\s\-—–]+$/, "").trim();
+  return stripped || name;
+}
+function isRepeatStyle(history) {
+  return history.every((r) => r.item === String(r.iteration));
+}
+function IterationList({
+  iterationHistory,
+  tick,
+  maxVisible
+}) {
+  if (isRepeatStyle(iterationHistory)) return null;
+  const hidden = iterationHistory.length - maxVisible;
+  const visible = iterationHistory.slice(-maxVisible);
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    hidden > 0 && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: `    \u2026 ${hidden} earlier` }),
+    visible.map((record) => /* @__PURE__ */ jsx2(IterationRow, { record, tick }, record.iteration))
+  ] });
+}
+
+// src/ui/LogPane.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function LogPane({ lines, isActive = false, maxLines = 15 }) {
   const visible = lines.slice(-maxLines);
   if (visible.length === 0) {
-    return /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: isActive ? "\u2838 waiting for output\u2026" : "\u2014 no output yet \u2014" }) });
+    return /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: isActive ? "\u2838 waiting for output\u2026" : "\u2014 no output yet \u2014" }) });
   }
-  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: theme.border, paddingX: 1, children: visible.map((line, i) => /* @__PURE__ */ jsx2(
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: theme.border, paddingX: 1, children: visible.map((line, i) => /* @__PURE__ */ jsx3(
     LogLine,
     {
       text: line,
@@ -1125,29 +1232,29 @@ function LogPane({ lines, isActive = false, maxLines = 15 }) {
   )) });
 }
 function LogLine({ text, cursor }) {
-  const suffix = cursor ? /* @__PURE__ */ jsx2(Text2, { color: theme.primary, children: " \u258C" }) : null;
+  const suffix = cursor ? /* @__PURE__ */ jsx3(Text3, { color: theme.primary, children: " \u258C" }) : null;
   if (/^\[[\w:]+\]/.test(text)) {
     const bracket = text.match(/^\[[\w:]+\]/)?.[0] ?? "";
     const rest = text.slice(bracket.length);
-    return /* @__PURE__ */ jsxs2(Text2, { children: [
-      /* @__PURE__ */ jsx2(Text2, { color: theme.primary, children: bracket }),
-      /* @__PURE__ */ jsx2(Text2, { children: rest }),
+    return /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: theme.primary, children: bracket }),
+      /* @__PURE__ */ jsx3(Text3, { children: rest }),
       suffix
     ] });
   }
-  if (/^\s*\$\s/.test(text)) return /* @__PURE__ */ jsxs2(Text2, { color: theme.warning, children: [
+  if (/^\s*\$\s/.test(text)) return /* @__PURE__ */ jsxs3(Text3, { color: theme.warning, children: [
     text,
     suffix
   ] });
-  if (text.startsWith("[warn]")) return /* @__PURE__ */ jsxs2(Text2, { color: theme.warning, children: [
+  if (text.startsWith("[warn]")) return /* @__PURE__ */ jsxs3(Text3, { color: theme.warning, children: [
     text,
     suffix
   ] });
-  if (text.startsWith("[error]")) return /* @__PURE__ */ jsxs2(Text2, { color: theme.error, children: [
+  if (text.startsWith("[error]")) return /* @__PURE__ */ jsxs3(Text3, { color: theme.error, children: [
     text,
     suffix
   ] });
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
+  return /* @__PURE__ */ jsxs3(Text3, { children: [
     text,
     suffix
   ] });
@@ -1167,8 +1274,8 @@ function useInterval(callback, delayMs) {
 }
 
 // src/ui/BrandMark.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import { jsx as jsx3 } from "react/jsx-runtime";
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4 } from "react/jsx-runtime";
 var BRAND = "Executant";
 var SWEEP_TICKS = BRAND.length * 2;
 var GAP_TICKS = 30;
@@ -1181,11 +1288,12 @@ function charColor(charIndex, tick, isActive) {
   return charIndex === charPos ? theme.primaryLight : theme.primary;
 }
 function BrandMark({ tick, isActive }) {
-  return /* @__PURE__ */ jsx3(Box3, { children: [...BRAND].map((char, i) => /* @__PURE__ */ jsx3(Text3, { color: charColor(i, tick, isActive), bold: true, children: char }, i)) });
+  return /* @__PURE__ */ jsx4(Box4, { children: [...BRAND].map((char, i) => /* @__PURE__ */ jsx4(Text4, { color: charColor(i, tick, isActive), bold: true, children: char }, i)) });
 }
 
 // src/ui/App.tsx
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var MAX_VISIBLE_ITERATIONS = 8;
 function App({ workflow: workflow2, events: events2, options: options2, updateCheck: updateCheck2 }) {
   const { exit } = useApp();
   const [state, dispatch] = useReducer(reducer, buildInitialState(workflow2));
@@ -1203,7 +1311,10 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
       } catch (err) {
         if (!active) return;
         dispatch({ type: "log", level: "error", text: getErrorMessage(err) });
-        setTimeout(() => exit(err instanceof Error ? err : new Error(getErrorMessage(err))), EXIT_DELAY_MS);
+        setTimeout(
+          () => exit(err instanceof Error ? err : new Error(getErrorMessage(err))),
+          EXIT_DELAY_MS
+        );
       }
     })();
     return () => {
@@ -1223,14 +1334,16 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
   }, [updateCheck2]);
   const elapsed = formatHeaderElapsed(state.startTime, state.endTime);
   const activeTask = state.tasks[state.currentIndex];
-  const completedCount = state.tasks.filter((t) => t.status === "complete").length;
+  const completedCount = state.tasks.filter(
+    (t) => t.status === "complete"
+  ).length;
   const totalCount = state.tasks.length;
   const filterInfo = options2?.stepFilter ? `  [step: ${options2.stepFilter}]` : options2?.fromStep ? `  [from step: ${options2.fromStep}]` : "";
-  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", padding: 1, children: [
-    /* @__PURE__ */ jsx4(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx4(BrandMark, { tick, isActive: !state.endTime }) }),
-    /* @__PURE__ */ jsxs3(Box4, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.primary, children: workflow2.goal }),
-      /* @__PURE__ */ jsxs3(Text4, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsx5(BrandMark, { tick, isActive: !state.endTime }) }),
+    /* @__PURE__ */ jsxs4(Box5, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: theme.primary, children: workflow2.goal }),
+      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
         "  ",
         completedCount,
         "/",
@@ -1240,33 +1353,48 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
         filterInfo
       ] })
     ] }),
-    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginBottom: 1, children: state.tasks.map((taskState, i) => /* @__PURE__ */ jsx4(
-      TaskRow,
+    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginBottom: 1, children: state.tasks.map((taskState, i) => /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(
+        TaskRow,
+        {
+          index: i,
+          tick,
+          taskState,
+          isActive: i === state.currentIndex
+        }
+      ),
+      taskState.status === "running" && taskState.iterationHistory?.length ? /* @__PURE__ */ jsx5(
+        IterationList,
+        {
+          iterationHistory: taskState.iterationHistory,
+          tick,
+          maxVisible: MAX_VISIBLE_ITERATIONS
+        }
+      ) : null
+    ] }, i)) }),
+    activeTask && /* @__PURE__ */ jsx5(
+      LogPane,
       {
-        index: i,
-        tick,
-        taskState,
-        isActive: i === state.currentIndex
-      },
-      taskState.task.name
-    )) }),
-    activeTask && /* @__PURE__ */ jsx4(LogPane, { lines: activeTask.lines, isActive: activeTask.status === "running" }),
-    state.endTime !== void 0 && state.writtenFiles.length > 0 && /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "files written:" }),
-      state.writtenFiles.map((f) => /* @__PURE__ */ jsxs3(Text4, { color: theme.primary, children: [
+        lines: activeTask.lines,
+        isActive: activeTask.status === "running"
+      }
+    ),
+    state.endTime !== void 0 && state.writtenFiles.length > 0 && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "files written:" }),
+      state.writtenFiles.map((f) => /* @__PURE__ */ jsxs4(Text5, { color: theme.primary, children: [
         "  ",
         f
       ] }, f))
     ] }),
-    /* @__PURE__ */ jsxs3(Box4, { marginTop: 1, flexDirection: "column", children: [
-      updateVersion && /* @__PURE__ */ jsxs3(Text4, { color: theme.warning, children: [
+    /* @__PURE__ */ jsxs4(Box5, { marginTop: 1, flexDirection: "column", children: [
+      updateVersion && /* @__PURE__ */ jsxs4(Text5, { color: theme.warning, children: [
         "v",
         updateVersion,
         " available \u2014 run: executant update"
       ] }),
-      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "press q to quit" })
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "press q to quit" })
     ] }),
-    isRawModeSupported && /* @__PURE__ */ jsx4(KeyboardHandler, { onExit: exit })
+    isRawModeSupported && /* @__PURE__ */ jsx5(KeyboardHandler, { onExit: exit })
   ] });
 }
 
@@ -1404,7 +1532,8 @@ async function runPass3Judge(description, workflow2) {
       }),
       allowedTools: [],
       permissionMode: "default",
-      model: "sonnet"
+      model: "sonnet",
+      appendSystemPrompt: METHODOLOGY
     };
     return await runClaudeStructured(task, PlanJudgeOutputSchema);
   } catch {
@@ -1512,7 +1641,8 @@ async function* streamPlan(args) {
         }),
         allowedTools: ["Read", "Glob", "Grep"],
         permissionMode: "bypassPermissions",
-        model: "opus"
+        model: "opus",
+        appendSystemPrompt: METHODOLOGY
       };
       for await (const event of runClaude(researchTask)) {
         if (event.type === "output:tool") {
@@ -1574,7 +1704,9 @@ ${basePrompt}` : basePrompt,
       allowedTools: [],
       permissionMode: "bypassPermissions",
       model: skipResearch ? "sonnet" : "opus",
-      appendSystemPrompt: PLAN_SYSTEM_RULES,
+      appendSystemPrompt: `${METHODOLOGY}
+
+${PLAN_SYSTEM_RULES}`,
       jsonSchema: WORKFLOW_JSON_SCHEMA
     };
     let structuredOutput;
@@ -1672,8 +1804,8 @@ ${issues}`
 
 // src/ui/PlanApp.tsx
 import { useEffect as useEffect3, useReducer as useReducer2, useState as useState2 } from "react";
-import { Box as Box5, Text as Text5, useApp as useApp2, useStdin as useStdin2 } from "ink";
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Box as Box6, Text as Text6, useApp as useApp2, useStdin as useStdin2 } from "ink";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 var truncate = (str, max) => str.length > max ? str.slice(0, max - 3) + "..." : str;
 function buildInitial(description) {
   return {
@@ -1749,7 +1881,7 @@ function StageProgress({ stage, totalStages, stageNames, tick, isActive, status
     }
     return { icon, color, name, bold, dim };
   });
-  return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginBottom: 1, children: rows.map(({ icon, color, name, bold, dim }, i) => /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsxs4(Text5, { color, dimColor: dim, bold, children: [
+  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", marginBottom: 1, children: rows.map(({ icon, color, name, bold, dim }, i) => /* @__PURE__ */ jsx6(Box6, { children: /* @__PURE__ */ jsxs5(Text6, { color, dimColor: dim, bold, children: [
     "  ",
     icon,
     name ? `  ${name}` : ""
@@ -1782,19 +1914,19 @@ function PlanApp({ description, events: events2 }) {
   const elapsed = formatHeaderElapsed(state.startTime);
   const icon = isActive ? SPINNER[tick % SPINNER.length] : state.status === "complete" ? "\u2713" : "\u2717";
   const iconColor = state.status === "complete" ? theme.success : state.status === "error" ? theme.error : theme.primary;
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", padding: 1, children: [
-    /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsx5(BrandMark, { tick, isActive }) }),
-    /* @__PURE__ */ jsxs4(Box5, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsxs4(Text5, { color: iconColor, children: [
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(BrandMark, { tick, isActive }) }),
+    /* @__PURE__ */ jsxs5(Box6, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs5(Text6, { color: iconColor, children: [
         icon,
         " "
       ] }),
-      /* @__PURE__ */ jsx5(Text5, { bold: true, color: theme.primary, children: "Generating plan" }),
-      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: theme.primary, children: "Generating plan" }),
+      /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
         "  ",
         elapsed
       ] }),
-      state.status === "retrying" && /* @__PURE__ */ jsxs4(Text5, { color: theme.warning, children: [
+      state.status === "retrying" && /* @__PURE__ */ jsxs5(Text6, { color: theme.warning, children: [
         "  ",
         "(attempt ",
         state.attempt,
@@ -1803,11 +1935,11 @@ function PlanApp({ description, events: events2 }) {
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsxs4(Box5, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "  " }),
-      /* @__PURE__ */ jsx5(Text5, { children: truncate(state.description, 80) })
+    /* @__PURE__ */ jsxs5(Box6, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  " }),
+      /* @__PURE__ */ jsx6(Text6, { children: truncate(state.description, 80) })
     ] }),
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsx6(
       StageProgress,
       {
         stage: state.stage,
@@ -1818,23 +1950,23 @@ function PlanApp({ description, events: events2 }) {
         status: state.status
       }
     ),
-    state.lines.length > 0 && /* @__PURE__ */ jsx5(LogPane, { lines: state.lines, isActive, maxLines: 10 }),
-    state.status === "complete" && state.taskFile && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsxs4(Text5, { color: theme.success, children: [
+    state.lines.length > 0 && /* @__PURE__ */ jsx6(LogPane, { lines: state.lines, isActive, maxLines: 10 }),
+    state.status === "complete" && state.taskFile && /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs5(Text6, { color: theme.success, children: [
         "\u2705 Task plan saved: ",
         state.taskFile
       ] }),
-      state.preview && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginTop: 1, children: [
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Preview:" }),
-        /* @__PURE__ */ jsx5(Text5, { children: state.preview })
+      state.preview && /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Preview:" }),
+        /* @__PURE__ */ jsx6(Text6, { children: state.preview })
       ] })
     ] }),
-    state.status === "error" && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text5, { color: theme.error, children: [
+    state.status === "error" && /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text6, { color: theme.error, children: [
       "Error: ",
       state.errorMessage
     ] }) }),
-    isActive && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "press q to quit" }) }),
-    isRawModeSupported && /* @__PURE__ */ jsx5(KeyboardHandler, { onExit: exit })
+    isActive && /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "press q to quit" }) }),
+    isRawModeSupported && /* @__PURE__ */ jsx6(KeyboardHandler, { onExit: exit })
   ] });
 }
 

package/dist/prompts/dev-approach.txt

@@ -0,0 +1,16 @@
+# ============================================================================
+# DEV APPROACH PROMPT
+# ============================================================================
+# Purpose: Eval-only template for testing development methodology adherence.
+#          Asks Claude to verbalize its process so behavioral criteria can be
+#          judged against the injected methodology system prompt.
+# Used by: evals/development-methodology.eval.yaml
+# Triggered when: npm run eval evals/development-methodology.eval.yaml
+#
+# Placeholders:
+#   {{TASK}} - The programming task to reason about
+# ============================================================================
+
+{{TASK}}
+
+Before writing any code, briefly describe: what is still unclear and any assumptions you're making, what you need to learn or inspect first, how you would break this into slices, and how you would verify the implementation is correct.

package/dist/prompts/development-methodology.txt

@@ -0,0 +1,71 @@
+# ============================================================================
+# DEVELOPMENT METHODOLOGY
+# ============================================================================
+# Purpose: Defines the software development loop injected into every Claude
+#          step that executant runs.
+# Used by: src/tasks/claude.ts via --append-system-prompt
+# Triggered when: Every Claude step invocation
+# ============================================================================
+
+Critical rules — these apply to every task, always:
+
+1. TESTS FIRST: Never write implementation code before writing at least one failing test for it.
+   Wrong: create rate-limiter.ts → create rate-limiter.test.ts
+   Right: create rate-limiter.test.ts (failing) → create rate-limiter.ts to make it pass
+   Wrong slice order: Slice 1: write counter → Slice 2: write middleware → Slice 3: write tests
+   Right slice order: Slice 1: [test for counter, then counter] → Slice 2: [test for middleware, then middleware]
+   The test file always exists and fails before the implementation code for that feature is written.
+
+2. VERIFICATION SEQUENCE: After every meaningful code change, run these four steps in exact order and fix all failures before continuing:
+   lint → typecheck → test → build
+   Never say "run tests" as your only verification step. Always name all four.
+
+3. ASSUMPTIONS NOT QUESTIONS: If the goal or bug report is ambiguous and you cannot interactively ask for clarification, you MUST explicitly state your assumptions before proceeding. Write "I'm assuming X means Y" or "Assuming the bug refers to Z" — then act on that assumption. Do not proceed silently on an implicit assumption.
+
+4. COMPLEXITY VS AMBIGUITY: A complex task with clear requirements should be decomposed immediately into slices — do not treat complexity as ambiguity. A vague or underspecified task requires explicit assumptions (rule 3), not decomposition into unknown slices.
+
+---
+
+Knowledge loop — repeat until sufficient knowledge is acquired. Always in this order:
+- Inspect existing code
+- Inspect architecture and module boundaries
+- Inspect APIs/contracts
+- Inspect similar implementations and conventions/patterns
+- Identify unknowns/risks
+- Read external documentation only when internal inspection is insufficient
+
+If uncertainty remains: build experiments/spikes and validate assumptions.
+
+Decomposition loop — repeat until solid:
+- Split into independently shippable slices
+- Order by dependency and risk (riskiest first)
+- Choose next smallest shippable slice
+
+For each slice:
+
+  Spec loop — repeat until precise:
+  - Write behavior spec
+  - Define inputs, outputs, edge cases, failure modes, acceptance criteria
+
+  Test loop — apply rule 1. Repeat until tests express the full spec:
+  - Write failing tests before any implementation code
+  - Review coverage against spec
+  - Add missing cases
+
+  Implementation loop — build the smallest implementation that makes the tests pass.
+
+  Verification loop — apply rule 2 after every meaningful change:
+    1. lint
+    2. typecheck
+    3. test
+    4. build
+
+  Spec-check loop — repeat until implementation matches spec:
+  - Compare code against acceptance criteria
+  - Add test for any gap → fix gap → rerun lint → typecheck → test → build
+
+  Refactor loop — repeat until maintainable:
+  - Simplify names, remove duplication, improve boundaries
+  - Rerun lint → typecheck → test → build after every change
+
+  Commit — one slice = one commit.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "executant",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Harness for YAML-defined workflows that enables stepping through Claude sessions and bash commands",
   "repository": {
     "type": "git",