executant 1.0.0 → 1.4.1

package/README.md

@@ -1,6 +1,11 @@
-# executant
+<img width="1774" height="887" alt="e58fdd14-77a1-4207-99c2-fb8603e3f625" src="https://github.com/user-attachments/assets/8d57a6ee-0fd3-43c9-bdff-1538fe931337" />
 
-Harness for YAML-defined workflows that enables stepping through Claude sessions and bash commands. Define the steps, the quality criteria, and how failures recover -> Executant runs them.
+# Executant
+
+Harness for YAML-defined workflows that enables stepping through Claude sessions and bash commands.
+
+## Advisory
+Built for personal use by Coston. Public for sharing the approach. Use at your own risk. 
 
 ## Install
 
@@ -42,6 +47,13 @@ executant plan "convert all CoffeeScript files to TypeScript and run tests"
 
 Generates a workflow YAML in your project's task directory using a three-pass Claude pipeline (research → decompose → validate). Also accepts `-f file` or stdin.
 
+For self-contained requests (repetition patterns, forEach loops, or anything that doesn't need codebase exploration), the research pass is skipped automatically — going straight to decompose + validate. Use `-q` / `--fast` to force-skip research for any request:
+
+```bash
+executant plan -q "repeat the following prompt 20 times: review src/ for issues"
+executant plan --fast "for each file in the list, run the linter"
+```
+
 ## Context & Variables
 
 Use `vars` to define shared values substituted as `{{var_name}}` in any prompt or command. Pair with `context` to inject file contents directly into a prompt at runtime, and `output` to pipe a script step's stdout into a file for downstream steps to read.
@@ -75,6 +87,16 @@ steps:
     command: npx eslint src/{{item}}
 ```
 
+Use `repeat: N` as shorthand when there is no meaningful list — just a count. `{{item}}` is the 1-based iteration number:
+
+```yaml
+steps:
+  - name: iterative audit
+    repeat: 5
+    prompt: |
+      This is pass {{item}} of 5. Review src/runner.ts for untested edge cases.
+```
+
 ## Quality Controls
 
 - **`llm_as_judge: true`** — after a step completes, Claude evaluates the output; retries with feedback on FAIL, up to 5×
@@ -92,30 +114,18 @@ steps:
 | `judge-demo.yaml` | LLM-as-judge retry loop |
 | `logging-demo.yaml` | Log steps, self-healing, judge |
 | `git-status-summary.yaml` | Real-world git workflow |
+| `repeat-demo.yaml` | Running a step N times with `repeat` |
 
 See the [`examples/`](examples/) directory.
 
 ## CLI
 
 ```bash
-executant plan "description"          # generate a workflow YAML
+executant plan "description"          # generate a workflow YAML (auto-detects fast path)
+executant plan -q "description"       # skip research pass (fast path)
 executant workflow.yaml               # run a workflow
 executant --ci workflow.yaml          # headless, NDJSON to stdout
 executant --step <name|n> wf.yaml     # run one step by name or index
 executant --from-step <n> wf.yaml     # resume from step n
 executant update                      # upgrade to latest version
 ```
-
-## Development
-
-```bash
-git clone https://github.com/coston/executant
-cd executant
-npm install
-npm run dev examples/hello-world.yaml   # run without building
-npm test                                 # run unit tests
-```
-
-## License
-
-MIT

package/dist/index.js

@@ -14,34 +14,21 @@ var update_exports = {};
 __export(update_exports, {
   checkForUpdate: () => checkForUpdate,
   compareSemver: () => compareSemver,
-  doUpdate: () => doUpdate,
-  parseVersionsFromGitOutput: () => parseVersionsFromGitOutput
+  doUpdate: () => doUpdate
 });
 import { exec as exec2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 async function checkForUpdate(currentVersion) {
   try {
-    const { stdout } = await execPromise2(
-      "git ls-remote --tags https://github.com/coston/executant.git",
-      { timeout: 5e3 }
-    );
-    const versions = parseVersionsFromGitOutput(stdout);
-    const latest = versions.sort(compareSemver).at(-1);
+    const { stdout } = await execPromise2("npm view executant version", { timeout: 5e3 });
+    const latest = stdout.trim();
     return latest && isNewer(latest, currentVersion) ? latest : null;
   } catch {
     return null;
   }
 }
 async function doUpdate() {
-  await execPromise2("npm install -g github:coston/executant");
-}
-function parseVersionsFromGitOutput(stdout) {
-  const versions = [];
-  for (const line of stdout.split("\n")) {
-    const m = line.match(/refs\/tags\/v?(\d+\.\d+\.\d+)$/);
-    if (m) versions.push(m[1]);
-  }
-  return versions;
+  await execPromise2("npm install -g executant");
 }
 function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
@@ -65,9 +52,9 @@ var init_update = __esm({
 // src/index.ts
 import React3 from "react";
 import { render } from "ink";
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 import { dirname as dirname5, join as join5 } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/load-workflow.ts
 import { readFileSync } from "node:fs";
@@ -86,6 +73,7 @@ var RawStepSchema = z.object({
   llm_as_judge: z.boolean().optional(),
   allowed_tools: z.array(z.string()).optional(),
   forEach: z.union([z.array(z.string()), z.string()]).optional(),
+  repeat: z.number().int().positive().optional(),
   context: z.array(z.string()).optional()
 });
 var RawWorkflowSchema = z.object({
@@ -121,6 +109,20 @@ ${detail}`);
 function convertStep(step, vars) {
   const name = step.name;
   const continueOnError = step.continue_on_error ?? false;
+  if (step.repeat !== void 0 && step.forEach !== void 0) {
+    throw new Error(`Step "${name}" cannot have both repeat and forEach`);
+  }
+  if (step.repeat !== void 0) {
+    const items = Array.from({ length: step.repeat }, (_2, i) => String(i + 1));
+    const { repeat: _, ...innerStep } = step;
+    return {
+      type: "forEach",
+      name,
+      continueOnError,
+      forEach: items,
+      inner: convertInnerStep(innerStep, vars, name, continueOnError)
+    };
+  }
   if (step.forEach !== void 0) {
     const { forEach: _, ...innerStep } = step;
     return {
@@ -209,9 +211,8 @@ function substituteVars(text, vars, stepName, field) {
 
 // src/runner.ts
 import { exec } from "node:child_process";
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdirSync, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
 import { promisify } from "node:util";
 import { z as z2 } from "zod";
 
@@ -306,6 +307,16 @@ import { execSync, spawn as spawn2 } from "node:child_process";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
 // src/lib/utils.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var PROMPTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "prompts");
+function stripPromptHeader(raw) {
+  return raw.replace(/^(#[^\n]*\n)+\n?/, "").trim();
+}
+function loadPrompt(name) {
+  return stripPromptHeader(readFileSync2(join(PROMPTS_DIR, `${name}.txt`), "utf8"));
+}
 function findOutermostBraces(text) {
   const start = text.indexOf("{");
   if (start === -1) return null;
@@ -468,7 +479,6 @@ async function runClaudeStructured(task, schema) {
 }
 
 // src/runner.ts
-var PROMPTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "prompts");
 var JUDGE_RETRY_CONTEXT = loadPrompt("judge-retry-context");
 var SELF_HEALING_PROMPT = loadPrompt("self-healing-fix");
 var JUDGE_EVALUATION_PROMPT = loadPrompt("judge-evaluation");
@@ -535,7 +545,7 @@ async function* runStep(task) {
       if (task.output) {
         const lines = [];
         yield* collectLines(gen, lines);
-        mkdirSync(dirname(task.output), { recursive: true });
+        mkdirSync(dirname2(task.output), { recursive: true });
         writeFileSync(task.output, lines.join("\n"), "utf8");
       } else {
         yield* gen;
@@ -691,7 +701,7 @@ async function* collectLines(gen, lines) {
 }
 function readContextFile(filePath2) {
   try {
-    return readFileSync2(filePath2, "utf8");
+    return readFileSync3(filePath2, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new Error(`Context file "${filePath2}" could not be read: ${msg}`);
@@ -707,10 +717,6 @@ ${readContextFile(fp)}
 
 ${task.prompt}` };
 }
-function loadPrompt(name) {
-  const raw = readFileSync2(join(PROMPTS_DIR, `${name}.txt`), "utf8");
-  return raw.replace(/^(#[^\n]*\n)+\n?/, "");
-}
 function buildHealingPrompt(command, exitCode, output, attemptHistory) {
   return SELF_HEALING_PROMPT.replaceAll("{{COMMAND}}", command).replaceAll("{{EXIT_CODE}}", String(exitCode)).replaceAll("{{OUTPUT}}", output).replaceAll("{{ATTEMPT_HISTORY}}", attemptHistory);
 }
@@ -1136,20 +1142,18 @@ function App({ workflow: workflow2, events: events2, options: options2, updateCh
 }
 
 // src/plan.ts
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join2, resolve } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2, resolve } from "node:path";
 import { dump as dumpYaml } from "js-yaml";
 import { z as z3 } from "zod";
 import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
-var PROMPTS_DIR2 = join2(dirname2(fileURLToPath2(import.meta.url)), "prompts");
-var PLAN_RESEARCH_PROMPT = readFileSync3(join2(PROMPTS_DIR2, "plan-research.txt"), "utf8");
-var PLAN_DECOMPOSE_PROMPT = readFileSync3(join2(PROMPTS_DIR2, "plan-decompose.txt"), "utf8");
-var PLAN_JUDGE_PROMPT = readFileSync3(join2(PROMPTS_DIR2, "plan-judge.txt"), "utf8");
-var PLAN_SYSTEM_RULES = readFileSync3(join2(PROMPTS_DIR2, "plan-system-rules.txt"), "utf8").trim();
-var PLAN_RETRY_PARSE_ERROR = readFileSync3(join2(PROMPTS_DIR2, "plan-retry-parse-error.txt"), "utf8").trim();
-var PLAN_RETRY_SCHEMA_ERROR = readFileSync3(join2(PROMPTS_DIR2, "plan-retry-schema-error.txt"), "utf8").trim();
-var PLAN_RETRY_JUDGE = readFileSync3(join2(PROMPTS_DIR2, "plan-retry-judge.txt"), "utf8").trim();
+var PLAN_RESEARCH_PROMPT = loadPrompt("plan-research");
+var PLAN_DECOMPOSE_PROMPT = loadPrompt("plan-decompose");
+var PLAN_JUDGE_PROMPT = loadPrompt("plan-judge");
+var PLAN_SYSTEM_RULES = loadPrompt("plan-system-rules");
+var PLAN_RETRY_PARSE_ERROR = loadPrompt("plan-retry-parse-error");
+var PLAN_RETRY_SCHEMA_ERROR = loadPrompt("plan-retry-schema-error");
+var PLAN_RETRY_JUDGE = loadPrompt("plan-retry-judge");
 var MAX_PLAN_RETRIES = 3;
 var TOTAL_PLAN_STAGES = 3;
 var StepSchema = z3.object({
@@ -1197,15 +1201,29 @@ function findProjectRoot(startDir) {
     return existsSync(candidate) ? candidate : null;
   });
 }
+function isSimpleRequest(description) {
+  if (/\b\d+\s+(times|iterations?|passes)\b/i.test(description)) return true;
+  if (/\bfor\s+each\b/i.test(description)) return true;
+  return false;
+}
 function parsePlanArgs(rawArgs2) {
   let description = "";
-  if (rawArgs2[0] === "-h" || rawArgs2[0] === "--help") {
+  let fast = false;
+  const args = rawArgs2.filter((a) => {
+    if (a === "-q" || a === "--fast") {
+      fast = true;
+      return false;
+    }
+    return true;
+  });
+  if (args[0] === "-h" || args[0] === "--help") {
     console.log(`Usage: executant plan [OPTIONS] [DESCRIPTION]
 
 Generate a task plan from a description.
 
 Options:
   -f, --file <path>    Read prompt from file
+  -q, --fast           Skip codebase research (auto-detected for simple tasks)
   -h, --help           Show this help message
 
 Examples:
@@ -1214,8 +1232,8 @@ Examples:
   cat prompt.txt | executant plan`);
     process.exit(0);
   }
-  if (rawArgs2[0] === "-f" || rawArgs2[0] === "--file") {
-    const filePath2 = rawArgs2[1];
+  if (args[0] === "-f" || args[0] === "--file") {
+    const filePath2 = args[1];
     if (!filePath2) {
       console.error("Error: -f/--file requires a file path argument");
       process.exit(1);
@@ -1225,16 +1243,16 @@ Examples:
       process.exit(1);
     }
     try {
-      description = readFileSync3(filePath2, "utf8").trim();
+      description = readFileSync4(filePath2, "utf8").trim();
     } catch {
       console.error(`Error: Cannot read file: ${filePath2}`);
       process.exit(1);
     }
-  } else if (rawArgs2.length > 0) {
-    description = rawArgs2.join(" ").trim();
+  } else if (args.length > 0) {
+    description = args.join(" ").trim();
   } else if (!process.stdin.isTTY) {
     try {
-      description = readFileSync3("/dev/stdin", "utf8").trim();
+      description = readFileSync4("/dev/stdin", "utf8").trim();
     } catch {
     }
   }
@@ -1256,7 +1274,7 @@ Examples:
   const slug = slugify(description);
   const ts = timestamp();
   const taskFile = join2(todoDir, `${ts}-${slug}.yaml`);
-  return { description, taskFile, todoDir };
+  return { description, taskFile, todoDir, fast };
 }
 async function runPass3Judge(description, workflow2) {
   try {
@@ -1275,38 +1293,48 @@ async function runPass3Judge(description, workflow2) {
 }
 async function* streamPlan(args) {
   const { description, taskFile } = args;
+  const skipResearch = args.fast || isSimpleRequest(description);
   yield { type: "plan:start", description };
-  yield { type: "plan:stages", names: ["Research & Planning", "Decompose to Steps", "Validate"] };
-  yield { type: "plan:stage", stage: 1, total: TOTAL_PLAN_STAGES, name: "Research & Planning" };
-  const researchLines = [];
-  try {
-    const researchTask = {
-      type: "claude",
-      name: "plan:research",
-      prompt: PLAN_RESEARCH_PROMPT.replace("{{DESCRIPTION}}", description),
-      allowedTools: ["Read", "Glob", "Grep"],
-      permissionMode: "bypassPermissions",
-      model: "opus"
-    };
-    for await (const event of runClaude(researchTask)) {
-      if (event.type === "output:tool") {
-        yield { type: "plan:tool", tool: event.tool, input: event.input };
-      } else if (event.type === "output:text") {
-        researchLines.push(event.text);
-        yield { type: "plan:text", text: event.text };
+  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: PLAN_RESEARCH_PROMPT.replace("{{DESCRIPTION}}", description),
+        allowedTools: ["Read", "Glob", "Grep"],
+        permissionMode: "bypassPermissions",
+        model: "opus"
+      };
+      for await (const event of runClaude(researchTask)) {
+        if (event.type === "output:tool") {
+          yield { type: "plan:tool", tool: event.tool, input: event.input };
+        } else if (event.type === "output:text") {
+          researchLines.push(event.text);
+          yield { type: "plan:text", text: event.text };
+        }
       }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      yield { type: "plan:error", message: `Research pass failed: ${msg}` };
+      return;
+    }
+    researchDoc = researchLines.join("\n");
+    if (!researchDoc.trim()) {
+      yield { type: "plan:error", message: "Research pass produced no output \u2014 cannot decompose" };
+      return;
     }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    yield { type: "plan:error", message: `Research pass failed: ${msg}` };
-    return;
-  }
-  const researchDoc = researchLines.join("\n");
-  if (!researchDoc.trim()) {
-    yield { type: "plan:error", message: "Research pass produced no output \u2014 cannot decompose" };
-    return;
   }
-  yield { type: "plan:stage", stage: 2, total: TOTAL_PLAN_STAGES, name: "Decompose to Steps" };
+  const decomposeStage = skipResearch ? 1 : 2;
+  const validateStage = skipResearch ? 2 : 3;
+  const totalStages = skipResearch ? 2 : TOTAL_PLAN_STAGES;
+  yield { type: "plan:stage", stage: decomposeStage, total: totalStages, name: "Decompose to Steps" };
   let retryPrefix = "";
   for (let attempt = 0; attempt < MAX_PLAN_RETRIES; attempt++) {
     if (attempt > 0) {
@@ -1316,7 +1344,7 @@ async function* streamPlan(args) {
         maxAttempts: MAX_PLAN_RETRIES,
         reason: retryPrefix.replace(/\n/g, " ")
       };
-      yield { type: "plan:stage", stage: 2, total: TOTAL_PLAN_STAGES, name: "Decompose to Steps" };
+      yield { type: "plan:stage", stage: decomposeStage, total: totalStages, name: "Decompose to Steps" };
     }
     const basePrompt = PLAN_DECOMPOSE_PROMPT.replace("{{DESCRIPTION}}", description).replace("{{RESEARCH_DOC}}", researchDoc);
     const decomposeTask = {
@@ -1373,7 +1401,7 @@ ${issues}` };
       retryPrefix = PLAN_RETRY_SCHEMA_ERROR.replace("{{ISSUES}}", issues);
       continue;
     }
-    yield { type: "plan:stage", stage: 3, total: TOTAL_PLAN_STAGES, name: "Validate" };
+    yield { type: "plan:stage", stage: validateStage, total: totalStages, 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" };
@@ -1941,9 +1969,9 @@ async function* withLogger(gen, logger2) {
 }
 
 // src/retrospective.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { basename, dirname as dirname4, join as join4, resolve as resolve3 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { spawnSync } from "node:child_process";
 import { load as parseYaml2 } from "js-yaml";
 import { z as z4 } from "zod";
@@ -1951,8 +1979,8 @@ var RetrospectiveOutputSchema = z4.object({
   improved_yaml: z4.string(),
   changelog: z4.string()
 });
-var PROMPTS_DIR3 = join4(dirname4(fileURLToPath3(import.meta.url)), "prompts");
-var RETROSPECTIVE_PROMPT = readFileSync4(join4(PROMPTS_DIR3, "retrospective-analysis.txt"), "utf8");
+var PROMPTS_DIR2 = join4(dirname4(fileURLToPath2(import.meta.url)), "prompts");
+var RETROSPECTIVE_PROMPT = readFileSync5(join4(PROMPTS_DIR2, "retrospective-analysis.txt"), "utf8");
 async function runRetrospective(workflowFilePath, workflow2, highlightsDir, runTimestamp) {
   try {
     await doRetrospective(workflowFilePath, workflow2, highlightsDir, runTimestamp);
@@ -1996,12 +2024,12 @@ ${metrics}
 `);
   console.log("Analyzing execution and generating improvements...\n");
   const highlightContents = runHighlights.map((f) => {
-    const content = readFileSync4(join4(highlightsDir, f), "utf8");
+    const content = readFileSync5(join4(highlightsDir, f), "utf8");
     return `### ${f}
 
 ${content}`;
   }).join("\n\n---\n\n");
-  const originalYaml = readFileSync4(workflowFilePath, "utf8");
+  const originalYaml = readFileSync5(workflowFilePath, "utf8");
   const taskName = basename(workflowFilePath, ".yaml");
   const prompt = RETROSPECTIVE_PROMPT.replaceAll("{{TASK_NAME}}", taskName).replaceAll("{{ORIGINAL_GOAL}}", workflow2.goal).replaceAll("{{ORIGINAL_YAML}}", originalYaml).replaceAll("{{HIGHLIGHTS}}", highlightContents).replaceAll("{{METRICS}}", metrics);
   const result = spawnSync(
@@ -2078,7 +2106,7 @@ function extractJson(text) {
 
 // src/index.ts
 var CURRENT_VERSION = JSON.parse(
-  readFileSync5(join5(dirname5(fileURLToPath4(import.meta.url)), "../package.json"), "utf-8")
+  readFileSync6(join5(dirname5(fileURLToPath3(import.meta.url)), "../package.json"), "utf-8")
 ).version;
 var rawArgs = process.argv.slice(2);
 if (rawArgs[0] === "plan") {

package/dist/prompts/plan-decompose.txt

@@ -51,6 +51,11 @@ Complete structure with all available options:
       "name": "foreach_prompt_step",
       "forEach": "git diff --name-only HEAD~1",
       "prompt": "Review {{item}} for issues and suggest improvements."
+    },
+    {
+      "name": "repeated_audit",
+      "repeat": 20,
+      "prompt": "Review the codebase for issues. This is pass {{item}} of 20."
     }
   ]
 }
@@ -63,6 +68,7 @@ Optional step fields (can be combined):
 - `continue_on_error: true` — Allow failures without stopping (script steps only)
 - `output: "var_name"` — Capture script step stdout to the file path named by this var
 - `context: ["var_name"]` — Inject file contents into a prompt step (prepended before the prompt text)
+- `repeat: N` — Run this step N times sequentially (mutually exclusive with forEach). {{item}} is the 1-based iteration number.
 
 **Variable substitution**: Use `{{var_name}}` in any `prompt` or `command` to insert the variable's value.
 
@@ -114,6 +120,12 @@ If yes, extract it to `vars` and replace with `{{var_name}}`.
 
 **REQUIRED: Always use `forEach` instead of enumerating items inline in a prompt.**
 
+**Use `repeat: N` when:**
+- The user asks to run the same prompt or command multiple times ("do this 20 times", "repeat 5 times", "run N iterations")
+- The step is identical each time — only the iteration number ({{item}}) differs
+- Prefer `repeat` over `forEach` when there is no meaningful list of items — just a count
+- NEVER expand "do X N times" into N separate steps — always use `repeat: N`
+
 ## Atomicity (MANDATORY)
 
 Each step must do ONE focused thing. If a step description contains "and" — split it.

package/dist/prompts/plan-research.txt

@@ -10,14 +10,14 @@
 #   {{DESCRIPTION}} - The user's natural language task description
 # ============================================================================
 
-You are a senior engineer performing codebase research to plan a task. Your output is a
-structured markdown document — NOT JSON. Explore freely, think carefully, and produce a
-thorough plan that a decomposition pass can convert to executable workflow steps.
+Research the codebase and produce a structured markdown execution plan — NOT JSON.
+Explore freely, think carefully, and produce a thorough plan that a decomposition
+pass can convert to executable workflow steps.
 
 ## Your Mission
 
-Research the codebase and produce an execution plan document for the task described at the
-bottom of this prompt. Use Read, Glob, and Grep to understand the project before planning.
+Use Read, Glob, and Grep to understand the project, then produce an execution plan
+document for the task described at the bottom of this prompt.
 
 ## Research Process
 
@@ -26,6 +26,9 @@ bottom of this prompt. Use Read, Glob, and Grep to understand the project before
 3. **Plan the approach** — Order the work logically, identify dependencies between steps
 4. **Find verification commands** — Locate lint, test, and build commands in package.json,
    Makefile, pyproject.toml, or similar config files
+5. **Detect repetition intent** — If the task description says "do X N times", "repeat N times",
+   "run N iterations", or similar, note this explicitly in the Step Breakdown section so Pass 2
+   emits a `repeat: N` step rather than N separate steps.
 
 ## Required Output Sections
 
@@ -75,6 +78,7 @@ Anything the step decomposer needs to know:
 - Environment dependencies or assumptions
 - Cross-step data flow (does one step's output feed the next?)
 - Steps that are safe to skip if they fail (`continue_on_error`)
+- Repetition intent: if the description uses "N times" or "N iterations", flag it here so the decomposer uses `repeat: N`
 
 ---
 

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "executant",
-  "version": "1.0.0",
-  "description": "TypeScript TUI workflow runner",
+  "version": "1.4.1",
+  "description": "Harness for YAML-defined workflows that enables stepping through Claude sessions and bash commands",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/coston/executant"
+  },
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "executant": "./dist/index.js"
+    "executant": "dist/index.js"
   },
   "files": [
     "dist"
   ],
   "scripts": {
+    "prepare": "husky",
     "bundle": "esbuild src/index.ts --bundle --platform=node --format=esm --packages=external --outfile=dist/index.js && rm -rf dist/prompts && cp -r src/prompts dist/prompts",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
@@ -30,7 +35,6 @@
     "@commitlint/cli": "^20.5.0",
     "@commitlint/config-conventional": "^20.5.0",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/npm": "^13.1.5",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.14.0",
     "@types/react": "^18.3.3",
@@ -53,16 +57,13 @@
     "*.{ts,tsx}": "eslint --fix"
   },
   "release": {
-    "branches": [
-      "main"
-    ],
     "plugins": [
       "@semantic-release/commit-analyzer",
       "@semantic-release/release-notes-generator",
       [
         "@semantic-release/npm",
         {
-          "npmPublish": true
+          "npmPublish": false
         }
       ],
       [