@towles/tool 0.0.66 → 0.0.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towles/tool",
-  "version": "0.0.66",
+  "version": "0.0.67",
   "description": "One off quality of life scripts that I use on a daily basis.",
   "homepage": "https://github.com/ChrisTowles/towles-tool#readme",
   "bugs": {

package/src/commands/auto-claude/retry.test.ts

@@ -3,23 +3,20 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import consola from "consola";
-import { x } from "tinyexec";
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
+import type { ExecSafeFn } from "../../lib/auto-claude/labels.js";
 import { LABELS } from "../../lib/auto-claude/labels.js";
 import { retryIssues } from "./retry.js";
 
 // Suppress consola output during tests
 consola.level = -999;
 
-// Mock tinyexec so setLabel/removeLabel (which use execSafe -> x) work
-vi.mock("tinyexec", () => ({
-  x: vi.fn().mockResolvedValue({ stdout: "", exitCode: 0, stderr: "" }),
-}));
+const mockExecSafe: ExecSafeFn = vi.fn().mockResolvedValue({ stdout: "", ok: true });
 
 function getGhEditCalls() {
   return vi
-    .mocked(x)
+    .mocked(mockExecSafe)
     .mock.calls.filter(
       ([cmd, args]) => cmd === "gh" && args?.[0] === "issue" && args?.[1] === "edit",
     )
@@ -41,7 +38,7 @@ describe("retryIssues", () => {
       },
     ];
 
-    const count = await retryIssues("owner/repo", "auto-claude", issues, false);
+    const count = await retryIssues("owner/repo", "auto-claude", issues, false, mockExecSafe);
 
     expect(count).toBe(1);
     const editCalls = getGhEditCalls();
@@ -70,7 +67,7 @@ describe("retryIssues", () => {
       },
     ];
 
-    const count = await retryIssues("owner/repo", "auto-claude", issues, false);
+    const count = await retryIssues("owner/repo", "auto-claude", issues, false, mockExecSafe);
 
     expect(count).toBe(2);
     const editCalls = getGhEditCalls();
@@ -79,7 +76,7 @@ describe("retryIssues", () => {
   });
 
   it("returns 0 when given empty selection", async () => {
-    const count = await retryIssues("owner/repo", "auto-claude", [], false);
+    const count = await retryIssues("owner/repo", "auto-claude", [], false, mockExecSafe);
     expect(count).toBe(0);
     expect(getGhEditCalls().length).toBe(0);
   });
@@ -103,7 +100,7 @@ describe("retryIssues", () => {
         },
       ];
 
-      await retryIssues("owner/repo", "auto-claude", issues, true);
+      await retryIssues("owner/repo", "auto-claude", issues, true, mockExecSafe);
       expect(existsSync(issueDir)).toBe(false);
     } finally {
       process.chdir(originalCwd);
@@ -129,7 +126,7 @@ describe("retryIssues", () => {
         },
       ];
 
-      await retryIssues("owner/repo", "auto-claude", issues, false);
+      await retryIssues("owner/repo", "auto-claude", issues, false, mockExecSafe);
       expect(existsSync(issueDir)).toBe(true);
     } finally {
       process.chdir(originalCwd);

package/src/commands/auto-claude/retry.ts

@@ -9,6 +9,7 @@ import prompts from "prompts";
 import { BaseCommand } from "../base.js";
 import { initConfig } from "../../lib/auto-claude/index.js";
 import { LABELS, removeLabel, setLabel } from "../../lib/auto-claude/labels.js";
+import type { ExecSafeFn } from "../../lib/auto-claude/labels.js";
 import { getIssues, isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
 import type { Issue } from "../../utils/git/gh-cli-wrapper.js";
 
@@ -21,14 +22,15 @@ export async function retryIssues(
   triggerLabel: string,
   selected: Issue[],
   clean: boolean,
+  exec?: ExecSafeFn,
 ): Promise<number> {
   for (const issue of selected) {
     consola.info(`Retrying issue #${issue.number}: ${issue.title}`);
 
-    await removeLabel(repo, issue.number, LABELS.failed);
+    await removeLabel(repo, issue.number, LABELS.failed, exec);
     consola.success(`  Removed '${LABELS.failed}' label`);
 
-    await setLabel(repo, issue.number, triggerLabel);
+    await setLabel(repo, issue.number, triggerLabel, exec);
     consola.success(`  Added '${triggerLabel}' label`);
 
     if (clean) {

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

@@ -5,7 +5,8 @@ import pc from "picocolors";
 
 import { getConfig } from "./config.js";
 import { sleep } from "./shell.js";
-import { spawnClaude } from "./spawn-claude.js";
+import { spawnClaude as defaultSpawnClaude } from "./spawn-claude.js";
+import type { SpawnClaudeFn } from "./spawn-claude.js";
 
 // ── Claude CLI ──
 
@@ -16,14 +17,26 @@ export interface ClaudeResult {
   num_turns: number;
 }
 
+export interface ClaudeLogger {
+  info: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  success: (...args: unknown[]) => void;
+  log: (...args: unknown[]) => void;
+}
+
 const PROCESS_RETRIES = 3;
 const PROCESS_RETRY_DELAY_MS = 5_000;
 
 export async function runClaude(opts: {
   promptFile: string;
   maxTurns?: number;
+  spawnFn?: SpawnClaudeFn;
+  logger?: ClaudeLogger;
 }): Promise<ClaudeResult> {
   const cfg = getConfig();
+  const spawnFn = opts.spawnFn ?? defaultSpawnClaude;
+  const log = opts.logger ?? consola;
   const args = [
     "-p",
     "--output-format",
@@ -37,23 +50,21 @@ export async function runClaude(opts: {
     `@${opts.promptFile}`,
   ];
 
-  consola.info(
-    `${pc.dim("▶")} Calling Claude${opts.maxTurns ? ` (max ${opts.maxTurns} turns)` : ""}…`,
-  );
+  log.info(`${pc.dim("▶")} Calling Claude${opts.maxTurns ? ` (max ${opts.maxTurns} turns)` : ""}…`);
 
   let lastError: Error | undefined;
   for (let attempt = 1; attempt <= PROCESS_RETRIES; attempt++) {
     try {
-      const result = await runClaudeStreaming(args);
-      consola.success(`Done — ${result.num_turns} turns, $${result.total_cost_usd.toFixed(4)}`);
+      const result = await runClaudeStreaming(args, spawnFn, log);
+      log.success(`Done — ${result.num_turns} turns, $${result.total_cost_usd.toFixed(4)}`);
       if (result.result) {
-        consola.log(result.result);
+        log.log(result.result);
       }
       return result;
     } catch (err) {
       lastError = err instanceof Error ? err : new Error(String(err));
       if (attempt < PROCESS_RETRIES) {
-        consola.warn(
+        log.warn(
           `Claude process failed (attempt ${attempt}/${PROCESS_RETRIES}), retrying in ${PROCESS_RETRY_DELAY_MS / 1000}s…`,
         );
         await sleep(PROCESS_RETRY_DELAY_MS);
@@ -63,9 +74,13 @@ export async function runClaude(opts: {
   throw lastError ?? new Error("runClaude failed after all retries");
 }
 
-function runClaudeStreaming(args: string[]): Promise<ClaudeResult> {
+function runClaudeStreaming(
+  args: string[],
+  spawnFn: SpawnClaudeFn,
+  log: ClaudeLogger,
+): Promise<ClaudeResult> {
   return new Promise((resolve, reject) => {
-    const proc = spawnClaude(args);
+    const proc = spawnFn(args);
     let capturedResult: ClaudeResult | null = null;
     let turnCount = 0;
 
@@ -80,7 +95,7 @@ function runClaudeStreaming(args: string[]): Promise<ClaudeResult> {
       if (!line.trim()) return;
       try {
         const event = JSON.parse(line) as Record<string, unknown>;
-        handleStreamEvent(event, (turns) => {
+        handleStreamEvent(event, log, (turns) => {
           turnCount = turns;
         });
 
@@ -146,14 +161,18 @@ function toolDetail(block: Record<string, unknown>): string {
   return "";
 }
 
-function logToolUse(block: Record<string, unknown>): void {
+function logToolUse(block: Record<string, unknown>, log: ClaudeLogger): void {
   const name = block.name;
   if (typeof name === "string") {
-    consola.info(`  ${pc.dim("\u21B3")} ${name}${toolDetail(block)}`);
+    log.info(`  ${pc.dim("\u21B3")} ${name}${toolDetail(block)}`);
   }
 }
 
-function handleStreamEvent(event: Record<string, unknown>, onTurn: (count: number) => void): void {
+function handleStreamEvent(
+  event: Record<string, unknown>,
+  log: ClaudeLogger,
+  onTurn: (count: number) => void,
+): void {
   // Only handle stream_event — assistant turn events duplicate the same tools
   if (event.type === "stream_event" && typeof event.event === "object" && event.event !== null) {
     const inner = event.event as Record<string, unknown>;
@@ -165,13 +184,13 @@ function handleStreamEvent(event: Record<string, unknown>, onTurn: (count: numbe
     ) {
       const block = inner.content_block as Record<string, unknown>;
       if (block.type === "tool_use") {
-        logToolUse(block);
+        logToolUse(block, log);
       } else if (block.type === "thinking") {
         const thinkingText =
           typeof block.thinking === "string" && block.thinking.length > 0
             ? pc.dim(` ${truncate(block.thinking.split("\n")[0].trim(), 60)}`)
             : "";
-        consola.info(`  ${pc.dim("\u21B3")} ${pc.italic("thinking")}${thinkingText}`);
+        log.info(`  ${pc.dim("\u21B3")} ${pc.italic("thinking")}${thinkingText}`);
       }
     }
   }

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

@@ -1,13 +1,9 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import { execSafe } from "../../utils/git/exec.js";
+import type { ExecSafeFn } from "./labels";
 import { ensureLabelsExist, LABELS, removeLabel, setLabel } from "./labels";
 
-vi.mock("../../utils/git/exec.js", () => ({
-  execSafe: vi.fn().mockResolvedValue({ stdout: "", ok: true }),
-}));
-
-const mockedExecSafe = vi.mocked(execSafe);
+const mockExecSafe: ExecSafeFn = vi.fn().mockResolvedValue({ stdout: "", ok: true });
 
 describe("LABELS", () => {
   it("has expected label values", () => {
@@ -28,11 +24,11 @@ describe("ensureLabelsExist", () => {
   });
 
   it("creates all labels with --force", async () => {
-    await ensureLabelsExist("owner/repo");
+    await ensureLabelsExist("owner/repo", mockExecSafe);
 
-    expect(mockedExecSafe).toHaveBeenCalledTimes(4);
+    expect(mockExecSafe).toHaveBeenCalledTimes(4);
     for (const label of Object.values(LABELS)) {
-      expect(mockedExecSafe).toHaveBeenCalledWith("gh", [
+      expect(mockExecSafe).toHaveBeenCalledWith("gh", [
         "label",
         "create",
         label,
@@ -50,9 +46,9 @@ describe("setLabel", () => {
   });
 
   it("calls gh issue edit with --add-label", async () => {
-    await setLabel("owner/repo", 42, "auto-claude-in-progress");
+    await setLabel("owner/repo", 42, "auto-claude-in-progress", mockExecSafe);
 
-    expect(mockedExecSafe).toHaveBeenCalledWith("gh", [
+    expect(mockExecSafe).toHaveBeenCalledWith("gh", [
       "issue",
       "edit",
       "42",
@@ -70,9 +66,9 @@ describe("removeLabel", () => {
   });
 
   it("calls gh issue edit with --remove-label", async () => {
-    await removeLabel("owner/repo", 42, "auto-claude-failed");
+    await removeLabel("owner/repo", 42, "auto-claude-failed", mockExecSafe);
 
-    expect(mockedExecSafe).toHaveBeenCalledWith("gh", [
+    expect(mockExecSafe).toHaveBeenCalledWith("gh", [
       "issue",
       "edit",
       "42",

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

@@ -1,4 +1,4 @@
-import { execSafe } from "../../utils/git/exec.js";
+import { execSafe as defaultExecSafe } from "../../utils/git/exec.js";
 
 // ── Label helpers ──
 
@@ -9,34 +9,33 @@ export const LABELS = {
   success: "auto-claude-success",
 } as const;
 
-export async function ensureLabelsExist(repo: string): Promise<void> {
+export type ExecSafeFn = (cmd: string, args: string[]) => Promise<{ stdout: string; ok: boolean }>;
+
+export async function ensureLabelsExist(
+  repo: string,
+  exec: ExecSafeFn = defaultExecSafe,
+): Promise<void> {
   await Promise.all(
     Object.values(LABELS).map((label) =>
-      execSafe("gh", ["label", "create", label, "--repo", repo, "--force"]),
+      exec("gh", ["label", "create", label, "--repo", repo, "--force"]),
     ),
   );
 }
 
-export async function setLabel(repo: string, issueNumber: number, label: string): Promise<void> {
-  await execSafe("gh", [
-    "issue",
-    "edit",
-    String(issueNumber),
-    "--repo",
-    repo,
-    "--add-label",
-    label,
-  ]);
+export async function setLabel(
+  repo: string,
+  issueNumber: number,
+  label: string,
+  exec: ExecSafeFn = defaultExecSafe,
+): Promise<void> {
+  await exec("gh", ["issue", "edit", String(issueNumber), "--repo", repo, "--add-label", label]);
 }
 
-export async function removeLabel(repo: string, issueNumber: number, label: string): Promise<void> {
-  await execSafe("gh", [
-    "issue",
-    "edit",
-    String(issueNumber),
-    "--repo",
-    repo,
-    "--remove-label",
-    label,
-  ]);
+export async function removeLabel(
+  repo: string,
+  issueNumber: number,
+  label: string,
+  exec: ExecSafeFn = defaultExecSafe,
+): Promise<void> {
+  await exec("gh", ["issue", "edit", String(issueNumber), "--repo", repo, "--remove-label", label]);
 }

package/src/lib/auto-claude/pipeline-execution.test.ts

@@ -9,50 +9,26 @@ import { initConfig } from "./config";
 import { ARTIFACTS } from "./prompt-templates/index";
 import {
   buildTestContext,
-  createSpawnClaudeMock,
+  createMockClaudeProcess,
   createTestRepoWithRemote,
   errorClaudeJson,
   successClaudeJson,
 } from "./test-helpers";
 import type { MockClaudeImpl, TestRepo } from "./test-helpers";
 import type { IssueContext } from "./utils";
+import type { SpawnClaudeFn } from "./spawn-claude";
+import type { ExecSafeFn } from "./labels";
 
 consola.level = -999;
 
-let mockClaudeImpl: MockClaudeImpl = null;
-vi.mock("./spawn-claude", () => createSpawnClaudeMock(() => mockClaudeImpl));
-
-// Track gh calls for label assertions
-let ghCalls: string[][] = [];
-
-vi.mock("tinyexec", async (importOriginal) => {
-  const original = await importOriginal<typeof import("tinyexec")>();
-  return {
-    ...original,
-    x: vi.fn(
-      async (
-        cmd: string,
-        args: string[],
-        opts?: Record<string, unknown>,
-      ): Promise<{ stdout: string; exitCode: number }> => {
-        if (cmd === "gh") {
-          ghCalls.push(args);
-          // Return empty success for label/issue/pr commands
-          return { stdout: "[]", exitCode: 0 };
-        }
-        return original.x(cmd, args, opts as never) as unknown as Promise<{
-          stdout: string;
-          exitCode: number;
-        }>;
-      },
-    ),
-  };
-});
-
 describe("runPipeline", () => {
   let originalCwd: string;
   let repo: TestRepo;
   let ctx: IssueContext;
+  let mockClaudeImpl: MockClaudeImpl;
+  let ghCalls: string[][];
+  let mockSpawnFn: SpawnClaudeFn;
+  let mockExec: ExecSafeFn;
 
   beforeEach(async () => {
     originalCwd = process.cwd();
@@ -66,6 +42,24 @@ describe("runPipeline", () => {
     ctx = buildTestContext(repo.dir);
     mockClaudeImpl = null;
     ghCalls = [];
+
+    mockSpawnFn = vi.fn((args: string[]) => {
+      if (mockClaudeImpl) {
+        const { stdout, exitCode } = mockClaudeImpl(args);
+        return createMockClaudeProcess(stdout, exitCode);
+      }
+      throw new Error("Unexpected spawnClaude call -- set mockClaudeImpl");
+    }) as SpawnClaudeFn;
+
+    mockExec = vi.fn(async (cmd: string, args: string[]) => {
+      if (cmd === "gh") {
+        ghCalls.push(args);
+        return { stdout: "[]", ok: true };
+      }
+      // Pass through non-gh commands to real exec
+      const { execSafe } = await import("../../utils/git/exec");
+      return execSafe(cmd, args);
+    }) as ExecSafeFn;
   });
 
   afterEach(() => {
@@ -78,7 +72,7 @@ describe("runPipeline", () => {
 
     mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     const ramblingsPath = join(ctx.issueDir, ARTIFACTS.initialRamblings);
     expect(existsSync(ramblingsPath)).toBe(true);
@@ -97,7 +91,7 @@ describe("runPipeline", () => {
 
     mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     const content = readFileSync(ramblingsPath, "utf-8");
     expect(content).toBe("# Existing ramblings");
@@ -116,7 +110,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx, "plan");
+    await runPipeline(ctx, "plan", { spawnFn: mockSpawnFn, exec: mockExec });
 
     expect(claudeCallCount).toBe(1);
   });
@@ -126,7 +120,7 @@ describe("runPipeline", () => {
 
     mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     const currentBranch = execSync("git branch --show-current", {
       cwd: repo.dir,
@@ -160,7 +154,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     expect(claudeCallCount).toBe(4);
 
@@ -209,7 +203,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     // 1 plan + 3 steps * 2 attempts = 7
     expect(claudeCallCount).toBe(7);
@@ -245,7 +239,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx);
+    await runPipeline(ctx, undefined, { spawnFn: mockSpawnFn, exec: mockExec });
 
     // 1 plan + 3 steps * 3 attempts (maxReviewRetries=2 → 3 total) = 10
     expect(claudeCallCount).toBe(10);
@@ -280,7 +274,7 @@ describe("runPipeline", () => {
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    await runPipeline(ctx, "implement");
+    await runPipeline(ctx, "implement", { spawnFn: mockSpawnFn, exec: mockExec });
 
     expect(claudeCallCount).toBe(2);
   });

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

@@ -8,16 +8,29 @@ import { createPr } from "./steps/create-pr.js";
 import { stepImplement } from "./steps/implement.js";
 import { stepPlan, stepReview, stepSimplify } from "./steps/simple-steps.js";
 import { LABELS, ensureLabelsExist, removeLabel, setLabel } from "./labels.js";
+import type { ExecSafeFn } from "./labels.js";
 import { ensureDir, 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 { log } from "./utils.js";
 import type { IssueContext } from "./utils.js";
+import type { SpawnClaudeFn } from "./spawn-claude.js";
 
 export { type StepName, STEP_NAMES } from "./prompt-templates/index.js";
 
-export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Promise<void> {
+export interface PipelineDeps {
+  spawnFn?: SpawnClaudeFn;
+  exec?: ExecSafeFn;
+}
+
+export async function runPipeline(
+  ctx: IssueContext,
+  untilStep?: StepName,
+  deps?: PipelineDeps,
+): Promise<void> {
   const cfg = getConfig();
+  const exec = deps?.exec;
+  const spawnFn = deps?.spawnFn;
   log(`Pipeline starting for ${ctx.repo}#${ctx.number}: ${ctx.title}`);
 
   ensureDir(ctx.issueDir);
@@ -29,14 +42,14 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
   }
 
   // Label management
-  await ensureLabelsExist(ctx.repo);
-  await removeLabel(ctx.repo, ctx.number, cfg.triggerLabel);
-  await setLabel(ctx.repo, ctx.number, LABELS.inProgress);
+  await ensureLabelsExist(ctx.repo, exec);
+  await removeLabel(ctx.repo, ctx.number, cfg.triggerLabel, exec);
+  await setLabel(ctx.repo, ctx.number, LABELS.inProgress, exec);
 
   try {
     // Step 1: Plan (runs once)
-    if (!(await stepPlan(ctx))) {
-      await handleFailure(ctx, "plan");
+    if (!(await stepPlan(ctx, spawnFn))) {
+      await handleFailure(ctx, "plan", undefined, exec);
       return;
     }
     if (untilStep === "plan") {
@@ -55,8 +68,8 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
       }
 
       // Implement
-      if (!(await stepImplement(ctx))) {
-        await handleFailure(ctx, "implement");
+      if (!(await stepImplement(ctx, spawnFn))) {
+        await handleFailure(ctx, "implement", undefined, exec);
         return;
       }
       if (untilStep === "implement") {
@@ -65,8 +78,8 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
       }
 
       // Simplify
-      if (!(await stepSimplify(ctx))) {
-        await handleFailure(ctx, "simplify");
+      if (!(await stepSimplify(ctx, spawnFn))) {
+        await handleFailure(ctx, "simplify", undefined, exec);
         return;
       }
       if (untilStep === "simplify") {
@@ -75,8 +88,8 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
       }
 
       // Review
-      if (!(await stepReview(ctx))) {
-        await handleFailure(ctx, "review");
+      if (!(await stepReview(ctx, spawnFn))) {
+        await handleFailure(ctx, "review", undefined, exec);
         return;
       }
       if (untilStep === "review") {
@@ -86,10 +99,10 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
 
       // Check review result
       if (isReviewPass(ctx)) {
-        const prUrl = await createPr(ctx);
-        await removeLabel(ctx.repo, ctx.number, LABELS.inProgress);
-        await setLabel(ctx.repo, ctx.number, LABELS.success);
-        await setLabel(ctx.repo, ctx.number, LABELS.review);
+        const prUrl = await createPr(ctx, exec);
+        await removeLabel(ctx.repo, ctx.number, LABELS.inProgress, exec);
+        await setLabel(ctx.repo, ctx.number, LABELS.success, exec);
+        await setLabel(ctx.repo, ctx.number, LABELS.review, exec);
         log(`Pipeline complete for ${ctx.repo}#${ctx.number} — ${prUrl}`);
         return;
       }
@@ -107,6 +120,7 @@ export async function runPipeline(ctx: IssueContext, untilStep?: StepName): Prom
       ctx,
       "review",
       `auto-claude: review did not pass after ${maxRetries + 1} attempts. Labelled \`${LABELS.failed}\`.`,
+      exec,
     );
   } finally {
     await checkoutMain();
@@ -125,11 +139,19 @@ function isReviewPass(ctx: IssueContext): boolean {
   return firstLine === "PASS";
 }
 
-async function handleFailure(ctx: IssueContext, stepName: string, comment?: string): Promise<void> {
-  await removeLabel(ctx.repo, ctx.number, LABELS.inProgress);
-  await setLabel(ctx.repo, ctx.number, LABELS.failed);
+async function handleFailure(
+  ctx: IssueContext,
+  stepName: string,
+  comment?: string,
+  exec?: ExecSafeFn,
+): Promise<void> {
+  await removeLabel(ctx.repo, ctx.number, LABELS.inProgress, exec);
+  await setLabel(ctx.repo, ctx.number, LABELS.failed, exec);
   if (comment) {
-    await ghRaw(["issue", "comment", String(ctx.number), "--repo", ctx.repo, "--body", comment]);
+    await ghRaw(
+      ["issue", "comment", String(ctx.number), "--repo", ctx.repo, "--body", comment],
+      exec,
+    );
   }
   log(`Pipeline stopped at "${stepName}" for ${ctx.repo}#${ctx.number}`);
 }