sawbuck 0.1.44 → 0.1.46

package/sawbuck-hook.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 import { ensureExcluded } from './exclude.mjs';
 // sawbuck-hook.mjs: the Sawbuck Claude Code Stop-hook entry.
-// Each turn: if a new commit landed, run reflect on it; then render the dispatch
-// on a fresh catch OR every N turns (config). State in .sawbuck/state.json.
+// Each turn: if a new commit landed, run reflect on it; then say so once on a fresh catch. State in .sawbuck/state.json.
 // Zero-dep. Usage (wired as a Stop hook): node sawbuck-hook.mjs --repo <path>
 
 import { execFileSync } from 'node:child_process';
@@ -32,7 +31,6 @@ const node = (f, a) => { try { return execFileSync(process.execPath, [f, ...a],
 
 let cfg = {};
 try { cfg = JSON.parse(readFileSync(join(repo, 'sawbuck.config.json'), 'utf8')); } catch {}
-const EVERY_TURNS = 5;
 
 const stDir = join(repo, '.sawbuck');
 const stPath = join(stDir, 'state.json');
@@ -132,7 +130,7 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
     const restore = Object.keys(before).length ? ' To put back what you overwrote: ' + Object.entries(before).map(([f, h]) => `restore ${f} to the content it had when the prompt began: git cat-file -p ${h} > ${f}`).join('; ') + '.' : '';
     const committedHit = hits.some((h) => h.files.some((f) => committedSince.includes(f)));
     const accept = committedHit ? ' To accept this change on purpose, change the rule in the contract or revert the path.' : '';
-    const upgrade = base ? '' : ' (No prompt baseline is recorded in this repo, so edits a person made before the prompt cannot be told apart from yours: ask them to run sawbuck attach --claude again, which upgrades the hooks.)';
+    const upgrade = base ? '' : ' (No prompt baseline is recorded in this repo, so edits a person made before the prompt cannot be told apart from yours: ask them to run sawbuck attach again, which upgrades the hooks.)';
     // one catch per prompt, however many times the turn is sent back. Kept beside rec.latest, never in it:
     // a block must not replace a gamed verdict that is still standing.
     if (st.mandateCountedPrompt !== promptId) {
@@ -177,12 +175,10 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE && st.turnBaseline && st.turnBaselin
   }
 }
 
-// 4) otherwise, surface a catch on a fresh catch or on cadence (a flag; never blocks)
-const freshCatch = total > (st.shownTotal || 0);
-const cadenceHit = st.turns % EVERY_TURNS === 0;
-if (freshCatch || cadenceHit) {
-  const out = node(join(HERE, 'dispatch.mjs'), ['--repo', repo]);
-  if (out.trim()) process.stdout.write(out.endsWith('\n') ? out : out + '\n');
+// 4) otherwise, say a fresh catch once (a flag; never blocks). The band and statusline carry the rest.
+if (total > (st.shownTotal || 0)) {
+  const L = rec && rec.latest;
+  process.stdout.write(`🐴 Sawbuck caught a ${L && L.kind === 'gamed' ? 'gamed change' : 'problem'}${L && L.file ? ` in ${L.file}` : ''}${L && L.reason ? `: ${L.reason}` : ''}\n`);
   st.shownTotal = total;
 }
 saveState();

package/sawbuck.mjs

@@ -1,16 +1,10 @@
 #!/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, erasedCommits } from './rewrites.mjs';
@@ -23,7 +17,6 @@ import { readFileSync, writeFileSync, existsSync, chmodSync, mkdirSync, unlinkSy
 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';
 
@@ -54,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');
@@ -62,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]
@@ -71,29 +64,22 @@ 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 --claude   Check every Claude Code turn in this repo. --dry-run prints the footprint and writes nothing
-                            Also: no flag for a git post-commit hook, --claude --shared for a tracked settings file,
-                            --user for every repo
-  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]       What attach --claude runs on a prompt: the frame, once a session and after a compaction
-
-  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
@@ -119,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
 
@@ -132,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;
   }
@@ -144,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;
@@ -187,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.');
@@ -195,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); }
@@ -239,7 +207,7 @@ switch (cmd) {
     // 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 --claude` on UserPromptSubmit and after a compaction.
+    // 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());
@@ -299,32 +267,6 @@ switch (cmd) {
     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;
@@ -334,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, {});
@@ -358,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; }
@@ -402,6 +339,23 @@ switch (cmd) {
   default: die(`unknown command '${cmd}'\n\n${help}`);
 }
 
+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;
@@ -456,40 +410,7 @@ function excludeFile(repo) { return gitPath(repo, 'info/exclude'); }
 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)}  (${EXCLUDED.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));
@@ -504,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() === ''; }
@@ -526,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 {}
   }
@@ -589,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);
@@ -627,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) {
@@ -656,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));
@@ -707,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'); }

package/shape.mjs

@@ -1,18 +1,17 @@
-// Your steering shape: what you push on, as 12 spokes in 4 groups. The model labels a sample of your messages; only the
-// totals are kept. Two models agree on single messages about half the time and on the shape at 0.93, so a single label is
-// never shown. It says what you pushed on, not how good you are. Each run is saved with its date to compare later.
+// Your steering shape: what you push on, as 11 spokes in 4 groups. The model labels a sample of your messages; only the
+// totals are kept. Three models agreed on single messages about 70% of the time and on the shape at 0.87 or better, so a
+// single label is never shown. It says what you pushed on, not how good you are. Each run is saved with its date.
 import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, rmSync, copyFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { prepareRules } from './rules.mjs';
-import { exposure, writtenRules } from './exposure.mjs';
 
-export const GROUPS = { Truth: ['correctness', 'proof', 'honesty'], Intent: ['direction', 'scope', 'autonomy'], Craft: ['voice', 'naming', 'visual', 'simplicity'], Control: ['process', 'safety'] };
+export const GROUPS = { Truth: ['correctness', 'proof', 'honesty'], Intent: ['scope', 'autonomy'], Craft: ['voice', 'naming', 'visual', 'simplicity'], Control: ['process', 'safety'] };
 const SPOKES = Object.values(GROUPS).flat();
 const MIN_SPOKES = 200;   // below this, spokes are noise: show the 4 groups
 const SAMPLE = 600;
-const paths = (home) => ({ dir: join(home, '.sawbuck'), rules: join(home, '.sawbuck', 'rule-input.txt'), input: join(home, '.sawbuck', 'shape-input.txt'), hist: join(home, '.sawbuck', 'shape-history.jsonl'), expo: join(home, '.sawbuck', 'shape-exposure.json'), svg: join(home, '.sawbuck', 'shape.svg') });
+const paths = (home) => ({ dir: join(home, '.sawbuck'), rules: join(home, '.sawbuck', 'rule-input.txt'), input: join(home, '.sawbuck', 'shape-input.txt'), hist: join(home, '.sawbuck', 'shape-history.jsonl'), svg: join(home, '.sawbuck', 'shape.svg') });
 const title = (s) => s[0].toUpperCase() + s.slice(1);
 
 export function prepareShape({ home = homedir() } = {}) {
@@ -22,14 +21,14 @@ export function prepareShape({ home = homedir() } = {}) {
   for (let i = lines.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [lines[i], lines[j]] = [lines[j], lines[i]]; }
   const pick = lines.slice(0, SAMPLE);
   writeFileSync(p.input, pick.map((l, i) => `${i + 1}\t${l}`).join('\n') + '\n', { mode: 0o600 });
-  writeFileSync(p.expo, JSON.stringify({ ...exposure({ root: join(home, '.claude', 'projects') }), written: writtenRules({ home }) }) + '\n');
   return { input: p.input, lines: pick.length, secrets: r.secrets };
 }
 
 export function tally(labels) {
   const counts = Object.fromEntries(SPOKES.map((s) => [s, 0]));
   let none = 0;
-  for (const v of Object.values(labels)) { if (v === 'none') none++; else if (v in counts) counts[v]++; }
+  // two models split scope and direction at random (shape r 0.55 with both, 0.97 merged), so they count as one
+  for (const raw of Object.values(labels)) { const v = raw === 'direction' ? 'scope' : raw; if (v === 'none') none++; else if (v in counts) counts[v]++; }
   const total = SPOKES.reduce((a, s) => a + counts[s], 0);
   const groups = Object.fromEntries(Object.entries(GROUPS).map(([g, ss]) => [g, total ? Math.round(100 * ss.reduce((a, s) => a + counts[s], 0) / total) : 0]));
   const top = Math.max(1, ...SPOKES.map((s) => counts[s]));
@@ -40,41 +39,13 @@ export function tally(labels) {
 }
 
 // What was not said: each spoke we can measure from what the agent did, read against how often you push on it.
-const MIN_TURNS = 30;   // a pattern needs enough turns behind it: 1 of 3 is not one
-const HIGH_PUSH = 8, HIGH_DOING = 10, HIGH_FAULT = 5;   // a fault counts sooner than plain activity
-const SEEN = {
-  proof: { fault: true, of: 'code', n: 'unverified', says: 'changed code and ran no check within 3 turns', rule: 'Run the tests before saying a change works.' },
-  safety: { fault: true, of: 'working', n: 'risky', says: 'touched something risky', rule: 'Ask before force pushing, deleting outside temp folders, or touching secrets, workflows or deploy files.' },
-  process: { of: 'working', n: 'shipped', says: 'committed, pushed or published', rule: 'Do not commit or push unless I ask.' },
-  voice: { of: 'working', n: 'copy', says: 'wrote docs or copy', rule: 'Write docs in plain, short sentences.' },
-  visual: { of: 'working', n: 'ui', says: 'changed the interface', rule: 'Show me interface changes before calling them done.' },
-  simplicity: { fault: true, of: 'working', n: 'big', says: 'added 200 lines or more', rule: 'Keep changes small. Ask before adding more than 200 lines.' },
-  naming: { of: 'working', n: 'renames', says: 'renamed something', rule: 'Ask before renaming anything public.' },
-  autonomy: { of: 'working', n: 'asked', says: 'stopped to ask you', rule: 'Keep going on reversible work without asking.' },
-};
-export function patterns(t, c) {
-  if (!c || !c.working) return [];
-  return Object.entries(SEEN).map(([s, m]) => {
-    const pct = Math.round(100 * (c[m.n] || 0) / Math.max(1, c[m.of]));
-    const push = t.shares[s], often = pct >= (m.fault ? HIGH_FAULT : HIGH_DOING), pushed = push >= HIGH_PUSH;
-    // a fault you keep raising is a fight; activity you raise is just attention, since committing is not a failure
-    const has = !!(c.written && c.written[s]);
-    const enough = c[m.of] >= MIN_TURNS;
-    const kind = !enough ? 'too few' : often && pushed ? (m.fault ? 'fighting it' : 'watched') : often ? (has ? 'covered' : 'blind spot') : pushed ? 'handled' : 'quiet';
-    return { spoke: s, kind, pct, count: c[m.n] || 0, of: c[m.of], push, says: m.says, rule: m.rule, has };
-  });
-}
-
-export function shapeSvg(t, found = []) {
+export function shapeSvg(t) {
   const names = t.spokes ? SPOKES : Object.keys(GROUPS);
   const vals = t.spokes ? names.map((s) => t.ratings[s] / 99) : names.map((g) => 0.25 + 0.75 * t.groups[g] / Math.max(1, ...Object.values(t.groups)));
   const pt = (i, v) => { const a = 2 * Math.PI * i / names.length; return [(500 + 330 * v * Math.sin(a)).toFixed(1), (520 - 330 * v * Math.cos(a)).toFixed(1)]; };
-  const doing = Object.fromEntries(found.map((f) => [f.spoke, f.pct]));
-  const topDoing = Math.max(1, ...Object.values(doing));
-  const seenPts = t.spokes && found.length ? names.flatMap((n, i) => (n in doing ? [pt(i, 0.4 + 0.59 * Math.sqrt(doing[n] / topDoing))] : [])) : [];
   const ring = (v) => names.map((_, i) => pt(i, v).join(',')).join(' ');
   const labels = names.map((n, i) => { const [x, y] = pt(i, 1.14); return `<text x="${x}" y="${y}" text-anchor="middle" fill="#e8e6e1" font-size="22" font-weight="700">${title(n)}</text><text x="${x}" y="${+y + 28}" text-anchor="middle" fill="#c9a24a" font-size="24" font-weight="700">${t.spokes ? t.ratings[n] : t.groups[n] + '%'}</text>`; }).join('');
-  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000" font-family="system-ui,sans-serif"><rect width="1000" height="1000" fill="#0b0e13"/><text x="50" y="70" fill="#e8e6e1" font-size="40" font-weight="700">My steering shape</text>${[0.25, 0.5, 0.75, 1].map((v) => `<polygon points="${ring(v)}" fill="none" stroke="#2a313b"/>`).join('')}<polygon points="${names.map((_, i) => pt(i, vals[i]).join(',')).join(' ')}" fill="#c9a24a" fill-opacity="0.35" stroke="#c9a24a" stroke-width="4"/>${seenPts.map(([x, y]) => `<circle cx="${x}" cy="${y}" r="9" fill="#4fb3a5"/>`).join('')}${labels}<text x="50" y="960" fill="#8d94a0" font-size="19">Gold: what I push on, from ${t.n} messages.${seenPts.length ? ' Teal dots: what the agent did.' : ''} Relative to my own top. Not a score. sawbuck.ai</text></svg>\n`;
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000" font-family="system-ui,sans-serif"><rect width="1000" height="1000" fill="#0b0e13"/><text x="50" y="70" fill="#e8e6e1" font-size="40" font-weight="700">My steering shape</text>${[0.25, 0.5, 0.75, 1].map((v) => `<polygon points="${ring(v)}" fill="none" stroke="#2a313b"/>`).join('')}<polygon points="${names.map((_, i) => pt(i, vals[i]).join(',')).join(' ')}" fill="#c9a24a" fill-opacity="0.35" stroke="#c9a24a" stroke-width="4"/>${labels}<text x="50" y="960" fill="#8d94a0" font-size="19">Gold: what I push on, from ${t.n} messages. Relative to my own top. Not a score. sawbuck.ai</text></svg>\n`;
 }
 
 // A PNG of the card, with what is already on the machine: sawbuck ships no image library. A snap browser sees neither
@@ -109,25 +80,15 @@ export function shapeCli(args, { home = homedir() } = {}) {
   mkdirSync(p.dir, { recursive: true });
   let prev = null;
   if (existsSync(p.hist)) { const l = readFileSync(p.hist, 'utf8').trim().split('\n').filter(Boolean); if (l.length) prev = JSON.parse(l[l.length - 1]); }
-  let c = null; try { c = JSON.parse(readFileSync(p.expo, 'utf8')); } catch {}
-  const found = patterns(t, c);
-  writeFileSync(p.svg, shapeSvg(t, found));
+  writeFileSync(p.svg, shapeSvg(t));
   const out = [`🐴 your steering shape, from ${t.n} messages that pushed on something (${t.none} did not). What you push on, not a score.`, ''];
   for (const [g, ss] of Object.entries(GROUPS)) {
     const was = prev && prev.groups[g] != null ? `  (was ${prev.groups[g]}%)` : '';
     out.push(`  ${g.padEnd(8)} ${String(t.groups[g]).padStart(3)}%${was}`);
     if (t.spokes) out.push(`    ${ss.map((s) => `${title(s)} ${t.ratings[s]}`).join('  ')}`);
   }
-  if (!t.spokes) out.push('', `  Too few messages for the 12 spokes (${t.n} of ${MIN_SPOKES}), so this shows the 4 groups.`);
-  appendFileSync(p.hist, JSON.stringify({ at: new Date().toISOString(), n: t.n, groups: t.groups, shares: t.shares, ...(c ? { exposure: c } : {}) }) + '\n');
-  const fight = found.filter((f) => f.kind === 'fighting it'), blind = found.filter((f) => f.kind === 'blind spot');
-  if (fight.length || blind.length) out.push('', '  Patterns to work on:');
-  for (const f of fight) out.push(`    Fighting it: ${title(f.spoke)}. You push on it (${f.push}%), and the agent still ${f.says} in ${f.pct}% of turns (${f.count} of ${f.of}).`, f.has ? '      You seem to have a written rule on this already, and it is not holding. Make it specific, or protect it in the contract.' : `      Try: ${f.rule}`);
-  for (const f of blind) out.push(`    Not said: ${title(f.spoke)}. The agent ${f.says} in ${f.pct}% of turns (${f.count} of ${f.of}), and only ${f.push}% of your pushes touch it. Is that what you want?`, `      Try: ${f.rule}`);
-  const covered = found.filter((f) => f.kind === 'covered');
-  if (covered.length) out.push('', `  Written down already, so left out: ${covered.map((f) => title(f.spoke)).join(', ')}. Matched by keyword, so check they say what you mean.`);
-  if (found.some((f) => f.kind === 'too few')) out.push('', `  Not enough recent turns to name every pattern yet: each needs ${MIN_TURNS}.`);
-  if (found.length) out.push('', '  What the agent did covers your last 90 days, not counting scratch work. Direction, scope, correctness and honesty have no behaviour signal, so they show only what you said.');
+  if (!t.spokes) out.push('', `  Too few messages for the 11 spokes (${t.n} of ${MIN_SPOKES}), so this shows the 4 groups.`);
+  appendFileSync(p.hist, JSON.stringify({ at: new Date().toISOString(), n: t.n, groups: t.groups, shares: t.shares }) + '\n');
   out.push('', `  Card: ${p.svg}`);
   if (args.includes('--png')) { const png = pngCard(p.svg); out.push(png ? `  Image to share: ${png}` : '  No image tool here (rsvg-convert or Chrome): open the card in a browser to save an image.'); }
   return out.join('\n');

package/status.mjs

@@ -137,7 +137,7 @@ if (!isGit) {
 } else if (state === 'watching') {
   out.push(`   Measuring here  ·  ${hasConfig ? '✓ wired in with a contract (promptwheel.config.json)' : '✓ wired in (zero-config auto-detect)'}. It verifies each commit/turn automatically.`);
 } else if (state === 'ready') {
-  out.push(`   Measuring here  ·  checkable but not wired yet. Try it now: \`sawbuck check\`  •  make it automatic: \`sawbuck attach --claude\``);
+  out.push(`   Measuring here  ·  checkable but not wired yet. Try it now: \`sawbuck check\`  •  make it automatic: \`sawbuck attach\``);
 } else {
   out.push(`   Measuring here  ·  ${hasConfig ? 'a contract exists' : 'no test command detected yet'}. \`sawbuck init\` to set up the check, or \`sawbuck context\` for the history alone.`);
 }

package/steers.mjs

@@ -37,7 +37,7 @@ export function steersReport({ json = false, home } = {}) {
   const groups = groupSteers(steers);
   const repeated = groups.filter((g) => g.n >= 3 && g.sessions >= 2);
   if (json) return JSON.stringify({ steers: steers.length, scored: stats.scored, unscored: stats.lost, repeated });
-  if (!steers.length && !stats.scored) return '🐴 sawbuck: no steers recorded. The plugin\'s live judge is off by default; /sawbuck-reins:rules reads your history instead.';
+  if (!steers.length && !stats.scored) return '🐴 sawbuck: no steers recorded yet. They appear as you work with the plugin\'s live judge on.';
   const out = [`🐴 ${steers.length} steers kept, from ${stats.scored} replies scored${stats.lost ? ` (${stats.lost} could not be scored, so this undercounts)` : ''}. Measured, not estimated.`];
   if (repeated.length) {
     out.push('', 'You keep saying:');

package/dispatch.mjs

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-// dispatch.mjs, the dispatch: a compact proof-of-work receipt from the results.
-// A receipt, not an ad. Silent when nothing's been recorded to show (unless --force).
-// Zero-dep. Usage: node dispatch.mjs [--repo <path>] [--force] [--json]
-
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const flag = (n, d) => { const i = process.argv.indexOf(n); return i > -1 ? (process.argv[i + 1] ?? true) : d; };
-const repo = flag('--repo', process.cwd());
-const force = process.argv.includes('--force');
-
-let rec = null;
-try { rec = JSON.parse(readFileSync(join(repo, '.sawbuck', 'results.json'), 'utf8')); } catch {}
-
-const total = rec ? (rec.regressions || 0) + (rec.gamed || 0) + (rec.mandates || 0) : 0;
-if (!rec || (!total && !force)) process.exit(0);          // nothing recorded → stay quiet
-if (process.argv.includes('--json')) { console.log(JSON.stringify(rec)); process.exit(0); }
-
-const n = (x, s) => `${x} ${s}${x === 1 ? '' : 's'}`;
-const L = rec.latest;
-// Attribute the latest catch to the agent that made it (the Claude hook passes 'claude').
-let head;
-if (L && L.kind === 'gamed') head = L.by ? `🐴 Sawbuck caught ${L.by} gaming a metric` : `🐴 Sawbuck caught a gamed change`;
-else if (L && L.kind === 'regression') head = L.by ? `🐴 Sawbuck caught a regression from ${L.by}` : `🐴 Sawbuck caught a regression`;
-else head = `🐴 Sawbuck`;
-let line = head;
-if (L) {
-  const why = String(L.reason || L.kind).replace(/^a change here was gamed,\s*/i, '').replace(/^a change here\s+/i, '');
-  line += `\n   ${L.file}: ${why}`;
-}
-const tally = [rec.gamed ? n(rec.gamed, 'gamed change') : '', rec.regressions ? n(rec.regressions, 'regression') : ''].filter(Boolean).join(', ');
-if (tally) line += `\n   (${tally} caught here so far)`;
-console.log(line);