executant 1.16.0 → 1.18.0

package/dist/index.js

@@ -268,6 +268,7 @@ function convertInnerStep(step, vars, name, continueOnError) {
         continueOnError,
         llmAsJudge: step.llm_as_judge,
         allowedTools: step.allowed_tools,
+        model: "sonnet",
         ...contextFiles.length > 0 && { contextFiles }
       };
     }
@@ -432,7 +433,7 @@ function resolveClaudePath() {
     );
   }
 }
-async function* runClaude(task, _channel) {
+async function* runClaude(task) {
   yield {
     type: "log",
     level: "info",
@@ -627,7 +628,7 @@ ${queued.join("\n")}
 ---
 ${expanded.prompt}`
       } : expanded;
-      yield* enriched.llmAsJudge ? runClaudeWithJudge(enriched, channel2) : runClaude(enriched, channel2);
+      yield* enriched.llmAsJudge ? runClaudeWithJudge(enriched) : runClaude(enriched);
       break;
     }
     case "forEach":
@@ -788,7 +789,8 @@ async function* runCommandWithHealing(task) {
         type: "claude",
         name: `${task.name}:heal-${attempt + 1}`,
         prompt: healPrompt,
-        allowedTools: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"]
+        allowedTools: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
+        model: "sonnet"
       };
       const toolCalls = [];
       const claudeLines = [];
@@ -811,14 +813,14 @@ async function* runCommandWithHealing(task) {
     }
   }
 }
-async function* runClaudeWithJudge(task, channel2) {
+async function* runClaudeWithJudge(task) {
   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 }, channel2), lines);
+    yield* collectLines(runClaude({ ...task, prompt }), lines);
     yield {
       type: "log",
       level: "info",
@@ -859,8 +861,9 @@ async function evaluateWithJudge(stepName, stepInstructions, output) {
       name: `judge:${stepName}`,
       prompt: buildJudgePrompt(stepName, stepInstructions, output),
       allowedTools: [],
-      permissionMode: "default"
+      permissionMode: "default",
       // judge only reads text — no tool access needed
+      model: "sonnet"
     },
     JudgeOutputSchema
   );
@@ -1012,18 +1015,18 @@ function formatToolCall2(tool, input) {
     case "Read":
     case "Edit":
     case "Write":
-      return `[${tool}] ${input["file_path"] ?? JSON.stringify(input)}`;
+    case "Glob":
+    case "Grep":
+      return `[${tool}] ${getToolArg(tool, 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"] ?? ""));
+        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 "";
@@ -1813,111 +1816,58 @@ function collapseSequentialSteps(steps) {
     { out: [], skip: 0 }
   ).out;
 }
-async function* streamPlan(args) {
-  const { description, taskFile } = args;
-  const skipResearch = args.fast || isSimpleRequest(description);
-  yield { type: "plan:start", description };
-  let researchDoc;
-  if (skipResearch) {
-    yield { type: "plan:stages", names: ["Decompose to Steps", "Validate"] };
-    researchDoc = "No codebase research performed \u2014 the task is self-contained. Work directly from the user's original goal.";
-  } else {
-    yield {
-      type: "plan:stages",
-      names: ["Research & Planning", "Decompose to Steps", "Validate"]
-    };
-    yield {
-      type: "plan:stage",
-      stage: 1,
-      total: TOTAL_PLAN_STAGES,
-      name: "Research & Planning"
-    };
-    const researchLines = [];
-    try {
-      const researchTask = {
-        type: "claude",
-        name: "plan:research",
-        prompt: fillTemplate(PLAN_RESEARCH_PROMPT, {
-          DESCRIPTION: description
-        }),
-        allowedTools: ["Read", "Glob", "Grep"],
-        permissionMode: "bypassPermissions",
-        model: "opus",
-        appendSystemPrompt: METHODOLOGY
-      };
-      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) {
-      yield {
-        type: "plan:error",
-        message: `Research pass failed: ${getErrorMessage(err)}`
-      };
-      return;
-    }
-    researchDoc = researchLines.join("\n");
-    if (!researchDoc.trim()) {
-      yield {
-        type: "plan:error",
-        message: "Research pass produced no output \u2014 cannot decompose"
-      };
-      return;
-    }
-  }
-  const stages = skipResearch ? { decompose: 1, validate: 2, total: 2 } : { decompose: 2, validate: 3, total: TOTAL_PLAN_STAGES };
-  yield {
-    type: "plan:stage",
-    stage: stages.decompose,
-    total: stages.total,
-    name: "Decompose to Steps"
-  };
+function writeWorkflowFile(taskFile, workflow2) {
+  const { goal, vars, steps, ...rest } = normalizeWorkflow(workflow2);
+  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 lines = yamlContent.split("\n");
+  return lines.slice(0, 30).join("\n") + (lines.length > 30 ? "\n..." : "");
+}
+async function* runRetryLoop(config) {
+  const {
+    maxRetries,
+    retryStageName,
+    retryStage,
+    retryTotal,
+    validateStage,
+    validateTotal,
+    schemaErrorLabel,
+    judgeRejectLabel,
+    description,
+    taskFile,
+    buildTask
+  } = config;
   let retryPrefix = "";
-  for (let attempt = 0; attempt < MAX_PLAN_RETRIES; attempt++) {
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
     if (attempt > 0) {
       yield {
         type: "plan:retry",
         attempt: attempt + 1,
-        maxAttempts: MAX_PLAN_RETRIES,
+        maxAttempts: maxRetries,
         reason: retryPrefix.replace(/\n/g, " ")
       };
       yield {
         type: "plan:stage",
-        stage: stages.decompose,
-        total: stages.total,
-        name: "Decompose to Steps"
+        stage: retryStage,
+        total: retryTotal,
+        name: retryStageName
       };
     }
-    const basePrompt = fillTemplate(PLAN_DECOMPOSE_PROMPT, {
-      DESCRIPTION: description,
-      RESEARCH_DOC: researchDoc
-    });
-    const decomposeTask = {
-      type: "claude",
-      name: "plan:decompose",
-      prompt: retryPrefix ? `${retryPrefix}
-
-${basePrompt}` : basePrompt,
-      allowedTools: [],
-      permissionMode: "bypassPermissions",
-      model: skipResearch ? "sonnet" : "opus",
-      appendSystemPrompt: `${METHODOLOGY}
-
-${PLAN_SYSTEM_RULES}`,
-      jsonSchema: WORKFLOW_JSON_SCHEMA
-    };
+    const task = buildTask(retryPrefix);
     let structuredOutput;
-    const decomposeTextLines = [];
+    const textLines = [];
     try {
-      for await (const event of runClaude(decomposeTask)) {
+      for await (const event of runClaude(task)) {
         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);
+          textLines.push(event.text);
           yield { type: "plan:text", text: event.text };
         } else if (event.type === "output:structured") {
           structuredOutput = event.data;
@@ -1925,19 +1875,19 @@ ${PLAN_SYSTEM_RULES}`,
       }
     } catch (err) {
       const msg = getErrorMessage(err);
-      if (attempt === MAX_PLAN_RETRIES - 1) {
+      if (attempt === maxRetries - 1) {
         yield { type: "plan:error", message: msg };
         return;
       }
       retryPrefix = fillTemplate(PLAN_RETRY_PARSE_ERROR, {
         ERROR: msg,
-        EXCERPT: decomposeTextLines.join("\n")
+        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_PLAN_RETRIES - 1) {
+      if (attempt === maxRetries - 1) {
         yield { type: "plan:error", message: issues };
         return;
       }
@@ -1947,10 +1897,10 @@ ${PLAN_SYSTEM_RULES}`,
     const zodResult = WorkflowSchema.safeParse(structuredOutput);
     if (!zodResult.success) {
       const issues = formatZodIssues(zodResult.error.issues);
-      if (attempt === MAX_PLAN_RETRIES - 1) {
+      if (attempt === maxRetries - 1) {
         yield {
           type: "plan:error",
-          message: `Plan did not match expected schema:
+          message: `${schemaErrorLabel} did not match expected schema:
 ${issues}`
         };
         return;
@@ -1960,8 +1910,8 @@ ${issues}`
     }
     yield {
       type: "plan:stage",
-      stage: stages.validate,
-      total: stages.total,
+      stage: validateStage,
+      total: validateTotal,
       name: "Validate"
     };
     const judgeResult = await runPass3Judge(description, zodResult.data);
@@ -1971,7 +1921,7 @@ ${issues}`
         message: "Judge skipped due to error \u2014 proceeding without validation"
       };
     }
-    if (!judgeResult.pass && attempt < MAX_PLAN_RETRIES - 1) {
+    if (!judgeResult.pass && attempt < maxRetries - 1) {
       retryPrefix = fillTemplate(PLAN_RETRY_JUDGE, {
         FEEDBACK: judgeResult.feedback
       });
@@ -1980,37 +1930,120 @@ ${issues}`
     if (!judgeResult.pass) {
       yield {
         type: "plan:warn",
-        message: `Judge rejected plan but retries exhausted: ${judgeResult.feedback}`
+        message: `Judge rejected ${judgeRejectLabel} but retries exhausted: ${judgeResult.feedback}`
       };
     }
-    const { goal, vars, steps, ...rest } = normalizeWorkflow(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 yamlLines = yamlContent.split("\n");
-    const preview = yamlLines.slice(0, 30).join("\n") + (yamlLines.length > 30 ? "\n..." : "");
+    const preview = writeWorkflowFile(taskFile, zodResult.data);
     yield { type: "plan:complete", taskFile, preview };
     return;
   }
   yield {
     type: "plan:error",
-    message: "Plan generation failed after maximum retries"
+    message: `${schemaErrorLabel} generation failed after maximum retries`
+  };
+}
+async function* streamPlan(args) {
+  const { description, taskFile } = args;
+  const skipResearch = args.fast || isSimpleRequest(description);
+  yield { type: "plan:start", description };
+  let researchDoc;
+  if (skipResearch) {
+    yield { type: "plan:stages", names: ["Decompose to Steps", "Validate"] };
+    researchDoc = "No codebase research performed \u2014 the task is self-contained. Work directly from the user's original goal.";
+  } else {
+    yield {
+      type: "plan:stages",
+      names: ["Research & Planning", "Decompose to Steps", "Validate"]
+    };
+    yield {
+      type: "plan:stage",
+      stage: 1,
+      total: TOTAL_PLAN_STAGES,
+      name: "Research & Planning"
+    };
+    const researchLines = [];
+    try {
+      const researchTask = {
+        type: "claude",
+        name: "plan:research",
+        prompt: fillTemplate(PLAN_RESEARCH_PROMPT, {
+          DESCRIPTION: description
+        }),
+        allowedTools: ["Read", "Glob", "Grep"],
+        permissionMode: "bypassPermissions",
+        model: "opus",
+        appendSystemPrompt: METHODOLOGY
+      };
+      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) {
+      yield {
+        type: "plan:error",
+        message: `Research pass failed: ${getErrorMessage(err)}`
+      };
+      return;
+    }
+    researchDoc = researchLines.join("\n");
+    if (!researchDoc.trim()) {
+      yield {
+        type: "plan:error",
+        message: "Research pass produced no output \u2014 cannot decompose"
+      };
+      return;
+    }
+  }
+  const stages = skipResearch ? { decompose: 1, validate: 2, total: 2 } : { decompose: 2, validate: 3, total: TOTAL_PLAN_STAGES };
+  yield {
+    type: "plan:stage",
+    stage: stages.decompose,
+    total: stages.total,
+    name: "Decompose to Steps"
   };
+  yield* runRetryLoop({
+    maxRetries: MAX_PLAN_RETRIES,
+    retryStageName: "Decompose to Steps",
+    retryStage: stages.decompose,
+    retryTotal: stages.total,
+    validateStage: stages.validate,
+    validateTotal: stages.total,
+    schemaErrorLabel: "Plan",
+    judgeRejectLabel: "plan",
+    description,
+    taskFile,
+    buildTask: (retryPrefix) => {
+      const basePrompt = fillTemplate(PLAN_DECOMPOSE_PROMPT, {
+        DESCRIPTION: description,
+        RESEARCH_DOC: researchDoc
+      });
+      return {
+        type: "claude",
+        name: "plan:decompose",
+        prompt: retryPrefix ? `${retryPrefix}
+
+${basePrompt}` : basePrompt,
+        allowedTools: [],
+        permissionMode: "bypassPermissions",
+        model: skipResearch ? "sonnet" : "opus",
+        appendSystemPrompt: `${METHODOLOGY}
+
+${PLAN_SYSTEM_RULES}`,
+        jsonSchema: WORKFLOW_JSON_SCHEMA
+      };
+    }
+  });
 }
 
 // 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";
+import { existsSync as existsSync2, readFileSync as readFileSync5 } from "node:fs";
+import { load as loadYaml } 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") {
@@ -2091,122 +2124,39 @@ async function* streamRefine(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}
+  yield* runRetryLoop({
+    maxRetries: MAX_REFINE_RETRIES,
+    retryStageName: "Refine",
+    retryStage: 1,
+    retryTotal: 2,
+    validateStage: 2,
+    validateTotal: 2,
+    schemaErrorLabel: "Refined plan",
+    judgeRejectLabel: "refinement",
+    description,
+    taskFile,
+    buildTask: (retryPrefix) => {
+      const basePrompt = fillTemplate(PLAN_REFINE_PROMPT, {
+        DESCRIPTION: description,
+        EXISTING_YAML: existingYaml,
+        INSTRUCTIONS: instructions
+      });
+      return {
+        type: "claude",
+        name: "plan:refine",
+        prompt: retryPrefix ? `${retryPrefix}
 
 ${basePrompt}` : basePrompt,
-      allowedTools: [],
-      permissionMode: "bypassPermissions",
-      model: "sonnet",
-      appendSystemPrompt: `${METHODOLOGY}
+        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}`
+        jsonSchema: WORKFLOW_JSON_SCHEMA
       };
     }
-    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
@@ -2383,7 +2333,7 @@ import {
   existsSync as existsSync3,
   mkdirSync as mkdirSync3,
   readdirSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync3
 } from "node:fs";
 import { dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
 function findExecutantLocalDir(startDir) {
@@ -2422,7 +2372,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`);
-  writeFileSync4(
+  writeFileSync3(
     logFile,
     `# Execution Log
 Task: ${ctx.slug}
@@ -2501,7 +2451,7 @@ function complexSequenceHeader(ctx, s) {
 }
 function createComplexSequenceFile(ctx, s) {
   const path = highlightPath(ctx, s.stepIndex, "complex_sequence");
-  writeFileSync4(path, complexSequenceHeader(ctx, s));
+  writeFileSync3(path, complexSequenceHeader(ctx, s));
   return path;
 }
 function onTool(ctx, s, tool, input) {
@@ -2519,7 +2469,7 @@ function onTool(ctx, s, tool, input) {
   return { ...s, toolCount, complexSequenceFile };
 }
 function saveJudgeHighlight(ctx, s, verdict, text) {
-  writeFileSync4(
+  writeFileSync3(
     highlightPath(ctx, s.stepIndex, `judge_${verdict}`),
     buildHighlightHeader(ctx, s, `Judge Verdict: ${verdict}`, [
       `**Attempt:** ${s.judgeAttempt}`
@@ -2540,7 +2490,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");
-      writeFileSync4(
+      writeFileSync3(
         selfHealingFile,
         buildHighlightHeader(ctx, s, "Self-Healing Activation") + [
           "## \u274C Failure Detected",
@@ -2611,7 +2561,7 @@ ${"\u2501".repeat(51)}
   );
   const indexFile = join3(ctx.highlightsDir, "README.md");
   if (!existsSync3(indexFile)) {
-    writeFileSync4(
+    writeFileSync3(
       indexFile,
       [
         "# Execution Highlights",
@@ -2710,7 +2660,7 @@ import {
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync2,
   readFileSync as readFileSync6,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync4
 } 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";
@@ -2855,8 +2805,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`);
-  writeFileSync5(improvedFile, improvedYaml + "\n", "utf8");
-  writeFileSync5(changelogFile, changelog + "\n", "utf8");
+  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(`
@@ -2876,22 +2826,10 @@ function extractJson(text) {
 
 // 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. */
+  /** Called by the TUI when the user submits an interjection message. */
   interject(message) {
-    if (this.sender) this.sender(message);
-    else this._queue.push(message);
+    this._queue.push(message);
   }
   /** Drains and returns any queued messages (for non-Claude steps to consume). */
   consumeQueue() {

package/package.json

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