@ikunin/sprintpilot 2.2.19 → 2.2.21

package/_Sprintpilot/lib/orchestrator/git-plan.js

@@ -523,6 +523,27 @@ function buildPrBody(state, profile, projectRoot, warnings) {
 // Both paths honor profile.squash_on_merge. The PR-merge path also
 // requires profile.platform_provider; non-github platforms fall through
 // to the local-merge sequence with a description note.
+// Build the worktree-cleanup steps appended to every merge_epic plan
+// when profile.worktree_cleanup_on_merge is true. Documented in
+// modules/git/config.yaml ("false = keep worktrees after epic
+// completion for inspection"). Falls back silently when the helper
+// script isn't available (partial install).
+function buildCleanupSteps(profile) {
+  if (!profile.worktree_cleanup_on_merge) return [];
+  if (!profile.worktree_enabled) return [];
+  return [
+    {
+      args: ['node', '_Sprintpilot/scripts/cleanup-worktrees.js'],
+      description: 'remove orphan worktrees whose branches were merged + deleted',
+      // SKIPPED (no .worktrees/ dir) returns 0; real failures here should
+      // not halt the merge — the epic is already merged, cleanup is
+      // best-effort housekeeping.
+      tolerate_exit_codes: [0, 1, 2],
+      optional: true,
+    },
+  ];
+}
+
 function planMergeEpic(state, profile, _action, branch) {
   const baseBranch = profile.base_branch || 'main';
   const squash = !!profile.squash_on_merge;
@@ -610,6 +631,7 @@ function planMergeEpic(state, profile, _action, branch) {
             description: `merge epic PR for ${branch} via gh (${squash ? 'squash' : 'merge'}, delete branch)`,
             env: Object.keys(env).length ? env : undefined,
           },
+          ...buildCleanupSteps(profile),
         ],
       };
     }
@@ -635,6 +657,7 @@ function planMergeEpic(state, profile, _action, branch) {
             description: `merge epic MR for ${branch} via glab${squash ? ' (squash)' : ''}`,
             env: Object.keys(env).length ? env : undefined,
           },
+          ...buildCleanupSteps(profile),
         ],
       };
     }
@@ -712,6 +735,7 @@ function planMergeEpic(state, profile, _action, branch) {
       retry: { attempts: 4, backoff_ms: [2000, 4000, 8000, 16000], on: 'network' },
     });
   }
+  for (const s of buildCleanupSteps(profile)) steps.push(s);
   return { branch, steps };
 }
 

package/_Sprintpilot/lib/orchestrator/profile-rules.js

@@ -105,6 +105,15 @@ function flatToProfile(resolved, profileName) {
       get(resolved, 'git.worktree.health_check_on_boot'),
       true,
     ),
+    // git.worktree.cleanup_on_merge — when true, planMergeEpic appends
+    // `git worktree prune` + per-directory cleanup steps so .worktrees/
+    // doesn't accumulate orphans after an epic merges. Documented in
+    // modules/git/config.yaml ("false = keep worktrees after epic
+    // completion for inspection").
+    worktree_cleanup_on_merge: coerceBool(
+      get(resolved, 'git.worktree.cleanup_on_merge'),
+      true,
+    ),
     squash_on_merge: coerceBool(get(resolved, 'git.squash_on_merge'), false),
     reuse_user_branch: coerceBool(get(resolved, 'git.reuse_user_branch'), false),
     merge_strategy: coerceEnum(

package/_Sprintpilot/lib/orchestrator/verify.js

@@ -353,22 +353,33 @@ function verifyDevRed(state, out, ctx) {
 
 function verifyDevGreen(state, out, ctx) {
   const issues = [];
+  let runnerTestsRun = null;
   if (ctx.runner) {
     const result = ctx.runner({ phase: 'green', files: out.test_files || [] });
     if (!result || typeof result.exit_code !== 'number') {
       issues.push('runner did not report exit_code');
     } else if (result.exit_code !== 0) {
       issues.push(`tests still failing on GREEN: exit ${result.exit_code}`);
-    } else if (typeof result.tests_run === 'number' && typeof out.tests_run === 'number') {
-      if (result.tests_run !== out.tests_run) {
-        issues.push(
-          `LLM reported ${out.tests_run} tests run but runner reported ${result.tests_run}`,
-        );
+    } else {
+      if (typeof result.tests_run === 'number') runnerTestsRun = result.tests_run;
+      if (typeof result.tests_run === 'number' && typeof out.tests_run === 'number') {
+        if (result.tests_run !== out.tests_run) {
+          issues.push(
+            `LLM reported ${out.tests_run} tests run but runner reported ${result.tests_run}`,
+          );
+        }
       }
     }
   }
+  // If the LLM omitted tests_run but the runner reported a positive
+  // count, accept the runner's number (same pattern as test_files
+  // auto-detect). A non-runner setup still requires the LLM to report.
   if (typeof out.tests_run !== 'number' || out.tests_run <= 0) {
-    issues.push('tests_run must be a positive number (per AGENTS.md test-result format)');
+    if (typeof runnerTestsRun === 'number' && runnerTestsRun > 0) {
+      // Recovered — don't push the "must be a positive number" issue.
+    } else {
+      issues.push('tests_run must be a positive number (per AGENTS.md test-result format)');
+    }
   }
   return { ok: issues.length === 0, issues };
 }
@@ -449,6 +460,7 @@ function verifyPatchApply(state, out, _ctx) {
 
 function verifyPatchRetest(state, out, ctx) {
   const issues = [];
+  let runnerTestsRun = null;
   if (ctx.runner) {
     const result = ctx.runner({
       phase: 'rereview',
@@ -458,10 +470,16 @@ function verifyPatchRetest(state, out, ctx) {
       issues.push('runner did not report exit_code');
     } else if (result.exit_code !== 0) {
       issues.push(`tests failed after patch: exit ${result.exit_code}`);
+    } else if (typeof result.tests_run === 'number') {
+      runnerTestsRun = result.tests_run;
     }
   }
+  // Same auto-recovery as verifyDevGreen: accept the runner's count when
+  // the LLM omits tests_run.
   if (typeof out.tests_run !== 'number' || out.tests_run <= 0) {
-    issues.push('tests_run must be a positive number');
+    if (!(typeof runnerTestsRun === 'number' && runnerTestsRun > 0)) {
+      issues.push('tests_run must be a positive number');
+    }
   }
   return { ok: issues.length === 0, issues };
 }

package/_Sprintpilot/manifest.yaml

@@ -1,6 +1,6 @@
 addon:
   name: sprintpilot
-  version: 2.2.19
+  version: 2.2.21
   description: Sprintpilot — autopilot and multi-agent addon for BMad Method (git workflow, parallel agents, autonomous story execution)
   bmad_compatibility: ">=6.2.0"
   modules:

package/_Sprintpilot/scripts/cleanup-worktrees.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+// cleanup-worktrees.js — remove orphan worktrees under .worktrees/.
+//
+// After `gh pr merge --delete-branch` (or any branch deletion), the
+// branch is gone but the `.worktrees/<name>/` directory remains. Git's
+// `git worktree prune` removes the `.git/worktrees/<name>/` metadata
+// but NOT the actual directory. Without explicit cleanup, .worktrees/
+// accumulates orphans every epic merge.
+//
+// This script:
+//   1. Runs `git worktree prune --expire now` to clear metadata.
+//   2. Walks `.worktrees/*` and removes directories whose branches no
+//      longer resolve (locally and on origin).
+//
+// Honors `git.worktree.cleanup_on_merge` via the orchestrator's plan —
+// this script is only invoked when that flag is true. Standalone use:
+//
+//   node _Sprintpilot/scripts/cleanup-worktrees.js \
+//     [--worktrees-dir .worktrees] [--project-root <path>] [--dry-run]
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const cp = require('node:child_process');
+
+const { parseArgs } = require('../lib/runtime/args');
+const log = require('../lib/runtime/log');
+
+function git(cwd, args, opts) {
+  return cp.spawnSync('git', ['-C', cwd, ...args], Object.assign({
+    encoding: 'utf8',
+    timeout: 10000,
+  }, opts || {}));
+}
+
+function localBranchExists(projectRoot, branch) {
+  const r = git(projectRoot, ['show-ref', '--verify', '--quiet', 'refs/heads/' + branch], {
+    stdio: 'ignore',
+  });
+  return r.status === 0;
+}
+
+function remoteBranchExists(projectRoot, branch) {
+  const r = git(
+    projectRoot,
+    ['show-ref', '--verify', '--quiet', 'refs/remotes/origin/' + branch],
+    { stdio: 'ignore' },
+  );
+  return r.status === 0;
+}
+
+function detectBranchFromGitfile(worktreeDir) {
+  const gitfile = path.join(worktreeDir, '.git');
+  let raw;
+  try {
+    raw = fs.readFileSync(gitfile, 'utf8');
+  } catch (_e) {
+    return { kind: 'unknown', branch: null };
+  }
+  const m = /^gitdir:\s*(.+)$/m.exec(raw);
+  if (!m) return { kind: 'unknown', branch: null };
+  const gitdir = m[1].trim();
+  if (!fs.existsSync(gitdir)) {
+    return { kind: 'orphan', branch: null };
+  }
+  const headPath = path.join(gitdir, 'HEAD');
+  let head;
+  try {
+    head = fs.readFileSync(headPath, 'utf8').trim();
+  } catch (_e) {
+    return { kind: 'orphan', branch: null };
+  }
+  const refMatch = /^ref:\s*refs\/heads\/(.+)$/m.exec(head);
+  if (!refMatch) return { kind: 'detached', branch: null };
+  return { kind: 'attached', branch: refMatch[1] };
+}
+
+function main() {
+  const { opts } = parseArgs(process.argv.slice(2));
+  if (opts.help) {
+    log.out(
+      'Usage: cleanup-worktrees.js [--worktrees-dir .worktrees] [--project-root <path>] [--dry-run]',
+    );
+    process.exit(0);
+  }
+  const projectRoot = opts['project-root'] || process.cwd();
+  const worktreesDir = opts['worktrees-dir']
+    ? path.resolve(opts['worktrees-dir'])
+    : path.join(projectRoot, '.worktrees');
+  const dryRun = !!opts['dry-run'];
+
+  const prune = git(projectRoot, ['worktree', 'prune', '--expire', 'now']);
+  if (prune.status !== 0 && prune.error) {
+    log.error('git worktree prune failed: ' + prune.error.message);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(worktreesDir)) {
+    log.out('SUMMARY:0:0:0');
+    return;
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(worktreesDir, { withFileTypes: true });
+  } catch (e) {
+    log.error('cannot read ' + worktreesDir + ': ' + e.message);
+    process.exit(1);
+  }
+
+  let inspected = 0;
+  let removed = 0;
+  let kept = 0;
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    inspected += 1;
+    const wt = path.join(worktreesDir, ent.name);
+    const info = detectBranchFromGitfile(wt);
+
+    let orphan = false;
+    if (info.kind === 'orphan') {
+      orphan = true;
+    } else if (info.kind === 'attached' && info.branch) {
+      const localOk = localBranchExists(projectRoot, info.branch);
+      const remoteOk = remoteBranchExists(projectRoot, info.branch);
+      if (!localOk && !remoteOk) orphan = true;
+    } else {
+      kept += 1;
+      continue;
+    }
+
+    if (!orphan) {
+      kept += 1;
+      continue;
+    }
+
+    log.out('ORPHAN:' + ent.name);
+    if (dryRun) {
+      removed += 1;
+      continue;
+    }
+    const r = git(projectRoot, ['worktree', 'remove', '--force', wt], { stdio: 'ignore' });
+    if (r.status !== 0) {
+      try {
+        fs.rmSync(wt, { recursive: true, force: true });
+      } catch (e) {
+        log.err('WARN: cannot remove ' + wt + ': ' + e.message);
+        continue;
+      }
+    }
+    removed += 1;
+  }
+
+  log.out('SUMMARY:' + inspected + ':' + removed + ':' + kept);
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikunin/sprintpilot",
-  "version": "2.2.19",
+  "version": "2.2.21",
   "description": "Sprintpilot — autopilot and multi-agent addon for BMad Method v6: git workflow, parallel agents, autonomous story execution",
   "license": "Apache-2.0",
   "repository": {