executant 1.13.0 → 1.15.0

package/README.md

@@ -121,6 +121,20 @@ steps:
 - **`self_healing: true`** — on script failure, Claude diagnoses and repairs the command, then re-runs it, up to 5×
 - **`self_improve: true`** — after the workflow finishes, Claude analyzes execution highlights and saves an improved YAML to `tasks/backlog/`
 
+## Interjection
+
+While a workflow is running, press **`i`** to open a text input at the bottom of the TUI. Type a correction and press **Enter** to send it; **Esc** cancels.
+
+The message is queued and prepended to the **next Claude step's prompt** as `[User correction from a previous step]`. Claude sees your note before it starts and incorporates it into its work. If you interject while a script step is running, the correction waits for the next Claude step in the workflow.
+
+```
+press i  →  ▷ don't delete that file, use git revert▌  esc to cancel
+```
+
+**What it's good for:** steering the next Claude step while watching the current one run — leaving a note for the step that's about to start.
+
+**What it can't do:** interrupt a Claude step mid-execution. The Claude CLI processes each invocation as a complete unit; there's no mechanism to inject a message partway through. To abort a runaway step immediately, press `q`.
+
 ## Examples
 
 | File | Demonstrates |

package/dist/index.js

@@ -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"];
@@ -1162,6 +1215,12 @@ var STATUS_COLOR = {
 function statusIcon(status, tick) {
   return status === "running" ? SPINNER[tick % SPINNER.length] : STATUS_ICON[status] ?? "\xB7";
 }
+function countIterationRows(iterationHistory, maxVisible) {
+  if (!iterationHistory?.length) return 0;
+  if (iterationHistory.every((r) => r.item === String(r.iteration))) return 0;
+  const visible = Math.min(iterationHistory.length, maxVisible);
+  return visible + (iterationHistory.length > maxVisible ? 1 : 0);
+}
 var EXIT_DELAY_MS = 300;
 function formatHeaderElapsed(start, end) {
   const ms = (end ?? Date.now()) - start;
@@ -1176,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);
@@ -1184,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
     ] })
@@ -1209,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: [
@@ -1233,7 +1292,7 @@ function IterationRow({ record, tick }) {
         ]
       }
     ),
-    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
       "  ",
       elapsed
     ] })
@@ -1255,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,
@@ -1289,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
   ] });
@@ -1354,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;
@@ -1368,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 () => {
@@ -1405,20 +1471,34 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
   }, [events2, exit]);
   const { isRawModeSupported } = useStdin();
   const { stdout } = useStdout();
-  const terminalRows = stdout?.rows ?? 24;
-  const FIXED_OVERHEAD = 12;
-  const logPaneMaxLines = Math.max(
-    5,
-    terminalRows - FIXED_OVERHEAD - state.tasks.length
-  );
-  const [tick, setTick] = useState(0);
-  useInterval(() => {
-    if (!state.endTime) setTick((t) => t + 1);
-  }, 100);
-  const [updateVersion, setUpdateVersion] = useState(null);
+  const [updateVersion, setUpdateVersion] = useState2(null);
   useEffect2(() => {
     updateCheck2.then(setUpdateVersion);
   }, [updateCheck2]);
+  const [tick, setTick] = useState2(0);
+  useInterval(() => {
+    if (!state.endTime) setTick((t) => t + 1);
+  }, 100);
+  const terminalRows = stdout?.rows ?? 24;
+  const LOG_PANE_MIN = 5;
+  const runningTask = state.tasks.find((t) => t.status === "running");
+  const iterationRowCount = countIterationRows(
+    runningTask?.iterationHistory,
+    MAX_VISIBLE_ITERATIONS
+  );
+  const FIXED_OVERHEAD = 12 + (updateVersion ? 1 : 0) + (isInterjecting ? 1 : 0);
+  const availableForTaskSection = Math.max(
+    1,
+    terminalRows - FIXED_OVERHEAD - LOG_PANE_MIN - iterationRowCount
+  );
+  const visibleTaskCount = state.tasks.length > availableForTaskSection ? availableForTaskSection - 1 : state.tasks.length;
+  const taskSlice = state.tasks.slice(-visibleTaskCount);
+  const hiddenTaskCount = state.tasks.length - taskSlice.length;
+  const taskRowsUsed = visibleTaskCount + (hiddenTaskCount > 0 ? 1 : 0);
+  const logPaneMaxLines = Math.max(
+    LOG_PANE_MIN,
+    terminalRows - FIXED_OVERHEAD - taskRowsUsed - iterationRowCount
+  );
   const elapsed = formatHeaderElapsed(state.startTime, state.endTime);
   const activeTask = state.tasks[state.currentIndex];
   const completedCount = state.tasks.filter(
@@ -1426,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,
         "/",
@@ -1440,26 +1520,37 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
         filterInfo
       ] })
     ] }),
-    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", marginBottom: 1, children: state.tasks.map((taskState, i) => /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx5(
-        TaskRow,
-        {
-          index: i,
-          tick,
-          taskState,
-          isActive: i === state.currentIndex
-        }
-      ),
-      taskState.status === "running" && taskState.iterationHistory?.length ? /* @__PURE__ */ jsx5(
-        IterationList,
-        {
-          iterationHistory: taskState.iterationHistory,
-          tick,
-          maxVisible: MAX_VISIBLE_ITERATIONS
-        }
-      ) : null
-    ] }, i)) }),
-    activeTask && /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", marginBottom: 1, children: [
+      hiddenTaskCount > 0 && /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
+        "  ",
+        "\xB7\xB7\xB7 ",
+        hiddenTaskCount,
+        " earlier"
+      ] }),
+      taskSlice.map((taskState, i) => {
+        const globalIndex = hiddenTaskCount + i;
+        return /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx6(
+            TaskRow,
+            {
+              index: globalIndex,
+              tick,
+              taskState,
+              isActive: globalIndex === state.currentIndex
+            }
+          ),
+          taskState.status === "running" && taskState.iterationHistory?.length ? /* @__PURE__ */ jsx6(
+            IterationList,
+            {
+              iterationHistory: taskState.iterationHistory,
+              tick,
+              maxVisible: MAX_VISIBLE_ITERATIONS
+            }
+          ) : null
+        ] }, globalIndex);
+      })
+    ] }),
+    activeTask && /* @__PURE__ */ jsx6(
       LogPane,
       {
         lines: activeTask.lines,
@@ -1467,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
+      }
+    )
   ] });
 }
 
@@ -1891,9 +2004,9 @@ ${issues}`
 }
 
 // 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 {
@@ -1969,7 +2082,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}` : ""
@@ -1994,7 +2107,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);
@@ -2002,19 +2115,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,
@@ -2023,11 +2136,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,
@@ -2038,23 +2151,23 @@ 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 })
   ] });
 }
 
@@ -2555,6 +2668,33 @@ 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(
@@ -2709,7 +2849,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);
@@ -2749,7 +2890,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(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "executant",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "Harness for YAML-defined workflows that enables stepping through Claude sessions and bash commands",
   "repository": {
     "type": "git",