executant 1.7.0 → 1.9.0

package/dist/index.js

@@ -113,22 +113,25 @@ function timestamp() {
 
 // src/load-workflow.ts
 import { z } from "zod";
-var RawStepSchema = z.object({
-  name: z.string(),
-  type: z.enum(["prompt", "script", "log", "command"]).optional(),
-  prompt: z.string().optional(),
-  command: z.string().optional(),
-  message: z.string().optional(),
-  continue_on_error: z.boolean().optional(),
-  self_healing: z.boolean().optional(),
-  max_healing_attempts: z.number().int().positive().optional(),
-  output: z.string().optional(),
-  llm_as_judge: z.boolean().optional(),
-  allowed_tools: z.array(z.string()).optional(),
-  forEach: z.union([z.array(z.string()), z.string()]).optional(),
-  repeat: z.number().int().positive().optional(),
-  context: z.array(z.string()).optional()
-});
+var RawStepSchema = z.lazy(
+  () => z.object({
+    name: z.string(),
+    type: z.enum(["prompt", "script", "log", "command"]).optional(),
+    prompt: z.string().optional(),
+    command: z.string().optional(),
+    message: z.string().optional(),
+    continue_on_error: z.boolean().optional(),
+    self_healing: z.boolean().optional(),
+    max_healing_attempts: z.number().int().positive().optional(),
+    output: z.string().optional(),
+    llm_as_judge: z.boolean().optional(),
+    allowed_tools: z.array(z.string()).optional(),
+    forEach: z.union([z.array(z.string()), z.string()]).optional(),
+    repeat: z.number().int().positive().optional(),
+    context: z.array(z.string()).optional(),
+    steps: z.array(RawStepSchema).min(1).optional()
+  })
+);
 var RawWorkflowSchema = z.object({
   goal: z.string(),
   steps: z.array(RawStepSchema),
@@ -140,7 +143,9 @@ function loadWorkflow(filePath2) {
   try {
     raw = readFileSync2(filePath2, "utf8");
   } catch (err) {
-    throw new Error(`Cannot read workflow file "${filePath2}": ${getErrorMessage(err)}`);
+    throw new Error(
+      `Cannot read workflow file "${filePath2}": ${getErrorMessage(err)}`
+    );
   }
   let doc;
   try {
@@ -164,16 +169,30 @@ function convertStep(step, vars) {
     throw new Error(`Step "${name}" cannot have both repeat and forEach`);
   }
   if (step.repeat !== void 0 || step.forEach !== void 0) {
+    if (step.steps && (step.command || step.prompt || step.message)) {
+      throw new Error(
+        `Step "${name}" cannot have both steps and command/prompt/message`
+      );
+    }
     const forEachValue = step.repeat !== void 0 ? Array.from({ length: step.repeat }, (_, i) => String(i + 1)) : step.forEach;
-    const { repeat: _r, forEach: _f, ...innerStep } = step;
+    const stepWithoutLoop = {
+      ...step,
+      repeat: void 0,
+      forEach: void 0,
+      steps: void 0
+    };
+    const inner = step.steps ? step.steps.map((s) => convertStep(s, vars)) : [convertInnerStep(stepWithoutLoop, vars, name, continueOnError)];
     return {
       type: "forEach",
       name,
       continueOnError,
       forEach: forEachValue,
-      inner: convertInnerStep(innerStep, vars, name, continueOnError)
+      inner
     };
   }
+  if (step.steps) {
+    throw new Error(`Step "${name}" has steps but no forEach or repeat`);
+  }
   return convertInnerStep(step, vars, name, continueOnError);
 }
 function convertInnerStep(step, vars, name, continueOnError) {
@@ -181,7 +200,8 @@ function convertInnerStep(step, vars, name, continueOnError) {
   switch (effectiveType) {
     case "script":
     case "command": {
-      if (!step.command) throw new Error(`Step "${name}" has type script but no command`);
+      if (!step.command)
+        throw new Error(`Step "${name}" has type script but no command`);
       return {
         type: "command",
         name,
@@ -189,7 +209,9 @@ function convertInnerStep(step, vars, name, continueOnError) {
         continueOnError,
         selfHealing: step.self_healing === true,
         maxHealingAttempts: step.max_healing_attempts,
-        ...step.output && { output: resolveOutputFile(step.output, vars, name) }
+        ...step.output && {
+          output: resolveOutputFile(step.output, vars, name)
+        }
       };
     }
     case "log": {
@@ -202,7 +224,8 @@ function convertInnerStep(step, vars, name, continueOnError) {
       };
     }
     case "prompt": {
-      if (!step.prompt) throw new Error(`Step "${name}" has type prompt but no prompt field`);
+      if (!step.prompt)
+        throw new Error(`Step "${name}" has type prompt but no prompt field`);
       const contextFiles = resolveContextFiles(step.context, vars, name);
       return {
         type: "claude",
@@ -225,13 +248,17 @@ function inferType(step) {
 }
 function resolveVarPath(varName, vars, stepName, label) {
   if (!(varName in vars)) {
-    throw new Error(`Step "${stepName}" ${label} references undefined var "${varName}" \u2014 add it to the vars section`);
+    throw new Error(
+      `Step "${stepName}" ${label} references undefined var "${varName}" \u2014 add it to the vars section`
+    );
   }
   return vars[varName];
 }
 function resolveContextFiles(contextVarNames, vars, stepName) {
   if (!contextVarNames || contextVarNames.length === 0) return [];
-  return contextVarNames.map((varName) => resolveVarPath(varName, vars, stepName, "context"));
+  return contextVarNames.map(
+    (varName) => resolveVarPath(varName, vars, stepName, "context")
+  );
 }
 function resolveOutputFile(varName, vars, stepName) {
   return resolveVarPath(varName, vars, stepName, "output");
@@ -507,7 +534,7 @@ async function* runWorkflow(workflow2, options2 = {}) {
     yield { type: "step:start", index: i, name: task.name };
     try {
       for await (const event of runStep(task)) {
-        if (event.type === "step:iteration" || event.type === "output:text" || event.type === "output:tool") {
+        if (event.type === "step:iteration" || event.type === "step:inner" || event.type === "output:text" || event.type === "output:tool") {
           yield { ...event, index: i };
         } else {
           yield event;
@@ -568,20 +595,55 @@ async function* runLog(task) {
 async function* runForEach(task) {
   const items = await resolveItems(task.forEach);
   const total = items.length;
+  const innerTotal = task.inner.length;
   for (const [i, item] of items.entries()) {
     yield { type: "step:iteration", index: -1, item, iteration: i + 1, total };
-    const substituted = substituteItem(task.inner, item);
-    yield* runStep(substituted);
+    for (const [j, innerTask] of task.inner.entries()) {
+      const substituted = substituteItem(innerTask, item);
+      if (innerTotal > 1) {
+        yield {
+          type: "step:inner",
+          index: -1,
+          iteration: i + 1,
+          innerIndex: j,
+          innerTotal,
+          name: substituted.name
+        };
+      }
+      try {
+        yield* runStep(substituted);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (!substituted.continueOnError) {
+          yield {
+            type: "log",
+            level: "warn",
+            text: `[forEach] Step "${substituted.name}" failed \u2014 aborting remaining children and iterations`
+          };
+          throw error;
+        }
+        yield {
+          type: "log",
+          level: "warn",
+          text: `[forEach] Step "${substituted.name}" failed (continuing): ${error.message}`
+        };
+      }
+    }
   }
 }
 async function resolveItems(forEach) {
   if (Array.isArray(forEach)) return forEach.filter(Boolean);
   try {
-    const { stdout } = await execPromise(forEach, { shell: "/bin/sh", timeout: 3e4 });
+    const { stdout } = await execPromise(forEach, {
+      shell: "/bin/sh",
+      timeout: 3e4
+    });
     return stdout.split("\n").filter((l) => l.trim().length > 0);
   } catch (err) {
-    throw new Error(`forEach shell command failed: ${getErrorMessage(err)}
-Command: ${forEach}`);
+    throw new Error(
+      `forEach shell command failed: ${getErrorMessage(err)}
+Command: ${forEach}`
+    );
   }
 }
 function substituteItem(task, item) {
@@ -590,12 +652,24 @@ function substituteItem(task, item) {
     case "command":
       return { ...task, name: sub(task.name), command: sub(task.command) };
     case "claude":
-      return { ...task, name: sub(task.name), prompt: sub(task.prompt), allowedTools: task.allowedTools?.map(sub) };
+      return {
+        ...task,
+        name: sub(task.name),
+        prompt: sub(task.prompt),
+        allowedTools: task.allowedTools?.map(sub)
+      };
     case "log":
       return { ...task, name: sub(task.name), message: sub(task.message) };
+    case "forEach":
+      return {
+        ...task,
+        name: sub(task.name),
+        forEach: Array.isArray(task.forEach) ? task.forEach : sub(task.forEach),
+        inner: task.inner.map((t) => substituteItem(t, item))
+      };
     default: {
       const _ = task;
-      throw new Error(`Unknown inner task type: ${JSON.stringify(_)}`);
+      throw new Error(`Unknown task type: ${JSON.stringify(_)}`);
     }
   }
 }
@@ -607,7 +681,11 @@ async function* runCommandWithHealing(task) {
     try {
       yield* collectLines(runCommand(task), lines);
       if (attempt > 0) {
-        yield { type: "log", level: "info", text: `[self-healing] Command passed after ${attempt + 1} attempts` };
+        yield {
+          type: "log",
+          level: "info",
+          text: `[self-healing] Command passed after ${attempt + 1} attempts`
+        };
       }
       return;
     } catch (err) {
@@ -615,7 +693,11 @@ async function* runCommandWithHealing(task) {
       const output = lines.join("\n");
       const remaining = maxAttempts - attempt - 1;
       if (remaining === 0) {
-        yield { type: "log", level: "warn", text: `[self-healing] Exhausted ${maxAttempts} attempts` };
+        yield {
+          type: "log",
+          level: "warn",
+          text: `[self-healing] Exhausted ${maxAttempts} attempts`
+        };
         throw new Error(
           `Step "${task.name}" failed after ${maxAttempts} self-healing attempts (last exit code: ${exitCode})`
         );
@@ -626,7 +708,12 @@ async function* runCommandWithHealing(task) {
         text: `[self-healing] Attempt ${attempt + 1}/${maxAttempts} failed (exit ${exitCode}), invoking Claude to fix\u2026`
       };
       const historyBlock = buildAttemptHistory(attemptHistory);
-      const healPrompt = buildHealingPrompt(task.command, exitCode, output, historyBlock);
+      const healPrompt = buildHealingPrompt(
+        task.command,
+        exitCode,
+        output,
+        historyBlock
+      );
       const healTask = {
         type: "claude",
         name: `${task.name}:heal-${attempt + 1}`,
@@ -637,7 +724,8 @@ async function* runCommandWithHealing(task) {
       const claudeLines = [];
       for await (const event of runClaude(healTask)) {
         if (event.type === "output:text") claudeLines.push(event.text);
-        else if (event.type === "output:tool") toolCalls.push(formatToolCall(event.tool, event.input));
+        else if (event.type === "output:tool")
+          toolCalls.push(formatToolCall(event.tool, event.input));
         yield event;
       }
       attemptHistory.push({
@@ -645,7 +733,11 @@ async function* runCommandWithHealing(task) {
         exitCode,
         cmdOutput: output
       });
-      yield { type: "log", level: "info", text: `[self-healing] Re-running command (${remaining} attempt(s) left)\u2026` };
+      yield {
+        type: "log",
+        level: "info",
+        text: `[self-healing] Re-running command (${remaining} attempt(s) left)\u2026`
+      };
     }
   }
 }
@@ -657,21 +749,37 @@ async function* runClaudeWithJudge(task) {
 ${fillTemplate(JUDGE_RETRY_CONTEXT, { FEEDBACK: judgeContext })}`;
     const lines = [];
     yield* collectLines(runClaude({ ...task, prompt }), lines);
-    yield { type: "log", level: "info", text: `[judge] Evaluating "${task.name}"\u2026` };
-    const verdict = await evaluateWithJudge(task.name, task.prompt, lines.join("\n"));
+    yield {
+      type: "log",
+      level: "info",
+      text: `[judge] Evaluating "${task.name}"\u2026`
+    };
+    const verdict = await evaluateWithJudge(
+      task.name,
+      task.prompt,
+      lines.join("\n")
+    );
     if (verdict.pass) {
       yield { type: "log", level: "info", text: "[judge] PASS" };
       return;
     }
     judgeContext = verdict.feedback;
-    yield { type: "log", level: "warn", text: `[judge] FAIL \u2014 ${verdict.feedback}` };
+    yield {
+      type: "log",
+      level: "warn",
+      text: `[judge] FAIL \u2014 ${verdict.feedback}`
+    };
     const remaining = MAX_JUDGE_RETRIES - attempt - 1;
     if (remaining === 0) {
       throw new Error(
         `Step "${task.name}" failed judge evaluation after ${MAX_JUDGE_RETRIES} attempts`
       );
     }
-    yield { type: "log", level: "info", text: `[judge] Retrying (${remaining} attempt(s) left)\u2026` };
+    yield {
+      type: "log",
+      level: "info",
+      text: `[judge] Retrying (${remaining} attempt(s) left)\u2026`
+    };
   }
 }
 async function evaluateWithJudge(stepName, stepInstructions, output) {
@@ -698,7 +806,9 @@ function readContextFile(filePath2) {
   try {
     return readFileSync3(filePath2, "utf8");
   } catch (err) {
-    throw new Error(`Context file "${filePath2}" could not be read: ${getErrorMessage(err)}`);
+    throw new Error(
+      `Context file "${filePath2}" could not be read: ${getErrorMessage(err)}`
+    );
   }
 }
 function expandContext(task) {
@@ -712,13 +822,23 @@ ${readContextFile(fp)}
 ${task.prompt}` };
 }
 function buildHealingPrompt(command, exitCode, output, attemptHistory) {
-  return fillTemplate(SELF_HEALING_PROMPT, { COMMAND: command, EXIT_CODE: String(exitCode), OUTPUT: output, ATTEMPT_HISTORY: attemptHistory });
+  return fillTemplate(SELF_HEALING_PROMPT, {
+    COMMAND: command,
+    EXIT_CODE: String(exitCode),
+    OUTPUT: output,
+    ATTEMPT_HISTORY: attemptHistory
+  });
 }
 function buildJudgePrompt(stepName, instructions, output) {
-  return fillTemplate(JUDGE_EVALUATION_PROMPT, { STEP_NAME: stepName, STEP_INSTRUCTIONS: instructions, OUTPUT: output });
+  return fillTemplate(JUDGE_EVALUATION_PROMPT, {
+    STEP_NAME: stepName,
+    STEP_INSTRUCTIONS: instructions,
+    OUTPUT: output
+  });
 }
 function formatToolCall(tool, input) {
-  if (tool === "Edit" || tool === "Write") return `${tool}(${String(input["file_path"] ?? "")})`;
+  if (tool === "Edit" || tool === "Write")
+    return `${tool}(${String(input["file_path"] ?? "")})`;
   if (tool === "Bash") return `Bash(${String(input["command"] ?? "")})`;
   return tool;
 }
@@ -743,7 +863,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";
@@ -811,32 +931,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":
+    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, {
-        iteration: { current: event.iteration, total: event.total, item: event.item }
+        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;
@@ -848,7 +1006,10 @@ function reducer(state, event) {
       const formatted = formatToolCall2(event.tool, event.input);
       const next = formatted ? appendLine(state, idx, formatted) : state;
       if (event.tool === "Write" && typeof event.input["file_path"] === "string") {
-        return { ...next, writtenFiles: [...next.writtenFiles, event.input["file_path"]] };
+        return {
+          ...next,
+          writtenFiles: [...next.writtenFiles, event.input["file_path"]]
+        };
       }
       return next;
     }
@@ -871,7 +1032,9 @@ function reducer(state, event) {
   }
 }
 function updateTask(state, index, patch) {
-  const tasks = state.tasks.map((t, i) => i === index ? { ...t, ...patch } : t);
+  const tasks = state.tasks.map(
+    (t, i) => i === index ? { ...t, ...patch } : t
+  );
   return { ...state, tasks };
 }
 function appendLine(state, index, line) {
@@ -886,20 +1049,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";
@@ -928,6 +1077,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 }) {
@@ -935,7 +1110,7 @@ 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 iterInfo = formatIterCount(taskState.iterationHistory);
   const label = `${index + 1}. ${task.name}${iterInfo}`;
   return /* @__PURE__ */ jsxs(Box, { children: [
     /* @__PURE__ */ jsxs(Text, { color, children: [
@@ -949,17 +1124,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";
 }
@@ -967,16 +1131,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,
@@ -986,29 +1208,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
   ] });
@@ -1028,8 +1250,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;
@@ -1042,11 +1264,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));
@@ -1064,7 +1287,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 () => {
@@ -1084,14 +1310,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,
         "/",
@@ -1101,33 +1329,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
+    ] }, taskState.task.name)) }),
+    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 })
   ] });
 }
 
@@ -1146,25 +1389,9 @@ var PLAN_RETRY_SCHEMA_ERROR = loadPrompt("plan-retry-schema-error");
 var PLAN_RETRY_JUDGE = loadPrompt("plan-retry-judge");
 var MAX_PLAN_RETRIES = 3;
 var TOTAL_PLAN_STAGES = 3;
-var StepSchema = z3.object({
-  name: z3.string(),
-  type: z3.enum(["prompt", "script", "log"]).optional(),
-  prompt: z3.string().optional(),
-  command: z3.string().optional(),
-  message: z3.string().optional(),
-  continue_on_error: z3.boolean().optional(),
-  self_healing: z3.boolean().optional(),
-  max_healing_attempts: z3.number().int().positive().optional(),
-  output: z3.string().optional(),
-  llm_as_judge: z3.boolean().optional(),
-  allowed_tools: z3.array(z3.string()).optional(),
-  forEach: z3.union([z3.array(z3.string()), z3.string()]).optional(),
-  repeat: z3.number().int().positive().optional(),
-  context: z3.array(z3.string()).optional()
-});
 var WorkflowSchema = z3.object({
   goal: z3.string(),
-  steps: z3.array(StepSchema).min(1),
+  steps: z3.array(RawStepSchema).min(1),
   vars: z3.record(z3.string()).optional(),
   self_improve: z3.boolean().optional()
 });
@@ -1184,7 +1411,10 @@ function walkUp(startDir, check) {
   }
 }
 function findGitRoot(startDir) {
-  return walkUp(startDir, (dir) => existsSync(join2(dir, ".git")) ? dir : null);
+  return walkUp(
+    startDir,
+    (dir) => existsSync(join2(dir, ".git")) ? dir : null
+  );
 }
 function findProjectRoot(startDir) {
   return walkUp(startDir, (dir) => {
@@ -1335,34 +1565,27 @@ function normalizeWorkflow(workflow2) {
   return { ...workflow2, steps: collapseSequentialSteps(steps) };
 }
 function collapseSequentialSteps(steps) {
-  const result = [];
-  let i = 0;
-  while (i < steps.length) {
-    const step = steps[i];
-    if (step.forEach !== void 0 || step.repeat !== void 0) {
-      result.push(step);
-      i++;
-      continue;
-    }
-    const m = step.name.match(/^(.+?)_1$/);
-    if (!m) {
-      result.push(step);
-      i++;
-      continue;
-    }
-    const prefix = m[1];
-    let n = 1;
-    while (i + n < steps.length && steps[i + n].name === `${prefix}_${n + 1}`) n++;
-    if (n < 2) {
-      result.push(step);
-      i++;
-      continue;
-    }
-    const { name: _name, ...rest } = step;
-    result.push({ ...rest, name: `${prefix}_{{item}}`, repeat: n });
-    i += n;
-  }
-  return result;
+  return steps.reduce(
+    ({ out, skip }, step, i, arr) => {
+      if (skip > 0) return { out, skip: skip - 1 };
+      if (step.forEach !== void 0 || step.repeat !== void 0 || step.steps !== void 0) {
+        return { out: [...out, step], skip: 0 };
+      }
+      const m = step.name.match(/^(.+?)_1$/);
+      if (!m) return { out: [...out, step], skip: 0 };
+      const prefix = m[1];
+      let n = 1;
+      while (i + n < arr.length && arr[i + n].name === `${prefix}_${n + 1}`)
+        n++;
+      if (n < 2) return { out: [...out, step], skip: 0 };
+      const { name: _name, ...rest } = step;
+      return {
+        out: [...out, { ...rest, name: `${prefix}_{{item}}`, repeat: n }],
+        skip: n - 1
+      };
+    },
+    { out: [], skip: 0 }
+  ).out;
 }
 async function* streamPlan(args) {
   const { description, taskFile } = args;
@@ -1373,14 +1596,24 @@ async function* streamPlan(args) {
     yield { type: "plan:stages", names: ["Decompose to Steps", "Validate"] };
     researchDoc = "No codebase research performed \u2014 the task is self-contained. Work directly from the user's original goal.";
   } else {
-    yield { type: "plan:stages", names: ["Research & Planning", "Decompose to Steps", "Validate"] };
-    yield { type: "plan:stage", stage: 1, total: TOTAL_PLAN_STAGES, name: "Research & Planning" };
+    yield {
+      type: "plan:stages",
+      names: ["Research & Planning", "Decompose to Steps", "Validate"]
+    };
+    yield {
+      type: "plan:stage",
+      stage: 1,
+      total: TOTAL_PLAN_STAGES,
+      name: "Research & Planning"
+    };
     const researchLines = [];
     try {
       const researchTask = {
         type: "claude",
         name: "plan:research",
-        prompt: fillTemplate(PLAN_RESEARCH_PROMPT, { DESCRIPTION: description }),
+        prompt: fillTemplate(PLAN_RESEARCH_PROMPT, {
+          DESCRIPTION: description
+        }),
         allowedTools: ["Read", "Glob", "Grep"],
         permissionMode: "bypassPermissions",
         model: "opus"
@@ -1394,17 +1627,28 @@ async function* streamPlan(args) {
         }
       }
     } catch (err) {
-      yield { type: "plan:error", message: `Research pass failed: ${getErrorMessage(err)}` };
+      yield {
+        type: "plan:error",
+        message: `Research pass failed: ${getErrorMessage(err)}`
+      };
       return;
     }
     researchDoc = researchLines.join("\n");
     if (!researchDoc.trim()) {
-      yield { type: "plan:error", message: "Research pass produced no output \u2014 cannot decompose" };
+      yield {
+        type: "plan:error",
+        message: "Research pass produced no output \u2014 cannot decompose"
+      };
       return;
     }
   }
   const stages = skipResearch ? { decompose: 1, validate: 2, total: 2 } : { decompose: 2, validate: 3, total: TOTAL_PLAN_STAGES };
-  yield { type: "plan:stage", stage: stages.decompose, total: stages.total, name: "Decompose to Steps" };
+  yield {
+    type: "plan:stage",
+    stage: stages.decompose,
+    total: stages.total,
+    name: "Decompose to Steps"
+  };
   let retryPrefix = "";
   for (let attempt = 0; attempt < MAX_PLAN_RETRIES; attempt++) {
     if (attempt > 0) {
@@ -1414,9 +1658,17 @@ async function* streamPlan(args) {
         maxAttempts: MAX_PLAN_RETRIES,
         reason: retryPrefix.replace(/\n/g, " ")
       };
-      yield { type: "plan:stage", stage: stages.decompose, total: stages.total, name: "Decompose to Steps" };
+      yield {
+        type: "plan:stage",
+        stage: stages.decompose,
+        total: stages.total,
+        name: "Decompose to Steps"
+      };
     }
-    const basePrompt = fillTemplate(PLAN_DECOMPOSE_PROMPT, { DESCRIPTION: description, RESEARCH_DOC: researchDoc });
+    const basePrompt = fillTemplate(PLAN_DECOMPOSE_PROMPT, {
+      DESCRIPTION: description,
+      RESEARCH_DOC: researchDoc
+    });
     const decomposeTask = {
       type: "claude",
       name: "plan:decompose",
@@ -1448,7 +1700,10 @@ ${basePrompt}` : basePrompt,
         yield { type: "plan:error", message: msg };
         return;
       }
-      retryPrefix = fillTemplate(PLAN_RETRY_PARSE_ERROR, { ERROR: msg, EXCERPT: decomposeTextLines.join("\n") });
+      retryPrefix = fillTemplate(PLAN_RETRY_PARSE_ERROR, {
+        ERROR: msg,
+        EXCERPT: decomposeTextLines.join("\n")
+      });
       continue;
     }
     if (structuredOutput === void 0) {
@@ -1464,24 +1719,40 @@ ${basePrompt}` : basePrompt,
     if (!zodResult.success) {
       const issues = formatZodIssues(zodResult.error.issues);
       if (attempt === MAX_PLAN_RETRIES - 1) {
-        yield { type: "plan:error", message: `Plan did not match expected schema:
-${issues}` };
+        yield {
+          type: "plan:error",
+          message: `Plan did not match expected schema:
+${issues}`
+        };
         return;
       }
       retryPrefix = fillTemplate(PLAN_RETRY_SCHEMA_ERROR, { ISSUES: issues });
       continue;
     }
-    yield { type: "plan:stage", stage: stages.validate, total: stages.total, name: "Validate" };
+    yield {
+      type: "plan:stage",
+      stage: stages.validate,
+      total: stages.total,
+      name: "Validate"
+    };
     const judgeResult = await runPass3Judge(description, zodResult.data);
     if (judgeResult.skipped) {
-      yield { type: "plan:warn", message: "Judge skipped due to error \u2014 proceeding without validation" };
+      yield {
+        type: "plan:warn",
+        message: "Judge skipped due to error \u2014 proceeding without validation"
+      };
     }
     if (!judgeResult.pass && attempt < MAX_PLAN_RETRIES - 1) {
-      retryPrefix = fillTemplate(PLAN_RETRY_JUDGE, { FEEDBACK: judgeResult.feedback });
+      retryPrefix = fillTemplate(PLAN_RETRY_JUDGE, {
+        FEEDBACK: judgeResult.feedback
+      });
       continue;
     }
     if (!judgeResult.pass) {
-      yield { type: "plan:warn", message: `Judge rejected plan but retries exhausted: ${judgeResult.feedback}` };
+      yield {
+        type: "plan:warn",
+        message: `Judge rejected plan but retries exhausted: ${judgeResult.feedback}`
+      };
     }
     const { goal, vars, steps, ...rest } = normalizeWorkflow(zodResult.data);
     const ordered = { goal, ...vars && { vars }, steps, ...rest };
@@ -1497,13 +1768,16 @@ ${issues}` };
     yield { type: "plan:complete", taskFile, preview };
     return;
   }
-  yield { type: "plan:error", message: "Plan generation failed after maximum retries" };
+  yield {
+    type: "plan:error",
+    message: "Plan generation failed after maximum retries"
+  };
 }
 
 // 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 {
@@ -1579,7 +1853,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}` : ""
@@ -1612,19 +1886,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,
@@ -1633,11 +1907,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,
@@ -1648,23 +1922,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 })
   ] });
 }
 
@@ -1724,39 +1998,57 @@ function onWorkflowStart(ctx, s) {
   mkdirSync3(ctx.logDir, { recursive: true });
   mkdirSync3(ctx.highlightsDir, { recursive: true });
   const logFile = join3(ctx.logDir, `${ctx.ts}_${ctx.slug}.log`);
-  writeFileSync3(logFile, `# Execution Log
+  writeFileSync3(
+    logFile,
+    `# Execution Log
 Task: ${ctx.slug}
 Started: ${(/* @__PURE__ */ new Date()).toISOString()}
 ${"\u2501".repeat(51)}
 
-`);
+`
+  );
   return { ...s, logFile };
 }
 function onStepStart(ctx, s, index, name) {
-  const next = { ...INIT_STATE, logFile: s.logFile, stepIndex: index, stepName: name, stepStartMs: Date.now() };
-  appendLog(next.logFile, `
+  const next = {
+    ...INIT_STATE,
+    logFile: s.logFile,
+    stepIndex: index,
+    stepName: name,
+    stepStartMs: Date.now()
+  };
+  appendLog(
+    next.logFile,
+    `
 ${"\u2501".repeat(51)}
 Step ${index + 1}: ${name}
 Started: ${(/* @__PURE__ */ new Date()).toISOString()}
 ${"\u2501".repeat(51)}
-`);
+`
+  );
   return next;
 }
 function finalizeComplexSequence(s) {
   if (s.toolCount >= 3 && s.complexSequenceFile) {
-    appendFileSync(s.complexSequenceFile, `
+    appendFileSync(
+      s.complexSequenceFile,
+      `
 ---
 
 *Total tools used: ${s.toolCount}*
 
 *Captured by Executant Logger*
-`);
+`
+    );
   }
 }
 function onStepComplete(s) {
-  appendLog(s.logFile, `
+  appendLog(
+    s.logFile,
+    `
 Step completed in ${((Date.now() - s.stepStartMs) / 1e3).toFixed(1)}s
-`);
+`
+  );
   finalizeComplexSequence(s);
   return s;
 }
@@ -1794,29 +2086,35 @@ function onTool(ctx, s, tool, input) {
   const toolCount = s.toolCount + 1;
   const complexSequenceFile = toolCount === 3 ? createComplexSequenceFile(ctx, s) : s.complexSequenceFile;
   if (toolCount >= 3 && complexSequenceFile) {
-    appendFileSync(complexSequenceFile, `${toolCount}. **${tool}** - ${desc}
-`);
+    appendFileSync(
+      complexSequenceFile,
+      `${toolCount}. **${tool}** - ${desc}
+`
+    );
   }
   return { ...s, toolCount, complexSequenceFile };
 }
 function saveJudgeHighlight(ctx, s, verdict, text) {
-  writeFileSync3(highlightPath(ctx, s.stepIndex, `judge_${verdict}`), [
-    `# Judge Verdict: ${verdict}`,
-    "",
-    `**Task:** ${ctx.slug}`,
-    `**Step:** ${s.stepName}`,
-    `**Attempt:** ${s.judgeAttempt}`,
-    `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
-    "",
-    "---",
-    "",
-    text,
-    "",
-    "---",
-    "",
-    "*Auto-captured*",
-    ""
-  ].join("\n"));
+  writeFileSync3(
+    highlightPath(ctx, s.stepIndex, `judge_${verdict}`),
+    [
+      `# Judge Verdict: ${verdict}`,
+      "",
+      `**Task:** ${ctx.slug}`,
+      `**Step:** ${s.stepName}`,
+      `**Attempt:** ${s.judgeAttempt}`,
+      `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      "",
+      "---",
+      "",
+      text,
+      "",
+      "---",
+      "",
+      "*Auto-captured*",
+      ""
+    ].join("\n")
+  );
 }
 var LOG_MATCHERS = [
   {
@@ -1832,29 +2130,32 @@ var LOG_MATCHERS = [
     pattern: /\[self-healing\].*failed.*exit\s+(\d+)/i,
     apply: (ctx, s, text, match) => {
       const selfHealingFile = highlightPath(ctx, s.stepIndex, "self_healing");
-      writeFileSync3(selfHealingFile, [
-        "# Self-Healing Activation",
-        "",
-        `**Task:** ${ctx.slug}`,
-        `**Step:** ${s.stepName}`,
-        `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
-        "",
-        "---",
-        "",
-        "## \u274C Failure Detected",
-        "",
-        `**Exit Code:** ${match[1]}`,
-        "",
-        "**Recent Output:**",
-        "```",
-        s.recentOutput.join("\n"),
-        "```",
-        "",
-        "---",
-        "",
-        "## \u{1F527} Claude's Healing Process",
-        ""
-      ].join("\n"));
+      writeFileSync3(
+        selfHealingFile,
+        [
+          "# Self-Healing Activation",
+          "",
+          `**Task:** ${ctx.slug}`,
+          `**Step:** ${s.stepName}`,
+          `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
+          "",
+          "---",
+          "",
+          "## \u274C Failure Detected",
+          "",
+          `**Exit Code:** ${match[1]}`,
+          "",
+          "**Recent Output:**",
+          "```",
+          s.recentOutput.join("\n"),
+          "```",
+          "",
+          "---",
+          "",
+          "## \u{1F527} Claude's Healing Process",
+          ""
+        ].join("\n")
+      );
       return { ...s, selfHealingFile, recentOutput: [] };
     }
   },
@@ -1862,21 +2163,24 @@ var LOG_MATCHERS = [
     pattern: /\[self-healing\].*Re-running/i,
     apply: (_ctx, s) => {
       if (!s.selfHealingFile) return s;
-      appendFileSync(s.selfHealingFile, [
-        "",
-        "*(See full log for Claude's diagnostic process)*",
-        "",
-        "---",
-        "",
-        "## \u2705 Resolution Applied",
-        "",
-        "The self-healing process completed. Check the full execution log to see Claude's analysis and fix.",
-        "",
-        "---",
-        "",
-        "*Auto-captured*",
-        ""
-      ].join("\n"));
+      appendFileSync(
+        s.selfHealingFile,
+        [
+          "",
+          "*(See full log for Claude's diagnostic process)*",
+          "",
+          "---",
+          "",
+          "## \u2705 Resolution Applied",
+          "",
+          "The self-healing process completed. Check the full execution log to see Claude's analysis and fix.",
+          "",
+          "---",
+          "",
+          "*Auto-captured*",
+          ""
+        ].join("\n")
+      );
       return { ...s, selfHealingFile: "" };
     }
   }
@@ -1893,30 +2197,39 @@ function onLogMessage(ctx, s, level, text) {
   ).state;
 }
 function onWorkflowComplete(ctx, s) {
-  appendLog(s.logFile, `
+  appendLog(
+    s.logFile,
+    `
 ${"\u2501".repeat(51)}
 Task Complete: ${ctx.slug}
 Finished: ${(/* @__PURE__ */ new Date()).toISOString()}
 ${"\u2501".repeat(51)}
-`);
+`
+  );
   const indexFile = join3(ctx.highlightsDir, "README.md");
   if (!existsSync2(indexFile)) {
-    writeFileSync3(indexFile, [
-      "# Execution Highlights",
-      "",
-      "This directory contains automatically extracted highlight moments from task executions.",
-      "",
-      "## Latest Highlights",
-      ""
-    ].join("\n"));
+    writeFileSync3(
+      indexFile,
+      [
+        "# Execution Highlights",
+        "",
+        "This directory contains automatically extracted highlight moments from task executions.",
+        "",
+        "## Latest Highlights",
+        ""
+      ].join("\n")
+    );
   }
   const highlights = readdirSync(ctx.highlightsDir).filter((f) => f.startsWith(ctx.ts) && f.endsWith(".md")).sort();
   if (highlights.length > 0) {
     const entries = highlights.map((f) => `- [${f.replace(/\.md$/, "")}](./${f})`).join("\n");
-    appendFileSync(indexFile, `
+    appendFileSync(
+      indexFile,
+      `
 ### ${ctx.slug} (${(/* @__PURE__ */ new Date()).toISOString()})
 ${entries}
-`);
+`
+    );
   }
   return s;
 }
@@ -1934,6 +2247,19 @@ function reduce(ctx, s, event) {
       return onStepComplete(s);
     case "step:error":
       return onStepError(s, event.error);
+    case "step:iteration":
+      appendLog(
+        s.logFile,
+        `
+\u2500\u2500 iteration ${event.iteration}/${event.total}: ${event.item}`
+      );
+      return s;
+    case "step:inner":
+      appendLog(
+        s.logFile,
+        `   \u21B3 [${event.innerIndex + 1}/${event.innerTotal}] ${event.name}`
+      );
+      return s;
     case "output:text":
       return onOutputText(s, event.text);
     case "output:tool":
@@ -2115,16 +2441,21 @@ function extractJson(text) {
 
 // src/index.ts
 var CURRENT_VERSION = JSON.parse(
-  readFileSync6(join5(dirname5(fileURLToPath2(import.meta.url)), "../package.json"), "utf-8")
+  readFileSync6(
+    join5(dirname5(fileURLToPath2(import.meta.url)), "../package.json"),
+    "utf-8"
+  )
 ).version;
 var rawArgs = process.argv.slice(2);
 if (rawArgs[0] === "plan") {
   const planArgs = parsePlanArgs(rawArgs.slice(1));
   const planEvents = streamPlan(planArgs);
-  const inkApp = render(React3.createElement(PlanApp, {
-    description: planArgs.description,
-    events: planEvents
-  }));
+  const inkApp = render(
+    React3.createElement(PlanApp, {
+      description: planArgs.description,
+      events: planEvents
+    })
+  );
   try {
     await inkApp.waitUntilExit();
   } catch {
@@ -2173,7 +2504,15 @@ YAML \u2014 step fields (all step types):
   forEach           string or list
                     Inline YAML array OR a shell command whose newline-split
                     stdout provides the items. {{item}} is substituted per
-                    iteration in the inner step's prompt or command.
+                    iteration in every child step's name, command, and prompt.
+  repeat            int     Run this step N times; {{item}} is the 1-based
+                    iteration number. Mutually exclusive with forEach.
+  steps             list    Multiple child steps to run per forEach/repeat
+                    iteration. Mutually exclusive with command/prompt on the
+                    parent step. Requires forEach or repeat.
+  context           list    Var names whose file-path values are prepended to
+                    a prompt step's content at runtime.
+  output            string  Var name; captures script stdout to that file path.
 
 YAML \u2014 prompt step fields (type: prompt, or inferred when prompt is present):
   prompt            string  (required) Instructions sent to Claude
@@ -2185,7 +2524,7 @@ YAML \u2014 prompt step fields (type: prompt, or inferred when prompt is present
 YAML \u2014 script step fields (type: script | command, or inferred when command is present):
   command           string  (required) Bash command to execute
   self_healing      bool    On failure, Claude diagnoses and fixes iteratively
-                            up to 5 attempts with accumulated context (default: true)
+                            up to 5 attempts with accumulated context (default: false)
   max_healing_attempts  int   Override max self-healing retries (default: 5)
 
 YAML \u2014 log step fields (type: log, or inferred when message is present and prompt is absent):
@@ -2263,9 +2602,17 @@ function errorReplacer(_key, value) {
 async function maybeRunRetrospective(filePath2, workflow2, logger2) {
   if (!logger2) return;
   try {
-    await runRetrospective(filePath2, workflow2, logger2.getHighlightsDir(), logger2.getTimestamp());
+    await runRetrospective(
+      filePath2,
+      workflow2,
+      logger2.getHighlightsDir(),
+      logger2.getTimestamp()
+    );
   } catch (err) {
-    console.warn("[executant] retrospective failed (non-fatal):", getErrorMessage(err));
+    console.warn(
+      "[executant] retrospective failed (non-fatal):",
+      getErrorMessage(err)
+    );
   }
 }
 if (ciMode) {
@@ -2281,7 +2628,9 @@ if (ciMode) {
     process.exit(1);
   });
 } else {
-  const inkApp = render(React3.createElement(App, { workflow, events, options, updateCheck }));
+  const inkApp = render(
+    React3.createElement(App, { workflow, events, options, updateCheck })
+  );
   if (workflow.selfImprove) {
     inkApp.waitUntilExit().then(() => maybeRunRetrospective(filePath, workflow, logger)).catch(() => {
     });