@towles/tool 0.0.61 → 0.0.63

package/src/lib/auto-claude/prompt-templates/03_simplify.prompt.md

@@ -0,0 +1,52 @@
+You are a code simplification agent. Review the changes on this branch and simplify the implementation.
+
+The issue is in @{{ISSUE_DIR}}/initial-ramblings.md — for context only.
+The completed summary is in @{{ISSUE_DIR}}/completed-summary.md.
+The code lives primarily at `{{SCOPE_PATH}}/`.
+The base branch is `{{MAIN_BRANCH}}`.
+
+## How to work
+
+1. Run `git diff {{MAIN_BRANCH}}...HEAD --stat` to see all changed files
+2. Run `git diff {{MAIN_BRANCH}}...HEAD` to review the full diff
+3. For each changed file, read the complete file (not just the diff) to understand the full context
+
+## What to simplify
+
+- **Dead code** — remove unused variables, imports, functions, or parameters added by the implementation
+- **Over-abstraction** — inline single-use helpers, remove unnecessary wrapper functions, flatten needless indirection
+- **Complexity** — simplify conditionals, reduce nesting, prefer early returns
+- **Duplication** — extract repeated patterns into shared helpers (only when genuinely duplicated, not merely similar)
+- **Naming** — rename unclear variables or functions for better readability
+- **Type safety** — remove unnecessary type assertions, tighten `any` types
+
+## What NOT to change
+
+- Do not alter behavior — every simplification must be behavior-preserving
+- Do not refactor code outside the scope of this branch's changes
+- Do not add new features or fix unrelated bugs
+- Do not remove code that is used elsewhere but appears unused in the diff
+
+## Verification
+
+After each round of simplifications:
+
+1. Run the project's type-check command — fix any errors
+2. Run the project's test command — fix any regressions
+3. Run the project's lint command — fix any violations
+
+Commit simplifications as `refactor(scope): code-simplify review for issue #N` (use the actual issue number from the issue directory name).
+
+## Output
+
+Write @{{ISSUE_DIR}}/simplify-summary.md with:
+
+- List of simplifications made (file path + what changed)
+- If no simplifications were needed, state that explicitly
+- Verification results (all checks pass / any issues encountered)
+
+## Guidelines
+
+- Prefer fewer, well-justified changes over many trivial ones
+- If the implementation is already clean, say so — don't force changes
+- Follow the project's coding conventions from CLAUDE.md

package/src/lib/auto-claude/prompt-templates/{06_review.prompt.md → 04_review.prompt.md}

@@ -1,4 +1,4 @@
-You are reviewing code changes for the issue in @{{ISSUE_DIR}}/initial-ramblings.md. The plan is in @{{ISSUE_DIR}}/plan.md and checklist in @{{ISSUE_DIR}}/plan-implementation.md.
+You are reviewing code changes for the issue in @{{ISSUE_DIR}}/initial-ramblings.md. The plan is in @{{ISSUE_DIR}}/plan.md.
 
 ## Automated checks
 
@@ -18,15 +18,38 @@ Run `git diff {{MAIN_BRANCH}}...HEAD` and check:
 8. **Incomplete work** — TODOs, placeholders, unfinished implementations?
 9. **Test coverage** — new behaviors covered by tests? Existing tests updated?
 
-After review, run the code-simplify skill on changed files. Apply simplifications that improve clarity without changing behavior — commit separately.
-
 Fix issues directly, commit as `fix(scope): review fixes for issue #N`.
 
 ## Write @{{ISSUE_DIR}}/review.md
 
-- **Status**: PASS, PASS WITH FIXES, or FAIL
-  - FAIL = fundamentally broken (wrong approach, missing core functionality, unfixable regressions). Explain what's wrong.
-- **Issues found** — what was wrong and what you fixed
+**CRITICAL**: The first line of review.md must be exactly `PASS` or `FAIL` (no markdown, no prefix, just the word). This is machine-parsed.
+
+Format:
+
+```
+PASS
+```
+
+or
+
+```
+FAIL
+```
+
+Followed by:
+
+- **Issues found** — what was wrong and what you fixed (if any)
 - **Confidence level** — high/medium/low
 - **Notes** — anything the PR reviewer should check
 - **Recommended follow-ups** — only if genuinely valuable. Omit if nothing worth flagging.
+
+### When to PASS vs FAIL
+
+- **PASS** — implementation is correct, tests pass, code quality is acceptable. Minor fixes you made during review are fine.
+- **FAIL** — fundamentally broken: wrong approach, missing core functionality, unfixable regressions, or critical bugs you cannot fix in review. Explain what's wrong and what the implementer should change. Your feedback will be passed back to the implement step for a retry.
+
+## Guidelines
+
+- Follow the project's coding conventions from CLAUDE.md
+- Be thorough but pragmatic — don't fail for style nits
+- If you fix issues during review, that's a PASS (with fixes noted), not a FAIL

package/src/lib/auto-claude/prompt-templates/index.test.ts

@@ -10,15 +10,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 describe("TEMPLATES", () => {
   it("should have all expected keys", () => {
-    expect(Object.keys(TEMPLATES)).toEqual([
-      "research",
-      "plan",
-      "planAnnotations",
-      "planImplementation",
-      "implement",
-      "review",
-      "refresh",
-    ]);
+    expect(Object.keys(TEMPLATES)).toEqual(["plan", "implement", "simplify", "review"]);
   });
 
   it("every template file should exist on disk", () => {
@@ -43,8 +35,8 @@ describe("TEMPLATES", () => {
 });
 
 describe("PIPELINE_STEPS", () => {
-  it("should have 8 steps", () => {
-    expect(PIPELINE_STEPS).toHaveLength(8);
+  it("should have 4 steps", () => {
+    expect(PIPELINE_STEPS).toHaveLength(4);
   });
 
   it("each step should have order, name, and label", () => {
@@ -65,16 +57,7 @@ describe("PIPELINE_STEPS", () => {
   });
 
   it("names should match expected pipeline order", () => {
-    expect(PIPELINE_STEPS.map((s) => s.name)).toEqual([
-      "research",
-      "plan",
-      "plan-annotations",
-      "plan-implementation",
-      "implement",
-      "review",
-      "create-pr",
-      "remove-label",
-    ]);
+    expect(PIPELINE_STEPS.map((s) => s.name)).toEqual(["plan", "implement", "simplify", "review"]);
   });
 
   it("labels should include the order number", () => {
@@ -92,25 +75,12 @@ describe("STEP_NAMES", () => {
 });
 
 describe("STEP_LABELS", () => {
-  it("should have camelCase keys for all pipeline steps plus refresh", () => {
-    expect(Object.keys(STEP_LABELS)).toEqual([
-      "research",
-      "plan",
-      "planAnnotations",
-      "planImplementation",
-      "implement",
-      "review",
-      "createPr",
-      "removeLabel",
-      "refresh",
-    ]);
+  it("should have keys matching step names", () => {
+    expect(Object.keys(STEP_LABELS)).toEqual(["plan", "implement", "simplify", "review"]);
   });
 
-  it("pipeline labels should have numeric prefixes", () => {
-    const pipelineLabels = { ...STEP_LABELS };
-    delete pipelineLabels.refresh;
-
-    for (const label of Object.values(pipelineLabels)) {
+  it("labels should have numeric prefixes", () => {
+    for (const label of Object.values(STEP_LABELS)) {
       expect(label).toMatch(/^\d{2}-/);
     }
   });
@@ -127,12 +97,9 @@ describe("ARTIFACTS", () => {
   it("should have all expected keys", () => {
     expect(Object.keys(ARTIFACTS)).toEqual([
       "initialRamblings",
-      "research",
       "plan",
-      "planAnnotations",
-      "planAnnotationsAddressed",
-      "planImplementation",
       "completedSummary",
+      "simplifySummary",
       "review",
       "prUrl",
     ]);

package/src/lib/auto-claude/prompt-templates/index.ts

@@ -1,45 +1,30 @@
 export const TEMPLATES = {
-  research: "01_research.prompt.md",
-  plan: "02_plan.prompt.md",
-  planAnnotations: "03_plan-annotations.prompt.md",
-  planImplementation: "04_plan-implementation.prompt.md",
-  implement: "05_implement.prompt.md",
-  review: "06_review.prompt.md",
-  refresh: "07_refresh.prompt.md",
+  plan: "01_plan.prompt.md",
+  implement: "02_implement.prompt.md",
+  simplify: "03_simplify.prompt.md",
+  review: "04_review.prompt.md",
 } as const;
 
 export const PIPELINE_STEPS = [
-  { order: 1, name: "research", label: "01-Research" },
-  { order: 2, name: "plan", label: "02-Plan" },
-  { order: 3, name: "plan-annotations", label: "03-Plan-Annotations" },
-  { order: 4, name: "plan-implementation", label: "04-Plan-Implementation" },
-  { order: 5, name: "implement", label: "05-Implement" },
-  { order: 6, name: "review", label: "06-Review" },
-  { order: 7, name: "create-pr", label: "07-Create PR" },
-  { order: 8, name: "remove-label", label: "08-Remove Label" },
+  { order: 1, name: "plan", label: "01-Plan" },
+  { order: 2, name: "implement", label: "02-Implement" },
+  { order: 3, name: "simplify", label: "03-Simplify" },
+  { order: 4, name: "review", label: "04-Review" },
 ] as const;
 
 export type StepName = (typeof PIPELINE_STEPS)[number]["name"];
 export const STEP_NAMES = PIPELINE_STEPS.map((s) => s.name);
 
-function toCamelCase(s: string): string {
-  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
-
-/** Keyed lookup for step labels (includes standalone "refresh" step) */
-export const STEP_LABELS = {
-  ...Object.fromEntries(PIPELINE_STEPS.map((s) => [toCamelCase(s.name), s.label])),
-  refresh: "Refresh",
-} as Record<string, string>;
+/** Keyed lookup for step labels */
+export const STEP_LABELS = Object.fromEntries(
+  PIPELINE_STEPS.map((s) => [s.name, s.label]),
+) as Record<string, string>;
 
 export const ARTIFACTS = {
   initialRamblings: "initial-ramblings.md",
-  research: "research.md",
   plan: "plan.md",
-  planAnnotations: "plan-annotations.md",
-  planAnnotationsAddressed: "plan-annotations-addressed.md",
-  planImplementation: "plan-implementation.md",
   completedSummary: "completed-summary.md",
+  simplifySummary: "simplify-summary.md",
   review: "review.md",
   prUrl: "pr-url.txt",
 } as const;

package/src/lib/auto-claude/run-claude.test.ts

@@ -43,11 +43,10 @@ describe("runClaude (mocked spawn-claude)", () => {
 
     await initConfig({ repo: "test/repo", mainBranch: "main" });
 
-    const { runClaude } = await import("./utils");
+    const { runClaude } = await import("./claude-cli");
 
     const result = await runClaude({
       promptFile: "test-prompt.md",
-      permissionMode: "plan",
       maxTurns: 10,
     });
 
@@ -62,8 +61,8 @@ describe("runClaude (mocked spawn-claude)", () => {
         "--output-format",
         "stream-json",
         "--verbose",
-        "--permission-mode",
-        "plan",
+        "--include-partial-messages",
+        "--dangerously-skip-permissions",
         "--max-turns",
         "10",
         "@test-prompt.md",
@@ -71,85 +70,66 @@ describe("runClaude (mocked spawn-claude)", () => {
     );
   });
 
-  it("returns fallback when no result event in stream", async () => {
+  it("logs tool names from stream_event and shows thinking indicator", async () => {
+    const infoSpy = vi.spyOn(consola, "info");
+
+    const thinkingEvent = {
+      type: "stream_event",
+      event: {
+        type: "content_block_start",
+        content_block: { type: "thinking" },
+      },
+    };
+    const toolEvent = {
+      type: "stream_event",
+      event: {
+        type: "content_block_start",
+        content_block: { type: "tool_use", name: "Edit" },
+      },
+    };
+    const resultEvent = {
+      result: "Done",
+      is_error: false,
+      total_cost_usd: 0.01,
+      num_turns: 1,
+    };
+
     mockSpawnImpl = () => ({
-      stdout: '{"type":"system","message":"starting"}',
+      stdout: [thinkingEvent, toolEvent, resultEvent].map((e) => JSON.stringify(e)).join("\n"),
       exitCode: 0,
     });
 
     await initConfig({ repo: "test/repo", mainBranch: "main" });
 
-    const { runClaude } = await import("./utils");
+    const { runClaude } = await import("./claude-cli");
+    const result = await runClaude({ promptFile: "test.md" });
 
-    const result = await runClaude({
-      promptFile: "test.md",
-      permissionMode: "acceptEdits",
-    });
+    expect(result.result).toBe("Done");
+    expect(result.num_turns).toBe(1);
 
-    expect(result.result).toBe("");
-    expect(result.is_error).toBe(false);
-    expect(result.total_cost_usd).toBe(0);
-  });
+    const infoCalls = infoSpy.mock.calls.map((c) => String(c[0]));
+    expect(infoCalls.some((msg) => msg.includes("thinking"))).toBe(true);
+    expect(infoCalls.some((msg) => msg.includes("Edit"))).toBe(true);
 
-  it("retries on failure when retry is enabled", async () => {
-    let callCount = 0;
-    mockSpawnImpl = () => {
-      callCount++;
-      if (callCount < 3) {
-        return { stdout: "", exitCode: 1 };
-      }
-      return {
-        stdout: JSON.stringify({
-          result: "ok",
-          is_error: false,
-          total_cost_usd: 0,
-          num_turns: 1,
-        }),
-        exitCode: 0,
-      };
-    };
+    infoSpy.mockRestore();
+  });
 
-    await initConfig({
-      repo: "test/repo",
-      mainBranch: "main",
-      loopRetryEnabled: true,
-      maxRetries: 5,
-      retryDelayMs: 1,
-      maxRetryDelayMs: 5,
+  it("returns fallback when no result event in stream", async () => {
+    mockSpawnImpl = () => ({
+      stdout: '{"type":"system","message":"starting"}',
+      exitCode: 0,
     });
 
-    const { runClaude } = await import("./utils");
+    await initConfig({ repo: "test/repo", mainBranch: "main" });
+
+    const { runClaude } = await import("./claude-cli");
 
     const result = await runClaude({
       promptFile: "test.md",
-      permissionMode: "plan",
-      retry: true,
-    });
-
-    expect(result.result).toBe("ok");
-    expect(callCount).toBe(3);
-  }, 10_000);
-
-  it("throws after max retries exhausted", async () => {
-    mockSpawnImpl = () => ({ stdout: "", exitCode: 1 });
-
-    await initConfig({
-      repo: "test/repo",
-      mainBranch: "main",
-      loopRetryEnabled: true,
-      maxRetries: 2,
-      retryDelayMs: 1,
-      maxRetryDelayMs: 5,
     });
 
-    const { runClaude } = await import("./utils");
-
-    await expect(
-      runClaude({
-        promptFile: "test.md",
-        permissionMode: "plan",
-        retry: true,
-      }),
-    ).rejects.toThrow("Claude failed after 2 retries");
-  }, 10_000);
+    expect(result.result).toBe("");
+    expect(result.is_error).toBe(false);
+    expect(result.total_cost_usd).toBe(0);
+  });
 });

package/src/lib/auto-claude/shell.ts

@@ -0,0 +1,6 @@
+export { execSafe, git } from "../../utils/git/exec.js";
+export { gh, ghRaw } from "../../utils/git/gh-cli-wrapper.js";
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/lib/auto-claude/steps/create-pr.ts

@@ -2,21 +2,23 @@ import { join } from "node:path";
 
 import consola from "consola";
 
+import { fileExists, readFile, writeFile } from "../../../utils/fs.js";
+import { execSafe, git } from "../../../utils/git/exec.js";
+import { ghRaw } from "../../../utils/git/gh-cli-wrapper.js";
 import { getConfig } from "../config.js";
-import { ARTIFACTS, STEP_LABELS } from "../prompt-templates/index.js";
-import { fileExists, ghRaw, git, log, logStep, readFile, writeFile } from "../utils.js";
+import { ARTIFACTS } from "../prompt-templates/index.js";
+import { log } from "../utils.js";
 import type { IssueContext } from "../utils.js";
 
-export async function stepCreatePR(ctx: IssueContext): Promise<boolean> {
+export async function createPr(ctx: IssueContext): Promise<string> {
   const cfg = getConfig();
 
-  if (await hasOpenPR(ctx.branch)) {
-    logStep(STEP_LABELS.createPr, ctx, true);
-    return true;
+  const existingUrl = await getExistingPrUrl(ctx.branch);
+  if (existingUrl) {
+    log(`PR already exists: ${existingUrl}`);
+    return existingUrl;
   }
 
-  logStep(STEP_LABELS.createPr, ctx);
-
   await git(["push", "-u", cfg.remote, ctx.branch]);
 
   const reviewPath = join(ctx.issueDir, ARTIFACTS.review);
@@ -33,9 +35,9 @@ export async function stepCreatePR(ctx: IssueContext): Promise<boolean> {
     "",
     "## Pipeline Artifacts",
     "",
-    `- Research: \`.auto-claude/issue-${ctx.number}/research.md\``,
     `- Plan: \`.auto-claude/issue-${ctx.number}/plan.md\``,
-    `- Implementation Plan: \`.auto-claude/issue-${ctx.number}/plan-implementation.md\``,
+    `- Implementation: \`.auto-claude/issue-${ctx.number}/completed-summary.md\``,
+    `- Simplify: \`.auto-claude/issue-${ctx.number}/simplify-summary.md\``,
     `- Review: \`.auto-claude/issue-${ctx.number}/review.md\``,
     "",
     "## Review Summary",
@@ -57,23 +59,84 @@ export async function stepCreatePR(ctx: IssueContext): Promise<boolean> {
     ctx.title,
     "--body",
     body,
-    "--label",
-    cfg.triggerLabel,
   ]);
 
-  if (prUrl) {
-    const url = prUrl.trim();
-    writeFile(join(ctx.issueDir, ARTIFACTS.prUrl), url);
-    log(`PR created: ${url}`);
-  } else {
-    consola.error("Failed to create PR");
-    return false;
+  if (!prUrl) {
+    throw new Error("Failed to create PR — gh returned empty output");
+  }
+
+  writeFile(join(ctx.issueDir, ARTIFACTS.prUrl), prUrl);
+  log(`PR created: ${prUrl}`);
+
+  try {
+    await attachArtifacts(ctx, prUrl);
+  } catch (e) {
+    consola.warn(`Artifact upload failed (non-blocking): ${e}`);
+  }
+
+  return prUrl;
+}
+
+async function attachArtifacts(ctx: IssueContext, prUrl: string): Promise<void> {
+  const archivePath = join(ctx.issueDir, "artifacts.tar.gz");
+  const tag = `ac-issue-${ctx.number}`;
+  const cfg = getConfig();
+
+  log("Archiving pipeline artifacts…");
+  await execSafe("tar", [
+    "czf",
+    archivePath,
+    "-C",
+    ctx.issueDir,
+    "--exclude=*.prompt.md",
+    "--exclude=artifacts.tar.gz",
+    ".",
+  ]);
+
+  log("Uploading artifacts to GitHub release…");
+  await ghRaw(["release", "delete", tag, "--yes", "--repo", cfg.repo]);
+
+  await ghRaw([
+    "release",
+    "create",
+    tag,
+    "--prerelease",
+    "--title",
+    `Artifacts: #${ctx.number}`,
+    "--repo",
+    cfg.repo,
+    archivePath,
+  ]);
+
+  const assetUrl = await ghRaw([
+    "release",
+    "view",
+    tag,
+    "--json",
+    "assets",
+    "--jq",
+    ".assets[0].url",
+    "--repo",
+    cfg.repo,
+  ]);
+
+  if (!assetUrl) {
+    consola.warn("Could not get artifact download URL — skipping PR comment");
+    return;
   }
 
-  return true;
+  const comment = [
+    "## Pipeline Artifacts",
+    "",
+    `[Download artifacts (tar.gz)](${assetUrl})`,
+    "",
+    "Contains: plan.md, completed-summary.md, simplify-summary.md, review.md",
+  ].join("\n");
+
+  await ghRaw(["pr", "comment", prUrl, "--body", comment]);
 }
 
-async function hasOpenPR(branch: string): Promise<boolean> {
+async function getExistingPrUrl(branch: string): Promise<string | null> {
   const out = await ghRaw([
     "pr",
     "list",
@@ -84,12 +147,13 @@ async function hasOpenPR(branch: string): Promise<boolean> {
     "--state",
     "open",
     "--json",
-    "number",
+    "url",
   ]);
   try {
-    const prs = JSON.parse(out);
-    return Array.isArray(prs) && prs.length > 0;
+    const prs = JSON.parse(out) as Array<{ url: string }>;
+    return prs.length > 0 ? prs[0].url : null;
   } catch {
-    return false;
+    consola.debug(`Failed to parse PR list JSON for branch "${branch}"`);
+    return null;
   }
 }

package/src/lib/auto-claude/steps/fetch-issues.ts

@@ -1,5 +1,7 @@
+import consola from "consola";
 import { getConfig } from "../config.js";
-import { buildIssueContext, gh, log } from "../utils.js";
+import { gh } from "../../../utils/git/gh-cli-wrapper.js";
+import { buildIssueContext, log } from "../utils.js";
 import type { IssueContext } from "../utils.js";
 
 interface GhIssue {
@@ -59,6 +61,7 @@ export async function fetchIssue(issueNumber: number): Promise<IssueContext | un
     ]);
     return buildIssueContext(issue, cfg.repo, cfg.scopePath);
   } catch {
+    consola.debug(`Could not fetch issue #${issueNumber} from ${cfg.repo}`);
     return undefined;
   }
 }

package/src/lib/auto-claude/steps/implement.ts

@@ -4,16 +4,11 @@ import consola from "consola";
 
 import { getConfig } from "../config.js";
 import { ARTIFACTS, STEP_LABELS, TEMPLATES } from "../prompt-templates/index.js";
-import {
-  buildTokens,
-  commitArtifacts,
-  fileExists,
-  git,
-  log,
-  logStep,
-  resolveTemplate,
-  runClaude,
-} from "../utils.js";
+import { fileExists, readFile } from "../../../utils/fs.js";
+import { git } from "../../../utils/git/exec.js";
+import { runClaude } from "../claude-cli.js";
+import { resolveTemplate } from "../templates.js";
+import { buildTokens, log, logStep } from "../utils.js";
 import type { IssueContext } from "../utils.js";
 
 export async function stepImplement(ctx: IssueContext): Promise<boolean> {
@@ -29,15 +24,17 @@ export async function stepImplement(ctx: IssueContext): Promise<boolean> {
 
   await git(["checkout", ctx.branch]);
 
+  const reviewPath = join(ctx.issueDir, ARTIFACTS.review);
+  const reviewFeedback = fileExists(reviewPath) ? readFile(reviewPath) : "";
+
   for (let i = 1; i <= maxIterations; i++) {
     log(`Implementation iteration ${i}/${maxIterations}`);
 
-    const tokens = buildTokens(ctx);
+    const tokens = buildTokens(ctx, { REVIEW_FEEDBACK: reviewFeedback });
     const promptFile = resolveTemplate(TEMPLATES.implement, tokens, ctx.issueDir);
 
     const result = await runClaude({
       promptFile,
-      permissionMode: "acceptEdits",
       maxTurns: getConfig().maxTurns,
     });
 
@@ -48,10 +45,6 @@ export async function stepImplement(ctx: IssueContext): Promise<boolean> {
 
     if (fileExists(completedPath)) {
       log(`Implementation complete after ${i} iteration(s)`);
-      await commitArtifacts(
-        ctx,
-        `chore(auto-claude): implementation complete for ${ctx.repo}#${ctx.number}`,
-      );
       return true;
     }
 

package/src/lib/auto-claude/steps/simple-steps.ts

@@ -0,0 +1,34 @@
+import { join } from "node:path";
+
+import { ARTIFACTS, STEP_LABELS, TEMPLATES } from "../prompt-templates/index.js";
+import { ensureBranch, runStepWithArtifact } from "../utils.js";
+import type { IssueContext } from "../utils.js";
+
+export async function stepPlan(ctx: IssueContext): Promise<boolean> {
+  await ensureBranch(ctx.branch);
+
+  return runStepWithArtifact({
+    stepName: STEP_LABELS.plan,
+    ctx,
+    artifactPath: join(ctx.issueDir, ARTIFACTS.plan),
+    templateName: TEMPLATES.plan,
+  });
+}
+
+export async function stepSimplify(ctx: IssueContext): Promise<boolean> {
+  return runStepWithArtifact({
+    stepName: STEP_LABELS.simplify,
+    ctx,
+    artifactPath: join(ctx.issueDir, ARTIFACTS.simplifySummary),
+    templateName: TEMPLATES.simplify,
+  });
+}
+
+export async function stepReview(ctx: IssueContext): Promise<boolean> {
+  return runStepWithArtifact({
+    stepName: STEP_LABELS.review,
+    ctx,
+    artifactPath: join(ctx.issueDir, ARTIFACTS.review),
+    templateName: TEMPLATES.review,
+  });
+}