@towles/tool 0.0.109 → 0.0.111

package/src/commands/auto-claude/config-init.ts

@@ -0,0 +1,159 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { defineCommand } from "citty";
+import consola from "consola";
+import prompts from "prompts";
+
+import { git, run } from "@towles/shared";
+import { debugArg } from "../shared.js";
+import { AutoClaudeConfigSchema } from "./config.js";
+import {
+  CONFIG_DIR,
+  CONFIG_PATH,
+  buildConfig,
+  formatConfigSummary,
+  serializeConfig,
+  validateBranchName,
+  validateScopePath,
+  validateTriggerLabel,
+} from "./config-init-helpers.js";
+
+async function detectRepo(): Promise<string> {
+  const result = await run(
+    "gh",
+    ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"],
+    { throwOnError: true },
+  );
+  return result.stdout.trim();
+}
+
+async function detectMainBranch(): Promise<string> {
+  try {
+    const branch = await git(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+    return branch.trim().replace("refs/remotes/origin/", "");
+  } catch {
+    return "main";
+  }
+}
+
+async function detectGitRoot(): Promise<string> {
+  return (await git(["rev-parse", "--show-toplevel"])).trim();
+}
+
+export default defineCommand({
+  meta: { name: "config-init", description: "Initialize auto-claude config for the current repo" },
+  args: {
+    debug: debugArg,
+    "non-interactive": {
+      type: "boolean" as const,
+      description: "Use all defaults without prompting",
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const gitRoot = await detectGitRoot();
+    const configPath = join(gitRoot, CONFIG_PATH);
+
+    if (existsSync(configPath)) {
+      consola.warn(`Config already exists at ${CONFIG_PATH}`);
+      if (!args["non-interactive"]) {
+        const { overwrite } = await prompts({
+          type: "confirm",
+          name: "overwrite",
+          message: "Overwrite existing config?",
+          initial: false,
+        });
+        if (!overwrite) {
+          consola.info("Aborted.");
+          return;
+        }
+      }
+    }
+
+    const defaults = AutoClaudeConfigSchema.parse({
+      repo: await detectRepo(),
+      mainBranch: await detectMainBranch(),
+    });
+
+    if (args["non-interactive"]) {
+      const config = buildConfig({
+        triggerLabel: defaults.triggerLabel,
+        mainBranch: defaults.mainBranch,
+        scopePath: defaults.scopePath,
+        model: defaults.model,
+        repo: defaults.repo,
+      });
+
+      const dirPath = join(gitRoot, CONFIG_DIR);
+      mkdirSync(dirPath, { recursive: true });
+      writeFileSync(configPath, serializeConfig(config));
+      consola.success(`Config written to ${CONFIG_PATH}`);
+      return;
+    }
+
+    // Interactive prompts
+    const answers = await prompts([
+      {
+        type: "text",
+        name: "triggerLabel",
+        message: "Trigger label",
+        initial: defaults.triggerLabel,
+        validate: (v: string) => validateTriggerLabel(v),
+      },
+      {
+        type: "text",
+        name: "mainBranch",
+        message: "Main branch name",
+        initial: defaults.mainBranch,
+        validate: (v: string) => validateBranchName(v),
+      },
+      {
+        type: "text",
+        name: "scopePath",
+        message: "Scope path",
+        initial: defaults.scopePath,
+        validate: (v: string) => validateScopePath(v),
+      },
+      {
+        type: "text",
+        name: "model",
+        message: "Claude model",
+        initial: defaults.model,
+      },
+    ]);
+
+    // User cancelled (Ctrl-C during prompts)
+    if (!answers.triggerLabel) {
+      consola.info("Aborted.");
+      return;
+    }
+
+    const config = buildConfig({
+      triggerLabel: answers.triggerLabel,
+      mainBranch: answers.mainBranch,
+      scopePath: answers.scopePath,
+      model: answers.model,
+      repo: defaults.repo,
+    });
+
+    consola.box(`Config summary:\n\n${formatConfigSummary(config)}`);
+
+    const { confirmed } = await prompts({
+      type: "confirm",
+      name: "confirmed",
+      message: `Write config to ${CONFIG_PATH}?`,
+      initial: true,
+    });
+
+    if (!confirmed) {
+      consola.info("Aborted.");
+      return;
+    }
+
+    const dirPath = join(gitRoot, CONFIG_DIR);
+    mkdirSync(dirPath, { recursive: true });
+    writeFileSync(configPath, serializeConfig(config));
+    consola.success(`Config written to ${CONFIG_PATH}`);
+  },
+});

package/src/{lib → commands}/auto-claude/config.ts

@@ -1,5 +1,5 @@
 import consola from "consola";
-import { x } from "tinyexec";
+import { run } from "@towles/shared";
 import { z } from "zod/v4";
 
 export const AutoClaudeConfigSchema = z.object({
@@ -25,13 +25,10 @@ export async function initConfig(
   // Auto-detect repo
   let repo = overrides.repo;
   if (!repo) {
-    const result = await x(
+    const result = await run(
       "gh",
       ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"],
-      {
-        nodeOptions: { cwd: process.cwd() },
-        throwOnError: true,
-      },
+      { throwOnError: true },
     );
     repo = result.stdout.trim();
   }
@@ -41,8 +38,7 @@ export async function initConfig(
   let mainBranch = overrides.mainBranch;
   if (!mainBranch) {
     try {
-      const result = await x("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
-        nodeOptions: { cwd: process.cwd() },
+      const result = await run("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
         throwOnError: true,
       });
       mainBranch = result.stdout.trim().replace("refs/remotes/origin/", "");

package/src/{lib → commands}/auto-claude/e2e.test.ts

@@ -78,7 +78,7 @@ describe("auto-claude e2e: full pipeline lifecycle", () => {
         return { stdout: "", ok: true };
       }
       // Pass through non-gh commands to real exec
-      const { execSafe } = await import("../../utils/git/exec");
+      const { execSafe } = await import("@towles/shared");
       return execSafe(cmd, args);
     }) as ExecSafeFn;
   });
@@ -221,7 +221,7 @@ describe("auto-claude e2e: label state transitions", () => {
         }
         return { stdout: "", ok: true };
       }
-      const { execSafe } = await import("../../utils/git/exec");
+      const { execSafe } = await import("@towles/shared");
       return execSafe(cmd, args);
     }) as ExecSafeFn;
   });
@@ -369,7 +369,7 @@ describe("auto-claude e2e: retry loop behavior", () => {
         }
         return { stdout: "", ok: true };
       }
-      const { execSafe } = await import("../../utils/git/exec");
+      const { execSafe } = await import("@towles/shared");
       return execSafe(cmd, args);
     }) as ExecSafeFn;
   });
@@ -511,7 +511,7 @@ describe("auto-claude e2e: --until flag behavior", () => {
       if (cmd === "gh") {
         return { stdout: "[]", ok: true };
       }
-      const { execSafe } = await import("../../utils/git/exec");
+      const { execSafe } = await import("@towles/shared");
       return execSafe(cmd, args);
     }) as ExecSafeFn;
   });
@@ -661,7 +661,7 @@ describe("auto-claude e2e: git operations", () => {
         }
         return { stdout: "", ok: true };
       }
-      const { execSafe } = await import("../../utils/git/exec");
+      const { execSafe } = await import("@towles/shared");
       return execSafe(cmd, args);
     }) as ExecSafeFn;
   });
@@ -791,7 +791,7 @@ describe("auto-claude e2e: edge cases", () => {
       if (cmd === "gh") {
         return { stdout: "[]", ok: true };
       }
-      const { execSafe } = await import("../../utils/git/exec");
+      const { execSafe } = await import("@towles/shared");
       return execSafe(cmd, args);
     }) as ExecSafeFn;
   });

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

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+
+import { ARTIFACTS, PIPELINE_STEPS, STEP_NAMES } from "./prompt-templates/index";
+import { buildStepInfos, printStepTemplate } from "./explain";
+
+describe("buildStepInfos", () => {
+  it("returns one entry per pipeline step", () => {
+    const infos = buildStepInfos();
+    expect(infos).toHaveLength(PIPELINE_STEPS.length);
+  });
+
+  it("preserves pipeline step order", () => {
+    const infos = buildStepInfos();
+    expect(infos.map((i) => i.name)).toEqual(STEP_NAMES);
+  });
+
+  it("every step has a template file, description, inputs, and outputs", () => {
+    for (const info of buildStepInfos()) {
+      expect(info.templateFile).toBeTruthy();
+      expect(info.description.length).toBeGreaterThan(0);
+      expect(info.inputs.length).toBeGreaterThan(0);
+      expect(info.outputs.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("plan step reads initial-ramblings and outputs plan", () => {
+    const plan = buildStepInfos().find((i) => i.name === "plan")!;
+    expect(plan.inputs).toContain(ARTIFACTS.initialRamblings);
+    expect(plan.outputs).toContain(ARTIFACTS.plan);
+  });
+
+  it("implement step reads plan and outputs completed-summary", () => {
+    const impl = buildStepInfos().find((i) => i.name === "implement")!;
+    expect(impl.inputs).toContain(ARTIFACTS.plan);
+    expect(impl.outputs).toContain(ARTIFACTS.completedSummary);
+  });
+
+  it("review step outputs review artifact", () => {
+    const review = buildStepInfos().find((i) => i.name === "review")!;
+    expect(review.outputs).toContain(ARTIFACTS.review);
+  });
+});
+
+describe("printStepTemplate", () => {
+  it("throws for an unknown step name", () => {
+    expect(() => printStepTemplate("nonexistent")).toThrow(/Unknown step "nonexistent"/);
+  });
+
+  it("throws with valid step names in the error message", () => {
+    expect(() => printStepTemplate("bad")).toThrow(/plan, implement, simplify, review/);
+  });
+
+  it("does not throw for valid step names", () => {
+    for (const name of STEP_NAMES) {
+      expect(() => printStepTemplate(name)).not.toThrow();
+    }
+  });
+});

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

@@ -0,0 +1,97 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import consola from "consola";
+import { colorize } from "consola/utils";
+
+import { ARTIFACTS, PIPELINE_STEPS, TEMPLATES } from "./prompt-templates/index.js";
+import type { StepName } from "./prompt-templates/index.js";
+import { TEMPLATES_DIR } from "./templates.js";
+
+interface StepInfo {
+  order: number;
+  name: string;
+  label: string;
+  templateFile: string;
+  description: string;
+  inputs: string[];
+  outputs: string[];
+}
+
+const STEP_DETAILS: Record<StepName, { description: string; inputs: string[]; outputs: string[] }> =
+  {
+    plan: {
+      description: "Research the issue and codebase, then produce a detailed implementation plan",
+      inputs: [ARTIFACTS.initialRamblings],
+      outputs: [ARTIFACTS.plan],
+    },
+    implement: {
+      description:
+        "Follow the plan checklist task-by-task using red/green TDD, then verify all checks pass",
+      inputs: [ARTIFACTS.plan, `${ARTIFACTS.review} (on retry)`],
+      outputs: [ARTIFACTS.completedSummary],
+    },
+    simplify: {
+      description:
+        "Review branch changes and simplify: remove dead code, inline over-abstractions, tighten types",
+      inputs: [ARTIFACTS.completedSummary],
+      outputs: [ARTIFACTS.simplifySummary],
+    },
+    review: {
+      description:
+        "Run automated checks then manually review the diff for correctness, security, and coverage",
+      inputs: [ARTIFACTS.plan, "git diff"],
+      outputs: [ARTIFACTS.review],
+    },
+  };
+
+export function buildStepInfos(): StepInfo[] {
+  const templateMap: Record<string, string> = TEMPLATES;
+  return PIPELINE_STEPS.map((s) => ({
+    order: s.order,
+    name: s.name,
+    label: s.label,
+    templateFile: templateMap[s.name] ?? "(none)",
+    ...STEP_DETAILS[s.name],
+  }));
+}
+
+export function printExplain(): void {
+  consola.log("");
+  consola.log(colorize("bold", "auto-claude pipeline"));
+  consola.log(
+    colorize("dim", "Steps 2-4 loop up to maxReviewRetries times if review returns FAIL\n"),
+  );
+
+  for (const step of buildStepInfos()) {
+    consola.log(colorize("cyan", `  ${step.label}`));
+    consola.log(`    ${step.description}`);
+    consola.log(`    ${colorize("dim", "template:")} ${step.templateFile}`);
+    consola.log(`    ${colorize("green", "inputs:")}  ${step.inputs.join(", ")}`);
+    consola.log(`    ${colorize("yellow", "outputs:")} ${step.outputs.join(", ")}`);
+    consola.log("");
+  }
+}
+
+export function printStepTemplate(stepName: string): void {
+  const step = PIPELINE_STEPS.find((s) => s.name === stepName);
+  if (!step) {
+    throw new Error(
+      `Unknown step "${stepName}". Valid steps: ${PIPELINE_STEPS.map((s) => s.name).join(", ")}`,
+    );
+  }
+
+  const templateMap: Record<string, string> = TEMPLATES;
+  const templateFile = templateMap[step.name];
+  if (!templateFile) {
+    throw new Error(`No template found for step "${stepName}"`);
+  }
+
+  const templatePath = join(TEMPLATES_DIR, templateFile);
+  const content = readFileSync(templatePath, "utf-8");
+
+  consola.log("");
+  consola.log(colorize("bold", `Template: ${templateFile}`));
+  consola.log(colorize("dim", `Step: ${step.label} (${step.name})\n`));
+  consola.log(content);
+}

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

@@ -6,20 +6,16 @@ import { defineCommand } from "citty";
 import consola from "consola";
 
 import { debugArg } from "../shared.js";
-import {
-  STEP_NAMES,
-  fetchIssue,
-  fetchIssues,
-  getConfig,
-  git,
-  initConfig,
-  log,
-  logBanner,
-  runClaude,
-  runPipeline,
-  sleep,
-} from "../../lib/auto-claude/index.js";
-import type { IssueContext, StepName } from "../../lib/auto-claude/index.js";
+import { printExplain, printStepTemplate } from "./explain.js";
+import { STEP_NAMES, runPipeline } from "./pipeline.js";
+import { fetchIssue, fetchIssues } from "./steps/fetch-issues.js";
+import { getConfig, initConfig } from "./config.js";
+import { git } from "@towles/shared";
+import { runClaude } from "./claude-cli.js";
+import { sleep } from "./shell.js";
+import { log, logBanner } from "./utils.js";
+import type { IssueContext } from "./utils.js";
+import type { StepName } from "./prompt-templates/index.js";
 
 export default defineCommand({
   meta: { name: "auto-claude", description: "Automated issue-to-PR pipeline using Claude Code" },
@@ -80,13 +76,40 @@ export default defineCommand({
       type: "string" as const,
       description: "Path within repo to scope work (default: .)",
     },
+    explain: {
+      type: "boolean" as const,
+      description: "Print a summary of all pipeline steps and exit",
+      default: false,
+    },
+    "step-template": {
+      type: "string" as const,
+      description: `Print the raw prompt template for a step and exit (${STEP_NAMES.join(", ")})`,
+    },
   },
   subCommands: {
     list: () => import("./list.js").then((m) => m.default),
     status: () => import("./status.js").then((m) => m.default),
     retry: () => import("./retry.js").then((m) => m.default),
+    "config-init": () => import("./config-init.js").then((m) => m.default),
   },
   async run({ args }) {
+    // Explain mode: print pipeline summary and exit
+    if (args.explain) {
+      printExplain();
+      return;
+    }
+
+    // Step template mode: print raw template and exit
+    if (args["step-template"]) {
+      try {
+        printStepTemplate(args["step-template"] as string);
+      } catch (e) {
+        consola.error(e instanceof Error ? e.message : String(e));
+        process.exit(1);
+      }
+      return;
+    }
+
     // Prompt mode: run a single prompt with structured output, skip issue pipeline
     if (args.prompt) {
       await initConfig({ model: args.model });

package/src/{lib → commands}/auto-claude/labels.ts

@@ -1,4 +1,4 @@
-import { execSafe as defaultExecSafe } from "../../utils/git/exec.js";
+import { execSafe as defaultExecSafe } from "@towles/shared";
 
 // ── Label helpers ──
 

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

@@ -7,10 +7,11 @@ import type { Choice } from "prompts";
 
 import { debugArg } from "../shared.js";
 import { buildIssueChoices, computeColumnLayout } from "../gh/branch.js";
-import { STEP_NAMES, fetchIssue, initConfig, runPipeline } from "../../lib/auto-claude/index.js";
-import type { StepName } from "../../lib/auto-claude/index.js";
-import { getIssues, isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
-import { getTerminalColumns } from "../../utils/render.js";
+import { STEP_NAMES, runPipeline } from "./pipeline.js";
+import { fetchIssue } from "./steps/fetch-issues.js";
+import { initConfig } from "./config.js";
+import type { StepName } from "./prompt-templates/index.js";
+import { getIssues, getTerminalColumns, isGithubCliInstalled } from "@towles/shared";
 
 export default defineCommand({
   meta: { name: "list", description: "Interactively pick an auto-claude issue to process" },

package/src/{lib → commands}/auto-claude/pipeline-execution.test.ts

@@ -57,7 +57,7 @@ describe("runPipeline", () => {
         return { stdout: "[]", ok: true };
       }
       // Pass through non-gh commands to real exec
-      const { execSafe } = await import("../../utils/git/exec");
+      const { execSafe } = await import("@towles/shared");
       return execSafe(cmd, args);
     }) as ExecSafeFn;
   });

package/src/{lib → commands}/auto-claude/pipeline.ts

@@ -9,9 +9,7 @@ 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 { ensureDir, execSafe, fileExists, ghRaw, git, readFile, writeFile } from "@towles/shared";
 import { log } from "./utils.js";
 import type { IssueContext } from "./utils.js";
 import type { SpawnClaudeFn } from "./spawn-claude.js";

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

@@ -7,8 +7,8 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 
 import type { Mock } from "vitest";
 
-import type { ExecSafeFn } from "../../lib/auto-claude/labels.js";
-import { LABELS } from "../../lib/auto-claude/labels.js";
+import type { ExecSafeFn } from "./labels.js";
+import { LABELS } from "./labels.js";
 import { retryIssues } from "./retry.js";
 
 // Suppress consola output during tests

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

@@ -7,11 +7,11 @@ import { colors } from "consola/utils";
 import prompts from "prompts";
 
 import { debugArg } from "../shared.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";
+import { initConfig } from "./config.js";
+import { LABELS, removeLabel, setLabel } from "./labels.js";
+import type { ExecSafeFn } from "./labels.js";
+import { getIssues, isGithubCliInstalled } from "@towles/shared";
+import type { Issue } from "@towles/shared";
 
 /**
  * Core retry logic: swap labels on failed issues to re-trigger the pipeline.

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

@@ -0,0 +1,3 @@
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -4,8 +4,8 @@ import { join } from "node:path";
 
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
-import type { Issue } from "../../utils/git/gh-cli-wrapper.js";
-import { LABELS } from "../../lib/auto-claude/labels.js";
+import type { Issue } from "@towles/shared";
+import { LABELS } from "./labels.js";
 import { checkArtifacts, findAcLabel, formatIssueStatus } from "./status.js";
 
 // ── Test fixtures ──

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

@@ -5,10 +5,10 @@ import { defineCommand } from "citty";
 import consola from "consola";
 import { colors } from "consola/utils";
 
-import type { Issue } from "../../utils/git/gh-cli-wrapper.js";
-import { getIssues, isGithubCliInstalled } from "../../utils/git/gh-cli-wrapper.js";
-import { ARTIFACTS } from "../../lib/auto-claude/prompt-templates/index.js";
-import { LABELS } from "../../lib/auto-claude/labels.js";
+import type { Issue } from "@towles/shared";
+import { getIssues, isGithubCliInstalled } from "@towles/shared";
+import { ARTIFACTS } from "./prompt-templates/index.js";
+import { LABELS } from "./labels.js";
 import { debugArg } from "../shared.js";
 
 /** All labels that indicate an issue is part of the auto-claude pipeline. */

package/src/{lib → commands}/auto-claude/steps/create-pr.ts

@@ -2,9 +2,7 @@ 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 { execSafe, fileExists, ghRaw, git, readFile, writeFile } from "@towles/shared";
 import { getConfig } from "../config.js";
 import { ARTIFACTS } from "../prompt-templates/index.js";
 import { log } from "../utils.js";

package/src/{lib → commands}/auto-claude/steps/fetch-issues.ts

@@ -1,6 +1,6 @@
 import consola from "consola";
 import { getConfig } from "../config.js";
-import { gh } from "../../../utils/git/gh-cli-wrapper.js";
+import { gh } from "@towles/shared";
 import { buildIssueContext, log } from "../utils.js";
 import type { IssueContext } from "../utils.js";
 

package/src/{lib → commands}/auto-claude/steps/implement.ts

@@ -4,8 +4,7 @@ import consola from "consola";
 
 import { getConfig } from "../config.js";
 import { ARTIFACTS, STEP_LABELS, TEMPLATES } from "../prompt-templates/index.js";
-import { fileExists, readFile } from "../../../utils/fs.js";
-import { git } from "../../../utils/git/exec.js";
+import { fileExists, git, readFile } from "@towles/shared";
 import { runClaude } from "../claude-cli.js";
 import { resolveTemplate } from "../templates.js";
 import { buildTokens, log, logStep } from "../utils.js";

package/src/{lib → commands}/auto-claude/utils-execution.test.ts

@@ -28,20 +28,20 @@ describe("shell helpers (real execution)", () => {
   });
 
   it("execSafe returns ok:true for a successful command", async () => {
-    const { execSafe } = await import("./shell");
+    const { execSafe } = await import("@towles/shared");
     const result = await execSafe("echo", ["hello"]);
     expect(result.ok).toBe(true);
     expect(result.stdout).toBe("hello");
   });
 
   it("execSafe returns ok:false for a failing command", async () => {
-    const { execSafe } = await import("./shell");
+    const { execSafe } = await import("@towles/shared");
     const result = await execSafe("git", ["checkout", "nonexistent-branch-xyz"]);
     expect(result.ok).toBe(false);
   });
 
   it("git() runs real git commands", async () => {
-    const { git } = await import("./shell");
+    const { git } = await import("@towles/shared");
     const status = await git(["status", "--porcelain"]);
     expect(typeof status).toBe("string");
   });
@@ -67,7 +67,7 @@ describe("ensureBranch (real git)", () => {
 
   it("creates a new branch from main when branch doesn't exist", async () => {
     const { ensureBranch } = await import("./utils");
-    const { git } = await import("./shell");
+    const { git } = await import("@towles/shared");
 
     await ensureBranch("feature/42-new-branch");
 
@@ -77,7 +77,7 @@ describe("ensureBranch (real git)", () => {
 
   it("checks out an existing local branch", async () => {
     const { ensureBranch } = await import("./utils");
-    const { git } = await import("./shell");
+    const { git } = await import("@towles/shared");
 
     execSync("git checkout -b feature/existing-branch", { cwd: repo.dir, stdio: "ignore" });
     execSync("git checkout main", { cwd: repo.dir, stdio: "ignore" });
@@ -90,7 +90,7 @@ describe("ensureBranch (real git)", () => {
 
   it("can checkout after branch creation", async () => {
     const { ensureBranch } = await import("./utils");
-    const { git } = await import("./shell");
+    const { git } = await import("@towles/shared");
 
     await ensureBranch("feature/99-test-checkout");
     const branch1 = await git(["branch", "--show-current"]);