executant 1.0.0

package/dist/index.js

@@ -0,0 +1,2252 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/update.ts
+var update_exports = {};
+__export(update_exports, {
+  checkForUpdate: () => checkForUpdate,
+  compareSemver: () => compareSemver,
+  doUpdate: () => doUpdate,
+  parseVersionsFromGitOutput: () => parseVersionsFromGitOutput
+});
+import { exec as exec2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+async function checkForUpdate(currentVersion) {
+  try {
+    const { stdout } = await execPromise2(
+      "git ls-remote --tags https://github.com/coston/executant.git",
+      { timeout: 5e3 }
+    );
+    const versions = parseVersionsFromGitOutput(stdout);
+    const latest = versions.sort(compareSemver).at(-1);
+    return latest && isNewer(latest, currentVersion) ? latest : null;
+  } catch {
+    return null;
+  }
+}
+async function doUpdate() {
+  await execPromise2("npm install -g github:coston/executant");
+}
+function parseVersionsFromGitOutput(stdout) {
+  const versions = [];
+  for (const line of stdout.split("\n")) {
+    const m = line.match(/refs\/tags\/v?(\d+\.\d+\.\d+)$/);
+    if (m) versions.push(m[1]);
+  }
+  return versions;
+}
+function compareSemver(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
+  }
+  return 0;
+}
+function isNewer(latest, current) {
+  return compareSemver(latest, current) > 0;
+}
+var execPromise2;
+var init_update = __esm({
+  "src/update.ts"() {
+    "use strict";
+    execPromise2 = promisify2(exec2);
+  }
+});
+
+// src/index.ts
+import React3 from "react";
+import { render } from "ink";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { dirname as dirname5, join as join5 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+
+// src/load-workflow.ts
+import { readFileSync } from "node:fs";
+import { load as parseYaml } from "js-yaml";
+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(),
+  context: z.array(z.string()).optional()
+});
+var RawWorkflowSchema = z.object({
+  goal: z.string(),
+  steps: z.array(RawStepSchema),
+  vars: z.record(z.string(), z.string()).optional(),
+  self_improve: z.boolean().optional()
+});
+function loadWorkflow(filePath2) {
+  let raw;
+  try {
+    raw = readFileSync(filePath2, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Cannot read workflow file "${filePath2}": ${msg}`);
+  }
+  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);
+    throw new Error(`Invalid workflow file "${filePath2}":
+${detail}`);
+  }
+  const vars = doc.vars ?? {};
+  return {
+    goal: doc.goal,
+    vars,
+    selfImprove: doc.self_improve,
+    tasks: doc.steps.map((step) => convertStep(step, vars))
+  };
+}
+function convertStep(step, vars) {
+  const name = step.name;
+  const continueOnError = step.continue_on_error ?? false;
+  if (step.forEach !== void 0) {
+    const { forEach: _, ...innerStep } = step;
+    return {
+      type: "forEach",
+      name,
+      continueOnError,
+      forEach: step.forEach,
+      inner: convertInnerStep(innerStep, vars, name, continueOnError)
+    };
+  }
+  return convertInnerStep(step, vars, name, continueOnError);
+}
+function convertInnerStep(step, vars, name, continueOnError) {
+  const effectiveType = step.type ?? inferType(step);
+  switch (effectiveType) {
+    case "script":
+    case "command": {
+      if (!step.command) throw new Error(`Step "${name}" has type script but no command`);
+      return {
+        type: "command",
+        name,
+        command: substituteVars(step.command, vars, name, "command"),
+        continueOnError,
+        selfHealing: step.self_healing === true,
+        maxHealingAttempts: step.max_healing_attempts,
+        ...step.output && { output: resolveOutputFile(step.output, vars, name) }
+      };
+    }
+    case "log": {
+      const message = step.message ?? step.prompt ?? name;
+      return {
+        type: "log",
+        name,
+        message: substituteVars(message, vars, name, "message"),
+        continueOnError
+      };
+    }
+    case "prompt": {
+      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",
+        name,
+        prompt: substituteVars(step.prompt, vars, name, "prompt"),
+        continueOnError,
+        llmAsJudge: step.llm_as_judge,
+        allowedTools: step.allowed_tools,
+        ...contextFiles.length > 0 && { contextFiles }
+      };
+    }
+    default:
+      throw new Error(`Step "${name}" has unknown type: "${effectiveType}"`);
+  }
+}
+function inferType(step) {
+  if (step.command) return "script";
+  if (step.message && !step.prompt) return "log";
+  return "prompt";
+}
+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`);
+  }
+  return vars[varName];
+}
+function resolveContextFiles(contextVarNames, vars, stepName) {
+  if (!contextVarNames || contextVarNames.length === 0) return [];
+  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 unknownTokens = [...result.matchAll(/\{\{(\w+)\}\}/g)].map((m) => m[1]).filter((key) => key !== "item");
+  if (unknownTokens.length > 0) {
+    throw new Error(
+      `Step "${stepName}" ${field} contains unknown placeholder "{{${unknownTokens[0]}}}" \u2014 add it to the vars section`
+    );
+  }
+  return result;
+}
+
+// src/runner.ts
+import { exec } from "node:child_process";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { z as z2 } from "zod";
+
+// src/tasks/command.ts
+import { spawn } from "node:child_process";
+
+// src/tasks/stream.ts
+var AsyncQueue = class {
+  buf = [];
+  waiter = null;
+  push(item) {
+    if (this.waiter) {
+      const w = this.waiter;
+      this.waiter = null;
+      w(item);
+    } else {
+      this.buf.push(item);
+    }
+  }
+  next() {
+    if (this.buf.length > 0) return Promise.resolve(this.buf.shift());
+    return new Promise((resolve4) => {
+      this.waiter = resolve4;
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      const item = await this.next();
+      if ("done" in item) return;
+      if ("error" in item) throw item.error;
+      yield item.value;
+    }
+  }
+};
+async function* mergeStreamsToLines(...streams) {
+  const q = new AsyncQueue();
+  let pending = streams.length;
+  for (const stream of streams) {
+    let buf = "";
+    stream.on("data", (chunk) => {
+      buf += chunk.toString();
+      const parts = buf.split("\n");
+      buf = parts.pop() ?? "";
+      for (const part of parts) q.push({ value: part });
+    });
+    stream.on("end", () => {
+      if (buf) {
+        q.push({ value: buf });
+        buf = "";
+      }
+      pending--;
+      if (pending === 0) q.push({ done: true });
+    });
+    stream.on("error", (err) => q.push({ error: err }));
+  }
+  yield* q;
+}
+function waitForExit(proc) {
+  return new Promise((resolve4, reject) => {
+    proc.on("close", (code) => resolve4(code ?? 0));
+    proc.on("error", reject);
+  });
+}
+
+// src/tasks/command.ts
+var CommandError = class extends Error {
+  constructor(exitCode, command, message) {
+    super(message ?? `Command "${command}" exited with code ${exitCode}`);
+    this.exitCode = exitCode;
+    this.command = command;
+    this.name = "CommandError";
+  }
+  exitCode;
+  command;
+};
+async function* runCommand(task) {
+  yield { type: "log", level: "info", text: `$ ${task.command}` };
+  const proc = spawn("bash", ["-c", task.command], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  for await (const line of mergeStreamsToLines(proc.stdout, proc.stderr)) {
+    yield { type: "output:text", index: -1, text: line };
+  }
+  const code = await waitForExit(proc);
+  if (code !== 0) {
+    throw new CommandError(code, task.command, `Command "${task.name}" exited with code ${code}`);
+  }
+}
+
+// src/tasks/claude.ts
+import { execSync, spawn as spawn2 } from "node:child_process";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// src/lib/utils.ts
+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 {
+    return execSync("which claude", { env: process.env }).toString().trim();
+  } catch {
+    throw new Error(
+      "claude CLI not found. Ensure it is installed and in PATH.\n  brew install claude  OR  npm install -g @anthropic-ai/claude-code"
+    );
+  }
+}
+async function* runClaude(task) {
+  const allowedTools = task.allowedTools ?? DEFAULT_TOOLS;
+  yield {
+    type: "log",
+    level: "info",
+    text: `claude -p "${task.prompt.slice(0, 60).replace(/\n/g, " ")}\u2026"`
+  };
+  const permissionMode = task.permissionMode ?? "bypassPermissions";
+  const args = [
+    "--print",
+    task.prompt,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--allowedTools",
+    allowedTools.join(","),
+    "--permission-mode",
+    permissionMode,
+    ...task.model ? ["--model", task.model] : [],
+    ...task.appendSystemPrompt ? ["--append-system-prompt", task.appendSystemPrompt] : [],
+    ...task.jsonSchema ? ["--json-schema", JSON.stringify(task.jsonSchema)] : []
+  ];
+  const claudeBin = resolveClaudePath();
+  let proc;
+  try {
+    proc = spawn2(claudeBin, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to spawn claude (${claudeBin}): ${msg}`);
+  }
+  const cleanup = () => {
+    try {
+      proc.kill();
+    } catch {
+    }
+  };
+  process.once("SIGTERM", cleanup);
+  process.once("SIGHUP", cleanup);
+  const plainLines = [];
+  try {
+    for await (const line of mergeStreamsToLines(proc.stdout, proc.stderr)) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        yield* parseClaudeMessage(msg);
+      } catch {
+        const clean = stripAnsi(line);
+        if (clean.trim()) {
+          plainLines.push(clean);
+          yield { type: "output:text", index: -1, text: clean };
+        }
+      }
+    }
+    const code = await waitForExit(proc);
+    if (code !== 0) throw buildExitError(code, plainLines);
+  } finally {
+    process.off("SIGTERM", cleanup);
+    process.off("SIGHUP", cleanup);
+  }
+}
+function* parseClaudeMessage(msg) {
+  if (!isObject(msg)) return;
+  if (msg["type"] === "assistant") {
+    const content = getArray(msg, "message", "content");
+    for (const block of content) {
+      if (!isObject(block)) continue;
+      if (block["type"] === "text") {
+        const text = getString(block, "text");
+        if (text) yield { type: "output:text", index: -1, text };
+      } else if (block["type"] === "tool_use") {
+        const tool = getString(block, "name") ?? "Unknown";
+        const input = isObject(block["input"]) ? block["input"] : {};
+        yield { type: "output:tool", index: -1, tool, input };
+      }
+    }
+  } else if (msg["type"] === "result") {
+    const cost = msg["total_cost_usd"];
+    if (typeof cost === "number") {
+      yield { type: "output:cost", usd: cost };
+    }
+    if (msg["structured_output"] != null) {
+      yield { type: "output:structured", data: msg["structured_output"] };
+    }
+  }
+}
+function buildExitError(code, plainLines) {
+  const detail = plainLines.length > 0 ? `
+${plainLines.join("\n")}` : "";
+  return new Error(`claude exited with code ${code}${detail}`);
+}
+var ANSI_RE = /\x1B\[[0-9;]*[A-Za-z]|\x1B\][^\x07]*\x07|\r/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function getArray(obj, ...keys) {
+  const result = keys.reduce((cur, k) => isObject(cur) ? cur[k] : null, obj);
+  return Array.isArray(result) ? result : [];
+}
+function getString(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" ? v : void 0;
+}
+async function runClaudeStructured(task, schema) {
+  const jsonSchema = zodToJsonSchema(schema);
+  let structuredOutput;
+  const lines = [];
+  for await (const event of runClaude({ ...task, jsonSchema })) {
+    if (event.type === "output:structured") structuredOutput = event.data;
+    else if (event.type === "output:text") lines.push(event.text);
+  }
+  if (structuredOutput === void 0 && process.env["NODE_ENV"] !== "test") {
+    console.warn("[executant] runClaudeStructured: no output:structured event \u2014 falling back to text parsing");
+  }
+  const data = structuredOutput ?? JSON.parse(extractJsonObject(lines.join("").trim()));
+  return schema.parse(data);
+}
+
+// src/runner.ts
+var PROMPTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "prompts");
+var JUDGE_RETRY_CONTEXT = loadPrompt("judge-retry-context");
+var SELF_HEALING_PROMPT = loadPrompt("self-healing-fix");
+var JUDGE_EVALUATION_PROMPT = loadPrompt("judge-evaluation");
+var execPromise = promisify(exec);
+var MAX_JUDGE_RETRIES = 5;
+var MAX_HEALING_ATTEMPTS = 5;
+var JudgeOutputSchema = z2.object({
+  pass: z2.boolean(),
+  reasoning: z2.string().optional(),
+  feedback: z2.string()
+});
+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) {
+      yield { type: "step:skip", index: i, name: task.name };
+      continue;
+    }
+    const stepStart = Date.now();
+    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") {
+          yield { ...event, index: i };
+        } else {
+          yield event;
+        }
+      }
+      yield {
+        type: "step:complete",
+        index: i,
+        name: task.name,
+        durationMs: Date.now() - stepStart
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      yield { type: "step:error", index: i, name: task.name, error };
+      if (!task.continueOnError) throw error;
+    }
+  }
+  yield {
+    type: "workflow:complete",
+    workflow: workflow2,
+    durationMs: Date.now() - workflowStart
+  };
+}
+async function* runStep(task) {
+  switch (task.type) {
+    case "log":
+      yield* runLog(task);
+      break;
+    case "command": {
+      const gen = task.selfHealing ? runCommandWithHealing(task) : runCommand(task);
+      if (task.output) {
+        const lines = [];
+        yield* collectLines(gen, lines);
+        mkdirSync(dirname(task.output), { recursive: true });
+        writeFileSync(task.output, lines.join("\n"), "utf8");
+      } else {
+        yield* gen;
+      }
+      break;
+    }
+    case "claude": {
+      const expanded = expandContext(task);
+      yield* expanded.llmAsJudge ? runClaudeWithJudge(expanded) : runClaude(expanded);
+      break;
+    }
+    case "forEach":
+      yield* runForEach(task);
+      break;
+    default: {
+      const _ = task;
+      throw new Error(`Unknown task type: ${JSON.stringify(_)}`);
+    }
+  }
+}
+async function* runLog(task) {
+  yield { type: "output:text", index: -1, text: task.message };
+}
+async function* runForEach(task) {
+  const items = await resolveItems(task.forEach);
+  const total = items.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);
+  }
+}
+async function resolveItems(forEach) {
+  if (Array.isArray(forEach)) return forEach.filter(Boolean);
+  try {
+    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}`);
+  }
+}
+function substituteItem(task, item) {
+  const sub = (s) => s.replace(/\{\{item\}\}/g, item);
+  switch (task.type) {
+    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) };
+    case "log":
+      return { ...task, name: sub(task.name), message: sub(task.message) };
+    default: {
+      const _ = task;
+      throw new Error(`Unknown inner task type: ${JSON.stringify(_)}`);
+    }
+  }
+}
+async function* runCommandWithHealing(task) {
+  const maxAttempts = task.maxHealingAttempts ?? MAX_HEALING_ATTEMPTS;
+  const attemptHistory = [];
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const lines = [];
+    try {
+      yield* collectLines(runCommand(task), lines);
+      if (attempt > 0) {
+        yield { type: "log", level: "info", text: `[self-healing] Command passed after ${attempt + 1} attempts` };
+      }
+      return;
+    } catch (err) {
+      const exitCode = err instanceof CommandError ? err.exitCode : 1;
+      const output = lines.join("\n");
+      const remaining = maxAttempts - attempt - 1;
+      if (remaining === 0) {
+        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})`
+        );
+      }
+      yield {
+        type: "log",
+        level: "warn",
+        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 healTask = {
+        type: "claude",
+        name: `${task.name}:heal-${attempt + 1}`,
+        prompt: healPrompt,
+        allowedTools: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"]
+      };
+      const toolCalls = [];
+      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));
+        yield event;
+      }
+      attemptHistory.push({
+        fixSummary: buildFixSummary(toolCalls, claudeLines),
+        exitCode,
+        cmdOutput: output
+      });
+      yield { type: "log", level: "info", text: `[self-healing] Re-running command (${remaining} attempt(s) left)\u2026` };
+    }
+  }
+}
+async function* runClaudeWithJudge(task) {
+  let judgeContext = "";
+  for (let attempt = 0; attempt < MAX_JUDGE_RETRIES; attempt++) {
+    const prompt = attempt === 0 ? task.prompt : `${task.prompt}
+
+${JUDGE_RETRY_CONTEXT.replace("{{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"));
+    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}` };
+    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` };
+  }
+}
+async function evaluateWithJudge(stepName, stepInstructions, output) {
+  const result = await runClaudeStructured(
+    {
+      type: "claude",
+      name: `judge:${stepName}`,
+      prompt: buildJudgePrompt(stepName, stepInstructions, output),
+      allowedTools: [],
+      permissionMode: "default"
+      // judge only reads text — no tool access needed
+    },
+    JudgeOutputSchema
+  );
+  return { pass: result.pass, feedback: result.feedback };
+}
+async function* collectLines(gen, lines) {
+  for await (const event of gen) {
+    if (event.type === "output:text") lines.push(event.text);
+    yield event;
+  }
+}
+function readContextFile(filePath2) {
+  try {
+    return readFileSync2(filePath2, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Context file "${filePath2}" could not be read: ${msg}`);
+  }
+}
+function expandContext(task) {
+  if (!task.contextFiles || task.contextFiles.length === 0) return task;
+  const header = task.contextFiles.map((fp) => `### ${fp}
+\`\`\`
+${readContextFile(fp)}
+\`\`\``).join("\n\n");
+  return { ...task, prompt: `${header}
+
+${task.prompt}` };
+}
+function loadPrompt(name) {
+  const raw = readFileSync2(join(PROMPTS_DIR, `${name}.txt`), "utf8");
+  return raw.replace(/^(#[^\n]*\n)+\n?/, "");
+}
+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);
+}
+function buildJudgePrompt(stepName, instructions, output) {
+  return JUDGE_EVALUATION_PROMPT.replace("{{STEP_NAME}}", stepName).replace("{{STEP_INSTRUCTIONS}}", instructions).replace("{{OUTPUT}}", output);
+}
+function formatToolCall(tool, input) {
+  if (tool === "Edit" || tool === "Write") return `${tool}(${String(input["file_path"] ?? "")})`;
+  if (tool === "Bash") return `Bash(${String(input["command"] ?? "")})`;
+  return tool;
+}
+function buildFixSummary(toolCalls, claudeLines) {
+  if (toolCalls.length > 0) return toolCalls.join(", ");
+  return claudeLines.join(" ").trim() || "No changes made";
+}
+function buildAttemptHistory(attempts) {
+  if (attempts.length === 0) return "";
+  const blocks = attempts.map(
+    (a, i) => `--- Attempt ${i + 1} ---
+Fix applied: ${a.fixSummary}
+Result: Failed with exit code ${a.exitCode}
+Output: ${a.cmdOutput}`
+  );
+  return `PREVIOUS ATTEMPTS:
+${blocks.join("\n\n")}`;
+}
+
+// src/index.ts
+init_update();
+
+// src/ui/App.tsx
+import { useEffect as useEffect2, useReducer, useState } from "react";
+import { Box as Box4, Text as Text4, useApp, useStdin } from "ink";
+
+// src/ui/KeyboardHandler.tsx
+import { useInput } from "ink";
+function KeyboardHandler({ onExit }) {
+  useInput((input, key) => {
+    if (input === "q" || key.ctrl && input === "c") onExit();
+  });
+  return null;
+}
+
+// src/ui/formatTool.ts
+function formatToolCall2(tool, input) {
+  switch (tool) {
+    case "Read":
+    case "Edit":
+    case "Write":
+      return `[${tool}] ${input["file_path"] ?? JSON.stringify(input)}`;
+    case "Bash":
+      return `[Bash] ${input["description"] ?? ""}
+  $ ${String(input["command"] ?? "").slice(0, 120)}`;
+    case "Glob":
+      return `[Glob] ${input["pattern"] ?? JSON.stringify(input)}`;
+    case "Grep":
+      return `[Grep] ${input["pattern"] ?? JSON.stringify(input)}`;
+    case "TodoWrite": {
+      const todos = input["todos"];
+      if (Array.isArray(todos)) {
+        const inProgress = todos.filter((t) => typeof t === "object" && t !== null && t["status"] === "in_progress").map((t) => String(t["content"] ?? ""));
+        if (inProgress.length > 0) return `[Task] ${inProgress.join(", ")}`;
+      }
+      return "";
+    }
+    case "Agent":
+      return `[Agent:${input["subagent_type"] ?? "?"}] ${input["description"] ?? ""}`;
+    default:
+      if (process.env["EXECUTANT_DEBUG"] === "1") {
+        return `[${tool}] ${JSON.stringify(input)}`;
+      }
+      return "";
+  }
+}
+
+// src/ui/reducer.ts
+function buildInitialState(workflow2) {
+  return {
+    workflow: workflow2,
+    tasks: workflow2.tasks.map((task) => ({
+      task,
+      status: "pending",
+      lines: []
+    })),
+    currentIndex: 0,
+    startTime: Date.now(),
+    writtenFiles: []
+  };
+}
+function reducer(state, event) {
+  switch (event.type) {
+    case "workflow:start":
+      return { ...state, startTime: Date.now() };
+    case "workflow:complete":
+      return { ...state, endTime: Date.now() };
+    case "step:start":
+      return updateTask(state, event.index, {
+        status: "running",
+        startTime: Date.now()
+      });
+    case "step:complete":
+      return {
+        ...updateTask(state, event.index, {
+          status: "complete",
+          endTime: Date.now()
+        }),
+        currentIndex: event.index + 1
+      };
+    case "step:error":
+      return {
+        ...updateTask(state, event.index, {
+          status: "error",
+          endTime: Date.now(),
+          error: event.error
+        }),
+        currentIndex: event.index + 1
+      };
+    case "step:skip":
+      return {
+        ...updateTask(state, event.index, { status: "skipped" }),
+        currentIndex: event.index + 1
+      };
+    case "step:iteration":
+      return updateTask(state, event.index, {
+        iteration: { current: event.iteration, total: event.total, item: event.item }
+      });
+    case "output:text": {
+      const idx = event.index;
+      if (idx >= state.tasks.length) return state;
+      return appendLine(state, idx, event.text);
+    }
+    case "output:tool": {
+      const idx = event.index;
+      if (idx >= state.tasks.length) return state;
+      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;
+    }
+    case "output:cost":
+      return state;
+    // cost events are intentionally not shown in the TUI
+    case "output:structured":
+      return state;
+    // structured output is consumed by callers, not shown in the TUI
+    case "log": {
+      const idx = state.currentIndex;
+      if (idx >= state.tasks.length) return state;
+      return appendLine(state, idx, `[${event.level}] ${event.text}`);
+    }
+    default: {
+      const _ = event;
+      void _;
+      return state;
+    }
+  }
+}
+function updateTask(state, index, patch) {
+  const tasks = state.tasks.map((t, i) => i === index ? { ...t, ...patch } : t);
+  return { ...state, tasks };
+}
+function appendLine(state, index, line) {
+  const tasks = state.tasks.map((t, i) => {
+    if (i !== index) return t;
+    const lines = [...t.lines, line];
+    return { ...t, lines };
+  });
+  return { ...state, tasks };
+}
+
+// src/ui/TaskRow.tsx
+import { Box, Text } from "ink";
+
+// src/ui/utils.ts
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var EXIT_DELAY_MS = 300;
+function formatHeaderElapsed(start, end) {
+  const ms = (end ?? Date.now()) - start;
+  return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+}
+function formatTaskElapsed(start, end, status) {
+  if (!start) return "";
+  const ms = (end ?? Date.now()) - start;
+  if (status === "running" || status === "complete" || status === "error") return `${(ms / 1e3).toFixed(1)}s`;
+  return "";
+}
+
+// src/ui/theme.ts
+import { createRequire } from "node:module";
+import { oklchToHex } from "@coston/design-tokens";
+var THEME_NAME = "purple-dark";
+var _require = createRequire(import.meta.url);
+var { themes } = _require("@coston/design-tokens/tokens.json");
+function hex(key) {
+  return oklchToHex(themes[THEME_NAME][key]);
+}
+var theme = {
+  foreground: hex("foreground"),
+  // primary text
+  muted: hex("muted-foreground"),
+  // dimmed / inactive text and borders
+  primary: hex("primary"),
+  // tool calls, cursor, active
+  primaryLight: hex("secondary-foreground"),
+  // lighter tint of primary (same hue, higher lightness)
+  success: hex("success"),
+  // completed steps
+  error: hex("destructive"),
+  // errors
+  warning: hex("warning"),
+  // warnings, retries, updates
+  border: hex("border")
+  // log pane border
+};
+
+// src/ui/TaskRow.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function TaskRow({ taskState, isActive, index, tick }) {
+  const { task, status, startTime, endTime } = taskState;
+  const icon = statusIcon(status, tick);
+  const color = statusColor(status, isActive);
+  const elapsed = formatTaskElapsed(startTime, endTime, status);
+  const iterInfo = taskState.iteration ? ` (${taskState.iteration.current}/${taskState.iteration.total}) ${taskState.iteration.item}` : "";
+  const label = `${index + 1}. ${task.name}${iterInfo}`;
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsxs(Text, { color, children: [
+      icon,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: isActive ? theme.foreground : theme.muted, bold: isActive, children: label }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "  ",
+      elapsed
+    ] })
+  ] });
+}
+var STATUS_ICON = {
+  complete: "\u2713",
+  error: "\u2717",
+  skipped: "\u2298",
+  pending: "\xB7"
+};
+var STATUS_COLOR = {
+  complete: theme.success,
+  error: theme.error,
+  pending: theme.muted
+};
+function statusIcon(status, tick) {
+  return status === "running" ? SPINNER[tick % SPINNER.length] : STATUS_ICON[status] ?? "\xB7";
+}
+function statusColor(status, isActive) {
+  if (isActive && status === "running") return theme.primary;
+  return STATUS_COLOR[status] ?? theme.foreground;
+}
+
+// src/ui/LogPane.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function LogPane({ lines, isActive = false, maxLines = 15 }) {
+  const visible = lines.slice(-maxLines);
+  if (visible.length === 0) {
+    return /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: isActive ? "\u2838 waiting for output\u2026" : "\u2014 no output yet \u2014" }) });
+  }
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: theme.border, paddingX: 1, children: visible.map((line, i) => /* @__PURE__ */ jsx2(
+    LogLine,
+    {
+      text: line,
+      cursor: isActive && i === visible.length - 1
+    },
+    i
+  )) });
+}
+function LogLine({ text, cursor }) {
+  const suffix = cursor ? /* @__PURE__ */ jsx2(Text2, { color: theme.primary, children: " \u258C" }) : null;
+  if (/^\[[\w:]+\]/.test(text)) {
+    const bracket = text.match(/^\[[\w:]+\]/)?.[0] ?? "";
+    const rest = text.slice(bracket.length);
+    return /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: theme.primary, children: bracket }),
+      /* @__PURE__ */ jsx2(Text2, { children: rest }),
+      suffix
+    ] });
+  }
+  if (/^\s*\$\s/.test(text)) return /* @__PURE__ */ jsxs2(Text2, { color: theme.warning, children: [
+    text,
+    suffix
+  ] });
+  if (text.startsWith("[warn]")) return /* @__PURE__ */ jsxs2(Text2, { color: theme.warning, children: [
+    text,
+    suffix
+  ] });
+  if (text.startsWith("[error]")) return /* @__PURE__ */ jsxs2(Text2, { color: theme.error, children: [
+    text,
+    suffix
+  ] });
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    text,
+    suffix
+  ] });
+}
+
+// src/ui/useInterval.ts
+import { useEffect, useRef } from "react";
+function useInterval(callback, delayMs) {
+  const saved = useRef(callback);
+  useEffect(() => {
+    saved.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    const id = setInterval(() => saved.current(), delayMs);
+    return () => clearInterval(id);
+  }, [delayMs]);
+}
+
+// src/ui/BrandMark.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var BRAND = "Executant";
+var SWEEP_TICKS = BRAND.length * 2;
+var GAP_TICKS = 30;
+var CYCLE = SWEEP_TICKS + GAP_TICKS;
+function charColor(charIndex, tick, isActive) {
+  if (!isActive) return theme.primary;
+  const pos = tick % CYCLE;
+  if (pos >= SWEEP_TICKS) return theme.primary;
+  const charPos = Math.floor(pos / 2);
+  return charIndex === charPos ? theme.primaryLight : theme.primary;
+}
+function BrandMark({ tick, isActive }) {
+  return /* @__PURE__ */ jsx3(Box3, { children: [...BRAND].map((char, i) => /* @__PURE__ */ jsx3(Text3, { color: charColor(i, tick, isActive), bold: true, children: char }, i)) });
+}
+
+// src/ui/App.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function App({ workflow: workflow2, events: events2, options: options2, updateCheck: updateCheck2 }) {
+  const { exit } = useApp();
+  const [state, dispatch] = useReducer(reducer, buildInitialState(workflow2));
+  useEffect2(() => {
+    let active = true;
+    (async () => {
+      try {
+        for await (const event of events2) {
+          if (!active) break;
+          dispatch(event);
+          if (event.type === "workflow:complete") {
+            setTimeout(() => exit(), EXIT_DELAY_MS);
+          }
+        }
+      } 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);
+      }
+    })();
+    return () => {
+      active = false;
+      events2.return(void 0).catch(() => {
+      });
+    };
+  }, [events2, exit]);
+  const { isRawModeSupported } = useStdin();
+  const [tick, setTick] = useState(0);
+  useInterval(() => {
+    if (!state.endTime) setTick((t) => t + 1);
+  }, 100);
+  const [updateVersion, setUpdateVersion] = useState(null);
+  useEffect2(() => {
+    updateCheck2.then(setUpdateVersion);
+  }, [updateCheck2]);
+  const elapsed = formatHeaderElapsed(state.startTime, state.endTime);
+  const activeTask = state.tasks[state.currentIndex];
+  const completedCount = state.tasks.filter((t) => t.status === "complete").length;
+  const totalCount = state.tasks.length;
+  const filterInfo = options2?.stepFilter ? `  [step: ${options2.stepFilter}]` : options2?.fromStep ? `  [from step: ${options2.fromStep}]` : "";
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx4(BrandMark, { tick, isActive: !state.endTime }) }),
+    /* @__PURE__ */ jsxs3(Box4, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.primary, children: workflow2.goal }),
+      /* @__PURE__ */ jsxs3(Text4, { dimColor: true, children: [
+        "  ",
+        completedCount,
+        "/",
+        totalCount,
+        " steps \xB7 ",
+        elapsed,
+        filterInfo
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginBottom: 1, children: state.tasks.map((taskState, i) => /* @__PURE__ */ jsx4(
+      TaskRow,
+      {
+        index: i,
+        tick,
+        taskState,
+        isActive: i === state.currentIndex
+      },
+      taskState.task.name
+    )) }),
+    activeTask && /* @__PURE__ */ jsx4(LogPane, { lines: activeTask.lines, isActive: activeTask.status === "running" }),
+    state.endTime !== void 0 && state.writtenFiles.length > 0 && /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "files written:" }),
+      state.writtenFiles.map((f) => /* @__PURE__ */ jsxs3(Text4, { color: theme.primary, children: [
+        "  ",
+        f
+      ] }, f))
+    ] }),
+    /* @__PURE__ */ jsxs3(Box4, { marginTop: 1, flexDirection: "column", children: [
+      updateVersion && /* @__PURE__ */ jsxs3(Text4, { color: theme.warning, children: [
+        "v",
+        updateVersion,
+        " available \u2014 run: executant update"
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "press q to quit" })
+    ] }),
+    isRawModeSupported && /* @__PURE__ */ jsx4(KeyboardHandler, { onExit: exit })
+  ] });
+}
+
+// src/plan.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2, resolve } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dump as dumpYaml } from "js-yaml";
+import { z as z3 } from "zod";
+import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
+var PROMPTS_DIR2 = join2(dirname2(fileURLToPath2(import.meta.url)), "prompts");
+var PLAN_RESEARCH_PROMPT = readFileSync3(join2(PROMPTS_DIR2, "plan-research.txt"), "utf8");
+var PLAN_DECOMPOSE_PROMPT = readFileSync3(join2(PROMPTS_DIR2, "plan-decompose.txt"), "utf8");
+var PLAN_JUDGE_PROMPT = readFileSync3(join2(PROMPTS_DIR2, "plan-judge.txt"), "utf8");
+var PLAN_SYSTEM_RULES = readFileSync3(join2(PROMPTS_DIR2, "plan-system-rules.txt"), "utf8").trim();
+var PLAN_RETRY_PARSE_ERROR = readFileSync3(join2(PROMPTS_DIR2, "plan-retry-parse-error.txt"), "utf8").trim();
+var PLAN_RETRY_SCHEMA_ERROR = readFileSync3(join2(PROMPTS_DIR2, "plan-retry-schema-error.txt"), "utf8").trim();
+var PLAN_RETRY_JUDGE = readFileSync3(join2(PROMPTS_DIR2, "plan-retry-judge.txt"), "utf8").trim();
+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(),
+  context: z3.array(z3.string()).optional()
+});
+var WorkflowSchema = z3.object({
+  goal: z3.string(),
+  steps: z3.array(StepSchema).min(1),
+  vars: z3.record(z3.string()).optional(),
+  self_improve: z3.boolean().optional()
+});
+var PlanJudgeOutputSchema = z3.object({
+  pass: z3.boolean(),
+  feedback: z3.string()
+});
+var WORKFLOW_JSON_SCHEMA = zodToJsonSchema2(WorkflowSchema);
+function walkUp(startDir, check) {
+  let dir = startDir;
+  while (true) {
+    const found = check(dir);
+    if (found !== null) return found;
+    const parent = join2(dir, "..");
+    if (resolve(parent) === resolve(dir)) return null;
+    dir = parent;
+  }
+}
+function findGitRoot(startDir) {
+  return walkUp(startDir, (dir) => existsSync(join2(dir, ".git")) ? dir : null);
+}
+function findProjectRoot(startDir) {
+  return walkUp(startDir, (dir) => {
+    const candidate = join2(dir, ".claude", "executant.local", "tasks");
+    return existsSync(candidate) ? candidate : null;
+  });
+}
+function parsePlanArgs(rawArgs2) {
+  let description = "";
+  if (rawArgs2[0] === "-h" || rawArgs2[0] === "--help") {
+    console.log(`Usage: executant plan [OPTIONS] [DESCRIPTION]
+
+Generate a task plan from a description.
+
+Options:
+  -f, --file <path>    Read prompt from file
+  -h, --help           Show this help message
+
+Examples:
+  executant plan "add user authentication"
+  executant plan -f plan-prompt.txt
+  cat prompt.txt | executant plan`);
+    process.exit(0);
+  }
+  if (rawArgs2[0] === "-f" || rawArgs2[0] === "--file") {
+    const filePath2 = rawArgs2[1];
+    if (!filePath2) {
+      console.error("Error: -f/--file requires a file path argument");
+      process.exit(1);
+    }
+    if (!existsSync(filePath2)) {
+      console.error(`Error: File not found: ${filePath2}`);
+      process.exit(1);
+    }
+    try {
+      description = readFileSync3(filePath2, "utf8").trim();
+    } catch {
+      console.error(`Error: Cannot read file: ${filePath2}`);
+      process.exit(1);
+    }
+  } else if (rawArgs2.length > 0) {
+    description = rawArgs2.join(" ").trim();
+  } else if (!process.stdin.isTTY) {
+    try {
+      description = readFileSync3("/dev/stdin", "utf8").trim();
+    } catch {
+    }
+  }
+  if (!description) {
+    console.error("Error: No task description provided");
+    console.error("Usage: executant plan [OPTIONS] [DESCRIPTION]");
+    console.error("       executant plan -f <filepath>");
+    console.error("       cat prompt.txt | executant plan");
+    process.exit(1);
+  }
+  let taskDir = findProjectRoot(process.cwd());
+  if (!taskDir) {
+    const base = findGitRoot(process.cwd()) ?? process.cwd();
+    taskDir = join2(base, ".claude", "executant.local", "tasks");
+    mkdirSync2(taskDir, { recursive: true });
+  }
+  const todoDir = join2(taskDir, "todo");
+  mkdirSync2(todoDir, { recursive: true });
+  const slug = slugify(description);
+  const ts = timestamp();
+  const taskFile = join2(todoDir, `${ts}-${slug}.yaml`);
+  return { description, taskFile, todoDir };
+}
+async function runPass3Judge(description, workflow2) {
+  try {
+    const task = {
+      type: "claude",
+      name: "plan:judge",
+      prompt: PLAN_JUDGE_PROMPT.replace("{{DESCRIPTION}}", description).replace("{{WORKFLOW_JSON}}", JSON.stringify(workflow2, null, 2)),
+      allowedTools: [],
+      permissionMode: "default",
+      model: "sonnet"
+    };
+    return await runClaudeStructured(task, PlanJudgeOutputSchema);
+  } catch {
+    return { pass: true, feedback: "", skipped: true };
+  }
+}
+async function* streamPlan(args) {
+  const { description, taskFile } = args;
+  yield { type: "plan:start", description };
+  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),
+      allowedTools: ["Read", "Glob", "Grep"],
+      permissionMode: "bypassPermissions",
+      model: "opus"
+    };
+    for await (const event of runClaude(researchTask)) {
+      if (event.type === "output:tool") {
+        yield { type: "plan:tool", tool: event.tool, input: event.input };
+      } else if (event.type === "output:text") {
+        researchLines.push(event.text);
+        yield { type: "plan:text", text: event.text };
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    yield { type: "plan:error", message: `Research pass failed: ${msg}` };
+    return;
+  }
+  const researchDoc = researchLines.join("\n");
+  if (!researchDoc.trim()) {
+    yield { type: "plan:error", message: "Research pass produced no output \u2014 cannot decompose" };
+    return;
+  }
+  yield { type: "plan:stage", stage: 2, total: TOTAL_PLAN_STAGES, name: "Decompose to Steps" };
+  let retryPrefix = "";
+  for (let attempt = 0; attempt < MAX_PLAN_RETRIES; attempt++) {
+    if (attempt > 0) {
+      yield {
+        type: "plan:retry",
+        attempt: attempt + 1,
+        maxAttempts: MAX_PLAN_RETRIES,
+        reason: retryPrefix.replace(/\n/g, " ")
+      };
+      yield { type: "plan:stage", stage: 2, total: TOTAL_PLAN_STAGES, name: "Decompose to Steps" };
+    }
+    const basePrompt = PLAN_DECOMPOSE_PROMPT.replace("{{DESCRIPTION}}", description).replace("{{RESEARCH_DOC}}", researchDoc);
+    const decomposeTask = {
+      type: "claude",
+      name: "plan:decompose",
+      prompt: retryPrefix ? `${retryPrefix}
+
+${basePrompt}` : basePrompt,
+      allowedTools: [],
+      permissionMode: "bypassPermissions",
+      model: "opus",
+      appendSystemPrompt: PLAN_SYSTEM_RULES,
+      jsonSchema: WORKFLOW_JSON_SCHEMA
+    };
+    let structuredOutput;
+    const decomposeTextLines = [];
+    try {
+      for await (const event of runClaude(decomposeTask)) {
+        if (event.type === "output:tool") {
+          yield { type: "plan:tool", tool: event.tool, input: event.input };
+        } else if (event.type === "output:text") {
+          decomposeTextLines.push(event.text);
+          yield { type: "plan:text", text: event.text };
+        } else if (event.type === "output:structured") {
+          structuredOutput = event.data;
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(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"));
+      continue;
+    }
+    if (structuredOutput === void 0) {
+      const issues = "No structured output returned \u2014 ensure the response is a JSON object";
+      if (attempt === MAX_PLAN_RETRIES - 1) {
+        yield { type: "plan:error", message: issues };
+        return;
+      }
+      retryPrefix = PLAN_RETRY_SCHEMA_ERROR.replace("{{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");
+      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);
+      continue;
+    }
+    yield { type: "plan:stage", stage: 3, total: TOTAL_PLAN_STAGES, 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);
+      continue;
+    }
+    if (!judgeResult.pass) {
+      yield { type: "plan:warn", message: `Judge rejected plan but retries exhausted: ${judgeResult.feedback}` };
+    }
+    const { goal, vars, steps, ...rest } = zodResult.data;
+    const ordered = { goal, ...vars && { vars }, steps, ...rest };
+    const yamlContent = dumpYaml(ordered, {
+      lineWidth: -1,
+      noRefs: true,
+      quotingType: '"',
+      forceQuotes: false
+    }).trimEnd();
+    writeFileSync2(taskFile, yamlContent + "\n", "utf8");
+    const preview = yamlContent.split("\n").slice(0, 30).join("\n") + (yamlContent.split("\n").length > 30 ? "\n..." : "");
+    yield { type: "plan:complete", taskFile, preview };
+    return;
+  }
+  yield { type: "plan:error", message: "Plan generation failed after maximum retries" };
+}
+
+// src/ui/PlanApp.tsx
+import { useEffect as useEffect3, useReducer as useReducer2, useState as useState2 } from "react";
+import { Box as Box5, Text as Text5, useApp as useApp2, useStdin as useStdin2 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var truncate = (str, max) => str.length > max ? str.slice(0, max - 3) + "..." : str;
+function buildInitial(description) {
+  return {
+    description,
+    lines: [],
+    status: "running",
+    attempt: 1,
+    maxAttempts: 3,
+    startTime: Date.now(),
+    stage: 0,
+    totalStages: 0,
+    stageName: "",
+    stageNames: []
+  };
+}
+function planReducer(state, event) {
+  switch (event.type) {
+    case "plan:start":
+      return { ...state, description: event.description, startTime: Date.now() };
+    case "plan:stages":
+      return { ...state, stageNames: event.names, totalStages: event.names.length };
+    case "plan:stage": {
+      const lines = [...state.lines, `[${event.stage}/${event.total}] ${event.name}`];
+      return { ...state, stage: event.stage, totalStages: event.total, stageName: event.name, status: "running", lines };
+    }
+    case "plan:tool": {
+      const formatted = formatToolCall2(event.tool, event.input);
+      if (!formatted) return state;
+      return { ...state, lines: [...state.lines, formatted] };
+    }
+    case "plan:text":
+      return state;
+    // text output is collected separately for JSON parsing
+    case "plan:warn": {
+      const lines = [...state.lines, `[warn] ${event.message}`];
+      return { ...state, lines };
+    }
+    case "plan:retry": {
+      const lines = [...state.lines, `[retry] Attempt ${event.attempt}/${event.maxAttempts}: ${event.reason}`];
+      return { ...state, status: "retrying", attempt: event.attempt, maxAttempts: event.maxAttempts, retryReason: event.reason, lines };
+    }
+    case "plan:complete":
+      return { ...state, status: "complete", taskFile: event.taskFile, preview: event.preview };
+    case "plan:error":
+      return { ...state, status: "error", errorMessage: event.message };
+  }
+}
+function StageProgress({ stage, totalStages, stageNames, tick, isActive, status }) {
+  if (totalStages === 0 || stageNames.length === 0) return null;
+  const rows = Array.from({ length: totalStages }, (_, i) => {
+    const stageIndex = i + 1;
+    const name = stageNames[i] ?? "";
+    let icon;
+    let color;
+    let bold = false;
+    let dim = false;
+    if (stageIndex < stage) {
+      icon = "\u2713";
+      color = theme.success;
+    } else if (stageIndex === stage && isActive) {
+      icon = SPINNER[tick % SPINNER.length];
+      color = theme.primary;
+      bold = true;
+    } else if (stageIndex === stage && !isActive) {
+      icon = status === "complete" ? "\u2713" : status === "error" ? "\u2717" : "\xB7";
+      color = status === "complete" ? theme.success : status === "error" ? theme.error : void 0;
+    } else if (!isActive && status === "complete") {
+      icon = "\u2713";
+      color = theme.success;
+    } else {
+      icon = "\xB7";
+      dim = true;
+    }
+    return { icon, color, name, bold, dim };
+  });
+  return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginBottom: 1, children: rows.map(({ icon, color, name, bold, dim }, i) => /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsxs4(Text5, { color, dimColor: dim, bold, children: [
+    "  ",
+    icon,
+    name ? `  ${name}` : ""
+  ] }) }, i)) });
+}
+function PlanApp({ description, events: events2 }) {
+  const { exit } = useApp2();
+  const [state, dispatch] = useReducer2(planReducer, buildInitial(description));
+  useEffect3(() => {
+    let active = true;
+    (async () => {
+      for await (const event of events2) {
+        if (!active) break;
+        dispatch(event);
+        if (event.type === "plan:complete" || event.type === "plan:error") {
+          setTimeout(() => exit(), EXIT_DELAY_MS);
+        }
+      }
+    })();
+    return () => {
+      active = false;
+    };
+  }, [events2, exit]);
+  const { isRawModeSupported } = useStdin2();
+  const [tick, setTick] = useState2(0);
+  const isActive = state.status === "running" || state.status === "retrying";
+  useInterval(() => {
+    if (isActive) setTick((t) => t + 1);
+  }, 100);
+  const elapsed = formatHeaderElapsed(state.startTime);
+  const icon = isActive ? SPINNER[tick % SPINNER.length] : state.status === "complete" ? "\u2713" : "\u2717";
+  const iconColor = state.status === "complete" ? theme.success : state.status === "error" ? theme.error : theme.primary;
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsx5(BrandMark, { tick, isActive }) }),
+    /* @__PURE__ */ jsxs4(Box5, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs4(Text5, { color: iconColor, children: [
+        icon,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: theme.primary, children: "Generating plan" }),
+      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+        "  ",
+        elapsed
+      ] }),
+      state.status === "retrying" && /* @__PURE__ */ jsxs4(Text5, { color: theme.warning, children: [
+        "  ",
+        "(attempt ",
+        state.attempt,
+        "/",
+        state.maxAttempts,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box5, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "  " }),
+      /* @__PURE__ */ jsx5(Text5, { children: truncate(state.description, 80) })
+    ] }),
+    /* @__PURE__ */ jsx5(
+      StageProgress,
+      {
+        stage: state.stage,
+        totalStages: state.totalStages,
+        stageNames: state.stageNames,
+        tick,
+        isActive,
+        status: state.status
+      }
+    ),
+    state.lines.length > 0 && /* @__PURE__ */ jsx5(LogPane, { lines: state.lines, isActive, maxLines: 10 }),
+    state.status === "complete" && state.taskFile && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs4(Text5, { color: theme.success, children: [
+        "\u2705 Task plan saved: ",
+        state.taskFile
+      ] }),
+      state.preview && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Preview:" }),
+        /* @__PURE__ */ jsx5(Text5, { children: state.preview })
+      ] })
+    ] }),
+    state.status === "error" && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text5, { color: theme.error, children: [
+      "Error: ",
+      state.errorMessage
+    ] }) }),
+    isActive && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "press q to quit" }) }),
+    isRawModeSupported && /* @__PURE__ */ jsx5(KeyboardHandler, { onExit: exit })
+  ] });
+}
+
+// src/logger.ts
+import {
+  appendFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readdirSync,
+  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) {
+    const candidate = join3(dir, ".claude", "executant.local");
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname3(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+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}
+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(
+      `
+${"\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,
+        `
+---
+
+*Total tools used: ${this.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")
+    );
+  }
+  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,
+      [
+        "# Self-Healing Activation",
+        "",
+        `**Task:** ${this.taskName}`,
+        `**Step:** ${this.stepName}`,
+        `**Timestamp:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
+        "",
+        "---",
+        "",
+        "## \u274C Failure Detected",
+        "",
+        `**Exit Code:** ${exitCode}`,
+        "",
+        "**Recent Output:**",
+        "```",
+        errorOutput,
+        "```",
+        "",
+        "---",
+        "",
+        "## \u{1F527} Claude's Healing Process",
+        ""
+      ].join("\n")
+    );
+  }
+  completeSelfHealingHighlight() {
+    if (!this.selfHealingFile) return;
+    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(
+      `
+${"\u2501".repeat(51)}
+Task Complete: ${this.taskName}
+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()})
+${entries}
+`);
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Log file writes
+  // --------------------------------------------------------------------------
+  appendLog(text) {
+    if (!this.logFile) return;
+    appendFileSync(this.logFile, text + "\n");
+  }
+};
+async function* withLogger(gen, logger2) {
+  for await (const event of gen) {
+    logger2.observe(event);
+    yield event;
+  }
+}
+
+// src/retrospective.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { basename, dirname as dirname4, join as join4, resolve as resolve3 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { spawnSync } from "node:child_process";
+import { load as parseYaml2 } from "js-yaml";
+import { z as z4 } from "zod";
+var RetrospectiveOutputSchema = z4.object({
+  improved_yaml: z4.string(),
+  changelog: z4.string()
+});
+var PROMPTS_DIR3 = join4(dirname4(fileURLToPath3(import.meta.url)), "prompts");
+var RETROSPECTIVE_PROMPT = readFileSync4(join4(PROMPTS_DIR3, "retrospective-analysis.txt"), "utf8");
+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}`);
+  }
+}
+async function doRetrospective(workflowFilePath, workflow2, highlightsDir, runTimestamp) {
+  if (!existsSync3(highlightsDir)) {
+    console.log("\nSelf-improvement: no highlights directory found, skipping.");
+    return;
+  }
+  const allFiles = readdirSync2(highlightsDir);
+  const runHighlights = allFiles.filter((f) => f.startsWith(runTimestamp) && f.endsWith(".md")).sort();
+  if (runHighlights.length === 0) {
+    console.log("\nSelf-improvement: no highlights for this run \u2014 task completed without issues, skipping.");
+    return;
+  }
+  const divider = "\u2501".repeat(51);
+  console.log(`
+${divider}`);
+  console.log("Self-Improvement: Analyzing execution and generating improvements...");
+  console.log(`${divider}
+`);
+  console.log(`Found ${runHighlights.length} highlight(s) to analyze`);
+  const countByPattern = (pat) => runHighlights.filter((f) => f.includes(pat)).length;
+  const judgeFailures = countByPattern("_judge_FAIL");
+  const selfHealingCount = countByPattern("_self_healing");
+  const complexSequences = countByPattern("_complex_sequence");
+  const metrics = [
+    `- Judge Failures: ${judgeFailures}`,
+    `- Self-Healing Activations: ${selfHealingCount}`,
+    `- Complex Tool Sequences: ${complexSequences}`,
+    `- Total Highlights: ${runHighlights.length}`
+  ].join("\n");
+  console.log(`
+Execution Metrics:
+${metrics}
+`);
+  console.log("Analyzing execution and generating improvements...\n");
+  const highlightContents = runHighlights.map((f) => {
+    const content = readFileSync4(join4(highlightsDir, f), "utf8");
+    return `### ${f}
+
+${content}`;
+  }).join("\n\n---\n\n");
+  const originalYaml = readFileSync4(workflowFilePath, "utf8");
+  const taskName = basename(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 result = spawnSync(
+    "claude",
+    [
+      "-p",
+      prompt,
+      "--allowedTools",
+      "Read",
+      "--permission-mode",
+      "bypassPermissions",
+      "--output-format",
+      "text"
+    ],
+    { encoding: "utf8", maxBuffer: 10 * 1024 * 1024 }
+  );
+  if (result.error) {
+    console.warn(`Self-improvement: failed to run claude: ${result.error.message}`);
+    return;
+  }
+  if (result.status !== 0) {
+    const stderr = result.stderr ?? "";
+    console.warn(`Self-improvement: claude exited with code ${result.status}${stderr ? ": " + stderr : ""}`);
+    return;
+  }
+  const response = result.stdout ?? "";
+  let parsed;
+  try {
+    parsed = JSON.parse(extractJson(response));
+  } catch {
+    console.warn(`Self-improvement: could not parse Claude response as JSON.
+Response: ${response.trim()}`);
+    return;
+  }
+  const zodResult = RetrospectiveOutputSchema.safeParse(parsed);
+  if (!zodResult.success) {
+    console.warn("Self-improvement: response schema mismatch \u2014 improved YAML not saved.");
+    return;
+  }
+  const improvedYaml = zodResult.data.improved_yaml.trim();
+  const changelog = zodResult.data.changelog.trim() || "No changelog generated.";
+  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.`);
+    return;
+  }
+  const startDir = dirname4(resolve3(workflowFilePath));
+  const executantLocal = findExecutantLocalDir(startDir);
+  const backlogDir = executantLocal ? join4(executantLocal, "tasks", "backlog") : join4(startDir, "..", "backlog");
+  mkdirSync4(backlogDir, { recursive: true });
+  const ts = formatTimestamp(/* @__PURE__ */ new Date());
+  const slug = slugify(taskName, 40);
+  const improvedFile = join4(backlogDir, `${ts}-${slug}-improved.yaml`);
+  const changelogFile = join4(backlogDir, `${ts}-${slug}-changelog.md`);
+  writeFileSync4(improvedFile, improvedYaml + "\n", "utf8");
+  writeFileSync4(changelogFile, changelog + "\n", "utf8");
+  console.log(`\u2705 Improved task saved: ${improvedFile}`);
+  console.log(`\u2705 Changelog saved: ${changelogFile}`);
+  console.log(`
+${divider}`);
+  console.log("Improvement Summary");
+  console.log(`${divider}
+`);
+  console.log(changelog);
+}
+function extractJson(text) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) throw new Error("no JSON object found in response");
+  return text.slice(start, end + 1);
+}
+
+// src/index.ts
+var CURRENT_VERSION = JSON.parse(
+  readFileSync5(join5(dirname5(fileURLToPath4(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
+  }));
+  try {
+    await inkApp.waitUntilExit();
+  } catch {
+  }
+  process.exit(0);
+}
+if (rawArgs[0] === "update") {
+  const { checkForUpdate: checkForUpdate2, doUpdate: doUpdate2 } = await Promise.resolve().then(() => (init_update(), update_exports));
+  const newer = await checkForUpdate2(CURRENT_VERSION);
+  if (!newer) process.exit(0);
+  console.log(`Updating to v${newer}...`);
+  try {
+    await doUpdate2();
+    console.log("Done.");
+  } catch (err) {
+    console.error("Update failed:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  process.exit(0);
+}
+if (rawArgs.length === 0 || rawArgs[0] === "--help" || rawArgs[0] === "-h") {
+  console.log(`Usage: executant [options] <workflow.yaml>
+       executant update
+
+Version: ${CURRENT_VERSION}
+
+Options:
+  --ci                  Headless mode \u2014 print events as NDJSON, no TUI
+  --step <name|index>   Run only the named step or step at 1-based index
+  --from-step <n>       Skip steps before n and run from there (1-based)
+  --help, -h            Show this help
+
+Commands:
+  plan <description>    Generate a task YAML from a natural language description
+  update                Upgrade executant to the latest version
+
+YAML \u2014 top-level fields:
+  goal    string   (required) Description shown in the TUI header
+  steps   array    (required) Ordered list of steps
+  vars    map      Key/value pairs substituted as {{var_name}} in prompts/commands
+
+YAML \u2014 step fields (all step types):
+  name              string  (required) Unique identifier for the step
+  type              string  prompt | script | command | log  (inferred if omitted)
+  continue_on_error bool    Keep going if step fails (default: false)
+  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.
+
+YAML \u2014 prompt step fields (type: prompt, or inferred when prompt is present):
+  prompt            string  (required) Instructions sent to Claude
+  allowed_tools     list    Claude tools to permit
+                            (default: Read,Edit,Write,Bash,Glob,Grep)
+  llm_as_judge      bool    After completion, Claude evaluates output quality;
+                            retries up to 5x on FAIL (default: false)
+
+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)
+  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):
+  message           string  Text to emit as a progress marker
+
+Type inference (when type is omitted):
+  has command field          \u2192 script
+  has message, no prompt     \u2192 log
+  otherwise                  \u2192 prompt
+
+Example:
+  goal: "Check and summarise recent changes"
+  steps:
+    - name: git-log
+      type: script
+      command: git log --oneline -10
+
+    - name: summarise
+      prompt: |
+        Summarise the 10 commits shown above in one short paragraph.
+        Focus on the theme of changes, not individual commit messages.`);
+  process.exit(0);
+}
+var ciMode = false;
+var stepFilter;
+var fromStep;
+var positional = [];
+for (let i = 0; i < rawArgs.length; i++) {
+  const a = rawArgs[i];
+  if (a === "--ci") {
+    ciMode = true;
+  } else if (a === "--step") {
+    if (!rawArgs[i + 1]) {
+      console.error("--step requires a value");
+      process.exit(1);
+    }
+    stepFilter = rawArgs[++i];
+  } else if (a === "--from-step") {
+    if (!rawArgs[i + 1]) {
+      console.error("--from-step requires a value");
+      process.exit(1);
+    }
+    fromStep = parseInt(rawArgs[++i], 10);
+    if (isNaN(fromStep)) {
+      console.error("--from-step must be a number");
+      process.exit(1);
+    }
+  } else {
+    positional.push(a);
+  }
+}
+var filePath = positional[0];
+if (!filePath) {
+  console.error("Error: no workflow file specified");
+  process.exit(1);
+}
+var workflow;
+try {
+  workflow = loadWorkflow(filePath);
+} catch (err) {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+}
+var options = { stepFilter, fromStep };
+var rawEvents = runWorkflow(workflow, options);
+var logger = new Logger(resolveLogDir(filePath), workflow.goal);
+var events = withLogger(rawEvents, logger);
+var updateCheck = checkForUpdate(CURRENT_VERSION);
+function errorReplacer(_key, value) {
+  if (value instanceof Error) {
+    return { name: value.name, message: value.message, stack: value.stack };
+  }
+  return value;
+}
+async function maybeRunRetrospective(filePath2, workflow2, logger2) {
+  if (!logger2) return;
+  try {
+    await runRetrospective(filePath2, workflow2, logger2.getHighlightsDir(), logger2.getTimestamp());
+  } catch (err) {
+    console.warn("[executant] retrospective failed (non-fatal):", err instanceof Error ? err.message : err);
+  }
+}
+if (ciMode) {
+  (async () => {
+    for await (const event of events) {
+      process.stdout.write(JSON.stringify(event, errorReplacer) + "\n");
+    }
+    if (workflow.selfImprove) {
+      await maybeRunRetrospective(filePath, workflow, logger);
+    }
+  })().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+} else {
+  const inkApp = render(React3.createElement(App, { workflow, events, options, updateCheck }));
+  if (workflow.selfImprove) {
+    inkApp.waitUntilExit().then(() => maybeRunRetrospective(filePath, workflow, logger)).catch(() => {
+    });
+  }
+}