@ericrisco/rsc 1.1.6 → 1.2.1

package/scripts/originality-check.js

@@ -0,0 +1,137 @@
+import {
+  existsSync, readdirSync, readFileSync, statSync, writeFileSync,
+} from 'node:fs';
+import { createHash } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { stackAgents } from '../targets/agent-catalog.js';
+import { allAgentNames } from '../targets/agents.js';
+import { resolveCommands } from '../targets/commands.js';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const META_PATH = join(ROOT, 'schema', 'ecc-originality.json');
+const DATA_PATH = join(ROOT, 'schema', 'ecc-originality.u64');
+const NGRAM_SIZE = 8;
+const EXEMPTION_CATEGORIES = new Set(['name', 'error', 'tool-command', 'language-term']);
+
+export function normalizeTokens(text) {
+  return String(text || '').normalize('NFKC').toLowerCase().match(/[\p{L}\p{N}_+.#/-]+/gu) || [];
+}
+
+function fingerprint(tokens, offset, size = NGRAM_SIZE) {
+  return createHash('sha256').update(tokens.slice(offset, offset + size).join(' ')).digest('hex').slice(0, 16);
+}
+
+function fingerprintsOf(text, size = NGRAM_SIZE) {
+  const tokens = normalizeTokens(text);
+  const out = [];
+  for (let offset = 0; offset <= tokens.length - size; offset += 1) {
+    out.push({ fingerprint: fingerprint(tokens, offset, size), offset });
+  }
+  return out;
+}
+
+function walk(directory) {
+  if (!existsSync(directory)) throw new Error(`originality: corpus directory missing: ${directory}`);
+  return readdirSync(directory).sort().flatMap((name) => {
+    const path = join(directory, name);
+    return statSync(path).isDirectory() ? walk(path) : [path];
+  });
+}
+
+function catalogDocuments() {
+  const skillIds = readdirSync(join(ROOT, 'skills')).filter((id) => {
+    try { return statSync(join(ROOT, 'skills', id, 'SKILL.md')).isFile(); } catch { return false; }
+  });
+  const commands = resolveCommands({
+    target: 'cursor', skills: skillIds, agents: allAgentNames(), memoryMode: 'full',
+  });
+  return [
+    ...stackAgents().map((agent) => ({ id: `agent:${agent.name}`, text: `${agent.desc}\n${agent.body}` })),
+    ...commands.map((command) => ({ id: `command:${command.name}`, text: `${command.description}\n${command.body}` })),
+  ];
+}
+
+export function fingerprintCorpus(metaPath = META_PATH, dataPath = DATA_PATH) {
+  const metadata = JSON.parse(readFileSync(metaPath, 'utf8'));
+  if (metadata.ngramSize !== NGRAM_SIZE) throw new Error(`originality: unsupported n-gram size ${metadata.ngramSize}`);
+  for (const exemption of metadata.exemptions || []) {
+    if (!EXEMPTION_CATEGORIES.has(exemption.category) || !/^[0-9a-f]{16}$/.test(exemption.fingerprint || '')) {
+      throw new Error('originality: every exemption needs a valid fingerprint and closed category');
+    }
+  }
+  const bytes = readFileSync(dataPath);
+  if (bytes.length % 8 !== 0 || bytes.length / 8 !== metadata.fingerprintCount) {
+    throw new Error('originality: fingerprint corpus length does not match its receipt');
+  }
+  const digest = createHash('sha256').update(bytes).digest('hex');
+  if (digest !== metadata.dataSha256) throw new Error('originality: fingerprint corpus failed its integrity receipt');
+  const fingerprints = new Set();
+  for (let offset = 0; offset < bytes.length; offset += 8) fingerprints.add(bytes.subarray(offset, offset + 8).toString('hex'));
+  return { metadata, fingerprints };
+}
+
+export function checkCatalogOriginality({ corpus = fingerprintCorpus(), documents = catalogDocuments() } = {}) {
+  const exempt = new Set((corpus.metadata.exemptions || []).map((entry) => entry.fingerprint));
+  const matches = [];
+  for (const document of documents) {
+    for (const candidate of fingerprintsOf(document.text, corpus.metadata.ngramSize)) {
+      if (corpus.fingerprints.has(candidate.fingerprint) && !exempt.has(candidate.fingerprint)) {
+        matches.push({ document: document.id, tokenOffset: candidate.offset, fingerprint: candidate.fingerprint });
+      }
+    }
+  }
+  return {
+    ngramSize: corpus.metadata.ngramSize,
+    corpusRevision: corpus.metadata.revision,
+    documents: documents.length,
+    exemptions: exempt.size,
+    matches,
+  };
+}
+
+function refresh(corpusRoot) {
+  const files = ['agents', 'commands'].flatMap((directory) => walk(join(corpusRoot, directory)));
+  const hashes = new Set();
+  for (const path of files) {
+    for (const candidate of fingerprintsOf(readFileSync(path, 'utf8'))) hashes.add(candidate.fingerprint);
+  }
+  const sorted = [...hashes].sort();
+  const bytes = Buffer.alloc(sorted.length * 8);
+  sorted.forEach((hash, index) => Buffer.from(hash, 'hex').copy(bytes, index * 8));
+  writeFileSync(DATA_PATH, bytes);
+  const revision = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: corpusRoot, encoding: 'utf8' }).trim();
+  const metadata = {
+    schemaVersion: 1,
+    source: 'https://github.com/affaan-m/everything-claude-code',
+    revision,
+    generatedAt: new Date().toISOString().slice(0, 10),
+    included: ['agents/**', 'commands/**'],
+    ngramSize: NGRAM_SIZE,
+    normalization: 'NFKC lowercase; Unicode letters/numbers plus _+.#/-; whitespace joined',
+    fingerprintFormat: 'first 64 bits of SHA-256, sorted big-endian; collisions fail closed',
+    fingerprintCount: sorted.length,
+    dataSha256: createHash('sha256').update(bytes).digest('hex'),
+    exemptions: [],
+  };
+  writeFileSync(META_PATH, `${JSON.stringify(metadata, null, 2)}\n`);
+  return metadata;
+}
+
+function main() {
+  if (process.argv[2] === '--refresh') {
+    if (!process.argv[3]) throw new Error('Usage: node scripts/originality-check.js --refresh <ecc-checkout>');
+    const metadata = refresh(process.argv[3]);
+    console.log(`originality corpus refreshed (${metadata.fingerprintCount} fingerprints at ${metadata.revision})`);
+    return;
+  }
+  const result = checkCatalogOriginality();
+  if (result.matches.length) {
+    for (const match of result.matches) console.error(`${match.document}: shared ${result.ngramSize}-token fingerprint ${match.fingerprint} at token ${match.tokenOffset}`);
+    process.exit(1);
+  }
+  console.log(`originality OK (${result.documents} documents vs ${fingerprintCorpus().metadata.fingerprintCount} corpus fingerprints; ${result.exemptions} exemptions)`);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main();

package/scripts/rsc.js

@@ -4,7 +4,8 @@ import { detectTarget, resolveTargets, TARGETS } from '../targets/index.js';
 import { detectRepo } from './detect-repo.js';
 import { rank } from './consult.js';
 import { expandRecommends, toOutcomes, hasOutcome } from './lib/recommend.js';
-import { applyInstall, listInstalled, uninstall, syncInstalled, purge, collisions } from './install-apply.js';
+import { applyInstall, listInstalled, listInstalledAgents, listInstalledCommands, uninstall, syncInstalled, purge, collisions } from './install-apply.js';
+import { stackAgentNames } from '../targets/agents.js';
 import { doctor } from './doctor.js';
 import { say, select, pickFrom, banner, confirm, isInteractive } from './lib/ui.js';
 import { refreshRegistry, registryStatus } from './lib/registry.js';
@@ -20,6 +21,54 @@ const cmd = argv[0];
 
 const targetLabel = (id) => TARGETS.find((t) => t.id === id)?.label || id;
 
+function requestedIds(start = 1) {
+  const valueFlags = new Set(['--target', '--profile', '--without']);
+  const ids = [];
+  for (let i = start; i < argv.length; i++) {
+    if (valueFlags.has(argv[i])) { i++; continue; }
+    if (argv[i].startsWith('--')) continue;
+    ids.push(argv[i]);
+  }
+  return ids;
+}
+
+function editDistance(a, b) {
+  const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = prev[0];
+    prev[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = prev[j];
+      prev[j] = Math.min(prev[j] + 1, prev[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+      diagonal = above;
+    }
+  }
+  return prev[b.length];
+}
+
+function classifyRequested(ids) {
+  const skills = new Set(loadManifest().skills.map((skill) => skill.id));
+  const agents = new Set(stackAgentNames());
+  const out = { skills: [], agents: [], unknown: [] };
+  for (const id of ids) {
+    if (skills.has(id)) out.skills.push(id);
+    else if (agents.has(id)) out.agents.push(id);
+    else out.unknown.push(id);
+  }
+  return out;
+}
+
+function reportUnknown(ids) {
+  if (!ids.length) return false;
+  const candidates = [...loadManifest().skills.map((skill) => skill.id), ...stackAgentNames()];
+  for (const id of ids) {
+    const close = [...candidates].sort((a, b) => editDistance(id, a) - editDistance(id, b) || a.localeCompare(b)).slice(0, 3);
+    console.error(`rsc: unknown skill or agent '${id}'. Closest: ${close.join(', ')}`);
+  }
+  process.exitCode = 1;
+  return true;
+}
+
 // Commands that act ON one assistant. Only these stop when two are installed and no
 // flag says which: `purge` sweeps every target by design, and the catalog/consult
 // side barely touches one, so blocking them would be a regression, not a safeguard.
@@ -113,6 +162,8 @@ function printNextSteps(targets, ids) {
   say('\n   Add something by hand anytime:    npx @ericrisco/rsc add <skill>');
   say('   Browse the catalog / get picks:   npx @ericrisco/rsc consult "whatever you need"');
   say('────────────────────────────────────────────────────────');
+  if (targets.includes('codex')) say('   Codex: review and trust the project lifecycle hook once with `/hooks`; until then memory is reported as requiring trust.');
+  if (targets.includes('cursor')) say('   Cursor: startup memory is assisted because its sessionStart hook is fire-and-forget; the installed always-on rule performs the read-before-action fallback.');
   printAgentHandoff();
 }
 
@@ -268,15 +319,12 @@ async function main() {
     case undefined:
       return wizard(f ? targets : null);
     case 'add': {
-      // Positional args = skill ids; skip flags and any flag value (the token after a --flag).
-      const requested = [];
-      for (let i = 1; i < argv.length; i++) {
-        if (argv[i].startsWith('--')) { i++; continue; }
-        requested.push(argv[i]);
-      }
-      const ids = withDefaultSkillFloor(requested);
+      const requested = requestedIds();
+      const selected = classifyRequested(requested);
+      if (reportUnknown(selected.unknown)) return;
+      const ids = withDefaultSkillFloor(selected.skills);
       if (!argv.includes('--force') && !(await guardCollisions(targets, ids))) return;
-      for (const t of targets) await applyInstall({ skillIds: ids, target: t });
+      for (const t of targets) await applyInstall({ skillIds: ids, agentIds: selected.agents, target: t });
       say(`✅ Installed for ${targets.join(', ')}: ${requested.join(', ')}`);
       return void say('   ↻ Reload/restart your assistant so the new skill activates.');
     }
@@ -328,14 +376,66 @@ async function main() {
       else say('\n(no harness wiki here — printed above only; run `harness` to keep a written record)');
       return;
     }
-    case 'list':
-      return void say(listInstalled({ target }).join('\n') || '(nothing installed)');
+    case 'list': {
+      const skills = listInstalled({ target }).map((id) => `skill\t${id}`);
+      const agents = listInstalledAgents({ target }).map((agent) => `agent\t${agent.id}\t${agent.source}${agent.skills.length ? `:${agent.skills.join(',')}` : ''}`);
+      const commands = listInstalledCommands({ target }).map((command) => `command\t${command.id}\t${command.path}`);
+      return void say([...skills, ...agents, ...commands].join('\n') || '(nothing installed)');
+    }
     case 'doctor': {
       const report = doctor({ target });
       if (argv.includes('--json')) return void say(JSON.stringify(report, null, 2));
       printContextBudget(report.contextBudget);
       return void say(JSON.stringify({ ...report, contextBudget: undefined }, null, 2));
     }
+    case 'memory': {
+      const sub = argv[1] || 'status';
+      const root = process.cwd();
+      if (sub === 'on' || sub === 'off') {
+        const { readManifest, writeManifest } = await import('./lib/manifest-file.js');
+        const current = readManifest(root) || { version: 1, targets: targets || [], skills: [], agents: [], ownSkills: [], optOuts: [] };
+        writeManifest(root, { ...current, memory: sub === 'off' ? false : { enabled: true } });
+        for (const t of targets) await syncInstalled({ target: t, cwd: root });
+        say(`rsc memory ${sub}: ${sub === 'on' ? 'enabled' : 'disabled'} for this project (${targets.join(', ') || 'declaration only'}).`);
+        return;
+      }
+      const M = await import('../targets/session-memory-core.mjs');
+      if (sub === 'status') {
+        const reports = targets.map((t) => doctor({ target: t, cwd: root }).memory);
+        return void say(JSON.stringify(reports.length === 1 ? reports[0] : reports, null, 2));
+      }
+      if (sub === 'resume') {
+        const result = M.resume({ cwd: root });
+        return void say(argv.includes('--json') ? JSON.stringify(result, null, 2) : (result.context || '(no local continuation for this branch/worktree)'));
+      }
+      if (sub === 'save') {
+        const result = M.capture({
+          cwd: root,
+          sessionId: typeof flag('session') === 'string' ? flag('session') : `manual-${Date.now()}`,
+          target: target || 'manual',
+          event: 'save',
+          force: true,
+        });
+        return void say(JSON.stringify(result, null, 2));
+      }
+      if (sub === 'learn') {
+        const value = (name) => { const v = flag(name); return typeof v === 'string' && !v.startsWith('--') ? v : undefined; };
+        const result = M.learn({
+          cwd: root,
+          text: value('text'),
+          evidence: value('evidence'),
+          scope: value('scope') || 'project',
+          confidence: value('confidence'),
+          approved: argv.includes('--approve'),
+        });
+        if (!result.saved) process.exitCode = 1;
+        return void say(JSON.stringify(result, null, 2));
+      }
+      if (sub === 'metrics') return void say(JSON.stringify(M.metricsSummary({ cwd: root }), null, 2));
+      say('Use: npx @ericrisco/rsc memory on|off|status|save [--session id]|resume [--json]|learn --text "…" --evidence "…" --scope project|global --confidence 0..1 --approve|metrics');
+      process.exitCode = 1;
+      return;
+    }
     case 'sync': {
       const dry = argv.includes('--dry-run');
       for (const t of targets) {
@@ -387,6 +487,52 @@ async function main() {
       say('Use: npx @ericrisco/rsc registry refresh | registry status');
       return;
     }
+    case 'worktrees': {
+      // The deterministic half of "the cleanup is the default". `ship` and the `worktrees` skill call
+      // this instead of judging by eye, which is what turns a rule that was only ever written down
+      // into one that actually runs.
+      const W = await import('../targets/worktree-reaper.mjs');
+      // From inside a worktree, home is the main checkout — you cannot remove the floor you stand on.
+      const root = W.resolveMainRoot(process.cwd());
+      const sub = argv[1];
+
+      if (!W.isCleanupEnabled(root)) {
+        say(`worktree cleanup is off for this project (.rsc/${W.OPT_OUT}). Delete that file to turn it back on.`);
+        return;
+      }
+
+      const candidates = W.classifyWorktrees(root).filter((c) => c.verdict !== 'skip');
+
+      if (sub === 'reap') {
+        const one = argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined;
+        // Naming a path SELECTS it; it does not accept the risk of removing it. Conflating the two
+        // meant the strongest refusal in the module — "holds files that are in no commit" — was
+        // defeated by an argument the sweep itself told the agent to type.
+        const confirmed = argv.includes('--confirm');
+        const targets = one ? [one] : candidates.filter((c) => c.verdict === 'safe').map((c) => c.path);
+        if (!targets.length) { say('nothing to clean up.'); return; }
+        for (const t of targets) {
+          const out = W.reapWorktree(root, t, { confirmed });
+          if (out.removed) {
+            say(`✅ removed ${out.path}`);
+            if (out.branchKept) say(`   branch ${out.branch} kept — git will not delete it safely, and while it exists the commits are recoverable.`);
+          } else {
+            say(`⏸  kept ${t} — ${out.reason}`);
+            if (one && !confirmed) say('   If that is acceptable and you want it gone anyway: add --confirm');
+            process.exitCode = 1;
+          }
+        }
+        return;
+      }
+
+      if (!candidates.length) { say('No worktrees to clean up.'); return; }
+      say(`${candidates.length} worktree(s) whose work has landed:`);
+      for (const c of candidates) say(W.describe(c));
+      say('');
+      say('Remove the safe ones:  npx @ericrisco/rsc worktrees reap');
+      say('Remove one by name:    npx @ericrisco/rsc worktrees reap <path> [--confirm]');
+      return;
+    }
     case 'capabilities': {
       // "What do I already have that solves this?" — the deterministic step the
       // automation-gap rule requires BEFORE anyone proposes creating a skill or an
@@ -446,6 +592,13 @@ async function main() {
         } else {
           say(`# ${caps.target} has no file-based agents — the agent option does not apply here`);
         }
+        if (caps.commandsSupported) {
+          for (const command of caps.commands) say(`command\t${command.id}\tproject\t${command.path}`);
+          if (!caps.commands.length) say('# no managed command files found (this target supports them)');
+        } else {
+          say(`# ${caps.target} has no supported project command surface`);
+        }
+        say(`memory\t${caps.memory.mode}\t${caps.memory.status}\t${caps.memory.reason}`);
       }
       if (!full) say('# catalog shown as ids; add --full for descriptions, or use `catalog --available` to match by meaning');
       return;
@@ -623,8 +776,9 @@ async function main() {
       const dry = argv.includes('--dry-run');
       // `uninstall --all` is an alias for a full purge.
       if (argv.includes('--all')) return void (await runPurge(dry, argv.includes('--with-docs')));
-      const ids = argv.slice(1).filter((a) => !a.startsWith('--'));
-      const removed = await uninstall({ skillIds: ids, target, dryRun: dry });
+      const selected = classifyRequested(requestedIds());
+      if (reportUnknown(selected.unknown)) return;
+      const removed = await uninstall({ skillIds: selected.skills, agentIds: selected.agents, target, dryRun: dry });
       return void say((dry ? 'Would remove:\n' : 'Removed:\n') + (removed.join('\n') || '(nothing)'));
     }
     case 'repair': {
@@ -652,7 +806,7 @@ async function main() {
       return void (await runPurge(argv.includes('--dry-run'), argv.includes('--with-docs')));
     default:
       say(`rsc: unknown command '${cmd}'.`);
-      say('Use: npx @ericrisco/rsc | add <id...> | install --profile <p> | consult "<text>" | list | capabilities [--full|gap-log] | audit | registry refresh | doctor | sync | sello <on|off|status|…> | backups | restore <id|latest> | upgrade | repair | uninstall <id> | purge');
+      say('Use: npx @ericrisco/rsc | add <id...> | install --profile <p> | consult "<text>" | list | capabilities [--full|gap-log] | audit | registry refresh | doctor | sync | memory <on|off|status|save|resume|learn|metrics> | sello <on|off|status|…> | worktrees [reap [path] [--confirm]] | backups | restore <id|latest> | upgrade | repair | uninstall <id> | purge');
       say('Any command takes --target <claude|codex|cursor|copilot|gemini|…> (comma-separate for several)');
       say('   → without it, rsc uses the assistant already installed here; if two are, it asks instead of guessing.');
       process.exitCode = 1;

package/skills/ship/SKILL.md

@@ -116,12 +116,17 @@ Stacked PR / feature-track support still fits inside the three landing options:
 git switch main && git pull --ff-only
 git merge --no-ff feature/<slug> -m "feat: <what shipped> (<spec-slug>)"   # no AI trailer
 git push origin main
-git branch -d feature/<slug>          # delete merged branch; -D only if intentionally dropping unmerged work
+npx @ericrisco/rsc worktrees reap <path-of-this-feature-worktree>   # by name: this one, not all of them
+git branch -d feature/<slug> 2>/dev/null || true   # no worktree involved? then the branch alone
 git push origin --delete feature/<slug> 2>/dev/null || true
 ```
 
 Use `--no-ff` so the feature is one legible merge commit tied to the spec. Confirm the trunk still builds after the merge if the repo has a local gate (defer the actual run to `verify`).
 
+**Name the path.** Bare `worktrees reap` retires *every* worktree that currently qualifies, which is not what landing one branch means — with `parallel` running two streams, it is how shipping A deletes B. Pass the path of the worktree this branch lived in; capture it before you switch, since you are usually standing in it (`WT=$(pwd)`).
+
+Naming a path selects it, it does not accept the risk of removing it: a worktree holding anything unsaved is still refused, with the reason. Add `--confirm` only after the user has seen that reason and said yes. Run it from anywhere — it finds the main checkout itself.
+
 ### Option 2 — pull request
 
 Write the **commit(s)** clean, push, then open the PR with `gh`. The PR body links the spec/plan and lists what shipped — **and carries no AI attribution.**
@@ -158,6 +163,8 @@ Implements `02-DOCS/wiki/sdd/specs/<slug>.md`. <the user-facing reason>
 
 Then either let the gate run (team/CI) or self-merge once green: `gh pr merge --squash --delete-branch` (or `--merge` to preserve the history). Squash when the branch history is noisy; preserve when each commit is meaningful.
 
+Once it is merged, pull the trunk and reap the one you landed — `git switch main && git pull --ff-only && npx @ericrisco/rsc worktrees reap "$WT"`. A squashed pull request is exactly the case the reaper judges by content rather than by commit identity, so it is recognised as landed; the local branch is kept, because git will not delete a squashed branch safely and while it exists the work is recoverable.
+
 For stacked PRs, create each PR against the previous branch or against a feature-track branch, with bodies that name their dependency:
 
 ```markdown
@@ -172,13 +179,13 @@ Never stack to hide review risk. Stack because each slice is independently revie
 - **Park:** leave the branch, push it so it's not lost (`git push -u origin feature/<slug>`), and log *why it's parked* to `02-DOCS/wiki/sdd/decisions.md`. Do not merge.
 - **Discard:** deletion is **destructive and unrecoverable** once the branch is gone from both sides, so it takes an explicit confirmation that quotes the branch name (the literal `yes, delete feature/<slug>`) before `git branch -D`. Anything ambiguous means keep it. Log the discard and the reason so the dead-end is remembered, not re-attempted.
 
-**If the work lived in a worktree, clean it up provenance-aware.** After the merge/park/discard, only
-remove a worktree **rsc created** (under `.worktrees/`/`worktrees/` or the `../<repo>-<slug>` dir),
-never one the user or a native tool owns. Guard first: confirm it's a linked worktree
-(`git rev-parse --git-dir` ≠ `--git-common-dir`), rule out a submodule
-(`git rev-parse --show-superproject-working-tree` is empty), `cd` to the main working tree before
-removing, and run `git worktree prune` after. Full procedure: `../worktrees/SKILL.md` (Provenance-aware
-cleanup). If a native `EnterWorktree`-style tool created it, exit through that tool, not raw git.
+**Park and discard do NOT reap.** The cleanup default acts only on work that is already in the trunk;
+a parked branch is the opposite of that, and `worktrees reap` refuses it by design. Leave the worktree
+where it is — the next `ship` that lands the branch will retire it. Discarding a worktree along with
+unmerged work stays what it always was: explicit, confirmed with the quoted branch name, and logged.
+
+If a native `EnterWorktree`-style tool created the workspace, exit through that tool rather than the
+reaper — it owns its own lifecycle and its tracking has to stay consistent.
 
 ## Commit message discipline
 

package/skills/worktrees/SKILL.md

@@ -109,39 +109,47 @@ git switch -c feat/<slug> origin/<default-branch>
 ```
 
 ```bash
-# when the work is done and merged (or abandoned) — clean up the worktree
-git worktree remove ../<repo>-<slug>      # refuses if dirty; resolve first, don't force blindly
-git branch -d feat/<slug>                  # -d (safe) not -D, unless the user confirms discarding
+# when the work has landed — the cleanup is the default, and it is a command, not a judgement call
+npx @ericrisco/rsc worktrees reap
 ```
 
 Either way, the contract is identical: **after this step, the cwd is an isolated branch off a clean
 base, and the default-branch checkout is exactly as it was.** Confirm that out loud (at the dial's
 level) before handing to `implement`.
 
-### Provenance-aware cleanup (don't remove a workspace you didn't create)
+### Cleanup is the default, and it is not yours to judge
 
-Removing the wrong worktree leaves phantom state and can destroy someone else's in-progress work.
-Before any `git worktree remove`, clear these guards:
+A worktree whose work is already in the trunk is retired **by default** — you do not decide that by
+reading the situation, because "is this safe to delete?" is a deterministic question and a wrong
+answer costs a directory that cannot be brought back. Ask the command:
 
 ```bash
-# 1) Are we even inside a linked worktree? (GIT_DIR != GIT_COMMON_DIR ⇒ yes)
-[ "$(git rev-parse --git-dir)" != "$(git rev-parse --git-common-dir)" ] && echo "linked worktree"
-# 2) Submodule false-positive guard — never treat a submodule as a worktree to remove
-git rev-parse --show-superproject-working-tree   # non-empty ⇒ this is a submodule; STOP
-# 3) cd to the MAIN working tree before removing (you cannot remove the worktree you stand in)
-cd "$(git rev-parse --git-common-dir)/.."
-git worktree remove <path>
-git worktree prune                                # self-heal stale administrative entries
+npx @ericrisco/rsc worktrees        # every landed worktree, with a verdict and a reason
+npx @ericrisco/rsc worktrees reap   # retire the ones that are safe with nothing to lose
+npx @ericrisco/rsc worktrees reap <path>   # retire one the user has just confirmed
 ```
 
-- **Only remove worktrees rsc/you created** — those under `.worktrees/` or `worktrees/`, or the
-  `../<repo>-<slug>` this skill made. A worktree the user or a native tool owns is **not yours to
-  delete**; leave it and say so.
-- **Native tool owns its own lifecycle.** If you isolated via a native `EnterWorktree`-style tool,
-  exit through that tool's `remove`/`keep` — do **not** hand-run `git worktree remove` on a workspace
-  the native tool created; let it clean up so its tracking stays consistent.
-- **`git worktree prune`** after a remove clears stale metadata when a directory vanished out from
-  under git — cheap self-healing, safe to run.
+Three things have to hold before a worktree is retired without asking, and each fails towards
+**keeping** it:
+
+- **rsc created it** — location *and* branch shape both match. Only one matches → it might be the
+  user's, so it is asked about, never removed silently. Neither → foreign; not touched, not offered.
+- **The branch adds nothing the trunk does not have** — asked about *content*, so a squash-merged
+  pull request counts as landed. Its branch is kept even so: git will not delete it safely, and while
+  it exists the commits survive a wrong call.
+- **Nothing inside would be lost** — not just "no pending changes": untracked and ignored files count,
+  because a worktree that git calls clean can still hold the only copy of a `.env` or a local
+  database. Installed dependencies and build output are the one carve-out.
+
+Anything else is reported with the reason and the way out. A refusal you cannot act on is not safety.
+
+**The native tool owns its own lifecycle.** If you isolated via a native `EnterWorktree`-style tool,
+exit through that tool's `remove`/`keep`; the reaper is for worktrees git alone knows about.
+
+**When the command is unavailable** (no rsc in this project), the manual equivalent is: confirm it is
+a linked worktree (`git rev-parse --git-dir` ≠ `--git-common-dir`), rule out a submodule
+(`git rev-parse --show-superproject-working-tree` must be empty), `cd` to the main working tree, then
+`git worktree remove` and `git worktree prune`. Never `-D` a branch to make the cleanup succeed.
 
 ## Model tier — `light` (opt-in routing)