pan-wizard 3.34.0 → 3.36.0

package/pan-wizard-core/bin/lib/verify-red.cjs

@@ -0,0 +1,138 @@
+'use strict';
+/**
+ * RED and catch proof (program V4): does each test this phase wrote actually test what
+ * the phase built?
+ *
+ * A test that passes before the phase's code exists cannot have caught anything: it is
+ * tautological, or it tests something the phase did not change. So, independent of the
+ * order the commits landed in (Meta's "weak catch"):
+ *
+ *   base    the parent of the phase's oldest plan commit (`{type}({phase}-{plan}):`)
+ *   tests   the test files the phase's plan commits added or changed, as they are now
+ *   red     in a throwaway worktree at the base, with the test file copied in from HEAD,
+ *           the test must FAIL (a crash on a missing module counts: the code is not there)
+ *   green   at HEAD it must PASS
+ *
+ *   caught       red at the base, green at HEAD
+ *   not_red      passes without the phase's code: it cannot have caught a regression
+ *   not_green    fails at HEAD: the test gate reports that, not this check
+ *   not_checked  no command can run that one file (cargo, Maven, Gradle, make), with why
+ *
+ * Each file runs on its own (`workflow.test_file_command`, else derived from the suite's
+ * runner: test-gate.cjs `fileCommand`). The worktree links the project's node_modules,
+ * which git does not track, so a JS runner resolves the same at the base as at HEAD.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execGit, findPhaseInternal, output, error } = require('./core.cjs');
+const { committedFiles } = require('./verify-scope.cjs');
+const { isTestFile } = require('./verify-integrity.cjs');
+const TG = require('./test-gate.cjs');
+
+const DEFAULT_FILE_TIMEOUT_MS = 5 * 60 * 1000;
+
+/**
+ * The commit the phase started from: the parent of its oldest plan commit.
+ * @returns {{base: string, files: Set<string>, commits: number}|{base: null, reason: string}}
+ */
+function phaseBase(cwd, phase) {
+  const c = committedFiles(cwd, phase);
+  if (!c.git) return { base: null, reason: 'git is unavailable' };
+  if (!c.commits) return { base: null, reason: 'the phase has no plan commits (subjects like feat(03-01): …)' };
+  const oldest = c.hashes[c.hashes.length - 1];
+  const r = execGit(cwd, ['rev-parse', '--verify', '-q', `${oldest}^`]);
+  if (r.exitCode !== 0 || !r.stdout) return { base: null, reason: 'the phase starts at the first commit of the repository: there is no base to run against' };
+  return { base: r.stdout.trim(), files: c.files, commits: c.commits };
+}
+
+/** Remove a directory link (a junction or a symlink) without touching what it points to. */
+function unlinkDir(p) {
+  try { fs.unlinkSync(p); } catch { try { fs.rmdirSync(p); } catch { /* already gone */ } }
+}
+
+/**
+ * Run `fn(dir)` in a detached worktree at `rev`, then remove the worktree. The project's
+ * node_modules is linked in (and unlinked before git removes the worktree, so the removal
+ * can never reach the real one).
+ * @returns {{value?: *, error?: string}}
+ */
+function withWorktree(cwd, rev, fn) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pan-wt-'));
+  const dir = path.join(root, 'wt');
+  const add = execGit(cwd, ['worktree', 'add', '--detach', '-q', dir, rev]);
+  if (add.exitCode !== 0) {
+    try { fs.rmSync(root, { recursive: true, force: true }); } catch { /* best effort */ }
+    return { error: `git worktree add failed: ${add.stderr || add.stdout}` };
+  }
+  const link = path.join(dir, 'node_modules');
+  let linked = false;
+  try {
+    const modules = path.join(cwd, 'node_modules');
+    if (fs.existsSync(modules) && !fs.existsSync(link)) {
+      try { fs.symlinkSync(modules, link, 'junction'); linked = true; } catch { /* runs without it */ }
+    }
+    return { value: fn(dir) };
+  } finally {
+    if (linked) unlinkDir(link);
+    execGit(cwd, ['worktree', 'remove', '--force', dir]);
+    execGit(cwd, ['worktree', 'prune']);
+    try { fs.rmSync(root, { recursive: true, force: true }); } catch { /* best effort */ }
+  }
+}
+
+const tail = (s) => TG.stripAnsi(String(s || '')).replace(/\r\n?/g, '\n').trim().split('\n').slice(-6).join('\n');
+
+/**
+ * The RED/catch proof for one phase.
+ * @param {string} cwd
+ * @param {string} phase
+ * @param {{timeoutMs?: number}} [opts]
+ * @returns {Object} `{phase, checked, ok, base, files: [{file, verdict, command, base_exit, head_exit, detail}], reason?}` or `{error, reason}`
+ */
+function checkRed(cwd, phase, opts = {}) {
+  const info = findPhaseInternal(cwd, phase);
+  if (!info) return { error: 'phase_not_found', reason: `no phase directory for phase ${phase}` };
+  const phaseNumber = info.phase_number || String(phase);
+  const b = phaseBase(cwd, phaseNumber);
+  if (!b.base) return { phase: phaseNumber, checked: false, ok: true, files: [], reason: b.reason };
+  const tests = [...b.files].filter((f) => isTestFile(f) && fs.existsSync(path.join(cwd, f))).sort();
+  if (!tests.length) return { phase: phaseNumber, checked: false, ok: true, base: b.base, files: [], reason: 'the phase changed no test file' };
+  const timeoutMs = opts.timeoutMs || DEFAULT_FILE_TIMEOUT_MS;
+  const files = [];
+  const wt = withWorktree(cwd, b.base, (dir) => {
+    for (const file of tests) {
+      const fc = TG.fileCommand(cwd, file);
+      if (!fc.command) { files.push({ file, verdict: 'not_checked', detail: fc.reason }); continue; }
+      const dest = path.join(dir, file);
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(path.join(cwd, file), dest);
+      const atBase = TG.runCommand(dir, fc.command, timeoutMs);
+      const atHead = TG.runCommand(cwd, fc.command, timeoutMs);
+      const red = atBase.exit !== 0;
+      const green = atHead.exit === 0;
+      const verdict = red && green ? 'caught' : (!red ? 'not_red' : 'not_green');
+      const detail = verdict === 'not_red'
+        ? 'passes without the phase\'s code: it is tautological, or tests something the phase did not change'
+        : verdict === 'not_green' ? `fails at HEAD: ${tail(atHead.output)}` : null;
+      files.push({ file, verdict, command: fc.command, base_exit: atBase.exit, head_exit: atHead.exit, ...(detail ? { detail } : {}) });
+    }
+  });
+  if (wt.error) return { phase: phaseNumber, checked: false, ok: true, base: b.base, files: [], reason: wt.error };
+  const ran = files.filter((f) => f.verdict !== 'not_checked');
+  return {
+    phase: phaseNumber, checked: ran.length > 0, ok: ran.every((f) => f.verdict === 'caught'), base: b.base,
+    caught: ran.filter((f) => f.verdict === 'caught').length, files,
+    ...(ran.length ? {} : { reason: 'no changed test file could be run on its own' }),
+  };
+}
+
+/** `pan-tools verify red <phase> [--timeout <ms>]`: exit 1 when a test is not_red or not_green. */
+function cmdVerifyRed(cwd, phase, raw, opts = {}) {
+  if (!phase) error('Usage: verify red <phase> [--timeout <ms>]');
+  const r = checkRed(cwd, phase, { timeoutMs: opts.timeout ? Number(opts.timeout) : undefined });
+  if (r.error) error(r.reason);
+  output(r, raw, !r.checked ? 'not_checked' : (r.ok ? 'caught' : 'not_caught'), r.ok ? 0 : 1);
+}
+
+module.exports = { checkRed, cmdVerifyRed, phaseBase, withWorktree };

package/pan-wizard-core/bin/lib/verify-scope.cjs

@@ -17,7 +17,7 @@
 const fs = require('fs');
 const path = require('path');
 const { safeReadFile, execGit, findPhaseInternal, toPosix, output, escapeRegex } = require('./core.cjs');
-const { extractFrontmatter } = require('./frontmatter.cjs');
+const { extractFrontmatter, parseMustHavesBlock } = require('./frontmatter.cjs');
 const { isPlanFile, isSummaryFile, isVerificationFile } = require('./constants.cjs');
 const { planningRel } = require('./utils.cjs');
 
@@ -68,27 +68,28 @@ function exclusionReason(file, planningPrefix) {
 
 /**
  * Files the phase's plan commits touched, paths relative to `cwd` (git's --relative).
- * @returns {{git: boolean, commits: number, files: Set<string>}}
+ * @returns {{git: boolean, commits: number, files: Set<string>, hashes: string[]}} hashes newest first
  */
 function committedFiles(cwd, phaseNumber) {
   const r = execGit(cwd, ['-c', 'core.quotepath=off', 'log', '--no-merges', '-n', String(COMMIT_SCAN_LIMIT), '--relative', '--name-only', '--format=@@%H%x09%s']);
-  if (r.exitCode !== 0) return { git: false, commits: 0, files: new Set() };
+  if (r.exitCode !== 0) return { git: false, commits: 0, files: new Set(), hashes: [] };
   // `{type}({phase}-{plan}):` with the phase's zero padding optional ("feat(03-01):", "fix(3-02)!:").
   const unpadded = String(phaseNumber).replace(/^0+(?=\d)/, '');
   const subjectRe = new RegExp(`^[a-z]+\\(0*${escapeRegex(unpadded)}-[0-9]+\\)!?:`);
   const files = new Set();
+  const hashes = [];
   let commits = 0;
   let inPhase = false;
   for (const line of r.stdout.split('\n')) {
     if (line.startsWith('@@')) {
       const subject = line.slice(2).split('\t').slice(1).join('\t');
       inPhase = subjectRe.test(subject);
-      if (inPhase) commits++;
+      if (inPhase) { commits++; hashes.push(line.slice(2).split('\t')[0]); }
       continue;
     }
     if (inPhase && line.trim()) files.add(normalisePath(line));
   }
-  return { git: true, commits, files };
+  return { git: true, commits, files, hashes };
 }
 
 /**
@@ -150,6 +151,147 @@ function scopePhase(cwd, phase) {
   };
 }
 
+// ─── Review scope (program R1) ───────────────────────────────────────────────
+// The reviewer used to get the summaries' key-files: what the executor said it touched.
+// A file the executor changed and did not list was never reviewed. The review scope is
+// the diff instead (the phase's plan commits, plus work not yet committed), with the
+// intent the code is judged against: each plan's objective, must_haves and Review Focus,
+// and the text of the requirements the plans claim.
+
+/** Files modified, staged or untracked in the working tree, relative to cwd. */
+function workingTreeFiles(cwd) {
+  // Porcelain v2 with -z: each entry starts with its type (`1`, `2`, `u`, `?`), never a
+  // space, and paths come unquoted. v1 starts an unstaged edit with a space (" M a.js"),
+  // which execGit's trim() cut off the first line, and the path lost its first letter.
+  const r = execGit(cwd, ['status', '--porcelain=v2', '-z', '--untracked-files=all', '--', '.']);
+  if (r.exitCode !== 0) return { git: false, uncommitted: [], untracked: [] };
+  const top = execGit(cwd, ['rev-parse', '--show-prefix']);
+  const prefix = top.exitCode === 0 ? normalisePath(top.stdout.trim()) : '';
+  const rel = (p) => { const n = normalisePath(p); return prefix && n.startsWith(prefix) ? n.slice(prefix.length) : n; };
+  const uncommitted = [];
+  const untracked = [];
+  const entries = r.stdout.split('\0');
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    if (!e) continue;
+    const f = e.split(' ');
+    if (e[0] === '?') untracked.push(rel(e.slice(2)));
+    else if (e[0] === '1') { if (!f[1].includes('D')) uncommitted.push(rel(f.slice(8).join(' '))); }
+    else if (e[0] === '2') { if (!f[1].includes('D')) uncommitted.push(rel(f.slice(9).join(' '))); i++; } // the next entry is the old path
+    else if (e[0] === 'u') uncommitted.push(rel(f.slice(10).join(' ')));
+  }
+  return { git: true, uncommitted, untracked };
+}
+
+/** A markdown section's body, from its `## <title>` heading to the next heading of the same or higher level. */
+function sectionBody(text, title) {
+  const lines = String(text || '').replace(/\r\n/g, '\n').split('\n');
+  const re = new RegExp(`^(#{1,6})\\s+${escapeRegex(title)}\\s*$`, 'i');
+  const at = lines.findIndex((l) => re.test(l.trim()));
+  if (at === -1) return null;
+  const level = lines[at].trim().match(/^#+/)[0].length;
+  const out = [];
+  for (let i = at + 1; i < lines.length; i++) {
+    const h = lines[i].match(/^(#{1,6})\s/);
+    if (h && h[1].length <= level) break;
+    out.push(lines[i]);
+  }
+  const body = out.join('\n').trim();
+  return body || null;
+}
+
+/** The text between `<tag>` and `</tag>`, trimmed, or null. */
+function tagBody(text, tag) {
+  const m = String(text || '').match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`));
+  return m && m[1].trim() ? m[1].trim() : null;
+}
+
+/**
+ * What a reviewer of one phase reads: the diff and the intent.
+ * @returns {Object} `{phase, directory, base, files: [{path, sources, listed}], unlisted, excluded,
+ *   intent: {plans: [{plan, objective, must_haves, review_focus, requirements}], requirements: [{id, text}], missing_requirements}, git, commits}`
+ *   or `{error, reason}`. `sources` is any of commit · summary · uncommitted · untracked;
+ *   `listed` is whether a summary's key-files names it; `unlisted` lists the files that are not.
+ */
+function reviewScope(cwd, phase) {
+  const info = findPhaseInternal(cwd, phase);
+  if (!info) return { error: 'phase_not_found', reason: `no phase directory for phase ${phase}` };
+  const dir = path.join(cwd, info.directory);
+  const sources = new Map();
+  const note = (file, source) => {
+    if (!file) return;
+    if (!sources.has(file)) sources.set(file, new Set());
+    sources.get(file).add(source);
+  };
+  const listed = new Set();
+  for (const f of info.summaries.filter(isSummaryFile)) {
+    const fm = extractFrontmatter(safeReadFile(path.join(dir, f)) || '');
+    const kf = fm['key-files'] || fm.key_files || {};
+    for (const p of [...asList(kf.created), ...asList(kf.modified)]) { const n = normalisePath(p); if (n) { listed.add(n); note(n, 'summary'); } }
+  }
+  const git = committedFiles(cwd, info.phase_number);
+  for (const p of git.files) note(p, 'commit');
+  const wt = workingTreeFiles(cwd);
+  for (const p of wt.uncommitted) note(p, 'uncommitted');
+  for (const p of wt.untracked) note(p, 'untracked');
+
+  const planningPrefix = normalisePath(planningRel());
+  const files = [];
+  const excluded = [];
+  for (const file of [...sources.keys()].sort()) {
+    const why = exclusionReason(file, planningPrefix);
+    if (why) { excluded.push({ path: file, reason: why }); continue; }
+    // A file deleted by the phase has nothing left to read.
+    if (!fs.existsSync(path.join(cwd, file))) continue;
+    files.push({ path: file, sources: [...sources.get(file)].sort(), listed: listed.has(file) });
+  }
+
+  const plans = [];
+  const reqIds = new Set();
+  for (const f of info.plans.filter(isPlanFile).sort()) {
+    const text = safeReadFile(path.join(dir, f)) || '';
+    const fm = extractFrontmatter(text);
+    const requirements = asList(fm.requirements).map((s) => s.trim()).filter(Boolean);
+    for (const id of requirements) reqIds.add(id);
+    const mh = fm.must_haves && typeof fm.must_haves === 'object' ? fm.must_haves : {};
+    plans.push({
+      plan: f,
+      objective: tagBody(text, 'objective'),
+      must_haves: { truths: asList(mh.truths), artifacts: parseMustHavesBlock(text, 'artifacts'), key_links: parseMustHavesBlock(text, 'key_links') },
+      review_focus: sectionBody(text, 'Review Focus'),
+      requirements,
+    });
+  }
+  const { requirementLines } = require('./roadmap.cjs');
+  const reqText = safeReadFile(path.join(cwd, planningRel(), 'requirements.md')) || '';
+  const ids = [...reqIds].sort();
+  const requirements = ids.map((id) => ({ id, text: requirementLines(reqText, [id]).lines.join('\n').trim() || null }));
+
+  let base = null;
+  if (git.hashes.length) {
+    const r = execGit(cwd, ['rev-parse', '--verify', '-q', `${git.hashes[git.hashes.length - 1]}^`]);
+    if (r.exitCode === 0 && r.stdout) base = r.stdout.trim();
+  }
+  return {
+    phase: info.phase_number,
+    directory: info.directory,
+    base,
+    files,
+    unlisted: files.filter((f) => !f.listed).map((f) => f.path),
+    excluded,
+    intent: { plans, requirements, missing_requirements: requirements.filter((r) => !r.text).map((r) => r.id) },
+    git: git.git,
+    commits: git.commits,
+  };
+}
+
+/** `pan-tools review scope <phase>`: the JSON scope; `--raw` prints the file paths, one per line. */
+function cmdReviewScope(cwd, phase, raw) {
+  if (!phase) { output({ error: 'phase_required', reason: 'Usage: review scope <phase>' }, raw); return; }
+  const r = reviewScope(cwd, phase);
+  output(r, raw, r.error ? undefined : r.files.map((f) => f.path).join('\n'));
+}
+
 function cmdVerifyScope(cwd, phase, raw) {
   if (!phase) { output({ error: 'phase_required', reason: 'Usage: verify scope <phase>' }, raw); return; }
   const r = scopePhase(cwd, phase);
@@ -223,4 +365,4 @@ function cmdVerifyStale(cwd, phase, raw) {
   output(r, raw, r.error ? undefined : r.state);
 }
 
-module.exports = { scopePhase, cmdVerifyScope, verificationFreshness, cmdVerifyStale, coveredFiles, LOCKFILES };
+module.exports = { scopePhase, cmdVerifyScope, reviewScope, cmdReviewScope, workingTreeFiles, sectionBody, verificationFreshness, cmdVerifyStale, coveredFiles, committedFiles, LOCKFILES, TEST_PATH_RE, TEST_FILE_RE };

package/pan-wizard-core/bin/lib/verify.cjs

@@ -572,8 +572,21 @@ function reconcilePhase(cwd, phaseNum) {
       contradictions.push(`verification status "${status}" but ${keyLinks.total - keyLinks.verified}/${keyLinks.total} key-link(s) UNWIRED`);
     }
   }
+  // The engine's test run (V2) is the record the verifier copies its test gate from: a
+  // verification that says otherwise, or passes over a failed run, contradicts it.
+  const testRun = require('./test-gate.cjs').readTestRun(cwd, phaseNum);
+  const writtenGate = (verRaw.match(/^test_gate:\s*([A-Za-z_]+)/m) || [])[1] || null;
+  if (testRun && testRun.status) {
+    const why = testRun.reason ? ` (${testRun.reason})` : '';
+    if (writtenGate && writtenGate.toLowerCase() !== testRun.status) {
+      contradictions.push(`verification test_gate "${writtenGate}" but the engine's test run recorded "${testRun.status}"${why}`);
+    } else if (!writtenGate && claimsPass && testRun.status === 'failed') {
+      contradictions.push(`verification status "${status}" but the engine's test run failed${why}`);
+    }
+  }
   return {
     phase: String(phaseNum), found: true, verification_status: status, claims_pass: claimsPass,
+    test_run: testRun ? { status: testRun.status, head: testRun.head || null, regressions: (testRun.regressions || []).length } : undefined,
     mechanical_signals: signals, artifacts, key_links: keyLinks, contradictions,
     reconciled: contradictions.length === 0,
     note: signals === 0 ? 'no must_haves declared — mechanical reconciliation unavailable; verdict trusted' : undefined,
@@ -1557,35 +1570,22 @@ function cmdValidateHealth(cwd, options, raw) {
 }
 
 /**
- * Run node --test and capture result.
+ * Run the project's tests through the engine's test gate (V2): any language, the
+ * project's own command, and a crash reads failed. `pass` is null when there was nothing
+ * to run (no test command, or one that ran no tests).
  */
 function runFullTestCheck(cwd) {
-  try {
-    const result = execFileSync('node', ['--test'], {
-      cwd,
-      timeout: 120000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      encoding: 'utf-8',
-    });
-    // Match both TAP ("# tests N") and spec-reporter ("ℹ tests N") summaries —
-    // modern node --test defaults to the spec reporter, which the old "# "-only
-    // regex silently missed (returning tests: null).
-    const testMatch = result.match(/[#ℹ]\s*tests\s+(\d+)/);
-    const passMatch = result.match(/[#ℹ]\s*pass\s+(\d+)/);
-    return {
-      pass: true,
-      exitCode: 0,
-      tests: testMatch ? parseInt(testMatch[1], 10) : null,
-      passing: passMatch ? parseInt(passMatch[1], 10) : null,
-    };
-  } catch (err) {
-    return {
-      pass: false,
-      exitCode: err.status || 1,
-      tests: null,
-      passing: null,
-    };
-  }
+  const rec = require('./test-gate.cjs').runTests(cwd, { timeoutMs: 120000 });
+  return {
+    pass: rec.status === 'passed' ? true : (rec.status === 'failed' ? false : null),
+    exitCode: rec.exit,
+    tests: rec.total,
+    passing: rec.passed,
+    status: rec.status,
+    command: rec.command,
+    reason: rec.reason || undefined,
+    failing: rec.failing && rec.failing.length ? rec.failing.slice(0, 20) : undefined,
+  };
 }
 
 /**

package/pan-wizard-core/bin/lib/whatif.cjs

@@ -210,10 +210,38 @@ function createWorktree(cwd, phaseNum, scenario, opts) {
   };
 }
 
+/** Registered worktrees as {path, branch}; branch is null on a detached HEAD. */
+function listWorktrees(cwd) {
+  const r = execGit(cwd, ['worktree', 'list', '--porcelain']);
+  if (r.exitCode !== 0) return [];
+  const list = [];
+  for (const line of r.stdout.split(/\r?\n/)) {
+    if (line.startsWith('worktree ')) list.push({ path: line.slice('worktree '.length), branch: null });
+    else if (line.startsWith('branch ') && list.length) list[list.length - 1].branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+  }
+  return list;
+}
+
+function samePath(a, b) {
+  const norm = (p) => {
+    let r = path.resolve(p);
+    try { r = fs.realpathSync.native(r); } catch { /* gone: compare the resolved form */ }
+    r = toPosix(r);
+    return process.platform === 'win32' ? r.toLowerCase() : r;
+  };
+  return norm(a) === norm(b);
+}
+
 /**
  * Remove a worktree + its branch. Best-effort: errors are surfaced but
  * don't block subsequent cleanups.
  *
+ * Only what-if's own objects are touched: the branch must carry BRANCH_PREFIX and the
+ * worktree, when git still lists it, must be checked out on that branch (or, with no
+ * branch given, on some BRANCH_PREFIX branch). Anything else is refused before a single
+ * git write, because `branch -D` and `worktree remove --force` destroy unmerged commits
+ * and uncommitted files.
+ *
  * @param {string} cwd - Main project root (for the cleanup git call)
  * @param {string} worktreePath - Path returned by createWorktree
  * @param {string} branch - Branch name returned by createWorktree
@@ -224,15 +252,29 @@ function cleanupWorktree(cwd, worktreePath, branch, opts) {
   if (!isGitRepo(cwd)) {
     return { error: 'Not a git repo' };
   }
+  if (branch && !branch.startsWith(BRANCH_PREFIX)) {
+    return { error: `Refusing to delete branch '${branch}': what-if only cleans up branches it created (${BRANCH_PREFIX}*)` };
+  }
+  const entry = listWorktrees(cwd).find(w => samePath(w.path, worktreePath));
+  if (entry) {
+    const owned = entry.branch && entry.branch.startsWith(BRANCH_PREFIX) && (!branch || entry.branch === branch);
+    if (!owned) {
+      return { error: `Refusing to remove worktree ${toPosix(worktreePath)}: it is on '${entry.branch || 'a detached HEAD'}', not ${branch || BRANCH_PREFIX + '*'}` };
+    }
+  }
   const warnings = [];
   const force = opts?.force === true;
 
-  const rmArgs = ['worktree', 'remove'];
-  if (force) rmArgs.push('--force');
-  rmArgs.push(worktreePath);
-  const removeResult = execGit(cwd, rmArgs);
-  if (removeResult.exitCode !== 0) {
-    warnings.push(`worktree remove: ${removeResult.stderr}`);
+  if (entry) {
+    const rmArgs = ['worktree', 'remove'];
+    if (force) rmArgs.push('--force');
+    rmArgs.push(worktreePath);
+    const removeResult = execGit(cwd, rmArgs);
+    if (removeResult.exitCode !== 0) {
+      warnings.push(`worktree remove: ${removeResult.stderr}`);
+    }
+  } else {
+    warnings.push(`worktree remove: ${toPosix(worktreePath)} is not a registered worktree (already removed?)`);
   }
 
   // Branch cleanup — only if branch still exists.