@ericrisco/rsc 2.1.0 → 3.0.0

package/targets/auto-update.mjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+// rsc update check, shared by every assistant that can run it. Standalone (Node built-ins only),
+// copied to `.rsc/auto-update.mjs` at install, like the other hooks.
+//
+// Three ways in, one rule:
+//   - Claude Code: `session-start.mjs` imports `updateNotice` and prints it with the always-on body.
+//   - Codex, Gemini CLI, Cursor: a session-start hook runs `node .rsc/auto-update.mjs hook <target>`
+//     and gets the notice back in that assistant's own output shape.
+//   - OpenCode: its plugin imports `updateNotice` and hands the notice to the model.
+//   - Any other assistant has no hook. The always-on body asks the agent to run
+//     `node .rsc/auto-update.mjs` on its first turn, and to relay what it prints.
+import { readFileSync, existsSync, writeFileSync, openSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Update check: compare the installed version (.rsc/.version, written at install)
+// against the latest published on npm, and nudge the agent to offer an update.
+// Fail-silent (offline / missing baseline / parse error → nothing). Disable with
+// RSC_NO_UPDATE_CHECK=1. RSC_LATEST overrides the npm lookup (tests / mirrors).
+function isNewer(a, b) {
+  const pa = String(a).split('.').map(Number);
+  const pb = String(b).split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return true;
+    if ((pa[i] || 0) < (pb[i] || 0)) return false;
+  }
+  return false;
+}
+
+// "rsc X is out" was being ignored — the maintainer's own workspace sat on 2.0.4 for days with this
+// notice on every session, and two people in two days reported bugs that were already fixed. A
+// version number names nothing anyone recognises. A symptom does: someone who sees a red error after
+// every turn updates the moment they are told that is what the update fixes (`suggest` §3: say what
+// is wrong as a symptom, not as a cause).
+//
+// The symptoms travel for free: the registry's `/latest` document is the published package.json, so
+// its `rscFixes` field — `{ fixedIn, symptom }` — arrives in the response this check already makes.
+// It is text a model will read, so every entry is reduced to one short plain line or dropped.
+const SEMVER_ONLY = /^\d+\.\d+\.\d+$/;
+function fixesSince(list, installed, latest) {
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const item of list) {
+    if (!item || typeof item !== 'object' || typeof item.symptom !== 'string') continue;
+    if (!SEMVER_ONLY.test(String(item.fixedIn))) continue;
+    if (!isNewer(item.fixedIn, installed) || isNewer(item.fixedIn, latest)) continue;
+    const symptom = item.symptom.replace(/[\u0000-\u001f\u007f]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 200);
+    if (symptom) out.push({ fixedIn: item.fixedIn, symptom });
+  }
+  return out.slice(0, 8);
+}
+
+// Auto-update. Asking was not enough: the notice depended on an agent relaying it, and people kept
+// running bugs that were already fixed. So a release in the SAME major installs itself; a new major
+// can change how the harness works, and still asks. On by default; `.rsc/.no-auto-update` (a project
+// decision, travels in `optOuts`) brings back the question for every release.
+//
+// It runs in the background because `npx` can take longer than a hook may, and it changes nothing in
+// this session anyway: the skills are already loaded. The version is the exact one seen here, never
+// `@latest` — what is published in between does not slip in. One attempt per version: a failure falls
+// back to asking, and is retried at most once a day.
+const stateFile = (root) => join(root, '.rsc', 'auto-update.json');
+const logFile = (root) => join(root, '.rsc', 'auto-update.log');
+const AUTO_RUNNING_MS = 15 * 60 * 1000;
+const AUTO_RETRY_MS = 24 * 60 * 60 * 1000;
+const majorOf = (v) => Number(String(v).split('.')[0]) || 0;
+
+function readAutoState(root) {
+  try { return JSON.parse(readFileSync(stateFile(root), 'utf8')); } catch { return null; }
+}
+function writeAutoState(root, state) {
+  try { writeFileSync(stateFile(root), `${JSON.stringify(state, null, 2)}\n`); } catch { /* best effort */ }
+}
+function declaredTargets(root) {
+  try {
+    const list = JSON.parse(readFileSync(join(root, '.rsc.json'), 'utf8')).targets;
+    return Array.isArray(list) ? list.filter((t) => typeof t === 'string' && /^[a-z0-9-]+$/.test(t)) : [];
+  } catch { return []; }
+}
+function launchUpdate(root, version, env) {
+  // RSC_AUTO_UPDATE_CMD (a JSON argv) replaces npx in tests; the arguments after it are the real ones.
+  const base = env.RSC_AUTO_UPDATE_CMD
+    ? JSON.parse(env.RSC_AUTO_UPDATE_CMD)
+    : ['npx', '-y', `@ericrisco/rsc@${version}`];
+  const targets = declaredTargets(root);
+  const args = [...base.slice(1), 'sync', ...(targets.length ? ['--target', targets.join(',')] : [])];
+  const log = openSync(logFile(root), 'w');
+  const child = spawn(base[0], args, {
+    cwd: root,
+    detached: true,
+    stdio: ['ignore', log, log],
+    windowsHide: true,
+    shell: process.platform === 'win32', // npx is npx.cmd there; every argument was validated above
+    env: { ...env, RSC_NO_UPDATE_CHECK: '1', RSC_AUTO_UPDATE_TO: version },
+  });
+  child.on('error', () => {});
+  child.unref();
+}
+
+export async function updateNotice(root, env = process.env) {
+  let out = '';
+  const say = (text) => { out += text; };
+  try {
+    const installed = readFileSync(join(root, '.rsc', '.version'), 'utf8').trim();
+    // A background update that finished since the last session: say so once, then keep quiet.
+    const prior = readAutoState(root);
+    if (prior && !prior.reported && SEMVER_ONLY.test(String(prior.to)) && !isNewer(prior.to, installed)) {
+      say(`
+===== rsc updated =====
+rsc updated itself in the background, from ${prior.from} to ${installed}. It is active in this session.
+ACTION: tell the user in one line. Files of the harness may show as changed in git.
+=======================
+`);
+      writeAutoState(root, { ...prior, reported: true });
+    }
+    let doc = null;
+    if (env.RSC_LATEST_JSON) doc = JSON.parse(env.RSC_LATEST_JSON);
+    else if (env.RSC_LATEST) doc = { version: env.RSC_LATEST };
+    else {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), 1500);
+      const res = await fetch('https://registry.npmjs.org/@ericrisco%2frsc/latest', { signal: ctrl.signal });
+      clearTimeout(timer);
+      doc = await res.json();
+    }
+    const latest = doc?.version;
+    if (installed && SEMVER_ONLY.test(String(latest)) && isNewer(latest, installed)) {
+      const newMajor = majorOf(latest) !== majorOf(installed);
+      const auto = !existsSync(join(root, '.rsc', '.no-auto-update')) && !newMajor;
+      const now = Date.now();
+      const since = prior && prior.to === latest ? now - new Date(prior.startedAt).getTime() : Infinity;
+      if (auto && since >= AUTO_RETRY_MS) {
+        launchUpdate(root, latest, env);
+        writeAutoState(root, { from: installed, to: latest, startedAt: new Date(now).toISOString() });
+        say(`
+===== rsc updating =====
+rsc ${latest} is out — you have ${installed}. It is installing itself in the background now and
+takes effect in the next session. Nothing to do.
+ACTION: tell the user in one line, then continue with the task.
+========================
+`);
+      } else if (auto && since < AUTO_RUNNING_MS) {
+        say(`
+===== rsc updating =====
+rsc ${latest} is still installing itself in the background. It takes effect in the next session.
+========================
+`);
+      } else {
+        // Asking: auto-update is off here, the release is a new major, or the background attempt failed.
+        let why = '';
+        if (auto) why = `The automatic update did not finish (log: .rsc/auto-update.log); it retries once a day.\n`;
+        else if (newMajor) why = 'It is a new major version: it can change how the harness works, so it asks first.\n';
+        let fixes = [];
+        try { fixes = fixesSince(doc.rscFixes, installed, latest); } catch { fixes = []; }
+        if (fixes.length) {
+          say(`
+===== rsc update available =====
+rsc ${latest} is out — you have ${installed}. It fixes problems this install still has:
+${fixes.map((f) => `  - ${f.symptom} (fixed in ${f.fixedIn})`).join('\n')}
+${why}ACTION: before starting the task, tell the user in one line that the update fixes what they
+may be seeing, and if they say yes, run it in this project:
+  npx @ericrisco/rsc@latest
+================================
+`);
+        } else {
+          say(`
+===== rsc update available =====
+rsc ${latest} is out — you have ${installed}.
+${why}ACTION: tell the user a new version is available and, if they say yes, run:
+  npx @ericrisco/rsc@latest
+(That reinstalls and refreshes the skill content to the latest.)
+================================
+`);
+        }
+      }
+    }
+  } catch { /* offline / no baseline / parse error → stay silent */ }
+  return out;
+}
+
+// What each assistant's session-start hook accepts. Codex and Gemini take Claude's shape; Cursor has
+// its own field names. Plain text for an agent that runs this by hand.
+export function hookOutput(target, notice) {
+  if (!notice) return target === 'agent' ? '' : '{}';
+  if (target === 'agent') return notice;
+  if (target === 'cursor') return JSON.stringify({ additional_context: notice });
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: notice } });
+}
+
+// Run as a script: `node auto-update.mjs [hook <target>] [root]`. Never fails a session.
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const hook = process.argv[2] === 'hook';
+  const target = hook ? String(process.argv[3] || 'agent') : 'agent';
+  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 */ }
+  if (!hook && !notice) notice = 'rsc is up to date.';
+  process.stdout.write(`${hookOutput(target, notice)}\n`);
+}

package/targets/branch-guard.mjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+// rsc Branch guard (claude). Wired by targets/claude.js onto PreToolUse (matcher Bash) as
+// `node ...`, like ship-guard. argv[2] = project root · stdin = PreToolUse hook JSON.
+//
+// Two rules from team-safe-default, each the deterministic floor of something the skills decide:
+//
+//   A · the default branch is closed for the agent where the project shows it is complex or in
+//       production (trunk-policy.mjs). A commit or a merge there is denied, and the message says
+//       how to carry on: a branch, or — if the project is in fact simple — the person unlocking it.
+//   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/`.
+//
+// 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 { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+function allow() { process.exit(0); }
+function deny(reason) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: reason },
+  }));
+  process.exit(0);
+}
+
+const GIT_OPTS = String.raw`(?:(?:-C\s+\S+|-c\s+\S+|--(?:work-tree|git-dir|namespace)\s+\S+|--\S+)\s+)*`;
+export const COMMITS_HERE = new RegExp(String.raw`\bgit\s+${GIT_OPTS}(?:commit|merge|cherry-pick|revert|am)(?![\w-])`);
+// A branch move: switch, or checkout of something that is not a path (`checkout -- f`, `checkout HEAD -- f`).
+export const MOVES_BRANCH = new RegExp(String.raw`\bgit\s+${GIT_OPTS}(?:switch(?![\w-])|checkout(?![\w-])(?![^;&|\n]*\s--(?:\s|$)))`);
+
+export const unquoted = (command) => command.replace(/"(?:[^"\\]|\\.)*"|'[^']*'/g, '""');
+
+/** Where the git command actually runs: `git -C <dir>`, or a leading `cd <dir> &&`, else the cwd. */
+export function effectiveDir(command, base) {
+  const c = command.match(/\bgit\s+(?:-c\s+\S+\s+)*-C\s+("[^"]+"|'[^']+'|\S+)/);
+  const d = command.match(/^\s*cd\s+("[^"]+"|'[^']+'|\S+)\s*&&/);
+  const raw = (c || d)?.[1]?.replace(/^["']|["']$/g, '');
+  if (!raw) return base;
+  return isAbsolute(raw) ? raw : resolve(base, raw);
+}
+
+const gitAt = (dir) => (...args) => {
+  const r = spawnSync('git', ['-C', dir, ...args], { encoding: 'utf8' });
+  return r.status === 0 ? (r.stdout || '').trim() : null;
+};
+
+const ago = (iso) => {
+  const min = Math.max(0, Math.round((Date.now() - new Date(iso).getTime()) / 60000));
+  return min <= 1 ? 'just now' : `${min} min ago`;
+};
+
+/** Heredoc bodies are text being written, not commands: `cat > notes.md <<EOF … git commit … EOF`. */
+export const withoutHeredocs = (command) => command.replace(/<<-?\s*(['"]?)([A-Za-z_]\w*)\1[^\n]*\n[\s\S]*?\n\s*\2\s*(?=\n|$)/g, '');
+
+/** The command split where the shell would run one thing after another, never inside quotes. */
+export function segments(command) {
+  const out = [];
+  let cur = '';
+  let q = null;
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i];
+    if (q) { cur += c; if (c === '\\' && q === '"') cur += command[++i] ?? ''; else if (c === q) q = null; continue; }
+    if (c === '"' || c === "'") { q = c; cur += c; continue; }
+    if (c === ';' || c === '\n' || c === '|' || c === '&') {
+      if ((c === '&' || c === '|') && command[i + 1] === c) i++;
+      out.push(cur); cur = ''; continue;
+    }
+    cur += c;
+  }
+  out.push(cur);
+  return out.filter((s) => s.trim());
+}
+const tokens = (s) => s.trim().split(/\s+/).filter(Boolean);
+
+/** What a branch-moving segment moves to, or null if it is a path checkout after all (`checkout .`). */
+function moveTarget(seg, dir) {
+  const t = tokens(seg.replace(/^.*?\bgit\s+/, '').replace(/^(?:(?:-C|-c)\s+\S+\s+|--\S+\s+)*/, ''));
+  const verb = t.shift();
+  const create = t.findIndex((x) => /^-[cCbB]$/.test(x));
+  if (create >= 0) return { name: t[create + 1] || null, created: true };
+  const name = t.find((x) => !x.startsWith('-'));
+  if (!name) return { name: null, created: false };
+  if (verb === 'checkout' && (name === '.' || (existsSync(resolve(dir, name)) && !gitAt(dir)('rev-parse', '--verify', '--quiet', `refs/heads/${name}`)))) return null;
+  return { name, created: false };
+}
+
+/**
+ * Rule A and rule B, judged segment by segment: a chain is followed the way the shell runs it, so
+ * `git switch -c feat/x && git commit` is a commit on feat/x (allowed) and `git switch main && git
+ * merge feat/x` is a merge on main (judged as one). `cd` and `git -C` move the folder being judged.
+ */
+export async function evaluate({ root, command, cwd, sessionId }) {
+  if (typeof command !== 'string' || !command) return null;
+  // Words inside quotes or heredocs are text, not commands: `grep -rn "git commit" docs/` is a search.
+  const bare = unquoted(withoutHeredocs(command));
+  if (!COMMITS_HERE.test(bare) && !MOVES_BRANCH.test(bare)) return null;
+  const self = (rel) => new URL(rel, import.meta.url);
+  const raw = segments(withoutHeredocs(command));
+  const segs = raw.map(unquoted);
+  let dir = cwd || root;
+  const branchAt = new Map(); // toplevel → branch the chain has moved it to
+
+  for (let i = 0; i < segs.length; i++) {
+    const seg = segs[i];
+    const cd = (raw[i] || seg).match(/^\s*cd\s+("[^"]+"|'[^']+'|\S+)\s*$/);
+    if (cd) { const d = cd[1].replace(/^["']|["']$/g, ''); dir = isAbsolute(d) ? d : resolve(dir, d); continue; }
+    const commits = COMMITS_HERE.test(seg);
+    const moves = MOVES_BRANCH.test(seg);
+    if (!commits && !moves) 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 (moves) {
+      const target = moveTarget(seg, at);
+      if (target) {
+        if (!existsSync(join(root, '.rsc', '.no-worktree-isolation'))) {
+          const reason = await isolationDenial({ root, here, sessionId, self });
+          if (reason) return reason;
+        }
+        if (target.name) branchAt.set(here, target.name);
+      }
+    }
+
+    if (commits && !existsSync(join(root, '.rsc', '.no-trunk-guard'))) {
+      try {
+        const { trunkPolicy, defaultBranchName } = await import(self('./trunk-policy.mjs'));
+        const branch = branchAt.get(here) ?? git('symbolic-ref', '--quiet', '--short', 'HEAD');
+        const trunk = defaultBranchName(here);
+        if (branch && trunk && branch === trunk) {
+          const policy = trunkPolicy(here);
+          if (policy.closed) return await trunkDenial({ root, here, sessionId, self, trunk, policy });
+        }
+      } catch { /* policy module missing → nothing to enforce */ }
+    }
+  }
+  return null;
+}
+
+async function othersHere({ root, here, sessionId, self }) {
+  try {
+    const { otherActiveSessions } = await import(self('./session-memory-core.mjs'));
+    return otherActiveSessions({ cwd: root, worktreeCwd: here, sessionId, target: 'claude' });
+  } catch { return []; } // no memory module → no detection
+}
+
+async function trunkDenial({ root, here, sessionId, self, trunk, policy }) {
+  // Where the branch goes depends on rule B: alone → this same folder; with company → .worktrees/.
+  const others = existsSync(join(root, '.rsc', '.no-worktree-isolation')) ? [] : await othersHere({ root, here, sessionId, self });
+  const where = others.length
+    ? 'Another session is working in this folder, so open it as a worktree inside the project: `git worktree add .worktrees/<branch> -b feat/<what-you-are-doing>` and commit inside `.worktrees/<branch>/`'
+    : 'You are the only session here, so stay in this same folder, no worktree: `git switch -c feat/<what-you-are-doing>` (or fix/…, docs/…) and commit there';
+  return `This project keeps its default branch "${trunk}" closed for the agent (it looks complex or in production: ${policy.signals.join(', ')}). ` +
+    `Do this work on a branch instead. ${where}; it reaches "${trunk}" through a pull request. ` +
+    'If this project is actually simple and the person asks to unlock it, run `npx @ericrisco/rsc main unlock` (a project decision, saved in .rsc.json).';
+}
+
+async function isolationDenial({ root, here, sessionId, self }) {
+  const others = await othersHere({ 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. ' +
+    'To turn this rule off for the project: `npx @ericrisco/rsc isolation off`.';
+}
+
+function isMain(metaUrl) {
+  const invoked = process.argv[1];
+  if (!invoked) return false;
+  const me = fileURLToPath(metaUrl);
+  try { return realpathSync(me) === realpathSync(invoked); } catch { return me === invoked; }
+}
+
+if (isMain(import.meta.url)) {
+  const root = process.argv[2] || process.cwd();
+  if (!existsSync(join(root, '.git'))) allow();
+  let input = {};
+  try { input = JSON.parse(readFileSync(0, 'utf8') || '{}'); } catch { allow(); }
+  if ((input.tool_name || input.toolName) !== 'Bash') allow();
+  const command = input.tool_input?.command || input.toolInput?.command || '';
+  const reason = await evaluate({ root, command, cwd: input.cwd || root, sessionId: input.session_id });
+  if (reason) deny(reason);
+  allow();
+}

package/targets/claude.js

@@ -118,6 +118,11 @@ export function wireHook(paths, sourceMd, policy = {}) {
   // Same reason: session-start imports the reaper for the landed-worktree sweep, so it travels as a
   // sibling too. Missing it does not break startup — the sweep is wrapped — it just goes silent.
   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'));
+  // 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'));
   copyFileSync(join(HERE, 'session-start.mjs'), scriptDest);
   // The one harness file that belongs in the committed tree rather than in `.rsc/`: it is the only
   // thing standing between a clone and seven stack traces, so it has to survive `git clone`.
@@ -179,6 +184,20 @@ export function wireHook(paths, sourceMd, policy = {}) {
   );
   settings.hooks.PreToolUse.push({ matcher: 'Bash', hooks: [{ type: 'command', command: sgCmd }] });
 
+  // Branch guard (team-safe-default): the default branch closed for the agent where the project shows
+  // it is complex or in production, and no branch switching under another session working in the same
+  // checkout. trunk-policy.mjs is its sibling import (and knowledge-sync's); session-memory-core.mjs
+  // comes with the memory wiring, and without it the isolation rule simply sees nobody. Fail-open,
+  // opt-outs `.rsc/.no-trunk-guard` and `.rsc/.no-worktree-isolation`.
+  const bgDest = join(paths.projectRoot, '.rsc', 'branch-guard.mjs');
+  copyFileSync(join(HERE, 'branch-guard.mjs'), bgDest);
+  copyFileSync(join(HERE, 'trunk-policy.mjs'), join(paths.projectRoot, '.rsc', 'trunk-policy.mjs'));
+  const bgCmd = viaBootstrap('guard', at('.rsc', 'branch-guard.mjs'), `"${P}"`);
+  settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+    (e) => !hookWiringOf(e).includes('.rsc/branch-guard.'),
+  );
+  settings.hooks.PreToolUse.push({ matcher: 'Bash', hooks: [{ type: 'command', command: bgCmd }] });
+
 
   // Gitmoji guard: a PreToolUse(Bash) hook that DENIES a `git commit` whose message
   // carries no gitmoji (gitmoji.dev) in front of the Conventional Commits header. The
@@ -211,18 +230,18 @@ export function wireHook(paths, sourceMd, policy = {}) {
     (e) => !hookWiringOf(e).includes('.rsc/userprompt-gate.'),
   );
   settings.hooks.UserPromptSubmit.push({ hooks: [{ type: 'command', command: fgCmd }] });
-  written.push(sgDest, gmDest, fgDest, join(paths.projectRoot, '.rsc', 'sello.mjs'));
+  written.push(sgDest, gmDest, fgDest, bgDest, join(paths.projectRoot, '.rsc', 'sello.mjs'), join(paths.projectRoot, '.rsc', 'trunk-policy.mjs'));
   } else {
     for (const event of ['PreToolUse', 'UserPromptSubmit']) {
       if (!settings.hooks[event]) continue;
       settings.hooks[event] = settings.hooks[event].filter((entry) => {
         const body = hookWiringOf(entry);
-        return !body.includes('.rsc/ship-guard.') &&
+        return !body.includes('.rsc/ship-guard.') && !body.includes('.rsc/branch-guard.') &&
           !body.includes('.rsc/gitmoji-guard.') && !body.includes('.rsc/userprompt-gate.');
       });
       if (!settings.hooks[event].length) delete settings.hooks[event];
     }
-    for (const name of ['ship-guard.mjs', 'gitmoji-guard.mjs', 'userprompt-gate.mjs', 'sello.mjs']) {
+    for (const name of ['ship-guard.mjs', 'branch-guard.mjs', 'trunk-policy.mjs', 'gitmoji-guard.mjs', 'userprompt-gate.mjs', 'sello.mjs']) {
       rmSync(join(paths.projectRoot, '.rsc', name), { force: true });
     }
     written.push(operationsSuggest);

package/targets/clone-bootstrap.mjs

@@ -43,7 +43,7 @@ const SEMVER = /^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?$/i;
  * nothing checks is just drift with a head start.
  */
 export const PROJECT_OPT_OUTS = [
-  'audit', 'claudemd-check', 'danger-guard', 'feature-gate', 'gitmoji', 'ship-guard', 'worktree-cleanup',
+  'audit', 'auto-update', 'claudemd-check', 'danger-guard', 'feature-gate', 'gitmoji', 'knowledge-sync', 'ship-guard', 'trunk-guard', 'worktree-cleanup', 'worktree-isolation',
 ];
 
 /**

package/targets/hook-once.mjs

@@ -94,12 +94,11 @@ Classify this turn before acting, and name the lane in one line.
 - Asks for information — explain, compare, audit, review, propose? -> Answer.
   Write nothing and create no artifact. Change intent unclear -> ask one
   question and stay read-only; ambiguity slows the lane, it never raises it.
-- Authorises a change? -> FTD (Fast-Track Development). One feature document,
-  tasks checked off only against observed proof, a branch if it writes code.
-- SDD, the ten-phase chain, is never entered by the harness alone. Propose it
-  only when durable spec/plan/tasks would remove a substantial ambiguity, and
-  enter it only on an explicit request or an accepted proposal. Size, file
-  count and risk never select it.
+- Authorises a change? YOU pick the lane, say it and why: simple -> FTD (one
+  feature document, tasks checked off against observed proof); big or
+  interlocking decisions -> SDD (spec + clarify approved, then autopilot or not).
+- Complex/production: no commits on the default branch, branch + PR. Simple:
+  default branch. Another session here: .worktrees/<branch>.
 Method: \`ftd\` · chain: \`sdd\` · full decisor in the always-on \`suggest\` body.
 =================================================
 `;