@bobbyg603/mog 1.5.1 → 1.5.3

package/README.md

@@ -11,10 +11,13 @@ mog workingdevshero/automate-it 123
 
 That's it. `mog` will:
 
-1. Fetch the issue title, description, and labels via `gh` CLI
+1. Fetch the issue title, description, labels, and comments via `gh` CLI
 2. Create a git worktree on a clean branch (`123-fix-broken-login`)
 3. Run Claude Code inside a persistent Docker sandbox (microVM) with `--dangerously-skip-permissions`
-4. Push the branch and open a PR that `Closes #123`
+4. **Plan** — analyze the codebase and create an implementation plan
+5. **Build** — execute each task in the plan, one at a time
+6. **Review** — self-review all changes for missed patterns, duplication, and quality
+7. Squash commits, push the branch, and open a PR that `Closes #123`
 
 ## Prerequisites
 
@@ -57,12 +60,37 @@ If your session ever expires, just run `mog init` again to re-authenticate.
 # One-time setup
 mog init
 
-# Basic usage
-mog owner/repo issue_number
+# Auto-detect repo from git remote (run from inside a git repo)
+mog 123
 
-# Examples
-mog workingdevshero/automate-it 123
-mog sparx-tech/hub-firmware 45
+# Explicit repo
+mog owner/repo 123
+
+# Include files the project needs at runtime (e.g. .env, credentials)
+# Files are copied into the worktree and removed before pushing
+mog 123 --include .env --include serviceAccountKey.json
+
+# List open issues
+mog list
+mog list --verbose
+mog owner/repo list --verbose
+```
+
+### Re-mogging
+
+Running `mog` again on an issue that already has an open PR will:
+
+1. Fetch review comments and feedback from the existing PR
+2. Include that feedback in the prompt so Claude addresses it
+3. Start fresh from the default branch
+4. Force-push to update the existing PR
+
+```bash
+# Re-mog after getting PR feedback — Claude sees reviewer comments
+mog 123
+
+# Start completely over, ignoring the existing PR
+mog 123 --fresh
 ```
 
 ## How it works
@@ -71,7 +99,8 @@ mog sparx-tech/hub-firmware 45
 ┌──────────────────────────────────────────────────────────┐
 │  Host machine                                            │
 │                                                          │
-│  1. gh issue view #123 → fetch title, body, labels       │
+│  1. gh issue view #123 → fetch title, body, labels,      │
+│     comments, and PR review feedback (if re-mogging)     │
 │  2. git worktree add → clean branch from default branch  │
 │                                                          │
 │  ┌────────────────────────────────────────────────────┐  │
@@ -80,12 +109,14 @@ mog sparx-tech/hub-firmware 45
 │  │  • ~/mog-repos mounted as workspace                │  │
 │  │  • Auth persists across runs (login once)          │  │
 │  │  • Isolated from host (own Docker daemon)          │  │
-│  │  • claude --dangerously-skip-permissions -p "..."  │  │
-│  │  • Reads code, implements fix, commits             │  │
+│  │  • Phase 1: Plan — analyze codebase, create plan   │  │
+│  │  • Phase 2: Build — execute tasks one at a time    │  │
+│  │  • Phase 3: Review — self-review for quality       │  │
 │  └────────────────────────────────────────────────────┘  │
 │                                                          │
-│  3. git push origin branch                               │
-│  4. gh pr create --body "Closes #123"                    │
+│  3. Squash commits into one                              │
+│  4. git push origin branch (force-push if updating PR)   │
+│  5. gh pr create --body "Closes #123" (or update PR)     │
 └──────────────────────────────────────────────────────────┘
 ```
 
@@ -94,7 +125,7 @@ mog sparx-tech/hub-firmware 45
 | Environment Variable | Default | Description |
 |---|---|---|
 | `MOG_REPOS_DIR` | `~/mog-repos` | Where repos are cloned and worktrees created (also the sandbox workspace) |
-| `MOG_MAX_ITERATIONS` | `10` | Max build loop iterations per issue |
+| `MOG_MAX_ITERATIONS` | `30` | Max build loop iterations per issue |
 | `MOG_MAX_CONTINUATIONS` | — | Legacy alias for `MOG_MAX_ITERATIONS` |
 
 ## Worktree management

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobbyg603/mog",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "One command to go from GitHub issue to pull request, powered by Claude Code in a Docker sandbox",
   "module": "src/index.ts",
   "type": "module",

package/src/github.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, expect } from "bun:test";
+import { cleanIssueTitle, getConventionalPrefix } from "./github";
+import type { Issue } from "./github";
+
+function makeIssue(labels: string): Issue {
+  return { title: "", body: "", labels, comments: "" };
+}
+
+describe("cleanIssueTitle", () => {
+  test("strips conventional commit prefix", () => {
+    expect(cleanIssueTitle("fix: BlueSky Integration")).toBe("BlueSky Integration");
+    expect(cleanIssueTitle("feat: Add new feature")).toBe("Add new feature");
+    expect(cleanIssueTitle("chore: Update deps")).toBe("Update deps");
+    expect(cleanIssueTitle("refactor: Clean up code")).toBe("Clean up code");
+  });
+
+  test("strips trailing issue references", () => {
+    expect(cleanIssueTitle("BlueSky Integration [#154]")).toBe("BlueSky Integration");
+    expect(cleanIssueTitle("Some feature [#42]")).toBe("Some feature");
+  });
+
+  test("strips both prefix and issue reference", () => {
+    expect(cleanIssueTitle("fix: BlueSky Integration [#154]")).toBe("BlueSky Integration");
+  });
+
+  test("strips multiple issue references", () => {
+    expect(cleanIssueTitle("fix: Something [#1] [#2]")).toBe("Something");
+    expect(cleanIssueTitle("BlueSky [#154] Integration [#184]")).toBe("BlueSky Integration");
+  });
+
+  test("leaves clean titles unchanged", () => {
+    expect(cleanIssueTitle("BlueSky Integration")).toBe("BlueSky Integration");
+    expect(cleanIssueTitle("Add support for webhooks")).toBe("Add support for webhooks");
+  });
+
+  test("is case-insensitive for prefix", () => {
+    expect(cleanIssueTitle("Fix: BlueSky Integration")).toBe("BlueSky Integration");
+    expect(cleanIssueTitle("FIX: BlueSky Integration")).toBe("BlueSky Integration");
+  });
+});
+
+describe("getConventionalPrefix", () => {
+  test("returns feat for enhancement label", () => {
+    expect(getConventionalPrefix(makeIssue("enhancement"))).toBe("feat");
+  });
+
+  test("returns feat for feature label", () => {
+    expect(getConventionalPrefix(makeIssue("feature"))).toBe("feat");
+  });
+
+  test("returns fix for bug label", () => {
+    expect(getConventionalPrefix(makeIssue("bug"))).toBe("fix");
+  });
+
+  test("returns fix for no labels", () => {
+    expect(getConventionalPrefix(makeIssue("none"))).toBe("fix");
+  });
+
+  test("does not false-positive on substring matches", () => {
+    expect(getConventionalPrefix(makeIssue("no-enhancement"))).toBe("fix");
+    expect(getConventionalPrefix(makeIssue("feature-request"))).toBe("fix");
+  });
+
+  test("handles multiple labels", () => {
+    expect(getConventionalPrefix(makeIssue("bug, enhancement"))).toBe("feat");
+    expect(getConventionalPrefix(makeIssue("priority, bug"))).toBe("fix");
+  });
+});

package/src/github.ts

@@ -127,6 +127,29 @@ export function fetchPRFeedback(repo: string, branchName: string): PRFeedback |
   return { prNumber, prUrl, reviews };
 }
 
+export function closePR(repo: string, prNumber: number): void {
+  const result = Bun.spawnSync([
+    "gh", "pr", "close", String(prNumber),
+    "--repo", repo,
+    "--delete-branch",
+  ]);
+  if (result.exitCode !== 0) {
+    log.warn(`Failed to close PR #${prNumber}.`);
+  }
+}
+
+export function cleanIssueTitle(title: string): string {
+  return title
+    .replace(/^(feat|fix|chore|docs|refactor|test|ci|build|perf|style):\s*/i, "")
+    .replace(/\s*\[#\d+\]/g, "")
+    .trim();
+}
+
+export function getConventionalPrefix(issue: Issue): string {
+  const labels = issue.labels.split(", ").map(l => l.trim());
+  return labels.includes("enhancement") || labels.includes("feature") ? "feat" : "fix";
+}
+
 export function pushAndCreatePR(
   repo: string,
   worktreeDir: string,
@@ -151,6 +174,8 @@ export function pushAndCreatePR(
     return;
   }
 
+  const prefix = getConventionalPrefix(issue);
+
   // Stage any unstaged changes Claude might have left
   if (hasUncommitted) {
     log.info("Staging uncommitted changes...");
@@ -158,22 +183,21 @@ export function pushAndCreatePR(
     if (addResult.exitCode !== 0) {
       log.die("Failed to stage changes.");
     }
-    const prefix = issue.labels.includes("enhancement") || issue.labels.includes("feature") ? "feat" : "fix";
-    const commitResult = Bun.spawnSync(["git", "commit", "-m", `${prefix}: address issue #${issueNum} - ${issue.title}`], { cwd: worktreeDir });
+    const commitResult = Bun.spawnSync(["git", "commit", "-m", `${prefix}: address issue #${issueNum} - ${cleanIssueTitle(issue.title)}`], { cwd: worktreeDir });
     if (commitResult.exitCode !== 0) {
       log.warn("Commit failed — changes may already be committed.");
     }
   }
 
-  // Squash all commits into one
-  const commitCount = Bun.spawnSync(["git", "rev-list", "--count", `${defaultBranch}..HEAD`], { cwd: worktreeDir });
+  // Squash all commits into one (use origin ref — local branch may be stale)
+  const mergeBase = `origin/${defaultBranch}`;
+  const commitCount = Bun.spawnSync(["git", "rev-list", "--count", `${mergeBase}..HEAD`], { cwd: worktreeDir });
   const count = parseInt(commitCount.stdout.toString().trim(), 10) || 0;
   if (count > 1) {
     log.info(`Squashing ${count} commits into one...`);
-    const prefix = issue.labels.includes("enhancement") || issue.labels.includes("feature") ? "feat" : "fix";
-    const squash = Bun.spawnSync(["git", "reset", "--soft", defaultBranch], { cwd: worktreeDir });
+    const squash = Bun.spawnSync(["git", "reset", "--soft", mergeBase], { cwd: worktreeDir });
     if (squash.exitCode === 0) {
-      const msg = `${prefix}: ${issue.title.toLowerCase()} (#${issueNum})`;
+      const msg = `${prefix}: ${cleanIssueTitle(issue.title).toLowerCase()} (#${issueNum})`;
       Bun.spawnSync(["git", "commit", "-m", msg], { cwd: worktreeDir });
       log.ok("Commits squashed.");
     } else {
@@ -181,9 +205,11 @@ export function pushAndCreatePR(
     }
   }
 
-  // Push (force-with-lease when updating an existing PR)
+  // Push — force-with-lease if the remote branch already exists
   log.info(`Pushing branch '${branchName}' to origin...`);
-  const pushArgs = existingPR
+  const remoteRef = Bun.spawnSync(["git", "ls-remote", "--heads", "origin", branchName], { cwd: worktreeDir });
+  const remoteBranchExists = remoteRef.stdout.toString().trim().length > 0;
+  const pushArgs = remoteBranchExists
     ? ["git", "push", "--force-with-lease", "-u", "origin", branchName]
     : ["git", "push", "-u", "origin", branchName];
   const push = Bun.spawnSync(pushArgs, { cwd: worktreeDir });
@@ -192,8 +218,22 @@ export function pushAndCreatePR(
   }
   log.ok("Branch pushed.");
 
+  const prTitle = `${prefix}: ${cleanIssueTitle(issue.title)} [#${issueNum}]`;
+  const prBody = buildPRBody(issueNum, summary);
+
   if (existingPR) {
-    // Update existing PR
+    // Update existing PR title and description
+    const edit = Bun.spawnSync([
+      "gh", "pr", "edit", String(existingPR.prNumber),
+      "--repo", repo,
+      "--title", prTitle,
+      "--body", prBody,
+    ], { cwd: worktreeDir });
+
+    if (edit.exitCode !== 0) {
+      log.warn("Failed to update PR title/description.");
+    }
+
     log.ok("Existing PR updated!");
     console.log(`\x1b[0;32m${existingPR.prUrl}\x1b[0m`);
     console.log();
@@ -206,26 +246,6 @@ export function pushAndCreatePR(
   // Create PR
   log.info("Opening pull request...");
 
-  const summarySection = summary
-    ? `### What was done\n\n${summary}\n\n`
-    : "";
-
-  const prBody = `## Summary
-
-Closes #${issueNum}
-
-${summarySection}This PR was generated by [mog](https://github.com/bobbyg603/mog) using Claude Code in a Docker sandbox.
-
-### Issue: ${issue.title}
-
-${issue.body}
-
----
-*Please review the changes carefully before merging.*`;
-
-  const prefix = issue.labels.includes("enhancement") || issue.labels.includes("feature") ? "feat" : "fix";
-  const prTitle = `${prefix}: ${issue.title} [#${issueNum}]`;
-
   const pr = Bun.spawnSync([
     "gh", "pr", "create",
     "--repo", repo,
@@ -248,3 +268,19 @@ ${issue.body}
   log.info(`Worktree: ${worktreeDir}`);
   log.info(`To clean up the worktree later: git worktree remove ${worktreeDir}`);
 }
+
+function buildPRBody(issueNum: string, summary?: string): string {
+  const summarySection = summary
+    ? `### What was done\n\n${summary}\n\n`
+    : "";
+
+  return `## Summary
+
+Closes #${issueNum}
+
+${summarySection}---
+
+This PR was generated by [mog](https://github.com/bobbyg603/mog) using Claude Code in a Docker sandbox.
+
+*Please review the changes carefully before merging.*`;
+}

package/src/index.ts

@@ -2,10 +2,9 @@
 
 import fs from "fs";
 import path from "path";
-import { fetchIssue, listIssues, fetchPRFeedback } from "./github";
+import { fetchIssue, listIssues, fetchPRFeedback, closePR, cleanIssueTitle, pushAndCreatePR } from "./github";
 import { detectRepo, ensureRepo, createWorktree } from "./worktree";
 import { runClaude } from "./sandbox";
-import { pushAndCreatePR } from "./github";
 import type { PRFeedback } from "./github";
 import { log } from "./log";
 
@@ -217,19 +216,21 @@ async function main() {
   log.info(`Default branch: ${defaultBranch}`);
 
   const { worktreeDir, branchName, reused } = createWorktree(
-    reposDir, owner, repoName, defaultBranch, issueNum, issue.title
+    reposDir, owner, repoName, defaultBranch, issueNum, cleanIssueTitle(issue.title), fresh
   );
 
-  // Check for existing PR (unless --fresh)
+  // Check for existing PR
   let existingPR: PRFeedback | undefined;
-  let isRetry = reused;
-  if (!fresh) {
-    const pr = fetchPRFeedback(repo, branchName);
-    if (pr) {
-      existingPR = pr;
-      isRetry = true;
-      log.ok(`Found existing PR #${pr.prNumber} — will include review feedback and update it.`);
-    }
+  let isRetry = fresh ? false : reused;
+  const pr = fetchPRFeedback(repo, branchName);
+  if (pr && fresh) {
+    log.info(`--fresh: closing existing PR #${pr.prNumber} and deleting remote branch...`);
+    closePR(repo, pr.prNumber);
+    log.ok(`PR #${pr.prNumber} closed. A new PR will be created.`);
+  } else if (pr) {
+    existingPR = pr;
+    isRetry = true;
+    log.ok(`Found existing PR #${pr.prNumber} — will include review feedback and update it.`);
   }
 
   // Copy included files into worktree
@@ -243,11 +244,12 @@ async function main() {
   }
 
   // Build prompts
-  const prFeedback = existingPR?.reviews || "";
+  const prFeedback = fresh ? "" : (existingPR?.reviews || "");
   const planningPrompt = buildPlanningPrompt(repo, issueNum, issue, prFeedback, isRetry);
   const buildingPromptFn = (remaining: string[], plan: string) =>
     buildBuildingPrompt(repo, issueNum, issue, remaining, plan);
-  const reviewPrompt = buildReviewPrompt(repo, issueNum, issue);
+  const reviewPrompt = buildReviewPrompt(repo, issueNum, issue, defaultBranch);
+  const summaryPrompt = buildSummaryPrompt(repo, issueNum, issue, defaultBranch);
 
   // Run Claude in sandbox
   log.info("Launching Claude Code in sandbox...");
@@ -255,7 +257,7 @@ async function main() {
   log.info(`Worktree: ${worktreeDir}`);
   console.log();
 
-  const summary = await runClaude(SANDBOX_NAME, worktreeDir, planningPrompt, buildingPromptFn, reviewPrompt);
+  const summary = await runClaude(SANDBOX_NAME, worktreeDir, defaultBranch, planningPrompt, buildingPromptFn, reviewPrompt, summaryPrompt);
 
   // Remove included files so they don't end up in the PR
   for (const filePath of copiedFiles) {
@@ -439,10 +441,46 @@ Rules:
 5. Do NOT work on any other tasks after committing.`;
 }
 
+function buildSummaryPrompt(
+  repo: string,
+  issueNum: string,
+  issue: { title: string; body: string; labels: string; comments: string },
+  defaultBranch: string,
+): string {
+  return `You are summarizing the changes made for GitHub issue #${issueNum} in the repository ${repo}.
+
+## Issue: ${issue.title}
+
+### Description
+${issue.body}
+
+## Instructions
+
+Run \`git diff ${defaultBranch}...HEAD\` to see all changes made on this branch.
+
+Write a concise summary of **all changes** made to resolve the issue and save it to a file called \`SUMMARY.md\` in the root of the repository. Do NOT commit this file.
+
+CRITICAL FORMATTING RULES — the file contents will be inserted directly into a PR body as-is:
+1. Do NOT make any code changes or commits.
+2. The file must start IMMEDIATELY with the first bullet point. No intro text like "Here's what was done" or "Let me summarize". No lead-in sentences whatsoever.
+3. Use a flat list of markdown bullet points (\`- \`). No headings, no sub-sections, no numbered lists.
+4. Each bullet should describe a concrete change: what was added, modified, or fixed and where.
+5. Keep it short — aim for 3-8 bullets. A reviewer should be able to scan it in 10 seconds.
+6. Do NOT list things that were reviewed but not changed. Only describe what actually changed.
+7. Do NOT repeat the issue title or description — the PR already includes those.
+8. End with the last bullet point. No closing remarks, no sign-off, no "Let me know" or "Done." after the bullets.
+
+Example of correct SUMMARY.md contents:
+- Added \`FooService\` class in \`src/services/foo.ts\` with retry logic and error handling
+- Updated \`src/routes/api.ts\` to wire up the new \`/foo\` endpoint
+- Added unit tests for \`FooService\` in \`src/services/__tests__/foo.test.ts\``;
+}
+
 function buildReviewPrompt(
   repo: string,
   issueNum: string,
   issue: { title: string; body: string; labels: string; comments: string },
+  defaultBranch: string,
 ): string {
   return `You are reviewing changes made for GitHub issue #${issueNum} in the repository ${repo}.
 
@@ -452,7 +490,7 @@ ${formatIssueContext(issueNum, issue)}
 
 All implementation tasks are complete. Your job is to **review the entire branch** for quality and completeness.
 
-Run \`git diff main...HEAD\` (or the equivalent for the default branch) to see all changes made.
+Run \`git diff ${defaultBranch}...HEAD\` to see all changes made.
 
 Check for:
 1. **Missed locations**: Search the codebase for similar patterns, logic, or code that handles the same concern as the changes. If the fix or feature was applied in one place but a similar pattern exists elsewhere, apply it there too.

package/src/sandbox.test.ts

@@ -0,0 +1,77 @@
+import { describe, test, expect } from "bun:test";
+import { readPlanFile, getUncheckedItems, isPlanComplete } from "./sandbox";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+describe("getUncheckedItems", () => {
+  test("returns unchecked items from plan content", () => {
+    const plan = `# Plan
+- [ ] First task
+- [x] Second task (done)
+- [ ] Third task`;
+    expect(getUncheckedItems(plan)).toEqual([
+      "- [ ] First task",
+      "- [ ] Third task",
+    ]);
+  });
+
+  test("returns empty array when all items are checked", () => {
+    const plan = `# Plan
+- [x] First task
+- [x] Second task`;
+    expect(getUncheckedItems(plan)).toEqual([]);
+  });
+
+  test("returns empty array for content with no checklist items", () => {
+    expect(getUncheckedItems("Just some text")).toEqual([]);
+  });
+
+  test("returns empty array for empty string", () => {
+    expect(getUncheckedItems("")).toEqual([]);
+  });
+});
+
+describe("isPlanComplete", () => {
+  test("returns true when all items are checked", () => {
+    const plan = `# Plan
+- [x] First task
+- [x] Second task`;
+    expect(isPlanComplete(plan)).toBe(true);
+  });
+
+  test("returns false when unchecked items remain", () => {
+    const plan = `# Plan
+- [x] First task
+- [ ] Second task`;
+    expect(isPlanComplete(plan)).toBe(false);
+  });
+
+  test("returns false when there are no checklist items at all", () => {
+    expect(isPlanComplete("Just some text")).toBe(false);
+  });
+
+  test("returns false for empty string", () => {
+    expect(isPlanComplete("")).toBe(false);
+  });
+});
+
+describe("readPlanFile", () => {
+  test("returns file content when plan file exists", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mog-test-"));
+    const planContent = "# Plan\n- [ ] Task one\n";
+    fs.writeFileSync(path.join(tmpDir, "IMPLEMENTATION_PLAN.md"), planContent);
+
+    expect(readPlanFile(tmpDir)).toBe(planContent);
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  test("returns null when plan file does not exist", () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mog-test-"));
+
+    expect(readPlanFile(tmpDir)).toBeNull();
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+});

package/src/sandbox.ts

@@ -22,6 +22,7 @@ const MAX_ITERATIONS = parseInt(
 );
 const MAX_STALLS = 2;
 const PLAN_FILENAME = "IMPLEMENTATION_PLAN.md";
+const SUMMARY_FILENAME = "SUMMARY.md";
 
 export function readPlanFile(worktreeDir: string): string | null {
   const planPath = `${worktreeDir}/${PLAN_FILENAME}`;
@@ -43,14 +44,24 @@ export function isPlanComplete(planContent: string): boolean {
   return unchecked.length === 0 && (checked?.length ?? 0) > 0;
 }
 
-function getCommitCount(sandboxName: string, worktreeDir: string): number {
+function getCommitCount(sandboxName: string, worktreeDir: string, defaultBranch: string): number {
   const result = Bun.spawnSync([
     "docker", "sandbox", "exec",
     "-w", worktreeDir,
     sandboxName,
-    "git", "rev-list", "HEAD", "--not", "--remotes", "--count",
+    "git", "rev-list", "--count", `origin/${defaultBranch}..HEAD`,
   ]);
-  if (result.exitCode !== 0) return 0;
+  if (result.exitCode !== 0) {
+    // Fallback: count commits not on any remote (works even if origin ref is missing)
+    const fallback = Bun.spawnSync([
+      "docker", "sandbox", "exec",
+      "-w", worktreeDir,
+      sandboxName,
+      "git", "rev-list", "HEAD", "--not", "--remotes", "--count",
+    ]);
+    if (fallback.exitCode !== 0) return 0;
+    return parseInt(fallback.stdout.toString().trim(), 10) || 0;
+  }
   return parseInt(result.stdout.toString().trim(), 10) || 0;
 }
 
@@ -71,17 +82,54 @@ function cleanupPlanFile(sandboxName: string, worktreeDir: string): void {
   ]);
 }
 
+function readSummaryFile(worktreeDir: string): string | null {
+  const summaryPath = `${worktreeDir}/${SUMMARY_FILENAME}`;
+  try {
+    const content = fs.readFileSync(summaryPath, "utf-8").trim();
+    // Clean up the file so it doesn't end up in commits
+    fs.unlinkSync(summaryPath);
+    return content || null;
+  } catch {
+    return null;
+  }
+}
+
+async function runSummaryPhase(
+  sandboxName: string,
+  worktreeDir: string,
+  defaultBranch: string,
+  summaryPrompt?: string,
+): Promise<string> {
+  if (!summaryPrompt || getCommitCount(sandboxName, worktreeDir, defaultBranch) <= 0) {
+    return "";
+  }
+
+  log.info("Summarizing changes...");
+  await execClaude(sandboxName, worktreeDir, ["-p", summaryPrompt]);
+
+  const summary = readSummaryFile(worktreeDir);
+  if (summary) {
+    log.ok("Summary generated.");
+    return summary;
+  }
+
+  log.warn("Claude did not write SUMMARY.md — PR will not have a summary section.");
+  return "";
+}
+
 export async function runClaude(
   sandboxName: string,
   worktreeDir: string,
+  defaultBranch: string,
   planningPrompt: string,
   buildingPromptFn: (remainingItems: string[], planContent: string) => string,
   reviewPrompt?: string,
+  summaryPrompt?: string,
 ): Promise<string> {
   let lastResult = "";
 
-  // Phase 1 — Planning
-  log.info("Phase 1: Creating implementation plan...");
+  // Planning
+  log.info("Planning implementation...");
   await execClaude(sandboxName, worktreeDir, ["-p", planningPrompt]);
 
   const planContent = readPlanFile(worktreeDir);
@@ -95,7 +143,7 @@ export async function runClaude(
     if (fallbackResult) lastResult = fallbackResult;
 
     for (let i = 0; i < MAX_ITERATIONS; i++) {
-      if (getCommitCount(sandboxName, worktreeDir) > 0) return lastResult;
+      if (getCommitCount(sandboxName, worktreeDir, defaultBranch) > 0) break;
       log.warn(`No commits yet — continuing Claude (attempt ${i + 2}/${MAX_ITERATIONS + 1})...`);
       const contResult = await execClaude(sandboxName, worktreeDir, [
         "--continue", "-p",
@@ -104,15 +152,17 @@ export async function runClaude(
       if (contResult) lastResult = contResult;
     }
 
-    if (getCommitCount(sandboxName, worktreeDir) === 0) {
+    if (getCommitCount(sandboxName, worktreeDir, defaultBranch) === 0) {
       log.warn("Claude did not produce any commits after all attempts.");
     }
-    return lastResult;
+
+    const summary = await runSummaryPhase(sandboxName, worktreeDir, defaultBranch, summaryPrompt);
+    return summary || lastResult;
   }
 
   log.ok(`Implementation plan created with ${unchecked.length} task(s).`);
 
-  // Phase 2 — Building loop
+  // Building loop
   let stallCount = 0;
 
   for (let i = 0; i < MAX_ITERATIONS; i++) {
@@ -128,7 +178,7 @@ export async function runClaude(
       break;
     }
 
-    const commitsBefore = getCommitCount(sandboxName, worktreeDir);
+    const commitsBefore = getCommitCount(sandboxName, worktreeDir, defaultBranch);
     const uncheckedBefore = remaining.length;
 
     log.info(`Iteration ${i + 1}/${MAX_ITERATIONS}: ${remaining[0]!.replace("- [ ] ", "")}`);
@@ -139,7 +189,7 @@ export async function runClaude(
 
     const planAfter = readPlanFile(worktreeDir);
     const uncheckedAfter = planAfter ? getUncheckedItems(planAfter).length : 0;
-    const commitsAfter = getCommitCount(sandboxName, worktreeDir);
+    const commitsAfter = getCommitCount(sandboxName, worktreeDir, defaultBranch);
 
     if (uncheckedAfter >= uncheckedBefore && commitsAfter <= commitsBefore) {
       stallCount++;
@@ -153,14 +203,14 @@ export async function runClaude(
     }
   }
 
-  // Phase 3 — Review
+  // Review
   if (reviewPrompt) {
-    log.info("Phase 3: Reviewing changes for quality and completeness...");
+    log.info("Reviewing changes for quality and completeness...");
     const reviewResult = await execClaude(sandboxName, worktreeDir, ["-p", reviewPrompt]);
     if (reviewResult) lastResult = reviewResult;
   }
 
-  // Phase 4 — Cleanup
+  // Cleanup
   cleanupPlanFile(sandboxName, worktreeDir);
 
   const finalPlan = readPlanFile(worktreeDir);
@@ -173,7 +223,9 @@ export async function runClaude(
     log.ok("Plan file cleaned up.");
   }
 
-  return lastResult;
+  // Summary
+  const summary = await runSummaryPhase(sandboxName, worktreeDir, defaultBranch, summaryPrompt);
+  return summary || lastResult;
 }
 
 async function execClaude(sandboxName: string, worktreeDir: string, claudeArgs: string[]): Promise<string> {

package/src/worktree.ts

@@ -72,7 +72,8 @@ export function createWorktree(
   repoName: string,
   defaultBranch: string,
   issueNum: string,
-  issueTitle: string
+  issueTitle: string,
+  fresh?: boolean,
 ): { worktreeDir: string; branchName: string; reused: boolean } {
   const safeTitle = issueTitle
     .toLowerCase()
@@ -85,6 +86,12 @@ export function createWorktree(
   const repoDir = `${reposDir}/${owner}/${repoName}`;
   const worktreeDir = `${reposDir}/${owner}/${repoName}-worktrees/${branchName}`;
 
+  if (fs.existsSync(worktreeDir) && fresh) {
+    log.info(`--fresh: removing existing worktree at ${worktreeDir}...`);
+    Bun.spawnSync(["git", "worktree", "remove", "--force", worktreeDir], { cwd: repoDir });
+    Bun.spawnSync(["git", "branch", "-D", branchName], { cwd: repoDir });
+  }
+
   if (fs.existsSync(worktreeDir)) {
     log.warn(`Worktree already exists at ${worktreeDir}, reusing.`);
     return { worktreeDir, branchName, reused: true };