executant 1.6.0 → 1.7.0

package/dist/index.js

@@ -54,11 +54,64 @@ 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(),
@@ -85,16 +138,15 @@ 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,29 +159,18 @@ ${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.forEach !== void 0) {
-    const { forEach: _, ...innerStep } = step;
+  if (step.repeat !== void 0 || step.forEach !== void 0) {
+    const forEachValue = step.repeat !== void 0 ? Array.from({ length: step.repeat }, (_, i) => String(i + 1)) : step.forEach;
+    const { repeat: _r, forEach: _f, ...innerStep } = step;
     return {
       type: "forEach",
       name,
       continueOnError,
-      forEach: step.forEach,
+      forEach: forEachValue,
       inner: convertInnerStep(innerStep, vars, name, continueOnError)
     };
   }
@@ -196,10 +237,7 @@ 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 +343,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 +383,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 +487,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;
     }
@@ -585,8 +580,7 @@ async function resolveItems(forEach) {
     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}
+    throw new Error(`forEach shell command failed: ${getErrorMessage(err)}
 Command: ${forEach}`);
   }
 }
@@ -660,7 +654,7 @@ 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` };
@@ -704,8 +698,7 @@ 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,10 +712,10 @@ ${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"] ?? "")})`;
@@ -1070,12 +1063,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 () => {
@@ -1283,7 +1272,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"
@@ -1388,7 +1380,7 @@ async function* streamPlan(args) {
       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,8 +1394,7 @@ 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");
@@ -1412,10 +1403,8 @@ async function* streamPlan(args) {
       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 +1414,9 @@ 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 +1443,12 @@ ${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,27 +1457,27 @@ ${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}` };
         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" };
     }
     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) {
@@ -1503,7 +1492,8 @@ ${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;
   }
@@ -1687,17 +1677,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,273 +1690,179 @@ 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)}
-`
-    );
-  }
-  onStepComplete() {
-    const durS = ((Date.now() - this.stepStartMs) / 1e3).toFixed(1);
-    this.appendLog(`
-Step completed in ${durS}s
-`);
-    this.finalizeComplexSequence();
-  }
-  onStepError(error) {
-    this.appendLog(`
-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`
-      );
-      writeFileSync3(
-        this.complexSequenceFile,
-        [
-          "# Complex Tool Sequence",
-          "",
-          `**Task:** ${this.taskName}`,
-          `**Step:** ${this.stepName}`,
-          `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
-          "",
-          "---",
-          "",
-          "## Claude's Tool Orchestration",
-          "",
-          "Claude used multiple tools to complete this step:",
-          ""
-        ].join("\n")
-      );
-    }
-    if (this.toolCount >= 3 && this.complexSequenceFile) {
-      appendFileSync(this.complexSequenceFile, `${this.toolCount}. **${tool}** - ${desc}
-`);
-    }
-  }
-  finalizeComplexSequence() {
-    if (this.toolCount >= 3 && this.complexSequenceFile) {
-      appendFileSync(
-        this.complexSequenceFile,
-        `
+  return next;
+}
+function finalizeComplexSequence(s) {
+  if (s.toolCount >= 3 && s.complexSequenceFile) {
+    appendFileSync(s.complexSequenceFile, `
 ---
 
-*Total tools used: ${this.toolCount}*
+*Total tools used: ${s.toolCount}*
 
 *Captured by Executant Logger*
-`
-      );
-    }
-  }
-  // --------------------------------------------------------------------------
-  // 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")
-    );
+}
+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}
+`);
+  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}
+`);
   }
-  startSelfHealingHighlight(exitCode) {
-    this.selfHealingFile = join3(
-      this.highlightsDir,
-      `${this.timestamp}_step${this.stepIndex + 1}_self_healing.md`
-    );
-    const errorOutput = this.recentOutput.join("\n");
-    this.recentOutput = [];
-    writeFileSync3(
-      this.selfHealingFile,
-      [
+  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(selfHealingFile, [
         "# Self-Healing Activation",
         "",
-        `**Task:** ${this.taskName}`,
-        `**Step:** ${this.stepName}`,
+        `**Task:** ${ctx.slug}`,
+        `**Step:** ${s.stepName}`,
         `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
         "",
         "---",
         "",
         "## \u274C Failure Detected",
         "",
-        `**Exit Code:** ${exitCode}`,
+        `**Exit Code:** ${match[1]}`,
         "",
         "**Recent Output:**",
         "```",
-        errorOutput,
+        s.recentOutput.join("\n"),
         "```",
         "",
         "---",
         "",
         "## \u{1F527} Claude's Healing Process",
         ""
-      ].join("\n")
-    );
-  }
-  completeSelfHealingHighlight() {
-    if (!this.selfHealingFile) return;
-    appendFileSync(
-      this.selfHealingFile,
-      [
+      ].join("\n"));
+      return { ...s, selfHealingFile, recentOutput: [] };
+    }
+  },
+  {
+    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)*",
         "",
@@ -1991,57 +1876,98 @@ Step failed: ${error.message}
         "",
         "*Auto-captured*",
         ""
-      ].join("\n")
-    );
-    this.selfHealingFile = "";
-  }
-  // --------------------------------------------------------------------------
-  // Workflow complete → index
-  // --------------------------------------------------------------------------
-  onWorkflowComplete() {
-    this.appendLog(
-      `
+      ].join("\n"));
+      return { ...s, selfHealingFile: "" };
+    }
+  }
+];
+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: ${this.taskName}
+Task Complete: ${ctx.slug}
 Finished: ${(/* @__PURE__ */ new Date()).toISOString()}
 ${"\u2501".repeat(51)}
-`
-    );
-    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")
-      );
-    }
-    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()})
+`);
+  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"));
+  }
+  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, `
+### ${ctx.slug} (${(/* @__PURE__ */ new Date()).toISOString()})
 ${entries}
 `);
-    }
   }
-  // --------------------------------------------------------------------------
-  // Log file writes
-  // --------------------------------------------------------------------------
-  appendLog(text) {
-    if (!this.logFile) return;
-    appendFileSync(this.logFile, text + "\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 "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 +1978,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 +1985,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 +2035,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 +2084,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,7 +2115,7 @@ 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") {
@@ -2212,7 +2140,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);
@@ -2318,12 +2246,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) {
@@ -2337,7 +2265,7 @@ async function maybeRunRetrospective(filePath2, workflow2, logger2) {
   try {
     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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "executant",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Harness for YAML-defined workflows that enables stepping through Claude sessions and bash commands",
   "repository": {
     "type": "git",
@@ -44,6 +44,7 @@
     "husky": "^9.1.7",
     "knip": "^5.88.1",
     "lint-staged": "^16.4.0",
+    "prettier": "^3.8.3",
     "semantic-release": "^24.2.9",
     "tsx": "^4.15.7",
     "typescript": "^5.4.5",
@@ -55,7 +56,10 @@
     ]
   },
   "lint-staged": {
-    "*.{ts,tsx}": "eslint --fix"
+    "*.{ts,tsx}": [
+      "prettier --write",
+      "eslint --fix"
+    ]
   },
   "release": {
     "plugins": [