@@ -363,7 +363,8 @@ or a live merged PR; the sweep and removal are covered by unit tests with a real
 
 - **Worktree hygiene.** Local pruning requires an explicit release of an exact commit,
   fresh merged-work proof, no active or dirty state, and a verified recovery bundle.
-  The shared command supports a daily macOS user job and keeps unknown legacy worktrees
+  A squash-merged tip whose tree matches the landed commit counts as proof, so branches
+  that merged `main` in before landing can be pruned. The shared command supports a daily macOS user job and keeps unknown legacy worktrees
   and remote branches. Desktop retirement respects project-script retention. Maintenance
   regression tests run in the standard test suite. [Procedure and recovery](worktree-hygiene.md)
   and [verification](reviews/2026-10-11-worktree-hygiene.md).
 
@@ -62,7 +62,9 @@ Each run fetches the GitHub default branch without pruning refs and reads PRs th
   malformed GitHub responses preserve work. Any open PR for the branch blocks pruning.
 - The exact tip is an ancestor of the freshly fetched default branch, or a merged PR has
   that exact repository, branch, and tip, and its reachable single-parent squash commit
-  has the identical complete binary diff. Ambiguous merge histories stay preserved.
+  either has the identical tree (every path, mode, blob, and gitlink) or the identical
+  complete binary diff. The tree match also covers branches that merged the default branch
+  in before landing. Without either match, ambiguous merge histories stay preserved.
 - Archive refs and a self-contained bundle have been created, restored into an empty
   bare repository, checked for exact tip equality, and passed `git fsck --full`.
 
 
@@ -248,7 +248,11 @@ export class WorktreeMaintenance {
       if (!this.ancestor(merge, info.defaultHead)) continue;
       const parents = this.text(['rev-list', '--parents', '-n', '1', merge]).split(' ').slice(1);
       if (parents.length !== 1) continue; // Only unambiguous single-parent squash commits.
-      const bases = this.text(['merge-base', '--all', row.head, parents[0]]).split('\n');
+      // An identical tree (every path, mode, blob and gitlink) means the tip is exactly the snapshot
+      // that landed, so merge commits on the branch cannot hold anything the default branch lacks.
+      const tree = this.text(['rev-parse', '--verify', `${row.head}^{tree}`]);
+      if (fullSha(tree) && tree === this.text(['rev-parse', '--verify', `${merge}^{tree}`])) return { kind: 'squash-tree', pull: pr.number, mergeCommit: merge, tree, defaultHead: info.defaultHead };
+      const bases =this.text(['merge-base', '--all', row.head, parents[0]]).split('\n');
       if (bases.length !== 1 || !bases[0]) continue;
       if (this.text(['rev-list', '--min-parents=2', `${bases[0]}..${row.head}`])) continue;
       const flags = ['diff', '--binary', '--full-index', '--no-ext-diff', '--no-textconv', '--no-renames', '--no-color', '--ignore-submodules=none', '--submodule=short', '--no-relative'];
 
@@ -132,6 +132,41 @@ for (const kind of ['wrong-head', 'wrong-base', 'patch-mismatch']) {
   });
 }
 
+// A branch that merged main into itself before landing, as long-lived PR branches do.
+function mergedMainBranch(f) {
+  const w = f.create();
+  fs.writeFileSync(path.join(f.primary, 'other.txt'), 'main moved\n');
+  git(f.primary, 'add', 'other.txt'); git(f.primary, 'commit', '-m', 'main moved'); git(f.primary, 'push', 'origin', 'main');
+  git(w.location, 'merge', '--no-ff', 'main', '-m', 'merge main');
+  w.head = git(w.location, 'rev-parse', 'HEAD');
+  assert.ok(git(w.location, 'rev-list', '--min-parents=2', 'main..HEAD'), 'branch carries a merge commit');
+  return w;
+}
+
+test('squash proof accepts a branch with merge commits whose tip tree is the landed tree', async (t) => {
+  const f = fixture(t); const w = mergedMainBranch(f); f.merge(w, true); await f.release(w);
+  assert.equal(git(f.primary, 'rev-parse', `${w.head}^{tree}`), git(f.primary, 'rev-parse', 'main^{tree}'));
+  const row = await f.row(w.name);
+  assert.equal(row.eligible, true, row.reasons.join(','));
+  assert.equal(row.proof.kind, 'squash-tree');
+  const result = await f.core.prune({ apply: true });
+  assert.equal(result.results[0].status, 'removed');
+  assert.equal(fs.existsSync(w.location), false);
+  assert.equal(result.run.entries[0].proof.kind, 'squash-tree');
+  assert.equal(git(f.primary, 'rev-parse', result.run.entries[0].archiveRef), w.head);
+});
+
+for (const kind of ['wrong-head', 'wrong-base', 'tree-mismatch']) {
+  test(`rejects tree proof for a branch with merge commits with ${kind}`, async (t) => {
+    const f = fixture(t); const w = mergedMainBranch(f); f.merge(w, true); await f.release(w);
+    if (kind === 'wrong-head') f.pulls[0].head.sha = '1'.repeat(40);
+    if (kind === 'wrong-base') f.pulls[0].base.ref = 'other';
+    if (kind === 'tree-mismatch') { fs.appendFileSync(path.join(f.primary, 'code.txt'), 'only part landed\n'); git(f.primary, 'commit', '-am', 'different squash', '--amend'); git(f.primary, 'push', '--force', 'origin', 'main'); f.pulls[0].merge_commit_sha = git(f.primary, 'rev-parse', 'HEAD'); }
+    assert.deepEqual((await f.row(w.name)).reasons, ['not-proven-merged']);
+    await f.core.prune({ apply: true }); assert.equal(f.exists(w), true);
+  });
+}
+
 test('changed head after audit is preserved by apply', async (t) => {
   const f = fixture(t); const w = f.create(); f.merge(w); await f.release(w);
   assert.equal((await f.row()).eligible, true);