executant 1.6.0 → 1.8.0

package/dist/index.js

@@ -54,28 +54,84 @@ import React3 from "react";
 import { render } from "ink";
 import { readFileSync as readFileSync6 } from "node:fs";
 import { dirname as dirname5, join as join5 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/load-workflow.ts
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import { load as parseYaml } from "js-yaml";
+
+// src/lib/utils.ts
+import { readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var __dir = dirname(fileURLToPath(import.meta.url));
+var PROMPTS_DIR = basename(__dir) === "lib" ? join(__dir, "..", "prompts") : join(__dir, "prompts");
+function stripPromptHeader(raw) {
+  return raw.replace(/^(#[^\n]*\n)+\n?/, "").trim();
+}
+function loadPrompt(name) {
+  return stripPromptHeader(readFileSync(join(PROMPTS_DIR, `${name}.txt`), "utf8"));
+}
+function findOutermostBraces(text) {
+  const start = text.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  for (let i = start; i < text.length; i++) {
+    if (text[i] === "{") depth++;
+    else if (text[i] === "}" && --depth === 0) return { start, end: i };
+  }
+  return null;
+}
+function extractJsonObject(text) {
+  const fenceMatch = text.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
+  if (fenceMatch) return fenceMatch[1].trim();
+  const bounds = findOutermostBraces(text);
+  return bounds ? text.slice(bounds.start, bounds.end + 1) : text.trim();
+}
+function getErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function fillTemplate(template, vars) {
+  return Object.entries(vars).reduce(
+    (acc, [key, val]) => acc.replaceAll(`{{${key}}}`, val),
+    template
+  );
+}
+function formatZodIssues(issues) {
+  return issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+}
+function slugify(text, maxLen = 20) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/, "");
+}
+function formatTimestamp(d) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+function timestamp() {
+  return formatTimestamp(/* @__PURE__ */ new Date());
+}
+
+// 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),
@@ -85,16 +141,17 @@ var RawWorkflowSchema = z.object({
 function loadWorkflow(filePath2) {
   let raw;
   try {
-    raw = readFileSync(filePath2, "utf8");
+    raw = readFileSync2(filePath2, "utf8");
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`Cannot read workflow file "${filePath2}": ${msg}`);
+    throw new Error(
+      `Cannot read workflow file "${filePath2}": ${getErrorMessage(err)}`
+    );
   }
   let doc;
   try {
     doc = RawWorkflowSchema.parse(parseYaml(raw));
   } catch (err) {
-    const detail = err instanceof z.ZodError ? err.errors.map((e) => `  ${e.path.join(".")}: ${e.message}`).join("\n") : String(err);
+    const detail = err instanceof z.ZodError ? formatZodIssues(err.errors) : String(err);
     throw new Error(`Invalid workflow file "${filePath2}":
 ${detail}`);
   }
@@ -107,32 +164,35 @@ ${detail}`);
   };
 }
 function convertStep(step, vars) {
-  const name = step.name;
-  const continueOnError = step.continue_on_error ?? false;
+  const { name, continue_on_error: continueOnError = false } = step;
   if (step.repeat !== void 0 && step.forEach !== void 0) {
     throw new Error(`Step "${name}" cannot have both repeat and forEach`);
   }
-  if (step.repeat !== void 0) {
-    const items = Array.from({ length: step.repeat }, (_2, i) => String(i + 1));
-    const { repeat: _, ...innerStep } = step;
-    return {
-      type: "forEach",
-      name,
-      continueOnError,
-      forEach: items,
-      inner: convertInnerStep(innerStep, vars, name, continueOnError)
+  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 stepWithoutLoop = {
+      ...step,
+      repeat: void 0,
+      forEach: void 0,
+      steps: void 0
     };
-  }
-  if (step.forEach !== void 0) {
-    const { forEach: _, ...innerStep } = step;
+    const inner = step.steps ? step.steps.map((s) => convertStep(s, vars)) : [convertInnerStep(stepWithoutLoop, vars, name, continueOnError)];
     return {
       type: "forEach",
       name,
       continueOnError,
-      forEach: step.forEach,
-      inner: convertInnerStep(innerStep, vars, name, continueOnError)
+      forEach: forEachValue,
+      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) {
@@ -140,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,
@@ -148,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": {
@@ -161,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",
@@ -184,22 +248,23 @@ 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");
 }
 function substituteVars(text, vars, stepName, field) {
-  const result = Object.entries(vars).reduce(
-    (acc, [key, value]) => acc.replaceAll(`{{${key}}}`, value),
-    text
-  );
+  const result = fillTemplate(text, vars);
   const unknownTokens = [...result.matchAll(/\{\{(\w+)\}\}/g)].map((m) => m[1]).filter((key) => key !== "item");
   if (unknownTokens.length > 0) {
     throw new Error(
@@ -305,47 +370,6 @@ async function* runCommand(task) {
 // src/tasks/claude.ts
 import { execSync, spawn as spawn2 } from "node:child_process";
 import { zodToJsonSchema } from "zod-to-json-schema";
-
-// src/lib/utils.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-var __dir = dirname(fileURLToPath(import.meta.url));
-var PROMPTS_DIR = basename(__dir) === "lib" ? join(__dir, "..", "prompts") : join(__dir, "prompts");
-function stripPromptHeader(raw) {
-  return raw.replace(/^(#[^\n]*\n)+\n?/, "").trim();
-}
-function loadPrompt(name) {
-  return stripPromptHeader(readFileSync2(join(PROMPTS_DIR, `${name}.txt`), "utf8"));
-}
-function findOutermostBraces(text) {
-  const start = text.indexOf("{");
-  if (start === -1) return null;
-  let depth = 0;
-  for (let i = start; i < text.length; i++) {
-    if (text[i] === "{") depth++;
-    else if (text[i] === "}" && --depth === 0) return { start, end: i };
-  }
-  return null;
-}
-function extractJsonObject(text) {
-  const fenceMatch = text.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
-  if (fenceMatch) return fenceMatch[1].trim();
-  const bounds = findOutermostBraces(text);
-  return bounds ? text.slice(bounds.start, bounds.end + 1) : text.trim();
-}
-function slugify(text, maxLen = 20) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/, "");
-}
-function formatTimestamp(d) {
-  const p = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
-}
-function timestamp() {
-  return formatTimestamp(/* @__PURE__ */ new Date());
-}
-
-// src/tasks/claude.ts
 var DEFAULT_TOOLS = ["Read", "Edit", "Write", "Bash", "Glob", "Grep"];
 function resolveClaudePath() {
   try {
@@ -386,8 +410,7 @@ async function* runClaude(task) {
       env: { ...process.env }
     });
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to spawn claude (${claudeBin}): ${msg}`);
+    throw new Error(`Failed to spawn claude (${claudeBin}): ${getErrorMessage(err)}`);
   }
   const cleanup = () => {
     try {
@@ -491,20 +514,19 @@ var JudgeOutputSchema = z2.object({
   reasoning: z2.string().optional(),
   feedback: z2.string()
 });
+function shouldSkipStep(stepNumber, name, options2) {
+  if (options2.stepFilter !== void 0) {
+    const matchByIndex = /^\d+$/.test(options2.stepFilter) && parseInt(options2.stepFilter, 10) === stepNumber;
+    return !matchByIndex && name !== options2.stepFilter;
+  }
+  return options2.fromStep !== void 0 && stepNumber < options2.fromStep;
+}
 async function* runWorkflow(workflow2, options2 = {}) {
   const workflowStart = Date.now();
   yield { type: "workflow:start", workflow: workflow2 };
   for (const [i, task] of workflow2.tasks.entries()) {
     const stepNumber = i + 1;
-    if (options2.stepFilter !== void 0) {
-      const matchByIndex = /^\d+$/.test(options2.stepFilter) && parseInt(options2.stepFilter, 10) === stepNumber;
-      const matchByName = task.name === options2.stepFilter;
-      if (!matchByIndex && !matchByName) {
-        yield { type: "step:skip", index: i, name: task.name };
-        continue;
-      }
-    }
-    if (options2.fromStep !== void 0 && stepNumber < options2.fromStep) {
+    if (shouldSkipStep(stepNumber, task.name, options2)) {
       yield { type: "step:skip", index: i, name: task.name };
       continue;
     }
@@ -512,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;
@@ -573,21 +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) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`forEach shell command failed: ${msg}
-Command: ${forEach}`);
+    throw new Error(
+      `forEach shell command failed: ${getErrorMessage(err)}
+Command: ${forEach}`
+    );
   }
 }
 function substituteItem(task, item) {
@@ -596,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(_)}`);
     }
   }
 }
@@ -613,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) {
@@ -621,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})`
         );
@@ -632,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}`,
@@ -643,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({
@@ -651,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`
+      };
     }
   }
 }
@@ -660,24 +746,40 @@ async function* runClaudeWithJudge(task) {
   for (let attempt = 0; attempt < MAX_JUDGE_RETRIES; attempt++) {
     const prompt = attempt === 0 ? task.prompt : `${task.prompt}
 
-${JUDGE_RETRY_CONTEXT.replace("{{FEEDBACK}}", judgeContext)}`;
+${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) {
@@ -704,8 +806,9 @@ function readContextFile(filePath2) {
   try {
     return readFileSync3(filePath2, "utf8");
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`Context file "${filePath2}" could not be read: ${msg}`);
+    throw new Error(
+      `Context file "${filePath2}" could not be read: ${getErrorMessage(err)}`
+    );
   }
 }
 function expandContext(task) {
@@ -719,13 +822,23 @@ ${readContextFile(fp)}
 ${task.prompt}` };
 }
 function buildHealingPrompt(command, exitCode, output, attemptHistory) {
-  return SELF_HEALING_PROMPT.replaceAll("{{COMMAND}}", command).replaceAll("{{EXIT_CODE}}", String(exitCode)).replaceAll("{{OUTPUT}}", output).replaceAll("{{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 JUDGE_EVALUATION_PROMPT.replace("{{STEP_NAME}}", stepName).replace("{{STEP_INSTRUCTIONS}}", instructions).replace("{{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;
 }
@@ -842,7 +955,20 @@ function reducer(state, event) {
       };
     case "step:iteration":
       return updateTask(state, event.index, {
-        iteration: { current: event.iteration, total: event.total, item: event.item }
+        iteration: {
+          current: event.iteration,
+          total: event.total,
+          item: event.item
+        },
+        inner: void 0
+      });
+    case "step:inner":
+      return updateTask(state, event.index, {
+        inner: {
+          index: event.innerIndex,
+          total: event.innerTotal,
+          name: event.name
+        }
       });
     case "output:text": {
       const idx = event.index;
@@ -855,7 +981,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;
     }
@@ -878,7 +1007,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) {
@@ -943,7 +1074,8 @@ function TaskRow({ taskState, isActive, index, 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 label = `${index + 1}. ${task.name}${iterInfo}`;
+  const innerInfo = taskState.inner ? ` \u2014 ${taskState.inner.name} [${taskState.inner.index + 1}/${taskState.inner.total}]` : "";
+  const label = `${index + 1}. ${task.name}${iterInfo}${innerInfo}`;
   return /* @__PURE__ */ jsxs(Box, { children: [
     /* @__PURE__ */ jsxs(Text, { color, children: [
       icon,
@@ -1070,12 +1202,8 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
         }
       } catch (err) {
         if (!active) return;
-        dispatch({
-          type: "log",
-          level: "error",
-          text: err instanceof Error ? err.message : String(err)
-        });
-        setTimeout(() => exit(err instanceof Error ? err : new Error(String(err))), EXIT_DELAY_MS);
+        dispatch({ type: "log", level: "error", text: getErrorMessage(err) });
+        setTimeout(() => exit(err instanceof Error ? err : new Error(getErrorMessage(err))), EXIT_DELAY_MS);
       }
     })();
     return () => {
@@ -1157,25 +1285,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()
 });
@@ -1195,7 +1307,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) => {
@@ -1283,7 +1398,10 @@ async function runPass3Judge(description, workflow2) {
     const task = {
       type: "claude",
       name: "plan:judge",
-      prompt: PLAN_JUDGE_PROMPT.replace("{{DESCRIPTION}}", description).replace("{{WORKFLOW_JSON}}", JSON.stringify(workflow2, null, 2)),
+      prompt: fillTemplate(PLAN_JUDGE_PROMPT, {
+        DESCRIPTION: description,
+        WORKFLOW_JSON: JSON.stringify(workflow2, null, 2)
+      }),
       allowedTools: [],
       permissionMode: "default",
       model: "sonnet"
@@ -1343,34 +1461,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;
@@ -1381,14 +1492,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: PLAN_RESEARCH_PROMPT.replace("{{DESCRIPTION}}", description),
+        prompt: fillTemplate(PLAN_RESEARCH_PROMPT, {
+          DESCRIPTION: description
+        }),
         allowedTools: ["Read", "Glob", "Grep"],
         permissionMode: "bypassPermissions",
         model: "opus"
@@ -1402,20 +1523,28 @@ async function* streamPlan(args) {
         }
       }
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      yield { type: "plan:error", message: `Research pass failed: ${msg}` };
+      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 decomposeStage = skipResearch ? 1 : 2;
-  const validateStage = skipResearch ? 2 : 3;
-  const totalStages = skipResearch ? 2 : TOTAL_PLAN_STAGES;
-  yield { type: "plan:stage", stage: decomposeStage, total: totalStages, name: "Decompose to Steps" };
+  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"
+  };
   let retryPrefix = "";
   for (let attempt = 0; attempt < MAX_PLAN_RETRIES; attempt++) {
     if (attempt > 0) {
@@ -1425,9 +1554,17 @@ async function* streamPlan(args) {
         maxAttempts: MAX_PLAN_RETRIES,
         reason: retryPrefix.replace(/\n/g, " ")
       };
-      yield { type: "plan:stage", stage: decomposeStage, total: totalStages, name: "Decompose to Steps" };
+      yield {
+        type: "plan:stage",
+        stage: stages.decompose,
+        total: stages.total,
+        name: "Decompose to Steps"
+      };
     }
-    const basePrompt = PLAN_DECOMPOSE_PROMPT.replace("{{DESCRIPTION}}", description).replace("{{RESEARCH_DOC}}", researchDoc);
+    const basePrompt = fillTemplate(PLAN_DECOMPOSE_PROMPT, {
+      DESCRIPTION: description,
+      RESEARCH_DOC: researchDoc
+    });
     const decomposeTask = {
       type: "claude",
       name: "plan:decompose",
@@ -1454,12 +1591,15 @@ ${basePrompt}` : basePrompt,
         }
       }
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg = getErrorMessage(err);
       if (attempt === MAX_PLAN_RETRIES - 1) {
         yield { type: "plan:error", message: msg };
         return;
       }
-      retryPrefix = PLAN_RETRY_PARSE_ERROR.replace("{{ERROR}}", msg).replace("{{EXCERPT}}", decomposeTextLines.join("\n"));
+      retryPrefix = fillTemplate(PLAN_RETRY_PARSE_ERROR, {
+        ERROR: msg,
+        EXCERPT: decomposeTextLines.join("\n")
+      });
       continue;
     }
     if (structuredOutput === void 0) {
@@ -1468,31 +1608,47 @@ ${basePrompt}` : basePrompt,
         yield { type: "plan:error", message: issues };
         return;
       }
-      retryPrefix = PLAN_RETRY_SCHEMA_ERROR.replace("{{ISSUES}}", issues);
+      retryPrefix = fillTemplate(PLAN_RETRY_SCHEMA_ERROR, { ISSUES: issues });
       continue;
     }
     const zodResult = WorkflowSchema.safeParse(structuredOutput);
     if (!zodResult.success) {
-      const issues = zodResult.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+      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 = PLAN_RETRY_SCHEMA_ERROR.replace("{{ISSUES}}", issues);
+      retryPrefix = fillTemplate(PLAN_RETRY_SCHEMA_ERROR, { ISSUES: issues });
       continue;
     }
-    yield { type: "plan:stage", stage: validateStage, total: totalStages, 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 = PLAN_RETRY_JUDGE.replace("{{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 };
@@ -1503,11 +1659,15 @@ ${issues}` };
       forceQuotes: false
     }).trimEnd();
     writeFileSync2(taskFile, yamlContent + "\n", "utf8");
-    const preview = yamlContent.split("\n").slice(0, 30).join("\n") + (yamlContent.split("\n").length > 30 ? "\n..." : "");
+    const yamlLines = yamlContent.split("\n");
+    const preview = yamlLines.slice(0, 30).join("\n") + (yamlLines.length > 30 ? "\n..." : "");
     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
@@ -1687,17 +1847,6 @@ import {
   writeFileSync as writeFileSync3
 } from "node:fs";
 import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
-var TOOL_SUMMARY = {
-  Read: (i) => String(i["file_path"] ?? i["path"] ?? ""),
-  Edit: (i) => String(i["file_path"] ?? ""),
-  Write: (i) => String(i["file_path"] ?? ""),
-  Bash: (i) => String(i["command"] ?? ""),
-  Glob: (i) => String(i["pattern"] ?? ""),
-  Grep: (i) => String(i["pattern"] ?? "")
-};
-function toolSummary(tool, input) {
-  return (TOOL_SUMMARY[tool] ?? ((i) => JSON.stringify(i)))(input);
-}
 function findExecutantLocalDir(startDir) {
   let dir = resolve2(startDir);
   while (true) {
@@ -1711,337 +1860,336 @@ function findExecutantLocalDir(startDir) {
 function resolveLogDir(workflowFilePath) {
   const startDir = dirname3(resolve2(workflowFilePath));
   const executantLocal = findExecutantLocalDir(startDir);
-  if (executantLocal) return join3(executantLocal, "logs");
-  return join3(startDir, "logs");
-}
-var Logger = class {
-  enabled;
-  logDir;
-  highlightsDir;
-  timestamp;
-  taskName;
-  logFile = "";
-  // Per-step state
-  stepIndex = -1;
-  stepName = "";
-  stepStartMs = 0;
-  toolCount = 0;
-  complexSequenceFile = "";
-  selfHealingFile = "";
-  judgeAttempt = 0;
-  recentOutput = [];
-  constructor(logDir, taskName) {
-    this.enabled = process.env["EXECUTANT_LOG"] !== "0";
-    this.logDir = logDir;
-    this.highlightsDir = join3(logDir, "highlights");
-    this.timestamp = formatTimestamp(/* @__PURE__ */ new Date());
-    this.taskName = slugify(taskName, 40) || "task";
-  }
-  getHighlightsDir() {
-    return this.highlightsDir;
-  }
-  getTimestamp() {
-    return this.timestamp;
-  }
-  /** Feed each event from the runner into the logger. */
-  observe(event) {
-    if (!this.enabled) return;
-    try {
-      this.dispatch(event);
-    } catch (err) {
-      console.warn(`[logger] error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  // --------------------------------------------------------------------------
-  // Event dispatch
-  // --------------------------------------------------------------------------
-  dispatch(event) {
-    switch (event.type) {
-      case "workflow:start":
-        this.initDirs();
-        break;
-      case "step:start":
-        this.onStepStart(event.index, event.name);
-        break;
-      case "step:complete":
-        this.onStepComplete();
-        break;
-      case "step:error":
-        this.onStepError(event.error);
-        break;
-      case "output:text":
-        this.appendLog(event.text);
-        this.recentOutput.push(event.text);
-        break;
-      case "output:tool":
-        this.onTool(event.tool, event.input);
-        break;
-      case "log":
-        this.onLogMessage(event.level, event.text);
-        break;
-      case "workflow:complete":
-        this.onWorkflowComplete();
-        break;
-    }
-  }
-  // --------------------------------------------------------------------------
-  // Initialisation
-  // --------------------------------------------------------------------------
-  initDirs() {
-    mkdirSync3(this.logDir, { recursive: true });
-    mkdirSync3(this.highlightsDir, { recursive: true });
-    this.logFile = join3(this.logDir, `${this.timestamp}_${this.taskName}.log`);
-    writeFileSync3(
-      this.logFile,
-      `# Execution Log
-Task: ${this.taskName}
+  return executantLocal ? join3(executantLocal, "logs") : join3(startDir, "logs");
+}
+var INIT_STATE = {
+  logFile: "",
+  stepIndex: -1,
+  stepName: "",
+  stepStartMs: 0,
+  toolCount: 0,
+  complexSequenceFile: "",
+  selfHealingFile: "",
+  judgeAttempt: 0,
+  recentOutput: []
+};
+var TOOL_SUMMARY = {
+  Read: (i) => String(i["file_path"] ?? i["path"] ?? ""),
+  Edit: (i) => String(i["file_path"] ?? ""),
+  Write: (i) => String(i["file_path"] ?? ""),
+  Bash: (i) => String(i["command"] ?? ""),
+  Glob: (i) => String(i["pattern"] ?? ""),
+  Grep: (i) => String(i["pattern"] ?? "")
+};
+function toolSummary(tool, input) {
+  return (TOOL_SUMMARY[tool] ?? ((i) => JSON.stringify(i)))(input);
+}
+function appendLog(logFile, text) {
+  if (logFile) appendFileSync(logFile, text + "\n");
+}
+function highlightPath(ctx, stepIndex, suffix) {
+  return join3(ctx.highlightsDir, `${ctx.ts}_step${stepIndex + 1}_${suffix}.md`);
+}
+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
+Task: ${ctx.slug}
 Started: ${(/* @__PURE__ */ new Date()).toISOString()}
 ${"\u2501".repeat(51)}
 
 `
-    );
-  }
-  // --------------------------------------------------------------------------
-  // Step lifecycle
-  // --------------------------------------------------------------------------
-  onStepStart(index, name) {
-    Object.assign(this, {
-      stepIndex: index,
-      stepName: name,
-      stepStartMs: Date.now(),
-      toolCount: 0,
-      complexSequenceFile: "",
-      selfHealingFile: "",
-      judgeAttempt: 0,
-      recentOutput: []
-    });
-    this.appendLog(
-      `
+  );
+  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,
+    `
 ${"\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,
+      `
+---
+
+*Total tools used: ${s.toolCount}*
+
+*Captured by Executant Logger*
 `
     );
   }
-  onStepComplete() {
-    const durS = ((Date.now() - this.stepStartMs) / 1e3).toFixed(1);
-    this.appendLog(`
-Step completed in ${durS}s
-`);
-    this.finalizeComplexSequence();
-  }
-  onStepError(error) {
-    this.appendLog(`
+}
+function onStepComplete(s) {
+  appendLog(
+    s.logFile,
+    `
+Step completed in ${((Date.now() - s.stepStartMs) / 1e3).toFixed(1)}s
+`
+  );
+  finalizeComplexSequence(s);
+  return s;
+}
+function onStepError(s, error) {
+  appendLog(s.logFile, `
 Step failed: ${error.message}
 `);
-    this.finalizeComplexSequence();
-  }
-  // --------------------------------------------------------------------------
-  // Tool calls → complex sequence highlights
-  // --------------------------------------------------------------------------
-  onTool(tool, input) {
-    const desc = toolSummary(tool, input);
-    this.appendLog(`   [${tool}] ${desc}`);
-    this.toolCount++;
-    if (this.toolCount === 3) {
-      this.complexSequenceFile = join3(
-        this.highlightsDir,
-        `${this.timestamp}_step${this.stepIndex + 1}_complex_sequence.md`
-      );
+  finalizeComplexSequence(s);
+  return s;
+}
+function complexSequenceHeader(ctx, s) {
+  return [
+    "# Complex Tool Sequence",
+    "",
+    `**Task:** ${ctx.slug}`,
+    `**Step:** ${s.stepName}`,
+    `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "---",
+    "",
+    "## Claude's Tool Orchestration",
+    "",
+    "Claude used multiple tools to complete this step:",
+    ""
+  ].join("\n");
+}
+function createComplexSequenceFile(ctx, s) {
+  const path = highlightPath(ctx, s.stepIndex, "complex_sequence");
+  writeFileSync3(path, complexSequenceHeader(ctx, s));
+  return path;
+}
+function onTool(ctx, s, tool, input) {
+  const desc = toolSummary(tool, input);
+  appendLog(s.logFile, `   [${tool}] ${desc}`);
+  const toolCount = s.toolCount + 1;
+  const complexSequenceFile = toolCount === 3 ? createComplexSequenceFile(ctx, s) : s.complexSequenceFile;
+  if (toolCount >= 3 && complexSequenceFile) {
+    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")
+  );
+}
+var LOG_MATCHERS = [
+  {
+    pattern: /\[judge\]\s+(PASS|FAIL)/i,
+    apply: (ctx, s, text, match) => {
+      const verdict = match[1].toUpperCase();
+      const judgeAttempt = s.judgeAttempt + 1;
+      saveJudgeHighlight(ctx, { ...s, judgeAttempt }, verdict, text);
+      return { ...s, judgeAttempt };
+    }
+  },
+  {
+    pattern: /\[self-healing\].*failed.*exit\s+(\d+)/i,
+    apply: (ctx, s, text, match) => {
+      const selfHealingFile = highlightPath(ctx, s.stepIndex, "self_healing");
       writeFileSync3(
-        this.complexSequenceFile,
+        selfHealingFile,
         [
-          "# Complex Tool Sequence",
+          "# Self-Healing Activation",
           "",
-          `**Task:** ${this.taskName}`,
-          `**Step:** ${this.stepName}`,
+          `**Task:** ${ctx.slug}`,
+          `**Step:** ${s.stepName}`,
           `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
           "",
           "---",
           "",
-          "## Claude's Tool Orchestration",
+          "## \u274C Failure Detected",
+          "",
+          `**Exit Code:** ${match[1]}`,
+          "",
+          "**Recent Output:**",
+          "```",
+          s.recentOutput.join("\n"),
+          "```",
           "",
-          "Claude used multiple tools to complete this step:",
+          "---",
+          "",
+          "## \u{1F527} Claude's Healing Process",
           ""
         ].join("\n")
       );
+      return { ...s, selfHealingFile, recentOutput: [] };
     }
-    if (this.toolCount >= 3 && this.complexSequenceFile) {
-      appendFileSync(this.complexSequenceFile, `${this.toolCount}. **${tool}** - ${desc}
-`);
-    }
-  }
-  finalizeComplexSequence() {
-    if (this.toolCount >= 3 && this.complexSequenceFile) {
+  },
+  {
+    pattern: /\[self-healing\].*Re-running/i,
+    apply: (_ctx, s) => {
+      if (!s.selfHealingFile) return s;
       appendFileSync(
-        this.complexSequenceFile,
-        `
----
-
-*Total tools used: ${this.toolCount}*
-
-*Captured by Executant Logger*
-`
+        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: "" };
     }
   }
-  // --------------------------------------------------------------------------
-  // Log events → judge / self-healing highlights
-  // --------------------------------------------------------------------------
-  onLogMessage(level, text) {
-    this.appendLog(`[${level}] ${text}`);
-    if (/\[judge\]\s+PASS/i.test(text)) {
-      this.judgeAttempt++;
-      this.saveJudgeHighlight("PASS", text);
-      return;
-    }
-    if (/\[judge\]\s+FAIL/i.test(text)) {
-      this.judgeAttempt++;
-      this.saveJudgeHighlight("FAIL", text);
-      return;
-    }
-    const healingMatch = text.match(/\[self-healing\].*failed.*exit\s+(\d+)/i);
-    if (healingMatch) {
-      this.startSelfHealingHighlight(healingMatch[1]);
-      return;
-    }
-    if (/\[self-healing\].*Re-running/i.test(text)) {
-      this.completeSelfHealingHighlight();
-    }
-  }
-  // --------------------------------------------------------------------------
-  // Highlight writers
-  // --------------------------------------------------------------------------
-  saveJudgeHighlight(verdict, output) {
-    const file = join3(
-      this.highlightsDir,
-      `${this.timestamp}_step${this.stepIndex + 1}_judge_${verdict}.md`
-    );
-    writeFileSync3(
-      file,
-      [
-        `# Judge Verdict: ${verdict}`,
-        "",
-        `**Task:** ${this.taskName}`,
-        `**Step:** ${this.stepName}`,
-        `**Attempt:** ${this.judgeAttempt}`,
-        `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
-        "",
-        "---",
-        "",
-        output,
-        "",
-        "---",
-        "",
-        "*Auto-captured*",
-        ""
-      ].join("\n")
-    );
-  }
-  startSelfHealingHighlight(exitCode) {
-    this.selfHealingFile = join3(
-      this.highlightsDir,
-      `${this.timestamp}_step${this.stepIndex + 1}_self_healing.md`
-    );
-    const errorOutput = this.recentOutput.join("\n");
-    this.recentOutput = [];
+];
+function onLogMessage(ctx, s, level, text) {
+  appendLog(s.logFile, `[${level}] ${text}`);
+  return LOG_MATCHERS.reduce(
+    ({ matched, state }, { pattern, apply }) => {
+      if (matched) return { matched, state };
+      const m = pattern.exec(text);
+      return m ? { matched: true, state: apply(ctx, state, text, m) } : { matched, state };
+    },
+    { matched: false, state: s }
+  ).state;
+}
+function onWorkflowComplete(ctx, s) {
+  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(
-      this.selfHealingFile,
+      indexFile,
       [
-        "# Self-Healing Activation",
-        "",
-        `**Task:** ${this.taskName}`,
-        `**Step:** ${this.stepName}`,
-        `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
-        "",
-        "---",
-        "",
-        "## \u274C Failure Detected",
-        "",
-        `**Exit Code:** ${exitCode}`,
-        "",
-        "**Recent Output:**",
-        "```",
-        errorOutput,
-        "```",
+        "# Execution Highlights",
         "",
-        "---",
+        "This directory contains automatically extracted highlight moments from task executions.",
         "",
-        "## \u{1F527} Claude's Healing Process",
+        "## Latest Highlights",
         ""
       ].join("\n")
     );
   }
-  completeSelfHealingHighlight() {
-    if (!this.selfHealingFile) return;
+  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(
-      this.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")
-    );
-    this.selfHealingFile = "";
-  }
-  // --------------------------------------------------------------------------
-  // Workflow complete → index
-  // --------------------------------------------------------------------------
-  onWorkflowComplete() {
-    this.appendLog(
+      indexFile,
       `
-${"\u2501".repeat(51)}
-Task Complete: ${this.taskName}
-Finished: ${(/* @__PURE__ */ new Date()).toISOString()}
-${"\u2501".repeat(51)}
+### ${ctx.slug} (${(/* @__PURE__ */ new Date()).toISOString()})
+${entries}
 `
     );
-    this.writeHighlightsIndex();
   }
-  writeHighlightsIndex() {
-    const indexFile = join3(this.highlightsDir, "README.md");
-    if (!existsSync2(indexFile)) {
-      writeFileSync3(
-        indexFile,
-        [
-          "# Execution Highlights",
-          "",
-          "This directory contains automatically extracted highlight moments from task executions.",
-          "",
-          "## Latest Highlights",
-          ""
-        ].join("\n")
+  return s;
+}
+function onOutputText(s, text) {
+  appendLog(s.logFile, text);
+  return { ...s, recentOutput: [...s.recentOutput, text] };
+}
+function reduce(ctx, s, event) {
+  switch (event.type) {
+    case "workflow:start":
+      return onWorkflowStart(ctx, s);
+    case "step:start":
+      return onStepStart(ctx, s, event.index, event.name);
+    case "step:complete":
+      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}`
       );
-    }
-    const files = readdirSync(this.highlightsDir);
-    const taskHighlights = files.filter((f) => f.startsWith(this.timestamp) && f.endsWith(".md")).sort();
-    if (taskHighlights.length > 0) {
-      const entries = taskHighlights.map((f) => `- [${f.replace(/\.md$/, "")}](./${f})`).join("\n");
-      appendFileSync(indexFile, `
-### ${this.taskName} (${(/* @__PURE__ */ new Date()).toISOString()})
-${entries}
-`);
-    }
-  }
-  // --------------------------------------------------------------------------
-  // Log file writes
-  // --------------------------------------------------------------------------
-  appendLog(text) {
-    if (!this.logFile) return;
-    appendFileSync(this.logFile, text + "\n");
+      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":
+      return onTool(ctx, s, event.tool, event.input);
+    case "log":
+      return onLogMessage(ctx, s, event.level, event.text);
+    case "workflow:complete":
+      return onWorkflowComplete(ctx, s);
+    default:
+      return s;
   }
-};
+}
+function createLogger(logDir, taskName) {
+  const ctx = {
+    logDir,
+    highlightsDir: join3(logDir, "highlights"),
+    ts: formatTimestamp(/* @__PURE__ */ new Date()),
+    slug: slugify(taskName, 40) || "task"
+  };
+  const enabled = process.env["EXECUTANT_LOG"] !== "0";
+  let state = INIT_STATE;
+  return {
+    getHighlightsDir: () => ctx.highlightsDir,
+    getTimestamp: () => ctx.ts,
+    observe(event) {
+      if (!enabled) return;
+      try {
+        state = reduce(ctx, state, event);
+      } catch (err) {
+        console.warn(`[logger] error: ${getErrorMessage(err)}`);
+      }
+    }
+  };
+}
 async function* withLogger(gen, logger2) {
   for await (const event of gen) {
     logger2.observe(event);
@@ -2052,7 +2200,6 @@ async function* withLogger(gen, logger2) {
 // src/retrospective.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { basename as basename2, dirname as dirname4, join as join4, resolve as resolve3 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { spawnSync } from "node:child_process";
 import { load as parseYaml2 } from "js-yaml";
 import { z as z4 } from "zod";
@@ -2060,15 +2207,13 @@ var RetrospectiveOutputSchema = z4.object({
   improved_yaml: z4.string(),
   changelog: z4.string()
 });
-var PROMPTS_DIR2 = join4(dirname4(fileURLToPath2(import.meta.url)), "prompts");
-var RETROSPECTIVE_PROMPT = readFileSync5(join4(PROMPTS_DIR2, "retrospective-analysis.txt"), "utf8");
+var RETROSPECTIVE_PROMPT = loadPrompt("retrospective-analysis");
 async function runRetrospective(workflowFilePath, workflow2, highlightsDir, runTimestamp) {
   try {
     await doRetrospective(workflowFilePath, workflow2, highlightsDir, runTimestamp);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
     console.warn(`
-Self-improvement: retrospective failed: ${msg}`);
+Self-improvement: retrospective failed: ${getErrorMessage(err)}`);
   }
 }
 async function doRetrospective(workflowFilePath, workflow2, highlightsDir, runTimestamp) {
@@ -2112,7 +2257,13 @@ ${content}`;
   }).join("\n\n---\n\n");
   const originalYaml = readFileSync5(workflowFilePath, "utf8");
   const taskName = basename2(workflowFilePath, ".yaml");
-  const prompt = RETROSPECTIVE_PROMPT.replaceAll("{{TASK_NAME}}", taskName).replaceAll("{{ORIGINAL_GOAL}}", workflow2.goal).replaceAll("{{ORIGINAL_YAML}}", originalYaml).replaceAll("{{HIGHLIGHTS}}", highlightContents).replaceAll("{{METRICS}}", metrics);
+  const prompt = fillTemplate(RETROSPECTIVE_PROMPT, {
+    TASK_NAME: taskName,
+    ORIGINAL_GOAL: workflow2.goal,
+    ORIGINAL_YAML: originalYaml,
+    HIGHLIGHTS: highlightContents,
+    METRICS: metrics
+  });
   const result = spawnSync(
     "claude",
     [
@@ -2155,8 +2306,7 @@ Response: ${response.trim()}`);
   try {
     parseYaml2(improvedYaml);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.warn(`Self-improvement: generated YAML is invalid (${msg}), skipping save.`);
+    console.warn(`Self-improvement: generated YAML is invalid (${getErrorMessage(err)}), skipping save.`);
     return;
   }
   const startDir = dirname4(resolve3(workflowFilePath));
@@ -2187,16 +2337,21 @@ function extractJson(text) {
 
 // src/index.ts
 var CURRENT_VERSION = JSON.parse(
-  readFileSync6(join5(dirname5(fileURLToPath3(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 {
@@ -2212,7 +2367,7 @@ if (rawArgs[0] === "update") {
     await doUpdate2();
     console.log("Done.");
   } catch (err) {
-    console.error("Update failed:", err instanceof Error ? err.message : String(err));
+    console.error("Update failed:", getErrorMessage(err));
     process.exit(1);
   }
   process.exit(0);
@@ -2245,7 +2400,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
@@ -2257,7 +2420,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):
@@ -2318,12 +2481,12 @@ var workflow;
 try {
   workflow = loadWorkflow(filePath);
 } catch (err) {
-  console.error(err instanceof Error ? err.message : String(err));
+  console.error(getErrorMessage(err));
   process.exit(1);
 }
 var options = { stepFilter, fromStep };
 var rawEvents = runWorkflow(workflow, options);
-var logger = new Logger(resolveLogDir(filePath), workflow.goal);
+var logger = createLogger(resolveLogDir(filePath), workflow.goal);
 var events = withLogger(rawEvents, logger);
 var updateCheck = checkForUpdate(CURRENT_VERSION);
 function errorReplacer(_key, value) {
@@ -2335,9 +2498,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):", err instanceof Error ? err.message : err);
+    console.warn(
+      "[executant] retrospective failed (non-fatal):",
+      getErrorMessage(err)
+    );
   }
 }
 if (ciMode) {
@@ -2353,7 +2524,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(() => {
     });