@ericrisco/rsc 3.4.0 → 3.6.0

package/README.md

@@ -239,7 +239,7 @@ project. rsc handles four things by default:
 | | What happens | Turn it off |
 | --- | --- | --- |
 | **You choose how the project works** | The install asks once: straight on `main`, or branches and pull requests? With branches, a commit on `main` is refused and the agent asks before each change: this branch, a new one, or unlock `main`? It never opens a branch on its own. | «unlock main», or `rsc main unlock` |
-| **One workspace per agent** | If another session works in the same folder, new work goes to `.worktrees/<branch>/`, inside the project and never committed. A `post-merge` hook retires it once the branch lands. | `rsc isolation off` |
+| **One workspace per agent** | If another session works in the same folder, new work goes to `.worktrees/<branch>/` at the root you work in (never inside a project folder) and is never committed. A `post-merge` hook retires it once the branch lands. | `rsc isolation off` |
 | **The agent picks the method** | FTD for simple changes, SDD for complex ones. The agent decides and says why. | Ask for the other lane |
 | **Knowledge reaches everyone** | `01-TOOLS/`, `02-DOCS/wiki/` and `02-DOCS/attachments/` travel through one exchange branch, `rsc/knowledge`, and reach `main` inside your normal pull requests. | `rsc knowledge-sync off` |
 

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.4.0",
+  "version": "3.6.0",
   "counts": {
     "skills": 269,
     "agents": 34,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "3.4.0",
+  "version": "3.6.0",
   "description": "A guided harness builder that turns your goal into a minimal, verified AI-agent setup using strict best practices.",
   "type": "module",
   "bin": {

package/scripts/install-apply.js

@@ -85,6 +85,7 @@ export function generatedHookFiles({ target, cwd, policy }) {
     join(cwd, '.rsc', 'shell-unwrap.mjs'),
     join(cwd, '.rsc', 'worktree-reaper.mjs'),
     join(cwd, '.rsc', 'auto-update.mjs'),
+    join(cwd, '.rsc', 'memslop-offer.mjs'),
     // team-safe-default: the 3.0 start-up duties and the trunk policy (also read by branch-guard).
     join(cwd, '.rsc', 'team-safe-start.mjs'),
     join(cwd, '.rsc', 'trunk-policy.mjs'),

package/scripts/rsc.js

@@ -927,7 +927,7 @@ async function main() {
             : 'rsc main lock: branches and pull requests for this project — the default branch is closed for the agent, and it asks before each code change where it goes. Commit .rsc.json so the team gets the same decision.')
           : (sub === OFF
             ? 'rsc isolation off: sessions may share this folder without a worktree. Commit .rsc.json so the team gets the same decision.'
-            : 'rsc isolation on: with another session active in this folder, new work goes to .worktrees/<branch>/. Commit .rsc.json so the team gets the same decision.'));
+            : 'rsc isolation on: with another session active in this folder, new work goes to .worktrees/<branch>/ at the root, never inside a project folder. Commit .rsc.json so the team gets the same decision.'));
         return;
       }
       if (sub === 'status') {

package/skills/ftd/SKILL.md

@@ -73,7 +73,7 @@ says which on every turn) — never a branch opened on your own:
   is no exception: an unrelated change does not go into it without asking. A new branch is named by
   intent and closes with a pull request. Unlocking is `rsc main unlock`; never without that answer.
 - **Docs, wiki or config only** → no question, no branch.
-- **Another session working in this same folder** → a worktree in `.worktrees/<branch>/`, never a
+- **Another session working in this same folder** → a worktree in `.worktrees/<branch>/` at the root you work in (never inside a project folder), never a
   branch switch under the other session. Not a question: rsc tells you when that is the case.
 
 A worktree only when another session is there: alone, setting one up costs more than it protects.

package/skills/worktrees/SKILL.md

@@ -114,11 +114,25 @@ git worktree add -b feat/<slug> .worktrees/<slug> origin/<default-branch>
 # work happens in .worktrees/<slug>; the main checkout is untouched
 ```
 
-**Inside the repo, always — never a sibling.** `.worktrees/` is already gitignored by the harness,
-the reaper already recognises it as its own, and the difference matters after the work lands: a
-sibling directory sits outside the tree, so it survives every cleanup of the repository and stops
-being visible to whoever would retire it. Two of them accumulated here before this was written down.
-Deleting the repo should delete its worktrees with it.
+**At the root you work in, always — never inside a project folder, never a sibling.** The root is
+the folder holding `.rsc.json`. For the repo at that root the worktree is `.worktrees/<slug>`. For a
+project that lives in a folder under it (a workspace with `03-PROJECTS/<p>/`), it is
+`<root>/.worktrees/<p>-<slug>`, and the path is written absolute — a relative one resolves inside
+the project, which is how they ended up there:
+
+```bash
+git -C 03-PROJECTS/<p> fetch origin
+git -C 03-PROJECTS/<p> worktree add -b feat/<slug> <root>/.worktrees/<p>-<slug> origin/<default-branch>
+```
+
+A worktree at the root is a fresh checkout with nothing above it to borrow from: install its
+dependencies inside it (`npm ci`, `uv sync`, …) before running anything. Inside the project, a
+missing `node_modules` was silently taken from the parent; at the root it fails loudly instead.
+
+rsc's branch guard denies any other place, with the right command in its message. `.worktrees/` is
+already gitignored at the root, the reaper recognises both shapes as its own, and a sibling
+directory would sit outside the tree, survive every cleanup and stop being visible to whoever would
+retire it. Deleting the workspace deletes its worktrees with it.
 
 ```bash
 # branch-only path (the degenerate case: no separate directory needed)

package/targets/auto-update.mjs

@@ -204,6 +204,14 @@ if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.ur
   const root = (hook ? process.argv[4] : process.argv[2]) || process.cwd();
   let notice = '';
   try { if (!process.env.RSC_NO_UPDATE_CHECK) notice = (await updateNotice(root)).trim(); } catch { /* fail open */ }
+  // Codex has no session-start.mjs: its one SessionStart hook is this one, so the MemSlop offer rides
+  // here (macOS 14+ only, rsc projects only). A sibling loaded lazily; any failure → no offer.
+  if (target === 'codex' && existsSync(join(root, '02-DOCS', 'wiki', 'harness', 'user-profile.md'))) {
+    try {
+      const said = (await import('./memslop-offer.mjs')).memslopNotice().trim();
+      if (said) notice = notice ? `${notice}\n\n${said}` : said;
+    } catch { /* no offer */ }
+  }
   if (!hook && !notice) notice = 'rsc is up to date.';
   process.stdout.write(`${hookOutput(target, notice)}\n`);
 }

package/targets/branch-guard.mjs

@@ -10,13 +10,16 @@
 //   B · another session is working in this same checkout (session-memory-core.mjs). Switching
 //       branches here would change its files under it, so it is denied, and the message says how to
 //       carry on: a worktree under `.worktrees/`.
+//   C · a worktree goes in `.worktrees/` at the root the session works in, never inside a project
+//       folder (Eric, 2026-10-27). In a workspace holding its projects as folders, `git -C <p>
+//       worktree add .worktrees/<b>` resolved inside the project; it is denied with the root's path.
 //
 // Every denial carries its way out (constitution P6). Only what the AGENT runs is seen: a person
 // committing in their own terminal is never touched (spec, P3). FAIL-OPEN: no repo, no git, a module
 // missing, anything unclear → allow. Opt-outs, both PROJECT switches: `.rsc/.no-trunk-guard`
 // («desbloquea main» / `rsc main unlock`) and `.rsc/.no-worktree-isolation` (`rsc isolation off`).
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
-import { isAbsolute, join, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
@@ -56,6 +59,52 @@ export function pushesTo(seg, trunk) {
   });
 }
 
+export const ADDS_WORKTREE = new RegExp(String.raw`\bgit\s+${GIT_OPTS}worktree\s+add(?![\w-])`);
+
+/** `git worktree add [opts] <path> [<commit-ish>]` → { path, branch } (branch from -b/-B), or null. */
+export function worktreeAddTarget(seg) {
+  const t = tokens(seg.replace(/^.*?\bgit\s+/, '').replace(/^(?:(?:-C|-c)\s+\S+\s+|--\S+\s+)*/, ''));
+  if (t.shift() !== 'worktree' || t.shift() !== 'add') return null;
+  let branch = null;
+  let path = null;
+  for (let i = 0; i < t.length; i++) {
+    if (/^-[bB]$/.test(t[i])) { branch = t[++i] ?? null; continue; }
+    if (t[i] === '--reason') { i++; continue; }
+    if (!t[i].startsWith('-') && path === null) path = t[i];
+  }
+  return path === null ? null : { path, branch };
+}
+
+/** realpath of what exists, with the not-yet-created tail kept: a worktree path does not exist yet. */
+function realish(p) {
+  let head = p;
+  const tail = [];
+  while (!existsSync(head)) { const up = dirname(head); if (up === head) return p; tail.unshift(basename(head)); head = up; }
+  try { return join(realpathSync(head), ...tail); } catch { return p; }
+}
+
+const within = (p, dir) => p === dir || p.startsWith(dir + sep);
+
+/** Rule C: the reason to deny this `worktree add`, or null. Repos outside the root are not judged. */
+export function worktreePlaceDenial({ root, here, seg, at }) {
+  const target = worktreeAddTarget(seg);
+  if (!target) return null;
+  const home = realish(root);
+  if (!within(here, home)) return null;
+  const dest = realish(isAbsolute(target.path) ? target.path : resolve(at, target.path));
+  const place = join(home, '.worktrees');
+  if (within(dest, place) && dest !== place) return null;
+  const slug = (target.branch || basename(dest)).replace(/[\\/]+/g, '-');
+  const b = target.branch ? ` -b ${target.branch}` : '';
+  const rel = relative(home, here).split(sep).join('/');
+  const how = here === home
+    ? `\`git worktree add .worktrees/${slug}${b}\``
+    : `\`git -C ${rel} worktree add ${join(place, `${basename(here)}-${slug}`)}${b}\``;
+  return 'rsc: a worktree goes in `.worktrees/` at the root you work in, never inside a project folder ' +
+    `and never beside it (${dest} is not under ${place}). Create it with ${how} and work inside it; ` +
+    'tell the person that is where the work now runs. To stop rsc judging worktrees: `npx @ericrisco/rsc isolation off`.';
+}
+
 export const unquoted = (command) => command.replace(/"(?:[^"\\]|\\.)*"|'[^']*'/g, '""');
 
 /** Where the git command actually runs: `git -C <dir>`, or a leading `cd <dir> &&`, else the cwd. */
@@ -133,7 +182,7 @@ export async function evaluate({ root, command, cwd, sessionId }) {
   // the segments judged are the ones the shell would really run (shell-unwrap.mjs).
   const raw = SH.expand(command);
   const segs = raw.map(unquoted);
-  if (!segs.some((s) => COMMITS_HERE.test(s) || MOVES_BRANCH.test(s) || MOVES_REF.test(s) || PUSHES.test(s))) return null;
+  if (!segs.some((s) => COMMITS_HERE.test(s) || MOVES_BRANCH.test(s) || MOVES_REF.test(s) || PUSHES.test(s) || ADDS_WORKTREE.test(s))) return null;
   const self = (rel) => new URL(rel, import.meta.url);
   let dir = cwd || root;
   const branchAt = new Map(); // toplevel → branch the chain has moved it to
@@ -146,13 +195,19 @@ export async function evaluate({ root, command, cwd, sessionId }) {
     const moves = MOVES_BRANCH.test(seg);
     const movesRef = MOVES_REF.test(seg);
     const pushes = PUSHES.test(seg);
-    if (!commits && !moves && !movesRef && !pushes) continue;
+    const addsWorktree = ADDS_WORKTREE.test(seg);
+    if (!commits && !moves && !movesRef && !pushes && !addsWorktree) continue;
     const at = effectiveDir(raw[i] || seg, dir);
     const git = gitAt(at);
     const top = git('rev-parse', '--show-toplevel');
     if (!top) continue;
     const here = (() => { try { return realpathSync(top); } catch { return top; } })();
 
+    if (addsWorktree && !existsSync(join(root, '.rsc', '.no-worktree-isolation'))) {
+      const reason = worktreePlaceDenial({ root, here, seg, at });
+      if (reason) return reason;
+    }
+
     if (moves) {
       const target = moveTarget(seg, at);
       if (target) {
@@ -237,7 +292,7 @@ async function isolationDenial({ root, here, sessionId, self }) {
   if (!others.length) return null;
   const who = others.map((o) => `${o.target}${o.branch ? ` on "${o.branch}"` : ''}, ${ago(o.updatedAt)}`).join('; ');
   return `Another session is working in this same folder (${who}). Switching branches here would change its files under it. ` +
-    'Work in a worktree instead, inside the project: `git worktree add .worktrees/<branch> -b <branch>` (or without -b for an existing branch) and run everything inside `.worktrees/<branch>/`; tell the person that is where the project now runs. ' +
+    'Work in a worktree instead, in `.worktrees/` at the root (never inside a project folder): `git worktree add .worktrees/<branch> -b <branch>` (or without -b for an existing branch; for a project in a folder, `git -C <project> worktree add <root>/.worktrees/<project>-<branch> -b <branch>`) and run everything inside it; tell the person that is where the project now runs. ' +
     'To turn this rule off for the project: `npx @ericrisco/rsc isolation off`.';
 }
 

package/targets/claude.js

@@ -123,6 +123,8 @@ export function wireHook(paths, sourceMd, policy = {}) {
   copyFileSync(join(HERE, 'worktree-reaper.mjs'), join(paths.projectRoot, '.rsc', 'worktree-reaper.mjs'));
   // session-start imports the shared update check, so it travels as a sibling too.
   copyFileSync(join(HERE, 'auto-update.mjs'), join(paths.projectRoot, '.rsc', 'auto-update.mjs'));
+  // session-start imports the optional MemSlop offer lazily, so it travels as a sibling too.
+  copyFileSync(join(HERE, 'memslop-offer.mjs'), join(paths.projectRoot, '.rsc', 'memslop-offer.mjs'));
   // team-safe-default: the 3.0 start-up duties and the trunk policy they read, as siblings.
   copyFileSync(join(HERE, 'team-safe-start.mjs'), join(paths.projectRoot, '.rsc', 'team-safe-start.mjs'));
   copyFileSync(join(HERE, 'trunk-policy.mjs'), join(paths.projectRoot, '.rsc', 'trunk-policy.mjs'));

package/targets/memslop-offer.mjs

@@ -0,0 +1,98 @@
+// MemSlop offer (macOS only). MemSlop is a menu bar app that closes the dev servers, test browsers and
+// other processes agents leave running. rsc tells the person about it once and, only on a yes, the
+// agent installs it. Shared by session-start (Claude Code) and the Codex SessionStart hook in
+// auto-update.mjs, so it travels as their sibling.
+//
+// Cost for anyone who does not want it: nothing. Off darwin it returns before touching the disk. On
+// macOS it only reads files (no subprocess, no network), and its single side effect is the cadence
+// stamp in ~/.rsc/memslop-offer.json. A "no" is per machine (~/.rsc/.no-memslop), because installing
+// an app is a machine decision; a per-project marker would re-ask in every repo. Silence is not a yes:
+// at most one offer every 7 days and 3 in total. Any error means no notice.
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir, release as osRelease } from 'node:os';
+import { join } from 'node:path';
+
+const MIN_DARWIN = 23; // macOS 14 Sonoma, the oldest MemSlop runs on
+const EVERY_DAYS = 7;
+const MAX_OFFERS = 3;
+
+// RSC_MEMSLOP_HOME exists so tests can point it somewhere disposable (same escape hatch as RSC_SELLO_HOME).
+// An injected home (either way) skips the system /Applications, so a real install cannot leak into a test.
+// RSC_MEMSLOP_PLATFORM / RSC_MEMSLOP_RELEASE let a test run the real hook as another OS.
+export function memslopHome() {
+  return process.env.RSC_MEMSLOP_HOME || homedir();
+}
+
+const statePath = (home) => join(home, '.rsc', 'memslop-offer.json');
+
+// Does this agent config connect MemSlop's session-end hook? Missing file → no. Malformed → throws,
+// which the caller turns into silence.
+function hookConnected(file) {
+  if (!existsSync(file)) return false;
+  const config = JSON.parse(readFileSync(file, 'utf8'));
+  const entries = config?.hooks?.SessionEnd;
+  if (!Array.isArray(entries)) return false;
+  return entries.some((e) => Array.isArray(e?.hooks) && e.hooks.some((h) =>
+    typeof h?.command === 'string' && h.command.includes('memslop') && h.command.includes('hook session-end')));
+}
+
+// 'offer' (not installed), 'connect' (CLI present, a hook missing) or null (opted out, too old, all set).
+export function memslopState(home = memslopHome(), system = !process.env.RSC_MEMSLOP_HOME) {
+  if (existsSync(join(home, '.rsc', '.no-memslop'))) return null;
+  const dirs = (system ? ['/Applications'] : []).concat(join(home, 'Applications'));
+  const app = dirs.map((d) => join(d, 'MemSlop.app')).find((p) => existsSync(p));
+  if (!app) return 'offer';
+  // MemSlop < 1.2 has no command line tool and does not update itself: stay silent.
+  if (!existsSync(join(app, 'Contents', 'Helpers', 'memslop'))) return null;
+  const agents = [['.claude', 'settings.json'], ['.codex', 'hooks.json']];
+  const missing = agents.some(([dir, file]) => existsSync(join(home, dir)) && !hookConnected(join(home, dir, file)));
+  return missing ? 'connect' : null;
+}
+
+const OFFER = `
+===== rsc mem-slop (optional, macOS) =====
+MemSlop is a menu bar app that closes the dev servers, test browsers and other processes
+AI agents leave running. Free, open source; the first day it closes nothing, it only shows
+what it would close and asks.
+ACTION: offer it ONCE, in one line, to the user. On yes, run:
+  curl -fsSL https://raw.githubusercontent.com/ericrisco/mem-slop/main/install.sh | bash
+then \`memslop hooks install\` (also optional; ask). On no, create ~/.rsc/.no-memslop.
+Never install it without that yes.
+=========================================
+`;
+
+const CONNECT = `
+===== rsc mem-slop hooks (optional, macOS) =====
+MemSlop is installed but not connected to every agent here. \`memslop hooks install\` lets it clean
+up the moment a Claude Code or Codex session ends; \`memslop hooks uninstall\` undoes it.
+ACTION: offer it ONCE, in one line, to the user, and run it only on a yes. On no, create ~/.rsc/.no-memslop.
+================================================
+`;
+
+/**
+ * The block to print this session, or ''. Records the offer when it returns one.
+ * `platform`, `release` and `now` are injectable for tests.
+ */
+export function memslopNotice({
+  platform = process.env.RSC_MEMSLOP_PLATFORM || process.platform,
+  release = process.env.RSC_MEMSLOP_RELEASE,
+  home,
+  now = Date.now(),
+} = {}) {
+  if (platform !== 'darwin') return '';
+  try {
+    if (Number.parseInt(release ?? osRelease(), 10) < MIN_DARWIN) return '';
+    const dir = home ?? memslopHome();
+    let seen = { offers: 0, last: null };
+    if (existsSync(statePath(dir))) seen = JSON.parse(readFileSync(statePath(dir), 'utf8'));
+    const offers = Number(seen.offers) || 0;
+    if (offers >= MAX_OFFERS) return '';
+    const last = seen.last ? new Date(seen.last).getTime() : NaN;
+    if (!Number.isNaN(last) && (now - last) / 86400000 < EVERY_DAYS) return '';
+    const state = memslopState(dir, home === undefined && !process.env.RSC_MEMSLOP_HOME);
+    if (!state) return '';
+    mkdirSync(join(dir, '.rsc'), { recursive: true });
+    writeFileSync(statePath(dir), JSON.stringify({ offers: offers + 1, last: new Date(now).toISOString() }) + '\n');
+    return state === 'offer' ? OFFER : CONNECT;
+  } catch { return ''; }
+}

package/targets/opt-outs.js

@@ -39,6 +39,7 @@ export const MACHINE_OPT_OUTS = [
   'context7',   // an MCP connection is machine wiring, and its consent is individual
   'git',        // only fires with no .git/, which a clone cannot be
   'harness',    // "not offered again ON THIS MACHINE" — the bootstrap's own words
+  'memslop',    // an app install is machine wiring, and its consent is individual (~/.rsc/.no-memslop)
   'scope-check',// compares the project and home scopes OF THIS MACHINE
 ];
 

package/targets/session-memory-adapter.mjs

@@ -122,8 +122,8 @@ export function isolationContext({ project, here, sessionId, target }) {
   if (!others.length) return '';
   const who = others.map((o) => `${o.target}${o.branch ? ` en «${o.branch}»` : ''}`).join(', ');
   return `rsc · aislamiento: otra sesión está trabajando en esta misma carpeta (${who}). ` +
-    'Cualquier cambio de esta petición se hace en un worktree dentro del proyecto: ' +
-    '`git worktree add .worktrees/<rama> -b <rama>` y se trabaja dentro de `.worktrees/<rama>/`. ' +
+    'Cualquier cambio de esta petición se hace en un worktree en `.worktrees/` de la raíz, nunca dentro de una carpeta de proyecto: ' +
+    '`git worktree add .worktrees/<rama> -b <rama>` (si el proyecto está en una subcarpeta, `git -C <proyecto> worktree add <raíz>/.worktrees/<proyecto>-<rama> -b <rama>`, con la ruta absoluta) y se trabaja dentro. ' +
     'No cambies de rama en esta carpeta. Dile a la persona en una línea dónde estás trabajando, para que ' +
     'abra o levante el proyecto desde allí.';
 }

package/targets/session-start.mjs

@@ -212,6 +212,16 @@ then reload the session. If you don't want it here: create .rsc/.no-context7.
 `);
 }
 
+// MemSlop (optional, macOS 14+ only): one offer per machine, a permanent no in ~/.rsc/.no-memslop.
+// Under emitBody so a project wired in both scopes prints it once. The module is a sibling loaded
+// lazily: missing or failing, it stays silent and never takes the other notices down with it.
+if (emitBody && profileExists) {
+  try {
+    const M = await import('./memslop-offer.mjs');
+    process.stdout.write(M.memslopNotice());
+  } catch { /* no notice */ }
+}
+
 // Periodic skill audit: for active rsc projects, nudge to re-audit when the last run
 // is stale (or never ran). Running \`rsc audit\` stamps .rsc/audit.json and silences
 // this for the cadence. Opt out with .rsc/.no-audit.

package/targets/team-safe-start.mjs

@@ -86,6 +86,7 @@ export async function relocateOldWorktrees(root) {
     for (const wt of W.listWorktrees(root)) {
       const path = real(wt.path);
       if (isInside(path, home)) continue; // already inside
+      if (W.atWorkspaceRoot?.(path, home)) continue; // a project folder's worktree, at the workspace root on purpose
       if (W.provenanceOf(root, { ...wt, path }) !== 'rsc') continue;
       if (others(path).length) { left.push(`${path} (una sesión trabaja en él)`); continue; }
       const name = basename(path);

package/targets/update-wiring.js

@@ -110,8 +110,8 @@ export default {
 `;
 
 export function updateManagedPaths(target, cwd = process.cwd()) {
-  const module = join(cwd, '.rsc', 'auto-update.mjs');
-  return CONFIG[target] ? [module, join(cwd, ...CONFIG[target].split('/'))] : [module];
+  const modules = [join(cwd, '.rsc', 'auto-update.mjs'), join(cwd, '.rsc', 'memslop-offer.mjs')];
+  return CONFIG[target] ? [...modules, join(cwd, ...CONFIG[target].split('/'))] : modules;
 }
 
 /** Wire it. Always: being off is the runtime's `.no-auto-update`, and the check itself stays on. */
@@ -119,8 +119,11 @@ export function wireUpdate(target, cwd = process.cwd()) {
   const module = join(cwd, '.rsc', 'auto-update.mjs');
   mkdirSync(dirname(module), { recursive: true });
   copyFileSync(join(HERE, 'auto-update.mjs'), module);
+  // The Codex hook imports the MemSlop offer lazily, so it travels as a sibling for every target.
+  const offer = join(cwd, '.rsc', 'memslop-offer.mjs');
+  copyFileSync(join(HERE, 'memslop-offer.mjs'), offer);
   if (!CONFIG[target]) {
-    return { mode: target === 'claude' ? 'hook' : 'agent', paths: [module] };
+    return { mode: target === 'claude' ? 'hook' : 'agent', paths: [module, offer] };
   }
   const configPath = join(cwd, ...CONFIG[target].split('/'));
   if (tracked(cwd, configPath)) return { mode: 'agent', reason: 'config-tracked', paths: [module] };

package/targets/worktree-reaper.mjs

@@ -169,13 +169,26 @@ export function listWorktrees(root) {
  * accumulates, nothing is lost), while one the user made by hand that happens to match the
  * convention would be indistinguishable from ours. So one signal alone is `ambiguous`, not `rsc`.
  */
+/**
+ * Where a project folder's worktree goes since 2026-10-27: `<root>/.worktrees/<repo>-<branch>`, at the
+ * workspace root that contains the repo (branch-guard rule C). Named after the repo, in a
+ * `.worktrees/` of an ancestor of the repo — both, or it is not this convention.
+ */
+export function atWorkspaceRoot(p, home) {
+  const parent = dirname(p);
+  if (basename(parent) !== '.worktrees' || !basename(p).startsWith(`${basename(home)}-`)) return false;
+  const ws = dirname(parent);
+  return home.startsWith(ws + sep) && home !== ws;
+}
+
 export function provenanceOf(root, wt) {
   const p = wt.path;
   const home = real(root);
   const inside = (dir) => p === dir || p.startsWith(dir + sep);
   const location = inside(join(home, '.worktrees'))
     || inside(join(home, 'worktrees'))
-    || (dirname(p) === dirname(home) && basename(p).startsWith(`${basename(home)}-`));
+    || (dirname(p) === dirname(home) && basename(p).startsWith(`${basename(home)}-`))
+    || atWorkspaceRoot(p, home);
   const branch = Boolean(wt.branch && RSC_BRANCH.test(wt.branch));
   if (location && branch) return 'rsc';
   if (location || branch) return 'ambiguous';