executant 1.14.0 → 1.16.0

package/dist/index.js

@@ -52,7 +52,7 @@ var init_update = __esm({
 // src/index.ts
 import React3 from "react";
 import { render } from "ink";
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { dirname as dirname5, join as join5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -406,12 +406,11 @@ import { execSync, spawn as spawn2 } from "node:child_process";
 import { zodToJsonSchema } from "zod-to-json-schema";
 var METHODOLOGY = loadPrompt("development-methodology");
 var DEFAULT_TOOLS = ["Read", "Edit", "Write", "Bash", "Glob", "Grep"];
-function buildClaudeArgs(task) {
+function buildClaudeArgs(task, interactive = false) {
   const allowedTools = task.allowedTools ?? DEFAULT_TOOLS;
   const permissionMode = task.permissionMode ?? "bypassPermissions";
   return [
-    "--print",
-    task.prompt,
+    ...interactive ? [] : ["--print", task.prompt],
     "--output-format",
     "stream-json",
     "--verbose",
@@ -433,7 +432,7 @@ function resolveClaudePath() {
     );
   }
 }
-async function* runClaude(task) {
+async function* runClaude(task, _channel) {
   yield {
     type: "log",
     level: "info",
@@ -562,7 +561,7 @@ function shouldSkipStep(stepNumber, name, options2) {
   }
   return options2.fromStep !== void 0 && stepNumber < options2.fromStep[0];
 }
-async function* runWorkflow(workflow2, options2 = {}) {
+async function* runWorkflow(workflow2, options2 = {}, channel2) {
   const workflowStart = Date.now();
   yield { type: "workflow:start", workflow: workflow2 };
   for (const [i, task] of workflow2.tasks.entries()) {
@@ -575,7 +574,7 @@ async function* runWorkflow(workflow2, options2 = {}) {
     yield { type: "step:start", index: i, name: task.name };
     const from = options2.fromStep && options2.fromStep[0] === stepNumber ? options2.fromStep.slice(1) : void 0;
     try {
-      for await (const event of runStep(task, from)) {
+      for await (const event of runStep(task, from, channel2)) {
         if (event.type === "step:iteration" || event.type === "step:inner" || event.type === "output:text" || event.type === "output:tool") {
           yield { ...event, index: i };
         } else {
@@ -600,7 +599,7 @@ async function* runWorkflow(workflow2, options2 = {}) {
     durationMs: Date.now() - workflowStart
   };
 }
-async function* runStep(task, from) {
+async function* runStep(task, from, channel2) {
   switch (task.type) {
     case "log":
       yield* runLog(task);
@@ -619,11 +618,20 @@ async function* runStep(task, from) {
     }
     case "claude": {
       const expanded = expandContext(task);
-      yield* expanded.llmAsJudge ? runClaudeWithJudge(expanded) : runClaude(expanded);
+      const queued = channel2?.consumeQueue() ?? [];
+      const enriched = queued.length > 0 ? {
+        ...expanded,
+        prompt: `[User correction from a previous step]
+${queued.join("\n")}
+
+---
+${expanded.prompt}`
+      } : expanded;
+      yield* enriched.llmAsJudge ? runClaudeWithJudge(enriched, channel2) : runClaude(enriched, channel2);
       break;
     }
     case "forEach":
-      yield* runForEach(task, from);
+      yield* runForEach(task, from, channel2);
       break;
     default: {
       const _ = task;
@@ -634,7 +642,7 @@ async function* runStep(task, from) {
 async function* runLog(task) {
   yield { type: "output:text", index: -1, text: task.message };
 }
-async function* runForEach(task, from) {
+async function* runForEach(task, from, channel2) {
   const items = await resolveItems(task.forEach);
   const total = items.length;
   const innerTotal = task.inner.length;
@@ -669,7 +677,7 @@ async function* runForEach(task, from) {
       }
       const childFrom = childIdx === startChild ? iterFrom?.slice(1) : void 0;
       try {
-        for await (const event of runStep(substituted, childFrom)) {
+        for await (const event of runStep(substituted, childFrom, channel2)) {
           if (event.type !== "step:iteration" && event.type !== "step:inner") {
             yield event;
           }
@@ -803,14 +811,14 @@ async function* runCommandWithHealing(task) {
     }
   }
 }
-async function* runClaudeWithJudge(task) {
+async function* runClaudeWithJudge(task, channel2) {
   let judgeContext = "";
   for (let attempt = 0; attempt < MAX_JUDGE_RETRIES; attempt++) {
     const prompt = attempt === 0 ? task.prompt : `${task.prompt}
 
 ${fillTemplate(JUDGE_RETRY_CONTEXT, { FEEDBACK: judgeContext })}`;
     const lines = [];
-    yield* collectLines(runClaude({ ...task, prompt }), lines);
+    yield* collectLines(runClaude({ ...task, prompt }, channel2), lines);
     yield {
       type: "log",
       level: "info",
@@ -918,18 +926,86 @@ ${blocks.join("\n\n")}`;
 init_update();
 
 // src/ui/App.tsx
-import { useEffect as useEffect2, useReducer, useState } from "react";
-import { Box as Box5, Text as Text5, useApp, useStdin, useStdout } from "ink";
+import { useEffect as useEffect2, useReducer, useState as useState2 } from "react";
+import { Box as Box6, Text as Text6, useApp, useStdin, useStdout } from "ink";
 
 // src/ui/KeyboardHandler.tsx
 import { useInput } from "ink";
-function KeyboardHandler({ onExit }) {
+function KeyboardHandler({
+  onExit,
+  onInterject,
+  isInterjecting
+}) {
   useInput((input, key) => {
+    if (isInterjecting) return;
     if (input === "q" || key.ctrl && input === "c") onExit();
+    if (input === "i" && onInterject) onInterject();
   });
   return null;
 }
 
+// src/ui/InterjectInput.tsx
+import { useState } from "react";
+import { Box, Text, useInput as useInput2 } from "ink";
+
+// 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/InterjectInput.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function InterjectInput({ onSubmit, onCancel }) {
+  const [value, setValue] = useState("");
+  useInput2((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      if (value.trim()) onSubmit(value.trim());
+      else onCancel();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setValue((v) => v.slice(0, -1));
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      setValue((v) => v + input);
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "row", children: [
+    /* @__PURE__ */ jsx(Text, { color: theme.primary, bold: true, children: "\u25B7 " }),
+    /* @__PURE__ */ jsx(Text, { children: value }),
+    /* @__PURE__ */ jsx(Text, { color: theme.primary, children: "\u258C" }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  esc to cancel" })
+  ] });
+}
+
 // src/ui/formatTool.ts
 function formatToolCall2(tool, input) {
   switch (tool) {
@@ -1081,6 +1157,11 @@ function reducer(state, event) {
       if (idx >= state.tasks.length) return state;
       return appendLines(state, idx, `[${event.level}] ${event.text}`);
     }
+    case "step:interjection": {
+      const idx = event.index;
+      if (idx >= state.tasks.length) return state;
+      return appendLines(state, idx, `[interjection] ${event.message}`);
+    }
     default: {
       const _ = event;
       void _;
@@ -1116,35 +1197,7 @@ function appendLines(state, index, text) {
 }
 
 // src/ui/TaskRow.tsx
-import { Box, Text } from "ink";
-
-// 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
-};
+import { Box as Box2, Text as Text2 } from "ink";
 
 // src/ui/utils.ts
 var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -1182,7 +1235,7 @@ function formatTaskElapsed(start, end, status) {
 }
 
 // src/ui/TaskRow.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function TaskRow({ taskState, isActive, index, tick }) {
   const { task, status, startTime, endTime } = taskState;
   const icon = statusIcon(status, tick);
@@ -1190,13 +1243,13 @@ function TaskRow({ taskState, isActive, index, tick }) {
   const elapsed = formatTaskElapsed(startTime, endTime, status);
   const iterInfo = formatIterCount(taskState.iterationHistory);
   const label = `${index + 1}. ${task.name}${iterInfo}`;
-  return /* @__PURE__ */ jsxs(Box, { children: [
-    /* @__PURE__ */ jsxs(Text, { color, children: [
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { color, children: [
       icon,
       " "
     ] }),
-    /* @__PURE__ */ jsx(Text, { color: isActive ? theme.foreground : theme.muted, bold: isActive, children: label }),
-    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: isActive ? theme.foreground : theme.muted, bold: isActive, children: label }),
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
       "  ",
       elapsed
     ] })
@@ -1215,22 +1268,22 @@ function formatIterCount(history) {
 }
 
 // src/ui/IterationRow.tsx
-import { Box as Box2, Text as Text2 } from "ink";
-import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+import { Box as Box3, Text as Text3 } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function IterationRow({ record, tick }) {
   const icon = statusIcon(record.status, tick);
   const color = STATUS_COLOR[record.status] ?? theme.primary;
   const innerText = record.inner ? ` \u2014 ${stripItem(record.inner.name, record.item)} [${record.inner.index + 1}/${record.inner.total}]` : "";
   const ms = (record.endTime ?? Date.now()) - record.startTime;
   const elapsed = `${(ms / 1e3).toFixed(1)}s`;
-  return /* @__PURE__ */ jsxs2(Box2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "    " }),
-    /* @__PURE__ */ jsx2(Text2, { color, children: icon }),
-    /* @__PURE__ */ jsx2(Text2, { children: " " }),
-    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: `[${record.iteration}/${record.total}]` }),
-    /* @__PURE__ */ jsx2(Text2, { children: " " }),
-    /* @__PURE__ */ jsxs2(
-      Text2,
+  return /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "    " }),
+    /* @__PURE__ */ jsx3(Text3, { color, children: icon }),
+    /* @__PURE__ */ jsx3(Text3, { children: " " }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: `[${record.iteration}/${record.total}]` }),
+    /* @__PURE__ */ jsx3(Text3, { children: " " }),
+    /* @__PURE__ */ jsxs3(
+      Text3,
       {
         color: record.status === "running" ? theme.foreground : theme.muted,
         children: [
@@ -1239,7 +1292,7 @@ function IterationRow({ record, tick }) {
         ]
       }
     ),
-    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
       "  ",
       elapsed
     ] })
@@ -1261,29 +1314,29 @@ function IterationList({
   if (isRepeatStyle(iterationHistory)) return null;
   const hidden = iterationHistory.length - maxVisible;
   const visible = iterationHistory.slice(-maxVisible);
-  return /* @__PURE__ */ jsxs2(Fragment, { children: [
-    hidden > 0 && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: `    \u2026 ${hidden} earlier` }),
-    visible.map((record) => /* @__PURE__ */ jsx2(IterationRow, { record, tick }, record.iteration))
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    hidden > 0 && /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: `    \u2026 ${hidden} earlier` }),
+    visible.map((record) => /* @__PURE__ */ jsx3(IterationRow, { record, tick }, record.iteration))
   ] });
 }
 
 // src/ui/LogPane.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function LogPane({ lines, isActive = false, maxLines = 15 }) {
   const visible = lines.slice(-maxLines);
   if (visible.length === 0) {
-    return /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: isActive ? "\u2838 waiting for output\u2026" : "\u2014 no output yet \u2014" }) });
+    return /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: isActive ? "\u2838 waiting for output\u2026" : "\u2014 no output yet \u2014" }) });
   }
-  return /* @__PURE__ */ jsx3(
-    Box3,
+  return /* @__PURE__ */ jsx4(
+    Box4,
     {
       flexDirection: "column",
       marginTop: 1,
       borderStyle: "single",
       borderColor: theme.border,
       paddingX: 1,
-      children: visible.map((line, i) => /* @__PURE__ */ jsx3(
+      children: visible.map((line, i) => /* @__PURE__ */ jsx4(
         LogLine,
         {
           text: line,
@@ -1295,52 +1348,52 @@ function LogPane({ lines, isActive = false, maxLines = 15 }) {
   );
 }
 function LogLine({ text, cursor }) {
-  const suffix = cursor ? /* @__PURE__ */ jsx3(Text3, { color: theme.primary, children: " \u258C" }) : null;
+  const suffix = cursor ? /* @__PURE__ */ jsx4(Text4, { color: theme.primary, children: " \u258C" }) : null;
   if (/^\[[\w:]+\]/.test(text)) {
     const bracket = text.match(/^\[[\w:]+\]/)?.[0] ?? "";
     const rest = text.slice(bracket.length);
-    return /* @__PURE__ */ jsxs3(Text3, { children: [
-      /* @__PURE__ */ jsx3(Text3, { color: theme.primary, children: bracket }),
-      /* @__PURE__ */ jsx3(Text3, { children: rest }),
+    return /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: theme.primary, children: bracket }),
+      /* @__PURE__ */ jsx4(Text4, { children: rest }),
       suffix
     ] });
   }
   if (/^\s*\$\s/.test(text))
-    return /* @__PURE__ */ jsxs3(Text3, { color: theme.warning, children: [
+    return /* @__PURE__ */ jsxs4(Text4, { color: theme.warning, children: [
       text,
       suffix
     ] });
   if (text.startsWith("[warn]"))
-    return /* @__PURE__ */ jsxs3(Text3, { color: theme.warning, children: [
+    return /* @__PURE__ */ jsxs4(Text4, { color: theme.warning, children: [
       text,
       suffix
     ] });
   if (text.startsWith("[error]"))
-    return /* @__PURE__ */ jsxs3(Text3, { color: theme.error, children: [
+    return /* @__PURE__ */ jsxs4(Text4, { color: theme.error, children: [
       text,
       suffix
     ] });
   if (/^[\s]*(✓|✔|✅|done|success|compiled|built|passed)/i.test(text) && !/\b(error|fail|failed|warn|warning)\b/i.test(text))
-    return /* @__PURE__ */ jsxs3(Text3, { color: theme.success, children: [
+    return /* @__PURE__ */ jsxs4(Text4, { color: theme.success, children: [
       text,
       suffix
     ] });
   if (/\b(error|failed|fail)\b/i.test(text))
-    return /* @__PURE__ */ jsxs3(Text3, { color: theme.error, children: [
+    return /* @__PURE__ */ jsxs4(Text4, { color: theme.error, children: [
       text,
       suffix
     ] });
   if (/\b(warn|warning)\b/i.test(text))
-    return /* @__PURE__ */ jsxs3(Text3, { color: theme.warning, children: [
+    return /* @__PURE__ */ jsxs4(Text4, { color: theme.warning, children: [
       text,
       suffix
     ] });
   if (/^[·…⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/.test(text))
-    return /* @__PURE__ */ jsxs3(Text3, { color: theme.muted, children: [
+    return /* @__PURE__ */ jsxs4(Text4, { color: theme.muted, children: [
       text,
       suffix
     ] });
-  return /* @__PURE__ */ jsxs3(Text3, { children: [
+  return /* @__PURE__ */ jsxs4(Text4, { children: [
     text,
     suffix
   ] });
@@ -1360,8 +1413,8 @@ function useInterval(callback, delayMs) {
 }
 
 // src/ui/BrandMark.tsx
-import { Box as Box4, Text as Text4 } from "ink";
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5 } from "react/jsx-runtime";
 var BRAND = "Executant";
 var SWEEP_TICKS = BRAND.length * 2;
 var GAP_TICKS = 30;
@@ -1374,15 +1427,22 @@ function charColor(charIndex, tick, isActive) {
   return charIndex === charPos ? theme.primaryLight : theme.primary;
 }
 function BrandMark({ tick, isActive }) {
-  return /* @__PURE__ */ jsx4(Box4, { children: [...BRAND].map((char, i) => /* @__PURE__ */ jsx4(Text4, { color: charColor(i, tick, isActive), bold: true, children: char }, i)) });
+  return /* @__PURE__ */ jsx5(Box5, { children: [...BRAND].map((char, i) => /* @__PURE__ */ jsx5(Text5, { color: charColor(i, tick, isActive), bold: true, children: char }, i)) });
 }
 
 // src/ui/App.tsx
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 var MAX_VISIBLE_ITERATIONS = 8;
-function App({ workflow: workflow2, events: events2, options: options2, updateCheck: updateCheck2 }) {
+function App({
+  workflow: workflow2,
+  events: events2,
+  options: options2,
+  updateCheck: updateCheck2,
+  interjectChannel
+}) {
   const { exit } = useApp();
   const [state, dispatch] = useReducer(reducer, buildInitialState(workflow2));
+  const [isInterjecting, setIsInterjecting] = useState2(false);
   useEffect2(() => {
     let active = true;
     (async () => {
@@ -1411,11 +1471,11 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
   }, [events2, exit]);
   const { isRawModeSupported } = useStdin();
   const { stdout } = useStdout();
-  const [updateVersion, setUpdateVersion] = useState(null);
+  const [updateVersion, setUpdateVersion] = useState2(null);
   useEffect2(() => {
     updateCheck2.then(setUpdateVersion);
   }, [updateCheck2]);
-  const [tick, setTick] = useState(0);
+  const [tick, setTick] = useState2(0);
   useInterval(() => {
     if (!state.endTime) setTick((t) => t + 1);
   }, 100);
@@ -1426,7 +1486,7 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
     runningTask?.iterationHistory,
     MAX_VISIBLE_ITERATIONS
   );
-  const FIXED_OVERHEAD = 12 + (updateVersion ? 1 : 0);
+  const FIXED_OVERHEAD = 12 + (updateVersion ? 1 : 0) + (isInterjecting ? 1 : 0);
   const availableForTaskSection = Math.max(
     1,
     terminalRows - FIXED_OVERHEAD - LOG_PANE_MIN - iterationRowCount
@@ -1446,11 +1506,11 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
   ).length;
   const totalCount = state.tasks.length;
   const filterInfo = options2?.stepFilter ? `  [step: ${options2.stepFilter}]` : options2?.fromStep ? `  [from step: ${options2.fromStep}]` : "";
-  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", padding: 1, children: [
-    /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsx5(BrandMark, { tick, isActive: !state.endTime }) }),
-    /* @__PURE__ */ jsxs4(Box5, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx5(Text5, { bold: true, color: theme.primary, children: workflow2.goal }),
-      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(BrandMark, { tick, isActive: !state.endTime }) }),
+    /* @__PURE__ */ jsxs5(Box6, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: theme.primary, children: workflow2.goal }),
+      /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
         "  ",
         completedCount,
         "/",
@@ -1460,8 +1520,8 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
         filterInfo
       ] })
     ] }),
-    /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginBottom: 1, children: [
-      hiddenTaskCount > 0 && /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginBottom: 1, children: [
+      hiddenTaskCount > 0 && /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
         "  ",
         "\xB7\xB7\xB7 ",
         hiddenTaskCount,
@@ -1469,8 +1529,8 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
       ] }),
       taskSlice.map((taskState, i) => {
         const globalIndex = hiddenTaskCount + i;
-        return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsx5(
+        return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx6(
             TaskRow,
             {
               index: globalIndex,
@@ -1479,7 +1539,7 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
               isActive: globalIndex === state.currentIndex
             }
           ),
-          taskState.status === "running" && taskState.iterationHistory?.length ? /* @__PURE__ */ jsx5(
+          taskState.status === "running" && taskState.iterationHistory?.length ? /* @__PURE__ */ jsx6(
             IterationList,
             {
               iterationHistory: taskState.iterationHistory,
@@ -1490,7 +1550,7 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
         ] }, globalIndex);
       })
     ] }),
-    activeTask && /* @__PURE__ */ jsx5(
+    activeTask && /* @__PURE__ */ jsx6(
       LogPane,
       {
         lines: activeTask.lines,
@@ -1498,22 +1558,44 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
         maxLines: logPaneMaxLines
       }
     ),
-    state.endTime !== void 0 && state.writtenFiles.length > 0 && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "files written:" }),
-      state.writtenFiles.map((f) => /* @__PURE__ */ jsxs4(Text5, { color: theme.primary, children: [
+    state.endTime !== void 0 && state.writtenFiles.length > 0 && /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "files written:" }),
+      state.writtenFiles.map((f) => /* @__PURE__ */ jsxs5(Text6, { color: theme.primary, children: [
         "  ",
         f
       ] }, f))
     ] }),
-    /* @__PURE__ */ jsxs4(Box5, { marginTop: 1, flexDirection: "column", children: [
-      updateVersion && /* @__PURE__ */ jsxs4(Text5, { color: theme.warning, children: [
+    isInterjecting && interjectChannel && /* @__PURE__ */ jsx6(
+      InterjectInput,
+      {
+        onSubmit: (msg) => {
+          interjectChannel.interject(msg);
+          dispatch({
+            type: "step:interjection",
+            index: state.currentIndex,
+            message: msg
+          });
+          setIsInterjecting(false);
+        },
+        onCancel: () => setIsInterjecting(false)
+      }
+    ),
+    /* @__PURE__ */ jsxs5(Box6, { marginTop: 1, flexDirection: "column", children: [
+      updateVersion && /* @__PURE__ */ jsxs5(Text6, { color: theme.warning, children: [
         "v",
         updateVersion,
         " available \u2014 run: executant update"
       ] }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "press q to quit" })
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: isInterjecting ? "typing interjection\u2026" : "press q to quit  \xB7  i to interject" })
     ] }),
-    isRawModeSupported && /* @__PURE__ */ jsx5(KeyboardHandler, { onExit: exit })
+    isRawModeSupported && /* @__PURE__ */ jsx6(
+      KeyboardHandler,
+      {
+        onExit: exit,
+        onInterject: interjectChannel ? () => setIsInterjecting(true) : void 0,
+        isInterjecting
+      }
+    )
   ] });
 }
 
@@ -1921,10 +2003,216 @@ ${issues}`
   };
 }
 
+// src/refine.ts
+import { existsSync as existsSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { load as loadYaml, dump as dumpYaml2 } from "js-yaml";
+var PLAN_REFINE_PROMPT = loadPrompt("plan-refine");
+var PLAN_SYSTEM_RULES2 = loadPrompt("plan-system-rules");
+var PLAN_RETRY_PARSE_ERROR2 = loadPrompt("plan-retry-parse-error");
+var PLAN_RETRY_SCHEMA_ERROR2 = loadPrompt("plan-retry-schema-error");
+var PLAN_RETRY_JUDGE2 = loadPrompt("plan-retry-judge");
+var MAX_REFINE_RETRIES = 3;
+function parseRefineArgs(rawArgs2) {
+  if (rawArgs2[0] === "-h" || rawArgs2[0] === "--help") {
+    console.log(`Usage: executant refine <task-file> [OPTIONS] [INSTRUCTIONS]
+
+Refine an existing task YAML with natural language instructions.
+
+Options:
+  -f, --file <path>    Read instructions from file
+  -h, --help           Show this help message
+
+Examples:
+  executant refine tasks/todo/my-task.yaml "make it simpler"
+  executant refine tasks/todo/my-task.yaml -f instructions.txt
+  cat instructions.txt | executant refine tasks/todo/my-task.yaml`);
+    process.exit(0);
+  }
+  const taskFile = rawArgs2[0];
+  if (!taskFile) {
+    console.error("Error: No task file specified");
+    console.error("Usage: executant refine <task-file> [INSTRUCTIONS]");
+    process.exit(1);
+  }
+  if (!existsSync2(taskFile)) {
+    console.error(`Error: File not found: ${taskFile}`);
+    process.exit(1);
+  }
+  let existingYaml;
+  try {
+    existingYaml = readFileSync5(taskFile, "utf8").trim();
+  } catch {
+    console.error(`Error: Cannot read file: ${taskFile}`);
+    process.exit(1);
+  }
+  let description = "Refine workflow";
+  try {
+    const parsed = loadYaml(existingYaml);
+    if (typeof parsed?.goal === "string") description = parsed.goal;
+  } catch {
+  }
+  const remaining = rawArgs2.slice(1);
+  let instructions = "";
+  if (remaining[0] === "-f" || remaining[0] === "--file") {
+    const filePath2 = remaining[1];
+    if (!filePath2) {
+      console.error("Error: -f/--file requires a file path argument");
+      process.exit(1);
+    }
+    if (!existsSync2(filePath2)) {
+      console.error(`Error: File not found: ${filePath2}`);
+      process.exit(1);
+    }
+    try {
+      instructions = readFileSync5(filePath2, "utf8").trim();
+    } catch {
+      console.error(`Error: Cannot read file: ${filePath2}`);
+      process.exit(1);
+    }
+  } else if (remaining.length > 0) {
+    instructions = remaining.join(" ").trim();
+  } else if (!process.stdin.isTTY) {
+    try {
+      instructions = readFileSync5("/dev/stdin", "utf8").trim();
+    } catch {
+    }
+  }
+  if (!instructions) {
+    console.error("Error: No refinement instructions provided");
+    console.error("Usage: executant refine <task-file> [INSTRUCTIONS]");
+    console.error("       executant refine <task-file> -f <filepath>");
+    console.error("       cat instructions.txt | executant refine <task-file>");
+    process.exit(1);
+  }
+  return { taskFile, existingYaml, instructions, description };
+}
+async function* streamRefine(args) {
+  const { taskFile, existingYaml, instructions, description } = args;
+  yield { type: "plan:start", description };
+  yield { type: "plan:stages", names: ["Refine", "Validate"] };
+  yield { type: "plan:stage", stage: 1, total: 2, name: "Refine" };
+  let retryPrefix = "";
+  for (let attempt = 0; attempt < MAX_REFINE_RETRIES; attempt++) {
+    if (attempt > 0) {
+      yield {
+        type: "plan:retry",
+        attempt: attempt + 1,
+        maxAttempts: MAX_REFINE_RETRIES,
+        reason: retryPrefix.replace(/\n/g, " ")
+      };
+      yield { type: "plan:stage", stage: 1, total: 2, name: "Refine" };
+    }
+    const basePrompt = fillTemplate(PLAN_REFINE_PROMPT, {
+      DESCRIPTION: description,
+      EXISTING_YAML: existingYaml,
+      INSTRUCTIONS: instructions
+    });
+    const refineTask = {
+      type: "claude",
+      name: "plan:refine",
+      prompt: retryPrefix ? `${retryPrefix}
+
+${basePrompt}` : basePrompt,
+      allowedTools: [],
+      permissionMode: "bypassPermissions",
+      model: "sonnet",
+      appendSystemPrompt: `${METHODOLOGY}
+
+${PLAN_SYSTEM_RULES2}`,
+      jsonSchema: WORKFLOW_JSON_SCHEMA
+    };
+    let structuredOutput;
+    const textLines = [];
+    try {
+      for await (const event of runClaude(refineTask)) {
+        if (event.type === "output:tool") {
+          yield { type: "plan:tool", tool: event.tool, input: event.input };
+        } else if (event.type === "output:text") {
+          textLines.push(event.text);
+          yield { type: "plan:text", text: event.text };
+        } else if (event.type === "output:structured") {
+          structuredOutput = event.data;
+        }
+      }
+    } catch (err) {
+      const msg = getErrorMessage(err);
+      if (attempt === MAX_REFINE_RETRIES - 1) {
+        yield { type: "plan:error", message: msg };
+        return;
+      }
+      retryPrefix = fillTemplate(PLAN_RETRY_PARSE_ERROR2, {
+        ERROR: msg,
+        EXCERPT: textLines.join("\n")
+      });
+      continue;
+    }
+    if (structuredOutput === void 0) {
+      const issues = "No structured output returned \u2014 ensure the response is a JSON object";
+      if (attempt === MAX_REFINE_RETRIES - 1) {
+        yield { type: "plan:error", message: issues };
+        return;
+      }
+      retryPrefix = fillTemplate(PLAN_RETRY_SCHEMA_ERROR2, { ISSUES: issues });
+      continue;
+    }
+    const zodResult = WorkflowSchema.safeParse(structuredOutput);
+    if (!zodResult.success) {
+      const issues = formatZodIssues(zodResult.error.issues);
+      if (attempt === MAX_REFINE_RETRIES - 1) {
+        yield {
+          type: "plan:error",
+          message: `Refined plan did not match expected schema:
+${issues}`
+        };
+        return;
+      }
+      retryPrefix = fillTemplate(PLAN_RETRY_SCHEMA_ERROR2, { ISSUES: issues });
+      continue;
+    }
+    yield { type: "plan:stage", stage: 2, total: 2, 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_REFINE_RETRIES - 1) {
+      retryPrefix = fillTemplate(PLAN_RETRY_JUDGE2, {
+        FEEDBACK: judgeResult.feedback
+      });
+      continue;
+    }
+    if (!judgeResult.pass) {
+      yield {
+        type: "plan:warn",
+        message: `Judge rejected refinement but retries exhausted: ${judgeResult.feedback}`
+      };
+    }
+    const { goal, vars, steps, ...rest } = normalizeWorkflow(zodResult.data);
+    const ordered = { goal, ...vars && { vars }, steps, ...rest };
+    const yamlContent = dumpYaml2(ordered, {
+      lineWidth: -1,
+      noRefs: true,
+      quotingType: '"',
+      forceQuotes: false
+    }).trimEnd();
+    writeFileSync3(taskFile, yamlContent + "\n", "utf8");
+    const yamlLines = yamlContent.split("\n");
+    const preview = yamlLines.slice(0, 30).join("\n") + (yamlLines.length > 30 ? "\n..." : "");
+    yield { type: "plan:complete", taskFile, preview };
+    return;
+  }
+  yield {
+    type: "plan:error",
+    message: "Refine failed after maximum retries"
+  };
+}
+
 // src/ui/PlanApp.tsx
-import { useEffect as useEffect3, useReducer as useReducer2, useState as useState2 } from "react";
-import { Box as Box6, Text as Text6, useApp as useApp2, useStdin as useStdin2 } from "ink";
-import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+import { useEffect as useEffect3, useReducer as useReducer2, useState as useState3 } from "react";
+import { Box as Box7, Text as Text7, useApp as useApp2, useStdin as useStdin2 } from "ink";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 var truncate = (str, max) => str.length > max ? str.slice(0, max - 3) + "..." : str;
 function buildInitial(description) {
   return {
@@ -2000,7 +2288,7 @@ function StageProgress({ stage, totalStages, stageNames, tick, isActive, status
     }
     return { icon, color, name, bold, dim };
   });
-  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", marginBottom: 1, children: rows.map(({ icon, color, name, bold, dim }, i) => /* @__PURE__ */ jsx6(Box6, { children: /* @__PURE__ */ jsxs5(Text6, { color, dimColor: dim, bold, children: [
+  return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", marginBottom: 1, children: rows.map(({ icon, color, name, bold, dim }, i) => /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsxs6(Text7, { color, dimColor: dim, bold, children: [
     "  ",
     icon,
     name ? `  ${name}` : ""
@@ -2025,7 +2313,7 @@ function PlanApp({ description, events: events2 }) {
     };
   }, [events2, exit]);
   const { isRawModeSupported } = useStdin2();
-  const [tick, setTick] = useState2(0);
+  const [tick, setTick] = useState3(0);
   const isActive = state.status === "running" || state.status === "retrying";
   useInterval(() => {
     if (isActive) setTick((t) => t + 1);
@@ -2033,19 +2321,19 @@ function PlanApp({ description, events: events2 }) {
   const elapsed = formatHeaderElapsed(state.startTime);
   const icon = isActive ? SPINNER[tick % SPINNER.length] : state.status === "complete" ? "\u2713" : "\u2717";
   const iconColor = state.status === "complete" ? theme.success : state.status === "error" ? theme.error : theme.primary;
-  return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", padding: 1, children: [
-    /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsx6(BrandMark, { tick, isActive }) }),
-    /* @__PURE__ */ jsxs5(Box6, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsxs5(Text6, { color: iconColor, children: [
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsx7(BrandMark, { tick, isActive }) }),
+    /* @__PURE__ */ jsxs6(Box7, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs6(Text7, { color: iconColor, children: [
         icon,
         " "
       ] }),
-      /* @__PURE__ */ jsx6(Text6, { bold: true, color: theme.primary, children: "Generating plan" }),
-      /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, color: theme.primary, children: "Generating plan" }),
+      /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
         "  ",
         elapsed
       ] }),
-      state.status === "retrying" && /* @__PURE__ */ jsxs5(Text6, { color: theme.warning, children: [
+      state.status === "retrying" && /* @__PURE__ */ jsxs6(Text7, { color: theme.warning, children: [
         "  ",
         "(attempt ",
         state.attempt,
@@ -2054,11 +2342,11 @@ function PlanApp({ description, events: events2 }) {
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsxs5(Box6, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  " }),
-      /* @__PURE__ */ jsx6(Text6, { children: truncate(state.description, 80) })
+    /* @__PURE__ */ jsxs6(Box7, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "  " }),
+      /* @__PURE__ */ jsx7(Text7, { children: truncate(state.description, 80) })
     ] }),
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       StageProgress,
       {
         stage: state.stage,
@@ -2069,40 +2357,40 @@ function PlanApp({ description, events: events2 }) {
         status: state.status
       }
     ),
-    state.lines.length > 0 && /* @__PURE__ */ jsx6(LogPane, { lines: state.lines, isActive, maxLines: 10 }),
-    state.status === "complete" && state.taskFile && /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsxs5(Text6, { color: theme.success, children: [
+    state.lines.length > 0 && /* @__PURE__ */ jsx7(LogPane, { lines: state.lines, isActive, maxLines: 10 }),
+    state.status === "complete" && state.taskFile && /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs6(Text7, { color: theme.success, children: [
         "\u2705 Task plan saved: ",
         state.taskFile
       ] }),
-      state.preview && /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginTop: 1, children: [
-        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Preview:" }),
-        /* @__PURE__ */ jsx6(Text6, { children: state.preview })
+      state.preview && /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Preview:" }),
+        /* @__PURE__ */ jsx7(Text7, { children: state.preview })
       ] })
     ] }),
-    state.status === "error" && /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text6, { color: theme.error, children: [
+    state.status === "error" && /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs6(Text7, { color: theme.error, children: [
       "Error: ",
       state.errorMessage
     ] }) }),
-    isActive && /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "press q to quit" }) }),
-    isRawModeSupported && /* @__PURE__ */ jsx6(KeyboardHandler, { onExit: exit })
+    isActive && /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "press q to quit" }) }),
+    isRawModeSupported && /* @__PURE__ */ jsx7(KeyboardHandler, { onExit: exit })
   ] });
 }
 
 // src/logger.ts
 import {
   appendFileSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync3,
   readdirSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "node:fs";
 import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
 function findExecutantLocalDir(startDir) {
   let dir = resolve2(startDir);
   while (true) {
     const candidate = join3(dir, ".claude", "executant.local");
-    if (existsSync2(candidate)) return candidate;
+    if (existsSync3(candidate)) return candidate;
     const parent = dirname3(dir);
     if (parent === dir) return null;
     dir = parent;
@@ -2134,7 +2422,7 @@ 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(
+  writeFileSync4(
     logFile,
     `# Execution Log
 Task: ${ctx.slug}
@@ -2213,7 +2501,7 @@ function complexSequenceHeader(ctx, s) {
 }
 function createComplexSequenceFile(ctx, s) {
   const path = highlightPath(ctx, s.stepIndex, "complex_sequence");
-  writeFileSync3(path, complexSequenceHeader(ctx, s));
+  writeFileSync4(path, complexSequenceHeader(ctx, s));
   return path;
 }
 function onTool(ctx, s, tool, input) {
@@ -2231,7 +2519,7 @@ function onTool(ctx, s, tool, input) {
   return { ...s, toolCount, complexSequenceFile };
 }
 function saveJudgeHighlight(ctx, s, verdict, text) {
-  writeFileSync3(
+  writeFileSync4(
     highlightPath(ctx, s.stepIndex, `judge_${verdict}`),
     buildHighlightHeader(ctx, s, `Judge Verdict: ${verdict}`, [
       `**Attempt:** ${s.judgeAttempt}`
@@ -2252,7 +2540,7 @@ var LOG_MATCHERS = [
     pattern: /\[self-healing\].*failed.*exit\s+(\d+)/i,
     apply: (ctx, s, _text, match) => {
       const selfHealingFile = highlightPath(ctx, s.stepIndex, "self_healing");
-      writeFileSync3(
+      writeFileSync4(
         selfHealingFile,
         buildHighlightHeader(ctx, s, "Self-Healing Activation") + [
           "## \u274C Failure Detected",
@@ -2322,8 +2610,8 @@ ${"\u2501".repeat(51)}
 `
   );
   const indexFile = join3(ctx.highlightsDir, "README.md");
-  if (!existsSync2(indexFile)) {
-    writeFileSync3(
+  if (!existsSync3(indexFile)) {
+    writeFileSync4(
       indexFile,
       [
         "# Execution Highlights",
@@ -2418,11 +2706,11 @@ async function* withLogger(gen, logger2) {
 
 // src/retrospective.ts
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync5,
-  writeFileSync as writeFileSync4
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync5
 } from "node:fs";
 import { basename as basename2, dirname as dirname4, join as join4, resolve as resolve3 } from "node:path";
 import { spawnSync } from "node:child_process";
@@ -2449,7 +2737,7 @@ Self-improvement: retrospective failed: ${getErrorMessage(err)}`
   }
 }
 async function doRetrospective(workflowFilePath, workflow2, highlightsDir, runTimestamp) {
-  if (!existsSync3(highlightsDir)) {
+  if (!existsSync4(highlightsDir)) {
     console.log("\nSelf-improvement: no highlights directory found, skipping.");
     return;
   }
@@ -2486,12 +2774,12 @@ ${metrics}
 `);
   console.log("Analyzing execution and generating improvements...\n");
   const highlightContents = runHighlights.map((f) => {
-    const content = readFileSync5(join4(highlightsDir, f), "utf8");
+    const content = readFileSync6(join4(highlightsDir, f), "utf8");
     return `### ${f}
 
 ${content}`;
   }).join("\n\n---\n\n");
-  const originalYaml = readFileSync5(workflowFilePath, "utf8");
+  const originalYaml = readFileSync6(workflowFilePath, "utf8");
   const taskName = basename2(workflowFilePath, ".yaml");
   const prompt = fillTemplate(RETROSPECTIVE_PROMPT, {
     TASK_NAME: taskName,
@@ -2567,8 +2855,8 @@ Response: ${response.trim()}`
   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");
+  writeFileSync5(improvedFile, improvedYaml + "\n", "utf8");
+  writeFileSync5(changelogFile, changelog + "\n", "utf8");
   console.log(`\u2705 Improved task saved: ${improvedFile}`);
   console.log(`\u2705 Changelog saved: ${changelogFile}`);
   console.log(`
@@ -2586,9 +2874,36 @@ function extractJson(text) {
   return text.slice(start, end + 1);
 }
 
+// src/types.ts
+var InterjectChannel = class {
+  sender = null;
+  _queue = [];
+  /** Called by runClaude when a Claude step starts to activate direct delivery. */
+  register(sender) {
+    this.sender = sender;
+    for (const msg of this._queue) sender(msg);
+    this._queue = [];
+  }
+  /** Called by runClaude when a Claude step ends. */
+  unregister() {
+    this.sender = null;
+  }
+  /** Called by the TUI. Delivers immediately if a Claude step is running, else queues. */
+  interject(message) {
+    if (this.sender) this.sender(message);
+    else this._queue.push(message);
+  }
+  /** Drains and returns any queued messages (for non-Claude steps to consume). */
+  consumeQueue() {
+    const q = this._queue.slice();
+    this._queue = [];
+    return q;
+  }
+};
+
 // src/index.ts
 var CURRENT_VERSION = JSON.parse(
-  readFileSync6(
+  readFileSync7(
     join5(dirname5(fileURLToPath2(import.meta.url)), "../package.json"),
     "utf-8"
   )
@@ -2609,6 +2924,21 @@ if (rawArgs[0] === "plan") {
   }
   process.exit(0);
 }
+if (rawArgs[0] === "refine") {
+  const refineArgs = parseRefineArgs(rawArgs.slice(1));
+  const refineEvents = streamRefine(refineArgs);
+  const inkApp = render(
+    React3.createElement(PlanApp, {
+      description: refineArgs.description,
+      events: refineEvents
+    })
+  );
+  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);
@@ -2637,6 +2967,7 @@ Options:
 
 Commands:
   plan <description>    Generate a task YAML from a natural language description
+  refine <file> <inst>  Refine an existing task YAML with natural language instructions
   update                Upgrade executant to the latest version
 
 YAML \u2014 top-level fields:
@@ -2740,7 +3071,8 @@ try {
   process.exit(1);
 }
 var options = { stepFilter, fromStep };
-var rawEvents = runWorkflow(workflow, options);
+var channel = new InterjectChannel();
+var rawEvents = runWorkflow(workflow, options, channel);
 var logger = createLogger(resolveLogDir(filePath), workflow.goal);
 var events = withLogger(rawEvents, logger);
 var updateCheck = checkForUpdate(CURRENT_VERSION);
@@ -2780,7 +3112,13 @@ if (ciMode) {
   });
 } else {
   const inkApp = render(
-    React3.createElement(App, { workflow, events, options, updateCheck })
+    React3.createElement(App, {
+      workflow,
+      events,
+      options,
+      updateCheck,
+      interjectChannel: channel
+    })
   );
   if (workflow.selfImprove) {
     inkApp.waitUntilExit().then(() => maybeRunRetrospective(filePath, workflow, logger)).catch(() => {