sawbuck 0.1.43 → 0.1.45

package/sawbuck.mjs

@@ -1,28 +1,22 @@
 #!/usr/bin/env node
 // sawbuck, the CLI. Zero-dep.
-// `attach` wires Sawbuck's reflex into a repo (a git post-commit hook by default,
-// or Claude Code hooks); `detach` removes it and leaves the repo exactly as it
-// was. Isolation invariant: the repo never imports Sawbuck, and detach is a true
-// inverse of attach. Rides two engines: promptwheel (the check) + @promptwheel/logbook.
+// `attach` wires the Claude Code hooks into a repo; `detach` removes them and leaves the repo exactly as it was. The
+// repo never imports Sawbuck. Rides two engines: promptwheel (the check) + @promptwheel/logbook.
 //
-// How removal stays honest: attach writes a receipt to .git/sawbuck/attach.json
-// recording every file/dir it created or modified and every .git/info/exclude
-// line it added. detach reads the receipt and reverses exactly that, deleting
-// what it created, stripping only its own lines from what it modified, touching
-// nothing it did not touch. `trace` prints the footprint; `detach --verify`
-// proves the repo came back clean; `doctor` checks the attachment still resolves.
+// attach writes a receipt to .git/sawbuck/attach.json recording every file it created or modified. detach reads it and
+// reverses exactly that; `detach --verify` proves the repo came back clean; `doctor` checks the attachment still resolves.
 
 import { execFileSync } from 'node:child_process';
-import { erasedBlock } from './rewrites.mjs';
+import { erasedBlock, erasedCommits } from './rewrites.mjs';
 import { steersReport } from './steers.mjs';
 import { rulesCli } from './rules.mjs';
 import { shapeCli } from './shape.mjs';
-import { ensureExcluded, RECORD_DIRS } from './exclude.mjs';
+import { ensureExcluded, clearExcluded, EXCLUDED, RECORD_DIRS } from './exclude.mjs';
+import { repoState } from './repo-state.mjs';
 import { readFileSync, writeFileSync, existsSync, chmodSync, mkdirSync, unlinkSync, rmdirSync, rmSync, readdirSync } from 'node:fs';
 import { basename, join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
-import { recall as memRecall, conform as memConform } from './memory.mjs';
 import { PW } from './bins.mjs';
 import { frameBlock, mandatesInForce, protectedDirty, blobAt, lockState } from './contract.mjs';
 
@@ -53,7 +47,7 @@ const argv = process.argv.slice(2);
 const cmd = argv[0];
 const rest = argv.slice(1);
 const flags = new Set(rest.filter((a) => a.startsWith('--')));
-// `-n N` (sawbuck log) is a flag with a value, not a repo path.
+// `-n N` (status --log) is a flag with a value, not a repo path.
 const positional = rest.filter((a, i) => !a.startsWith('--') && a !== '-n' && rest[i - 1] !== '-n');
 const repoArg = () => resolve(positional[0] || '.');
 const dry = flags.has('--dry-run');
@@ -61,7 +55,7 @@ const dry = flags.has('--dry-run');
 let version = '0.0.0';
 try { version = JSON.parse(readFileSync(join(HERE, 'package.json'), 'utf8')).version; } catch {}
 
-const help = `sawbuck ${version}: sign your agent to a contract
+const help = `sawbuck ${version}: write down the rules your agent follows, and prove they held
 
 Usage:
   sawbuck check [repo] [--base R --head R] [--repeat N] [--allow "<reason>"] [--json]
@@ -70,42 +64,29 @@ Usage:
                             fastest way to see it work. Every promptwheel run flag passes through.
                             Exit 0 verified · 1 regression · 2 gamed · 3 inconclusive · 64 could not run
   sawbuck init [--yes] [--wizard] [--no-investigate] [--no-agent-block]
-                            Customize the contract (promptwheel.config.json), with notes from what your
-                            git history shows actually breaks, plus a short contract guide in AGENTS.md
+                            Customize the rules (promptwheel.config.json), with notes from what your
+                            git history shows actually breaks, plus a short guide in AGENTS.md
                             (--no-agent-block to skip). Wizard in a terminal, non-interactive in a pipe/CI (or --yes).
-  sawbuck attach [repo]     Enforce the contract on every commit (a git post-commit hook)
-      --claude              instead on every Claude Code turn (project hooks in .claude/settings.local.json)
-      --shared              with --claude, write the tracked .claude/settings.json (team-shared, visible in git)
-      --user                user-level Claude hooks that follow your cwd (attach once, every project)
-      --dry-run             print the exact footprint it would leave, and write nothing
-  sawbuck detach [repo] [--claude | --user] [--all] [--verify] [--purge]
+  sawbuck attach [repo]     Check every Claude Code turn in this repo. --user for every repo. --dry-run prints the footprint
+  sawbuck detach [repo] [--user] [--verify] [--purge]
                             Remove it and restore the repo (no flag: whatever is attached here); --verify
                             proves it came back clean; --purge also deletes the record (.sawbuck/)
   sawbuck status [repo]     The inventory: caught over time + debt accruing now + whether it is armed. --json
-  sawbuck log [repo] [-n N] Recent checks, newest first (verified / gamed / regression)
+                            --log [-n N] for the recent checks, newest first
   sawbuck debt [repo] [--since REF] [--fail-on undocumented|test|any|N]
                             The live suppression debt in HEAD, risk-ranked, undocumented flagged. --since REF
                             shows only what a branch adds; --fail-on exits nonzero (a CI gate)
   sawbuck context [repo]    Relevant history for the files you are changing (reverts, weakened tests, hot spots)
-  sawbuck frame [repo]      The contract's protected paths, inherited ones included, as one compact block;
-                            silent without a contract (--speak explains)
-  sawbuck turn [repo]       frame + context in one block: what attach --claude runs on every prompt
-
-  sawbuck trace [repo]      Show every file Sawbuck has placed in this repo (the footprint)
-  sawbuck doctor [repo]     Check the attachment still resolves to a live sawbuck; --all for every repo
-  sawbuck where             List every repo Sawbuck is attached to
-  sawbuck contract          Sign this repo: tests, tripwires, protected paths, and the architecture lock (--dry-run to preview)
+  sawbuck doctor [repo]     Check the attachment still resolves to a live sawbuck
+  sawbuck contract          Give this repo its rules: protected paths, your tests (--dry-run to preview)
+                            --full adds supply-chain guards, the repo lock and a CI check; --strict makes them block
   sawbuck rules --prepare   Gather your messages on this machine so an agent can propose the rules you never wrote
   sawbuck rules --check F   Keep only proposed rules with 2 quotes that are really yours
   sawbuck shape --prepare   Gather a sample of your messages so an agent can label what you push on
-  sawbuck shape --check F   Draw your steering shape from the labels, keeping only the totals
+  sawbuck shape --check F   Draw your steering shape from the labels, keeping only the totals (--png for an image)
   sawbuck steers            What you keep correcting, from the plugin's scratchpad on this machine (--json)
-  sawbuck statusline        One-line segment for your status line (🐴 watching | N caught | steer %)
+  sawbuck statusline        One-line segment for your status line (🐴 watching | N caught)
 
-  sawbuck recall [repo]     Related notes for your changes from extra memory providers
-                            (SAWBUCK_MEMORY=logbook,obsidian + OBSIDIAN_VAULT), alongside context
-  sawbuck memory-conformance <bin>
-                            Check a provider bin speaks the Memory Contract (recall/debt/record)
   sawbuck --help | --version
 
 Engines: promptwheel (the check) + @promptwheel/logbook (memory). Zero-LLM, offline, free.`;
@@ -124,9 +105,9 @@ const out = (s) => process.stdout.write(s.endsWith('\n') ? s : s + '\n');
 
 if (cmd === '--version' || cmd === '-v') { console.log(version); process.exit(0); }
 if (!cmd || cmd === '--help' || cmd === '-h' || cmd === 'help') {
-  out(flags.has('--all') ? help : `sawbuck ${version}: sign your agent to a contract
+  out(flags.has('--all') ? help : `sawbuck ${version}: write down the rules your agent follows, and prove they held
 
-  sawbuck contract   sign this repo: protected paths, your tests, CI
+  sawbuck contract   give this repo its rules: protected paths, your tests
   sawbuck check      verify your latest change right now
   sawbuck status     what it has caught here
 
@@ -137,8 +118,8 @@ if (!cmd || cmd === '--help' || cmd === '-h' || cmd === 'help') {
 switch (cmd) {
   case 'contract': {
     const top = gitTop(repoArg());
-    if (!top) usage(`${repoArg()} is not a git repository (a contract signs one; run it inside your project)`);
-    try { execFileSync(process.execPath, [join(HERE, 'contract-cmd.mjs'), top, ...rest.filter((a) => ['--dry-run', '--strict', '--no-ci'].includes(a))], { stdio: 'inherit' }); }
+    if (!top) usage(`${repoArg()} is not a git repository (run it inside your project)`);
+    try { execFileSync(process.execPath, [join(HERE, 'contract-cmd.mjs'), top, ...rest.filter((a) => ['--dry-run', '--full', '--strict'].includes(a))], { stdio: 'inherit' }); }
     catch (e) { process.exit(e.status || 1); }
     break;
   }
@@ -149,7 +130,8 @@ switch (cmd) {
   }
   case 'status': {
     // the inventory: one view unioning what the check has caught over time, what debt is accruing
-    // now, and whether it is armed here. The "show me everything" face.
+    // now, and whether it is armed here. The "show me everything" face. --log is the recent feed.
+    if (flags.has('--log')) { logReport(repoArg(), rest); break; }
     try { execFileSync(process.execPath, [join(HERE, 'status.mjs'), '--repo', repoArg(), ...rest.filter((a) => a.startsWith('--'))], { stdio: 'inherit' }); }
     catch (e) { process.exit(e.status || 1); }
     break;
@@ -192,7 +174,7 @@ switch (cmd) {
     if (rep.verdict === 'pass' && win) out(`🐴 ✓ verified: your ${where} change earned it. "${win.name}" improved, and the source carried the win (it survives a source-only re-run).`);
     else if (rep.verdict === 'pass') out(`🐴 ✓ held: nothing got worse in your ${where} change, and there was no win to re-prove.`);
     else if (rep.verdict === 'gamed') out('🐴 🚩 gamed: a win here came from editing the test, config, or grader, not the source. It does NOT survive a source-only re-run, so it does not count.');
-    else if (rep.verdict === 'fail' && (rep.mandates || []).length) out('🐴 ✗ sent back: a hard rule in the contract was broken, however green the rest is.');
+    else if (rep.verdict === 'fail' && (rep.mandates || []).length) out('🐴 ✗ sent back: a rule in the contract was broken, however green the rest is.');
     else if (rep.verdict === 'fail') out('🐴 ✗ sent back: this change made something worse.');
     else out('🐴 ≈ inconclusive: the check ran but could not measure your metric (it did not run in isolation). Point it at your real test command: `sawbuck init`, or set setup/linkDirs in promptwheel.config.json.');
     if ((rep.metrics || []).some((x) => x.heldByTestEdit)) out('🐴 ⚠ your tests changed too, and the old tests fail on this source. Fine for an intended change. Otherwise check the tests were not weakened: a green that stays green is not proved.');
@@ -200,25 +182,6 @@ switch (cmd) {
     if (rep.gate && rep.gate.changed) out(`🐴 ⚠ the gate definition changed in this change (fingerprint ${rep.gate.fingerprint.base} -> ${rep.gate.fingerprint.head}): a metric, guard, evaluatorPath or mandate was added, removed or edited.`);
     process.exit(code);
   }
-  case 'log': {
-    // the event feed: a running log of what the check did, so you can watch it work.
-    const repo = repoArg();
-    let lines = [];
-    try { lines = readFileSync(join(repo, '.sawbuck', 'activity.jsonl'), 'utf8').split('\n').filter(Boolean); } catch {}
-    if (!lines.length) { out('sawbuck: no activity recorded yet (the check logs here on each commit/turn).'); break; }
-    const ni = rest.indexOf('-n');
-    const n = ni > -1 ? (parseInt(rest[ni + 1], 10) || 20) : 20;
-    const icon = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive: '≈', allowed: '✎', mandate: '⛔' };
-    const recent = lines.slice(-n).reverse();
-    out(`sawbuck activity (last ${recent.length}):`);
-    for (const l of recent) {
-      try {
-        const e = JSON.parse(l);
-        out(`  ${(e.at || '').slice(0, 16).replace('T', ' ')}  ${icon[e.kind] || '·'} ${String(e.kind).padEnd(11)} ${e.file || ''}${e.reason ? '   ' + e.reason : ''}`);
-      } catch {}
-    }
-    break;
-  }
   case 'rank': {
     try { execFileSync(process.execPath, [join(HERE, 'rank.mjs'), ...rest], { stdio: 'inherit' }); }
     catch (e) { process.exit(e.status || 1); }
@@ -241,9 +204,10 @@ switch (cmd) {
     break;
   }
   case 'turn': {
-    // the ONE per-prompt hook: the contract frame (forward: what must hold) and the relevant history
-    // (backward: what broke here before) in a single block, one process per prompt. Silent when
-    // there is nothing to say. Wired by `attach --claude` on UserPromptSubmit and after a compaction.
+    // the ONE per-prompt hook. The agent gets the contract frame once a session and again after a compaction: one
+    // written statement held in every bench, so saying it on each prompt only spends context. The relevant history
+    // is on demand (`sawbuck context`), and per turn only with {"turn":{"context":true}} in sawbuck.config.json.
+    // Wired by `attach` on UserPromptSubmit and after a compaction.
     // the repository the way the Stop hook sees it: the root of the cwd under user-level wiring (a
     // subdirectory belongs to its repo), the pinned path under project wiring; '' outside a repo
     const top = gitTop(repoArg());
@@ -258,8 +222,8 @@ switch (cmd) {
     // a file still carrying the content the last violation flagged is never baselined; and the
     // baseline's commit does not advance past a flagged commit until a clean stop or a commit the
     // person made between turns that no longer carries the flagged content.
-    let hookEvent = '';
-    if (flags.has('--hook') && !process.stdin.isTTY) { try { hookEvent = String(JSON.parse(readFileSync(0, 'utf8') || '{}').hook_event_name || ''); } catch {} }
+    let hookEvent = '', session = '', framed = false;
+    if (flags.has('--hook') && !process.stdin.isTTY) { try { const h = JSON.parse(readFileSync(0, 'utf8') || '{}'); hookEvent = String(h.hook_event_name || ''); session = String(h.session_id || ''); } catch {} }
     if (hookEvent === 'UserPromptSubmit' && top) {
       try {
         ensureExcluded(repo);   // before the first write: under user-level hooks nothing else has done it yet
@@ -290,40 +254,19 @@ switch (cmd) {
             st.turnBaseline = { at: now, sha: ((!moved || stillInHead) && pin && st.lastViolation.sha) || sha, files, lock: lockState(repo), rules: mandatesInForce(repo) };
           }
         }
+        framed = !!session && st.framedSession === session;
+        if (session) st.framedSession = session;
         st.lastPromptAt = now;   // every prompt, mandates or not: the walls key their block budgets on it when the harness sends no prompt_id
         mkdirSync(stDir, { recursive: true }); writeFileSync(stPath, JSON.stringify(st, null, 2) + '\n');
       } catch { /* the frame never fails a prompt */ }
     }
-    const o = [frameBlock(repo), contextBlock(repo, false)].filter(Boolean).join('\n');
+    let history = false;
+    try { history = JSON.parse(readFileSync(join(repo, 'sawbuck.config.json'), 'utf8')).turn?.context === true; } catch {}
+    if (!history && top) erasedCommits(repo);   // the ledger outlives the reflog whether or not it is printed
+    const o = [framed ? '' : frameBlock(repo), history ? contextBlock(repo, false) : ''].filter(Boolean).join('\n');
     if (o) out(o);
     break;
   }
-  case 'recall': {
-    // the notes face: supplementary relevant notes for your current changes, from any non-git memory
-    // provider (e.g. an Obsidian vault). On-demand. Git history + live debt come from context / debt.
-    const repo = repoRoot();
-    const g = (...a) => { try { return execFileSync('git', ['-C', repo, ...a], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return ''; } };
-    let changed = g('diff', '--name-only', 'HEAD').split('\n').filter(Boolean);
-    if (!changed.length) changed = g('diff', '--name-only', 'HEAD~1', 'HEAD').split('\n').filter(Boolean);
-    if (!changed.length) { out('🐴 sawbuck: nothing changed to look up.'); break; }
-    const notes = memRecall(repo, changed);
-    if (!notes.length) { out('🐴 sawbuck: no related notes (configure extra memory providers with SAWBUCK_MEMORY, e.g. logbook,obsidian; logbook history is in `sawbuck context`).'); break; }
-    out(`🐴 related notes for ${changed.length} changed path${changed.length === 1 ? '' : 's'} (leads, not conclusions):`);
-    for (const n of notes) out(`  - [${n.source}] ${n.summary}${n.ref ? `  (${n.ref})` : ''}`);
-    break;
-  }
-  case 'memory-conformance': {
-    // check that a provider bin speaks the Memory Contract (recall returns Finding[]; debt returns
-    // Suppression[] or exits nonzero to signal it is not a git-truth provider). Read-only probe.
-    const bin = positional[0];
-    if (!bin) die('usage: sawbuck memory-conformance <provider-bin>   (a bin speaking the contract verbs recall/debt/record)');
-    const r = memConform(bin, process.cwd());
-    out(`🐴 memory-conformance: ${bin}`);
-    out(`   recall: ${r.recall}`);
-    out(`   debt:   ${r.debt}`);
-    out(r.pass ? '   ✓ conforms to the Memory Contract.' : '   ✗ does not conform (see above).');
-    process.exit(r.pass ? 0 : 1);
-  }
   case '__hook': {
     try { execFileSync(process.execPath, [HOOK, ...rest], { stdio: 'inherit' }); } catch (e) { process.exit(e.status || 0); }
     break;
@@ -333,21 +276,18 @@ switch (cmd) {
     const top = gitTop(repoArg());
     if (!top && !user) usage(`${repoArg()} is not a git repository (attach wires one; run it inside your project, or name its path)`);
     const repo = top || repoArg();
-    if (user) { wireClaude(repo, { user: true }); if (!dry) verifyAttach(repo); break; }
-    if (flags.has('--claude')) { wireClaude(repo, { shared: flags.has('--shared') }); if (!dry) verifyAttach(repo); break; }
-    wireGit(repo);
+    wireClaude(repo, { user });
     if (!dry) verifyAttach(repo);
     break;
   }
   case 'detach': {
     const purge = flags.has('--purge');
-    if (flags.has('--all')) { detachAll(purge); break; }
     const repo = repoRoot();
     if (flags.has('--user')) unwireClaude(repo, { user: true });
     else if (flags.has('--claude')) unwireClaude(repo, {});
     else {
-      // no flag: reverse whatever this repo's receipt says is attached (git and/or project Claude
-      // hooks), so a bare `detach` is always the inverse of the `attach` you ran.
+      // no flag: reverse whatever this repo's receipt says is attached, older git hooks included,
+      // so a bare `detach` is always the inverse of the `attach` you ran.
       const a = readManifest(manifestPath(repo)).attachments || {};
       const hasClaude = !!(a.claude || a['claude-shared']);
       if (hasClaude) unwireClaude(repo, {});
@@ -357,9 +297,7 @@ switch (cmd) {
     if (flags.has('--verify')) verifyClean(repo);
     break;
   }
-  case 'trace': { traceRepo(repoRoot()); break; }
-  case 'doctor': { if (flags.has('--all')) doctorAll(); else doctorRepo(repoRoot()); break; }
-  case 'where': { whereAttached(); break; }
+  case 'doctor': { doctorRepo(repoRoot()); break; }
   case 'rules': { out(rulesCli(rest)); break; }
   case 'shape': { out(shapeCli(rest)); break; }
   case 'steers': { out(steersReport({ json: flags.has('--json') })); break; }
@@ -370,22 +308,16 @@ switch (cmd) {
       if (!repo) process.stdout.write('🐴 sawbuck · no repo here');
       if (repo) {
         const name = basename(repo);
-        let caught = 0;
-        try { const r = JSON.parse(readFileSync(join(repo, '.sawbuck', 'results.json'), 'utf8')); caught = (r.regressions || 0) + (r.gamed || 0) + (r.mandates || 0); } catch {}
+        const { caught, state, steer } = repoState(repo);
         // the last verdict from the activity feed (includes verified passes), so you see it working each turn
         let last = '';
         try { const L = readFileSync(join(repo, '.sawbuck', 'activity.jsonl'), 'utf8').trim().split('\n'); const e = JSON.parse(L[L.length - 1]); last = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive: '≈', allowed: '✎' }[e.kind] || ''; } catch {}
-        // one state model, shared with the Reins band: watching (wired in) / ready (checkable, not wired yet) / memory (history only)
-        const active = existsSync(join(repo, '.sawbuck', 'state.json'));
-        const armed = existsSync(join(repo, 'promptwheel.config.json')) || existsSync(join(repo, 'package.json'));
-        const mem = existsSync(join(repo, 'LOGBOOK.md')) || existsSync(join(repo, 'events.jsonl'));
-        const label = caught > 0 ? `${caught} caught` : active ? 'watching' : armed ? 'ready' : mem ? 'memory' : '';
+        const label = caught > 0 ? `${caught} caught` : state;
         const seg = label ? `🐴 sawbuck · ${label}` : '';
         const named = label ? `🐴 sawbuck · ${name} · ${label}` : '';   // which repo it detected, in the default line
         const base = named ? (last ? `${named} · ${last}` : named) : '';
         // live steering % from the reins engine's file (OFFLINE read; reins does the LLM work, never sawbuck)
-        let st = '';
-        try { const sj = JSON.parse(readFileSync(join(repo, '.sawbuck', 'steer.json'), 'utf8')); if (sj && sj.scored) { const p = Math.round(((sj.ema != null ? sj.ema : sj.steeringRate) || 0) * 100); st = `${p >= 50 ? '✊' : '🐎'} steer ${p}%`; } } catch {}
+        const st = steer ? `${steer.rate >= 50 ? '✊' : '🐎'} steer ${steer.rate}%` : '';
         // configurable template: SAWBUCK_STATUSLINE picks which segments show and in what order
         // (tokens {status} {sawbuck} {repo} {verdict} {steer} plus any literal text); empty tokens collapse
         // so you never get a dangling separator. Unset = the default composition. Mix in other
@@ -407,7 +339,24 @@ switch (cmd) {
   default: die(`unknown command '${cmd}'\n\n${help}`);
 }
 
-// --- the per-turn block: frame (forward, from contract.mjs) + context (backward) ---------------
+function logReport(repo, rest) {
+  let lines = [];
+  try { lines = readFileSync(join(repo, '.sawbuck', 'activity.jsonl'), 'utf8').split('\n').filter(Boolean); } catch {}
+  if (!lines.length) { out('sawbuck: no activity recorded yet (the check logs here on each commit/turn).'); return; }
+  const ni = rest.indexOf('-n');
+  const n = ni > -1 ? (parseInt(rest[ni + 1], 10) || 20) : 20;
+  const icon = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive: '≈', allowed: '✎', mandate: '⛔' };
+  const recent = lines.slice(-n).reverse();
+  out(`sawbuck activity (last ${recent.length}):`);
+  for (const l of recent) {
+    try {
+      const e = JSON.parse(l);
+      out(`  ${(e.at || '').slice(0, 16).replace('T', ' ')}  ${icon[e.kind] || '·'} ${String(e.kind).padEnd(11)} ${e.file || ''}${e.reason ? '   ' + e.reason : ''}`);
+    } catch {}
+  }
+}
+
+// --- context: the ranked history for the files in hand, on demand ---------------------------
 // the read face: ranked relevant history for what you're working on right now. Silent when there is
 // nothing to say, so it is safe on every UserPromptSubmit (that hook's stdout is injected into context;
 // "nothing notable" every turn would be noise). `speak` forces a reply for the explicit command.
@@ -456,67 +405,18 @@ function delFile(p) { try { if (existsSync(p)) unlinkSync(p); } catch {} }
 function rmIfEmptyDir(d) { try { if (existsSync(d) && readdirSync(d).length === 0) rmdirSync(d); } catch {} }
 
 // --- .git/info/exclude: keep the worktree clean without touching .gitignore --
-// Rewrites a single marked block to the union of excludes the current
-// attachments need. Never deletes the file (an empty one is git's own default).
+// Any attachment keeps the block, the last one out takes it. Returns whether the file changed.
 function excludeFile(repo) { return gitPath(repo, 'info/exclude'); }
-function syncExclude(repo, manifest) {
-  const need = new Set();
-  const a = manifest.attachments || {};
-  if (Object.keys(a).length) for (const d of RECORD_DIRS) need.add(d);     // any attach → the check may write the record dirs
-  if (a.claude) need.add('.claude/settings.local.json');                    // default claude settings are local; hide them too
-  const lines = [...need];
-  const f = excludeFile(repo);
-  let body = (existsSync(f) ? readFileSync(f, 'utf8') : '').replace(BLOCK_RE, '\n').replace(/\n{3,}/g, '\n\n');
-  if (lines.length) {
-    if (body && !body.endsWith('\n')) body += '\n';
-    body += `${S_START}\n${lines.join('\n')}\n${S_END}\n`;
-    mkdirSync(dirname(f), { recursive: true });
-    writeFileSync(f, body);
-  } else if (existsSync(f)) {
-    writeFileSync(f, body);                                                 // strip our block, leave the rest
-  }
-}
+function syncExclude(repo, manifest) { return Object.keys(manifest.attachments || {}).length ? ensureExcluded(repo) : clearExcluded(repo); }
 
 // --- git post-commit --------------------------------------------------------
-// The hook prefers a `sawbuck` on PATH (so it survives a reinstall/upgrade) and
-// falls back to the absolute path of the sawbuck that attached (dev checkouts).
-function hookBlock(repo) {
-  const r = JSON.stringify(repo);
-  // git exports GIT_DIR / GIT_INDEX_FILE / GIT_WORK_TREE into its hooks. The check
-  // shells out to git (worktrees, diffs) and would inherit them, operate on the wrong
-  // repo, and silently catch nothing. Clear them so the reflex runs against `repo` clean.
-  return `${S_START}\nunset GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE GIT_PREFIX GIT_OBJECT_DIRECTORY GIT_COMMON_DIR\nif command -v sawbuck >/dev/null 2>&1; then sawbuck __hook --repo ${r}; else ${nodeCmd()} ${JSON.stringify(SELF)} __hook --repo ${r}; fi || true\n${S_END}\n`;
-}
-function wireGit(repo) {
-  if (!gitTop(repo)) usage(`${repo} is not a git repository`);
-  const pc = gitPath(repo, 'hooks/post-commit');
-  const existed = existsSync(pc);
-  let body = existed ? readFileSync(pc, 'utf8') : '#!/bin/sh\n';
-  if (body.includes(S_START)) { out(`sawbuck: already attached (git) in ${repo}`); return; }
-  if (!body.startsWith('#!')) body = '#!/bin/sh\n' + body;
-  if (!body.endsWith('\n')) body += '\n';
-  if (dry) {
-    out(dryText([
-      `${existed ? 'modify' : 'create'}  ${pc}  (post-commit hook block)`,
-      `exclude ${excludeFile(repo)}  (${RECORD_DIRS.join(', ')})`,
-      `create  ${manifestPath(repo)}  (attach receipt)`,
-    ]));
-    return;
-  }
-  writeFileSync(pc, body + hookBlock(repo));
-  chmodSync(pc, 0o755);
-  const m = readManifest(manifestPath(repo));
-  m.attachments = { ...m.attachments, git: { pc: { created: !existed } } };
-  syncExclude(repo, m);
-  writeManifest(manifestPath(repo), m);
-  regAdd(repo, 'git');
-  out(`sawbuck: attached (git post-commit) in ${repo}`);
-}
+// Older versions could attach here. Nothing wires it now; detach still takes it out.
 function unwireGit(repo) {
   const pc = gitPath(repo, 'hooks/post-commit');
   const m = readManifest(manifestPath(repo));
   const hasReceipt = !!m.attachments?.git;
-  if (!existsSync(pc) && !hasReceipt) { out('sawbuck: nothing to detach'); return; }
+  // signing with no attach still hides the record, so a repo with no receipt can have a block to take back
+  if (!existsSync(pc) && !hasReceipt) { out(syncExclude(repo, m) ? `sawbuck: removed the record lines from ${excludeFile(repo)}` : 'sawbuck: nothing to detach'); return; }
   if (existsSync(pc)) {
     const stripped = readFileSync(pc, 'utf8').replace(BLOCK_RE, '\n').replace(/\n{3,}/g, '\n\n');
     const created = m.attachments?.git?.pc?.created;
@@ -525,7 +425,6 @@ function unwireGit(repo) {
     else writeFileSync(pc, stripped);
   }
   if (hasReceipt) { delete m.attachments.git; syncExclude(repo, m); writeManifest(manifestPath(repo), m); }
-  regRemove(repo, 'git');
   out(`sawbuck: detached (git) from ${repo}`);
 }
 function isTrivialHook(text) { return text.replace(/^#!.*\n?/, '').trim() === ''; }
@@ -547,10 +446,10 @@ export function nodeCmd(execPath = process.execPath, platform = process.platform
   return `"$(command -v node || echo ${JSON.stringify(execPath).replace(/^"|"$/g, "'")})"`;
 }
 function wireClaude(repo, opts) {
-  const { user, shared } = opts;
+  const { user } = opts;
   // user-level hooks already cover every repo; a second set would run each check twice and spend the
   // send-back budget twice as fast. --shared is a deliberate team file, so it is written anyway.
-  if (!user && !shared) {
+  if (!user) {
     const uf = claudeFile(repo, { user: true }).f;
     try { if (readFileSync(uf, 'utf8').includes('sawbuck.mjs')) { out(`sawbuck: already watching here through your user-level hooks (${uf}); nothing to add`); return; } } catch {}
   }
@@ -578,7 +477,7 @@ function wireClaude(repo, opts) {
   if (dry) {
     out(dryText([
       `${upgrading ? 'update' : fileExisted ? 'modify' : 'create'}  ${f}  (UserPromptSubmit + SessionStart[compact] + Stop hooks: the per-turn block, and the check)`,
-      user ? null : `exclude ${excludeFile(repo)}  (${RECORD_DIRS.join(', ')}${shared ? '' : ', .claude/settings.local.json'})`,
+      user ? null : `exclude ${excludeFile(repo)}  (${EXCLUDED.join(', ')})`,
       `create  ${user ? userManifestPath() : manifestPath(repo)}  (attach receipt)`,
     ].filter(Boolean)));
     return;
@@ -589,8 +488,8 @@ function wireClaude(repo, opts) {
     cfg.hooks[event].push({ ...(matcher ? { matcher } : {}), hooks: [{ type: 'command', command }] });
   };
   put('UserPromptSubmit', ctx);
-  // right after a compaction the summary has just dropped detail: re-impress the contract frame and the
-  // relevant history there too (SessionStart with the `compact` source injects stdout into context).
+  // right after a compaction the summary has just dropped detail: re-impress the contract frame there too
+  // (SessionStart with the `compact` source injects stdout into context).
   put('SessionStart', ctx, 'compact');
   put('Stop', chk);
   mkdirSync(dir, { recursive: true });
@@ -610,19 +509,17 @@ function wireClaude(repo, opts) {
       }
     } catch {}
   }
-  const mode = user ? 'user' : shared ? 'claude-shared' : 'claude';
+  const mode = user ? 'user' : 'claude';
   const mp = user ? userManifestPath() : manifestPath(repo);
   const m = readManifest(mp);
   const prev = (m.attachments || {})[mode];   // an upgrade keeps the receipt of what the first attach created
   m.attachments = { ...m.attachments, [mode]: { file: f, fileCreated: prev ? !!prev.fileCreated : !fileExisted, dirCreated: prev ? !!prev.dirCreated : !dirExisted } };
   if (!user) syncExclude(repo, m);
   writeManifest(mp, m);
-  regAdd(repo, mode);
-  out(upgrading ? `sawbuck: updated the ${user ? 'USER-LEVEL' : shared ? 'shared project' : 'project'} Claude Code hooks in ${f} to this version`
-                : `sawbuck: wired ${user ? 'USER-LEVEL' : shared ? 'shared project' : 'project'} Claude Code hooks in ${f}`);
+  out(upgrading ? `sawbuck: updated the ${user ? 'USER-LEVEL' : 'project'} Claude Code hooks in ${f} to this version`
+                : `sawbuck: wired ${user ? 'USER-LEVEL' : 'project'} Claude Code hooks in ${f}`);
   if (!user && !existsSync(join(repo, 'AGENTS.md')) && !existsSync(join(repo, 'CLAUDE.md'))) out('  no written rule here yet, and that is what changes the agent: run sawbuck contract.');
   if (user) out('  profile-switches by cwd: memory in any git repo, the check where a promptwheel.config.json exists.');
-  else if (!shared) out('  (settings.local.json is gitignored; use --shared to commit the hooks for your team)');
 }
 function unwireClaude(repo, { user }) {
   const mp = user ? userManifestPath() : manifestPath(repo);
@@ -648,7 +545,6 @@ function unwireClaude(repo, { user }) {
     if (rec) { delete m.attachments[mode]; touched = true; }
   }
   if (touched) { if (!user) syncExclude(repo, m); writeManifest(mp, m); }
-  for (const mode of modes) regRemove(repo, mode);
   if (!did && !touched) out('sawbuck: no Claude attachment found to detach');
 }
 function removeClaudeEntries(cfg) {
@@ -677,13 +573,6 @@ function footprint(repo) {
   if (existsSync(mp)) { const m = readManifest(mp); items.push({ what: mp, state: `receipt: ${Object.keys(m.attachments || {}).join(', ') || 'empty'}` }); }
   return items;
 }
-function traceRepo(repo) {
-  const items = footprint(repo);
-  if (!items.length) { out(`sawbuck: no footprint in ${repo}, nothing attached.`); return; }
-  out(`sawbuck footprint in ${repo}:`);
-  for (const it of items) out(`  ${it.state.padEnd(22)} ${it.what}`);
-  out('\n  detach reverses every line above; `detach --verify` proves it.');
-}
 function verifyClean(repo) {
   // the record dirs may stay (your data, unless --purge); the mechanism must be gone.
   const left = footprint(repo).filter((it) => !/record dir/.test(it.state));
@@ -728,41 +617,5 @@ function doctorRepo(repo) {
   out(pathOk ? '\n  sawbuck resolves on PATH, attachments survive a reinstall.' : '\n  tip: `npm i -g sawbuck` so hooks resolve by PATH and survive an upgrade.');
   if (bad) process.exitCode = 1;
 }
-function doctorAll() {
-  const r = regRead();
-  if (!r.repos.length) { out('sawbuck: nothing to check (registry empty).'); return; }
-  const repos = [...new Set(r.repos.map((x) => x.repo))];
-  for (const repo of repos) doctorRepo(repo);
-}
-
-// --- registry: know and remove every attachment -----------------------------
-function regPath() { return join(homedir(), '.sawbuck', 'registry.json'); }
-function regRead() { try { const r = JSON.parse(readFileSync(regPath(), 'utf8')); r.repos = (r.repos || []).filter((x) => existsSync(x.repo)); return r; } catch { return { repos: [] }; } }   // a repo that is gone is not attached
-function regWrite(r) {
-  const f = regPath();
-  if (!r.repos.length) { delFile(f); rmIfEmptyDir(dirname(f)); return; }
-  mkdirSync(dirname(f), { recursive: true });
-  writeFileSync(f, JSON.stringify(r, null, 2) + '\n');
-}
-function regAdd(repo, mode) { const r = regRead(); r.repos = r.repos.filter((x) => !(x.repo === repo && x.mode === mode)); r.repos.push({ repo, mode, at: new Date().toISOString() }); regWrite(r); }
-function regRemove(repo, mode) { const r = regRead(); r.repos = r.repos.filter((x) => !(x.repo === repo && x.mode === mode)); regWrite(r); }
-function whereAttached() {
-  const r = regRead();
-  if (!r.repos.length) { out('sawbuck: not attached anywhere (registry empty).'); return; }
-  out('sawbuck is attached to:');
-  for (const x of r.repos) out(`  ${x.mode.padEnd(14)} ${x.repo}`);
-}
-function detachAll(purge) {
-  const r = regRead();
-  if (!r.repos.length) { out('sawbuck: nothing to detach (registry empty).'); return; }
-  for (const x of [...r.repos]) {
-    if (x.mode === 'git') unwireGit(x.repo);
-    else if (x.mode === 'user') unwireClaude(x.repo, { user: true });
-    else unwireClaude(x.repo, {});
-    if (purge) purgeRecord(x.repo);
-  }
-  out('sawbuck: detached everywhere.');
-}
-
 // --- shared helpers ---------------------------------------------------------
 function dryText(plan) { return ['sawbuck --dry-run: would leave this footprint (writing nothing):', ...plan.map((p) => '  ' + p), '  all of it reversible with `detach`.'].join('\n'); }