@damiangilgonzalez/harness 1.3.17 → 1.3.18

package/targets/memory.js

@@ -76,10 +76,15 @@ function handler(target, event) {
     : target === 'codex'
       ? '"$(git rev-parse --show-toplevel)/.rsc/session-memory-adapter.mjs"'
       : '".rsc/session-memory-adapter.mjs"';
+  // PreCompact gets more room than the per-turn events. It runs once, right before a compaction that
+  // itself takes tens of seconds, so a longer ceiling costs nothing in the normal case; and a
+  // cancelled PreCompact is the one that loses the budget reset. The per-turn events keep 5 s:
+  // they run on every tool call and must stay cheap.
+  const seconds = event === 'compact' ? 15 : event === 'end' && target === 'codex' ? 3 : 5;
   const value = {
     type: 'command',
     command: `node ${unixScript} ${target} ${event}`,
-    timeout: target === 'gemini' ? 5000 : event === 'end' && target === 'codex' ? 3 : 5,
+    timeout: target === 'gemini' ? seconds * 1000 : seconds,
   };
   if (target === 'codex') {
     value.commandWindows = `node \"$((git rev-parse --show-toplevel).Trim())/.rsc/session-memory-adapter.mjs\" ${target} ${event}`;

package/targets/session-memory-adapter.mjs

@@ -108,7 +108,10 @@ export function handleLifecycle({ target, event, native = {}, cwd, settings } =
     const id = sessionId(native, target);
     const eventName = hookEventName(target, event, native);
     if (event === 'start') {
-      const started = capture({ cwd: project, worktreeCwd: here, sessionId: id, target, event: 'start', settings: config });
+      // `source: "compact"` is the SessionStart that follows a compaction. It resets the edit budget
+      // on its own, so the count still restarts when the PreCompact hook itself never finished.
+      const reset = native?.source === 'compact';
+      const started = capture({ cwd: project, worktreeCwd: here, sessionId: id, target, event: 'start', reset, settings: config });
       const resumed = resume({ cwd: project, worktreeCwd: here, target, settings: config });
       return {
         output: nativeOutput(target, eventName, resumed.context),

package/targets/session-memory-core.mjs

@@ -1,5 +1,5 @@
 import {
-  appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync,
+  appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync,
 } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
@@ -167,11 +167,22 @@ function parseStatus(output) {
 // runs on every hook event: a few hundred dirty files were enough to blow the 5 s hook timeout.
 // `--stdin-paths` stops at the first path it cannot read (a deleted file), so on failure each file
 // is hashed on its own, which keeps the old per-file `null` for the unreadable ones.
+//
+// A deleted file is the ordinary case, not the exotic one — any `rm` or `git rm` puts one in the
+// status — and it used to send EVERY file down the per-file path, back over the timeout (400 dirty
+// files and one deletion: ~20 s per event, so PreCompact was cancelled). So paths that are not a
+// readable regular file are settled here, as `null`, before the batch ever sees them.
 function fingerprintFiles(worktree, files) {
   if (!files.length) return {};
-  const batch = git(worktree, ['hash-object', '--no-filters', '--stdin-paths'], `${files.join('\n')}\n`);
+  const readable = files.filter((path) => {
+    try { return statSync(join(worktree, path)).isFile(); } catch { return false; }
+  });
+  const isReadable = new Set(readable);
+  const missing = Object.fromEntries(files.filter((path) => !isReadable.has(path)).map((path) => [path, null]));
+  if (!readable.length) return missing;
+  const batch = git(worktree, ['hash-object', '--no-filters', '--stdin-paths'], `${readable.join('\n')}\n`);
   const hashes = batch.ok ? batch.out.split('\n') : [];
-  if (hashes.length === files.length) return Object.fromEntries(files.map((path, i) => [path, hashes[i]]));
+  if (hashes.length === readable.length) return { ...missing, ...Object.fromEntries(readable.map((path, i) => [path, hashes[i]])) };
   return Object.fromEntries(files.map((path) => {
     const result = git(worktree, ['hash-object', '--no-filters', '--', path]);
     return [path, result.ok ? result.out : null];
@@ -346,13 +357,27 @@ export function capture(input = {}) {
   const observed = Object.entries(repo.fingerprints || {})
     .filter(([path, fingerprint]) => fingerprint && previousFingerprints[path] !== fingerprint).length;
   const editDelta = Math.max(finiteOrNull(input.editDelta, true) || 0, observed);
-  // Compaction closes a context window, so the edit budget starts again from zero.
-  const previousEdits = input.event === 'compact' ? 0 : (existing?.editCount || 0);
+  // Compaction closes a context window, so the edit budget starts again from zero. Two signals say
+  // it happened, and either is enough: PreCompact (`compact`) and the SessionStart that follows it
+  // (`reset`, from `source: "compact"`). Relying on PreCompact alone meant a cancelled PreCompact
+  // hook — which is what the 5 s timeout did on a dirty tree — left the old count standing.
+  const resetsBudget = input.event === 'compact' || input.reset === true;
+  const previousEdits = resetsBudget ? 0 : (existing?.editCount || 0);
   const editCount = Math.max(0, previousEdits + editDelta);
   // Hint once per threshold crossed, and only on the edit that crosses it: re-emitting on
   // every later event (Stop in particular) wakes the model again and loops.
   const crossedThreshold = editCount > previousEdits
     && Math.floor(editCount / config.editThreshold) > Math.floor(previousEdits / config.editThreshold);
+  // And never ON a turn end, even the one that crosses. A Stop hook that speaks is a Stop hook that
+  // can start another turn, and that turn ends in another Stop: the field report is ~150 empty
+  // assistant replies in a row. A crossing seen at a turn end is kept on the anchor and said by the
+  // next event that is not one (the person's next prompt, or the next tool call). Compaction and
+  // start never say it either — "consider compacting" while compacting is noise — and a reset
+  // drops whatever was pending, because the window it was about is gone.
+  const mutedEvents = ['turn', 'stop', 'compact', 'start', 'end', 'sessionEnd'];
+  const hintDue = !resetsBudget && (crossedThreshold || anchor.hintPending === true);
+  const speaks = !mutedEvents.includes(input.event);
+  const hintPending = hintDue && !speaks;
   const baselineFiles = new Set(anchor.baselineFiles || []);
   const newDirtyPath = repo.files.some((path) => !baselineFiles.has(path));
   const baselineFingerprints = anchor.baselineFingerprints || {};
@@ -391,13 +416,20 @@ export function capture(input = {}) {
   if (errors.length) return { record: null, path: null, notice: null, compactionHint: false, errors };
   atomicJson(recordPath, record);
   existing = record;
-  const compactionHint = Boolean(config.compactionHint && crossedThreshold);
+  const compactionHint = Boolean(config.compactionHint && hintDue && speaks);
   // The fingerprints the next event compares against live on the ANCHOR, not on the record: the
   // record's schema is closed and every field of it is required, so a new field there would fail
   // validation on every record already written. Written only when they moved, so a read-only shell
-  // command costs no extra disk.
+  // command costs no extra disk. The pending hint lives there for the same reason.
   const fingerprintsMoved = observed > 0 || !anchor.lastFingerprints;
-  if (fingerprintsMoved) atomicJson(anchorPath, { ...anchor, lastFingerprints: repo.fingerprints || {} });
+  if (fingerprintsMoved || Boolean(anchor.hintPending) !== hintPending) {
+    const { hintPending: _previous, ...rest } = anchor;
+    atomicJson(anchorPath, {
+      ...rest,
+      lastFingerprints: fingerprintsMoved ? (repo.fingerprints || {}) : anchor.lastFingerprints,
+      ...(hintPending ? { hintPending: true } : {}),
+    });
+  }
   return {
     record,
     path: recordPath,

package/targets/session-start.mjs

@@ -274,7 +274,8 @@ ${candidates.map((c) => W.summarize(c, root)).join('\n')}
 ACTION: offer to retire them in ONE line and wait for a yes. On a yes run:
   npx @damiangilgonzalez/harness worktrees reap          (the ones marked safe)
   npx @damiangilgonzalez/harness worktrees reap <path>   (one the user confirmed by name)
-A yes in bulk covers only the safe ones; anything marked \`ask\` is confirmed on its own.
+  npx @damiangilgonzalez/harness worktrees reap --merged --confirm   (safe + "provenance unclear" only, after a fetch; say so when offering)
+A yes in bulk covers only those; any other \`ask\` (uncommitted changes, files in no commit) is confirmed on its own.
 A no holds for this session. Permanent off: .rsc/.no-worktree-cleanup
 ================================
 `;

package/targets/ship-guard.mjs

@@ -5,9 +5,10 @@
 //
 // Enforces the "close the feature before you leave it" rule at the one deterministic
 // moment it matters: when a Bash command tries to switch to the trunk (main/master)
-// or merge into it. If the current feature branch has uncommitted changes or commits
-// that were never pushed, the guard DENIES the command and tells the agent to run
-// `ship` (commit → push → PR). Opening the PR itself is `ship`'s job and the skill's
+// or merge into it. If the current feature branch has commits that were never pushed,
+// the guard DENIES the command and tells the agent to run `ship` (commit → push → PR).
+// Uncommitted changes alone only earn a hint: they may be the user's own work, and git
+// already refuses a switch that would overwrite them. Opening the PR itself is `ship`'s job and the skill's
 // hard rule; this hook guarantees you cannot quietly abandon unsaved/unpushed work.
 //
 // Design: precise (only fires on a trunk switch/merge), local-only (no network, no gh),
@@ -77,10 +78,26 @@ if (!branch || branch === 'HEAD' || branch === 'main' || branch === 'master') al
 
 const tail = '\n(If this is intentional and you accept the risk, create .rsc/.no-ship-guard to disable this guard.)';
 
-// 1) Uncommitted work would be carried off the feature branch.
+// 1) Uncommitted changes are NOT a reason to deny. They may well be the user's own work in the main
+// checkout, not the agent's: in real sessions this denied five branch switches over a diff the agent
+// had no business committing, and "commit them first" pushed it to do exactly that. Git itself
+// refuses a switch that would overwrite local changes, and carries the rest along untouched, so the
+// switch is left to git and the agent gets a hint: leave that diff alone and work in a worktree.
+// The unpushed-commits rule below is the guard's real purpose and still denies.
 const dirty = git('status', '--porcelain');
-if (dirty && dirty.length > 0) {
-  deny(`You're leaving feature branch "${branch}" with uncommitted changes. Commit them first — run the \`ship\` skill (commit → push → PR), don't abandon the diff.${tail}`);
+const worktreeHint = dirty && dirty.length > 0
+  ? `The working tree on "${branch}" has uncommitted changes, and they may be the user's, not yours: ` +
+    `do not commit, stash or discard them to make room. If git refuses the switch, work in a separate ` +
+    `worktree instead: \`git worktree add .claude/worktrees/<name> -b <branch> origin/main\` ` +
+    `(or \`npx @damiangilgonzalez/harness worktrees new <name>\`).`
+  : '';
+function hint() {
+  if (!worktreeHint) allow();
+  process.stdout.write(JSON.stringify({
+    systemMessage: 'ship-guard: hay cambios sin commitear en el árbol; no se tocan.',
+    hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: worktreeHint },
+  }));
+  process.exit(0);
 }
 
 // 2) Commits exist but were never pushed.
@@ -88,14 +105,14 @@ const upstream = git('rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'
 if (upstream) {
   const ahead = git('rev-list', '--count', `${upstream}..HEAD`);
   if (ahead && Number(ahead) > 0) {
-    deny(`Feature branch "${branch}" has ${ahead} commit(s) not pushed to ${upstream}. Push them and open the PR — run the \`ship\` skill — before switching to the trunk.${tail}`);
+    deny(`Feature branch "${branch}" has ${ahead} commit(s) not pushed to ${upstream}. Push them and open the PR — run the \`ship\` skill — before switching to the trunk.${worktreeHint ? `\n${worktreeHint}` : ''}${tail}`);
   }
 } else {
   // No upstream at all: if the branch carries commits beyond the trunk, it was never pushed.
   const aheadOfTrunk = git('rev-list', '--count', 'main..HEAD') ?? git('rev-list', '--count', 'master..HEAD');
   if (aheadOfTrunk && Number(aheadOfTrunk) > 0) {
-    deny(`Feature branch "${branch}" was never pushed (no upstream, ${aheadOfTrunk} commit(s) ahead of the trunk). Push it and open a PR — run the \`ship\` skill — before leaving it.${tail}`);
+    deny(`Feature branch "${branch}" was never pushed (no upstream, ${aheadOfTrunk} commit(s) ahead of the trunk). Push it and open a PR — run the \`ship\` skill — before leaving it.${worktreeHint ? `\n${worktreeHint}` : ''}${tail}`);
   }
 }
 
-allow();
+hint();

package/targets/userprompt-gate.mjs

@@ -14,7 +14,7 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { claimOnce, readHookInput, WORKFLOW_GATE_TEXT } from './hook-once.mjs';
+import { claimOnce, readHookInput, renderGate, WORKFLOW_GATE_TEXT } from './hook-once.mjs';
 
 const root = process.argv[2] || process.cwd();
 
@@ -33,4 +33,9 @@ if (hook.session_id && turnKey && !claimOnce(`up:${hook.session_id}:${turnKey}`)
 // that is not installed sends the agent looking for something that does not exist, so the line only
 // ships when the skill is present in this project or in the user scope.
 const hasFlujo = [root, homedir()].some((r) => existsSync(join(r, '.claude', 'skills', 'flujo-interfaz', 'SKILL.md')));
-process.stdout.write(hasFlujo ? WORKFLOW_GATE_TEXT : WORKFLOW_GATE_TEXT.split('\n').filter((l) => !l.includes('flujo-interfaz')).join('\n'));
+const gate = hasFlujo ? WORKFLOW_GATE_TEXT : WORKFLOW_GATE_TEXT.split('\n').filter((l) => !l.includes('flujo-interfaz')).join('\n');
+// Skills marked `disable-model-invocation: true` are rendered as the slash command the user types,
+// read from the installed SKILL.md so the gate cannot contradict the skill (see renderGate).
+let out = gate;
+try { out = renderGate(gate, [root, homedir()]); } catch { /* fail-safe: keep the plain gate */ }
+process.stdout.write(out);

package/targets/worklog-checkpoint.mjs

@@ -5,7 +5,7 @@
 // Reminds the agent to run a Worklog Sweep (capture what we did this session into
 // docs/raw/worklog/). The hook only reminds; the agent writes the worklog.
 // Silent when this workspace has no harness wiki yet.
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
 const root = process.argv[2] || process.cwd();
@@ -13,10 +13,25 @@ const root = process.argv[2] || process.cwd();
 // No harness wiki here → nothing to document into. Stay silent.
 if (!existsSync(join(root, 'docs', 'wiki'))) process.exit(0);
 
+// The sweep used to open with the agent running `ls docs/raw/worklog` to see what was there, and in
+// a wiki scaffolded before that folder existed (or whose .gitkeep never got committed) that printed
+// an error into the session on every compaction. The hook already knows the answer, so it says it:
+// what is there, or that the folder has to be created first. Nothing is left to list blindly.
+// It does not create the folder itself: an untracked docs/raw/worklog/ is where the session memory
+// prefers to keep its journal, and moving that store mid-session would orphan the session's anchor.
+let state;
+try {
+  const entries = readdirSync(join(root, 'docs', 'raw', 'worklog')).filter((name) => name.endsWith('.md'));
+  state = `docs/raw/worklog/ exists with ${entries.length} worklog file(s); no need to list it.`;
+} catch {
+  state = 'docs/raw/worklog/ does not exist yet: create it first (mkdir -p docs/raw/worklog); do not list it.';
+}
+
 process.stdout.write(`
 ===== rsc worklog checkpoint =====
 If this session did meaningful work (files changed, a decision made, a commit),
 run a WORKLOG SWEEP before context is lost:
+  ${state}
   1. Write docs/raw/worklog/<YYYY-MM-DD>-<slug>.md using the harness
      wiki-worklog-template.md (what we did · why · files touched · outcome · next).
   2. Compile it into wiki/ (update existing articles first; wikilinks + Related);

package/targets/worktree-reaper.mjs

@@ -115,9 +115,127 @@ export function isCleanupEnabled(root) {
 
 /** The first trunk ref that actually exists, or null when there is nothing to compare against. */
 export function resolveTrunk(root) {
+  // What the remote itself calls its default branch comes first: a trunk called `develop` or
+  // `trunk` is invisible to the table below, and guessing `main` there compares against nothing.
+  const announced = remoteDefault(root);
+  if (announced) return announced.ref;
   return TRUNKS.find((ref) => git(root, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]).ok) || null;
 }
 
+// `origin/HEAD` as the remote announced it, or null. A plain `git init` + `remote add` never writes
+// that ref (only `clone` and `remote set-head` do), so null is common and is not an error.
+function remoteDefault(root) {
+  const sym = git(root, ['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD']);
+  if (!sym.ok || !sym.out.startsWith('refs/remotes/origin/')) return null;
+  const name = sym.out.slice('refs/remotes/origin/'.length);
+  if (!git(root, ['rev-parse', '--verify', '--quiet', `origin/${name}^{commit}`]).ok) return null;
+  return { ref: `origin/${name}`, name };
+}
+
+/**
+ * The branch a new worktree starts from: origin's default, never the local one.
+ *
+ * Measured in a user's project: the local `main` was 400 commits behind origin, and a worktree cut
+ * from it starts 400 commits in the past — every review and every merge after that pays for it.
+ * The remote tip is the only base that is current by construction. Null when there is no origin.
+ */
+export function defaultBranch(root) {
+  const announced = remoteDefault(root);
+  if (announced) return announced;
+  for (const name of ['main', 'master']) {
+    if (git(root, ['rev-parse', '--verify', '--quiet', `origin/${name}^{commit}`]).ok) return { ref: `origin/${name}`, name };
+  }
+  return null;
+}
+
+/** `git fetch origin`, reported rather than thrown: offline is a warning, not a crash. */
+export function fetchOrigin(root) {
+  const r = git(root, ['fetch', '--quiet', 'origin']);
+  return { ok: r.ok, err: r.err };
+}
+
+// A worktree name becomes a directory under `.claude/worktrees/` and, by default, a branch. One
+// segment of plain characters, so `../../elsewhere` or an absolute path can never be where it lands.
+const WORKTREE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+
+/** Why this name cannot be used, or null when it can. */
+export function invalidWorktreeName(name) {
+  if (typeof name !== 'string' || !name) return 'a name is required';
+  if (!WORKTREE_NAME.test(name) || name.includes('..') || name.endsWith('.lock') || name.endsWith('.')) {
+    return `"${name}" is not a valid worktree name: use letters, digits, '.', '_' or '-' (no '/', no '..')`;
+  }
+  return null;
+}
+
+/**
+ * The preparation hook a project defines for a new worktree, or null.
+ *
+ * A worktree is born with what git tracks and nothing else: no `.env`, no dependencies. What each
+ * project needs to be runnable is the project's knowledge, not ours, so rsc does not guess it — it
+ * runs the project's own script if there is one. The new worktree's copy wins (it is the code of
+ * the branch that will run), the main checkout's is the fallback (a hook not yet committed).
+ */
+export const PREPARE_HOOKS = ['scripts/dev/preparar-worktree.sh', 'scripts/dev/preparar-worktree.mjs'];
+export function findPrepareHook(...dirs) {
+  for (const dir of dirs) {
+    for (const rel of PREPARE_HOOKS) if (existsSync(join(dir, rel))) return join(dir, rel);
+  }
+  return null;
+}
+
+/**
+ * Create a worktree at `.claude/worktrees/<name>` on a NEW branch cut from origin's default branch.
+ *
+ * `--no-track` because a branch cut from `origin/main` would otherwise track `origin/main`, and
+ * the first `git pull` from the worktree would merge the trunk into the feature behind your back.
+ * The branch gets its own upstream on its first `git push -u`.
+ */
+export function createWorktree(root, name, { branch } = {}) {
+  const bad = invalidWorktreeName(name);
+  if (bad) return { created: false, reason: bad };
+  const ref = branch || name;
+  if (!git(root, ['check-ref-format', '--branch', ref]).ok) return { created: false, reason: `"${ref}" is not a valid branch name` };
+  if (git(root, ['rev-parse', '--verify', '--quiet', `refs/heads/${ref}`]).ok) {
+    return { created: false, reason: `branch ${ref} already exists; pick another with --branch <rama>` };
+  }
+  const path = join(real(root), '.claude', 'worktrees', name);
+  if (existsSync(path)) return { created: false, reason: `${path} already exists` };
+
+  const fetched = fetchOrigin(root);
+  const base = defaultBranch(root);
+  if (!base) {
+    return { created: false, reason: 'no origin default branch to start from (no `origin` remote, or neither origin/main nor origin/master exists). Add the remote and push the trunk first.' };
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  const add = git(root, ['worktree', 'add', '--quiet', '--no-track', '-b', ref, path, base.ref]);
+  if (!add.ok) return { created: false, reason: `git refused to create it: ${add.err || add.out}` };
+  return { created: true, path: real(path), branch: ref, base: base.ref, fetched: fetched.ok, fetchError: fetched.ok ? null : fetched.err };
+}
+
+/** Run the preparation hook inside the new worktree. Its output goes straight to the person. */
+export function runPrepareHook(hook, worktreePath, mainRoot) {
+  const runner = hook.endsWith('.mjs') ? process.execPath : 'bash';
+  const r = spawnSync(runner, [hook], {
+    cwd: worktreePath,
+    stdio: 'inherit',
+    windowsHide: true,
+    env: { ...process.env, RSC_MAIN_WORKTREE: real(mainRoot), RSC_WORKTREE: worktreePath },
+  });
+  if (r.error) return { ok: false, reason: `could not start ${runner}: ${r.error.message}` };
+  return { ok: r.status === 0, reason: r.status === 0 ? null : `exited with code ${r.status}` };
+}
+
+/**
+ * The candidates a bulk `reap --merged` may take: landed and empty of anything unsaved, where the
+ * only thing missing is certainty about provenance. That doubt is what `--confirm` accepts, once,
+ * for the whole list the person was just shown. Nothing else is: a dirty worktree, or one holding a
+ * file in no commit, is never part of a bulk yes (test 14's rule, unchanged).
+ */
+export function mergedCandidates(classified) {
+  return classified.filter((c) => c.verdict === 'safe'
+    || (c.verdict === 'ask' && c.reasons.length && c.reasons.every((r) => r === 'provenance-ambiguous')));
+}
+
 /** Every working tree git knows about. The first entry is always the main one. */
 export function listWorktrees(root) {
   const { ok, out } = git(root, ['worktree', 'list', '--porcelain']);
@@ -166,8 +284,12 @@ export function provenanceOf(root, wt) {
   const p = wt.path;
   const home = real(root);
   const inside = (dir) => p === dir || p.startsWith(dir + sep);
+  // `.claude/worktrees/` is where Claude Code puts the worktrees it opens, and where
+  // `rsc worktrees new` puts them too. Left out, every one of them read as foreign: up to fourteen
+  // piled up in one user's project, invisible to the cleanup, until they were removed by hand.
   const location = inside(join(home, '.worktrees'))
     || inside(join(home, 'worktrees'))
+    || inside(join(home, '.claude', 'worktrees'))
     || (dirname(p) === dirname(home) && basename(p).startsWith(`${basename(home)}-`));
   const branch = Boolean(wt.branch && RSC_BRANCH.test(wt.branch));
   if (location && branch) return 'rsc';
@@ -236,7 +358,7 @@ export function integrationOf(root, wt, trunk) {
  * with nothing pending can still hold the only copy of an .env, a local database or a page of notes,
  * and removing the directory takes them with it. `--ignored` is the only way to be told they exist.
  */
-export function contentOutsideHistory(wtPath) {
+export function contentOutsideHistory(wtPath, mainRoot) {
   const { ok, raw } = git(wtPath, ['status', '--porcelain', '-z', '-uall', '--ignored=matching']);
   const dirty = [];
   const outside = [];
@@ -252,12 +374,27 @@ export function contentOutsideHistory(wtPath) {
     // does not exist — the exact failure the `raw` comment above exists to prevent (P6).
     if (code[0] === 'R' || code[0] === 'C') { i++; dirty.push(path); continue; }
     if (code === '??' || code === '!!') {
-      if (!isRegenerable(path)) outside.push(path);
+      if (!isRegenerable(path) && !copiedFromMain(wtPath, mainRoot, path)) outside.push(path);
     } else dirty.push(path);
   }
   return { dirty, outside, readable: true };
 }
 
+// A file byte-identical to the same path in the main checkout is a copy, not the only copy: the
+// preparation hook of `rsc worktrees new` puts the `.env` there exactly that way. Without this, every
+// prepared worktree would hold "a file in no commit" for ever and no cleanup could take it. Compared
+// by content, never by name: an `.env` edited inside the worktree differs and still blocks.
+function copiedFromMain(wtPath, mainRoot, path) {
+  if (!mainRoot || path.endsWith('/')) return false;
+  const original = join(mainRoot, path);
+  if (real(original) === real(join(wtPath, path))) return false;
+  try {
+    return readFileSync(original).equals(readFileSync(join(wtPath, path)));
+  } catch {
+    return false;
+  }
+}
+
 // A directory name counts anywhere it is used as a DIRECTORY; a filename counts only as a filename.
 // Matching the table against the last segment made `config/env` — a dotenv full of live credentials —
 // read as a virtualenv and get deleted. Matching it only at position 0 fixed that and broke every
@@ -307,7 +444,7 @@ export function classifyWorktrees(root) {
       if (integration !== 'integrated') return { ...base, reasons: [integration] };
       if (!hasLandedWork(root, wt)) return { ...base, reasons: ['nothing-landed'] };
 
-      const { dirty, outside, readable } = contentOutsideHistory(wt.path);
+      const { dirty, outside, readable } = contentOutsideHistory(wt.path, real(root));
       if (!readable) return { ...base, reasons: ['unreadable'] };
 
       const reasons = [];
@@ -371,7 +508,10 @@ export function reapWorktree(root, targetPath, { confirmed = false } = {}) {
   // `-d` refuses an unmerged branch, which is the recovery net — but it happily deletes the TRUNK,
   // which is an ancestor of everything. A sibling checkout of `main` classified as ambiguous, the user
   // confirmed removing a stray directory, and the trunk ref went with it.
-  const branchDeleted = candidate.branch && !isTrunkName(candidate.branch)
+  // The default branch the remote announces is a trunk too, whatever it is called.
+  const announced = remoteDefault(root);
+  const isTrunk = isTrunkName(candidate.branch || '') || Boolean(announced && candidate.branch === announced.name);
+  const branchDeleted = candidate.branch && !isTrunk
     ? git(root, ['branch', '-d', candidate.branch]).ok
     : false;
   // No `git worktree prune` here. It has no expiry of its own, so running it while another worktree's