sawbuck 0.1.41 → 0.1.43

package/README.md

@@ -21,10 +21,10 @@ Or from the command line:
 # 1 · try it (no install, no commitment): verify your latest change right now
 npx sawbuck check
 
-# 2 · enforce it: attach once to this repo
+# 2 · sign this repo: the written rule, your tests, protected paths, CI
 npm i -g sawbuck
-sawbuck attach            # every commit (a git post-commit hook)
-sawbuck attach --claude   # or protected paths every Claude Code turn, plus every commit (a project-scoped Stop hook)
+sawbuck contract
+sawbuck attach --claude   # then watch every Claude Code turn
 ```
 
 **Zero-config:** it auto-detects your test command, so there is nothing to write to start.
@@ -60,19 +60,17 @@ Exit codes: `0` verified · `1` regression · `2` gamed · `3` inconclusive · `
 
 | command | what |
 |---|---|
+| `sawbuck contract` | one command to sign a repo: keeps your contract, adds tests and tripwires if there are none, protected paths, the supply-chain guards, and the architecture lock. `--dry-run` previews it. |
 | `sawbuck check [--base R --head R] [--repeat N] [--allow "reason"] [--json]` | verify your latest change (working tree if dirty, else the last commit, or a range); zero-config, no attach, no record. Every `promptwheel run` flag passes through: this is the engine with a plain-spoken verdict |
-| `sawbuck init` | write the contract (`promptwheel.config.json`), tuned by what your git history shows actually breaks |
 | `sawbuck attach [--claude \| --user]` | enforce it (git post-commit / project Claude hooks / user-level for every project) |
 | `sawbuck detach [--claude \| --user]` | remove it; no flag reverses whatever is attached here |
+| `/sawbuck-reins:rules` | proposes the rules you keep enforcing, from your own messages, each with quotes; you pick what to keep. Tested on one person so far |
+| `/sawbuck-reins:shape` | what you push on, what the agent did, and the gap between them, as a card |
 | `sawbuck status` · `sawbuck log` | the inventory (caught over time + debt now + armed state), in one view; and the recent per-check feed |
 | `sawbuck debt` | the whole-repo live suppression debt: what is still silenced in HEAD now, disabled tests first, heaviest files ranked |
 | `sawbuck context` | the ranked relevant history for the current change |
-| `sawbuck frame` | the contract's hard rules (mandates, inherited ones included) as one compact block; silent without a contract |
-| `sawbuck turn` | frame + context in one block: what `attach --claude` runs on every prompt and again right after a compaction |
-| `sawbuck recall` | related notes for your current change from extra memory providers you compose in (bring your own) |
 | `sawbuck trace` · `sawbuck doctor` · `detach --verify` | show the footprint; check the attachment resolves; prove a clean removal |
-| `sawbuck contract` | one command to sign a repo: keeps your contract, adds tests and tripwires if there are none, protected paths, the supply-chain guards, and the architecture lock. `--dry-run` previews it. |
-| `sawbuck where` · `sawbuck statusline` | list every repo it is attached to; a one-line status-line segment (🐴 watching / N caught / steer %) |
+| `sawbuck statusline` | a one-line status-line segment (🐴 watching / N caught / steer %) |
 
 ## Give your agent the contract
 

package/agent-block.mjs

@@ -0,0 +1,33 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+// Your standing rules, one per line, kept in ~/.sawbuck/rules.md: the rules you picked from /sawbuck-reins:rules. Signing
+// carries them into each repo, so they follow you. They are your words, and they land in a file you review before committing.
+export function standingRules(home = homedir()) {
+  try {
+    return readFileSync(join(home, '.sawbuck', 'rules.md'), 'utf8').split('\n').map((l) => l.replace(/^[-*\s]+/, '').trim()).filter((l) => l && !l.startsWith('#') && l.length <= 200).slice(0, 30);
+  } catch { return []; }
+}
+
+// Write (or refresh) the agent-orienting contract block so a coding agent (or a loop not wired to the
+// `attach --claude` hook) knows the rules. AGENTS.md (the cross-tool convention; created if absent) +
+// CLAUDE.md / .cursorrules when present. Idempotent + safe: only the sentinel-delimited block is
+// touched. `--no-agent-block` skips it.
+export function writeAgentBlock(repo) {
+  const START = '<!-- sawbuck:contract -->', END = '<!-- /sawbuck:contract -->';
+  const block = `${START}\n## Sawbuck contract\n\nThis repo is under a Sawbuck contract: a change is done only when the win survives verification from the source alone. Before finishing, run \`npx -y sawbuck check\`. If it reads \`gamed\`, the green came from editing a test, config, or grader, not the source, so undo that and earn it in the source. Run \`npx -y sawbuck context\` after your first edit to see what broke in these files before (reverts, weakened tests, fragile spots). Never skip, weaken, or delete a test to go green.\n${END}\n`;
+  const mine = standingRules();
+  const body = mine.length ? block.replace(END, `\n### Standing rules\n\n${mine.map((r) => `- ${r}`).join('\n')}\n${END}`) : block;
+  const targets = ['AGENTS.md', ...['CLAUDE.md', '.cursorrules'].filter((f) => existsSync(join(repo, f)))];
+  const done = [];
+  for (const f of targets) {
+    const p = join(repo, f);
+    let text = existsSync(p) ? readFileSync(p, 'utf8') : '';
+    const s = text.indexOf(START);
+    if (s > -1) { const e = text.indexOf(END, s); text = (e > -1 ? text.slice(0, s) + body + text.slice(e + END.length).replace(/^\n+/, '\n') : text.slice(0, s) + body); }
+    else { text = (text.trim() ? text.replace(/\n*$/, '\n\n') : '') + body; }
+    try { writeFileSync(p, text); done.push(f); } catch { /* best-effort */ }
+  }
+  return done;
+}

package/contract-cmd.mjs

@@ -4,6 +4,7 @@
 // lock. Zero-LLM. Re-running changes nothing. Protected product code (auth, billing) is suggested, never added:
 // freezing those is a person's decision.
 import { ensureExcluded } from './exclude.mjs';
+import { writeAgentBlock, standingRules } from './agent-block.mjs';
 import { execFileSync } from 'node:child_process';
 import { readFileSync, writeFileSync, existsSync, mkdtempSync, rmSync, cpSync, mkdirSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
@@ -63,7 +64,7 @@ try {
     writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n');
     const pack = join(repo, '.promptwheel', 'packs', 'supply-chain');
     mkdirSync(pack, { recursive: true });
-    cpSync(join(scratch, '.promptwheel', 'packs', 'supply-chain'), pack, { recursive: true });
+    cpSync(join(scratch, '.promptwheel', 'packs', 'supply-chain'), pack, { recursive: true, filter: (f) => !/(README\.md|pack\.json)$/.test(f) });
     // the gate measures in clean worktrees, so the scanners must reach git. A repo attached earlier, or one that
     // ignores .promptwheel/ for the outcome record, would hide them and every guard would read unmeasurable.
     for (const f of [join(repo, '.gitignore'), resolve(repo, execFileSync('git', ['-C', repo, 'rev-parse', '--git-path', 'info/exclude'], { encoding: 'utf8' }).trim())]) {
@@ -73,6 +74,8 @@ try {
       if (next !== text) writeFileSync(f, next);
     }
     ensureExcluded(repo);
+    // the written rule is what changes the agent (the pressure bench: 11 of 20 to 0 of 20), so every signing writes it
+    writeAgentBlock(repo);
     // CI goes in here, before the rules take hold: afterwards the contract itself would refuse an agent the file.
     // Only for a GitHub repo with a real test command: a placeholder would fail every pull request.
     const wf = join(repo, '.github', 'workflows', 'sawbuck.yml');
@@ -83,7 +86,7 @@ try {
     const locked = existsSync(join(repo, 'promptwheel.lock.json'));
     if (!locked) run([join(pack, 'lock.mjs'), 'write', repo], repo);
     const added = (cfg.mandates.length - before.m) + (cfg.metrics.length - before.g);
-    process.stdout.write(added || !locked ? `sawbuck: signed. ${cfg.metrics.length} guards, ${cfg.mandates.length} protected-path rules, and the shape of this repo in promptwheel.lock.json.\n${strict ? '' : '  New dependencies and structure changes show as notes for now; protected paths and install scripts block. --strict blocks them all.\n'}${ci ? '  Added .github/workflows/sawbuck.yml, so pull requests are checked in CI. Commit it with the contract.\n' : ''}` : 'sawbuck: already signed, nothing changed.\n');
+    process.stdout.write(added || !locked ? `sawbuck: signed. ${cfg.metrics.length} guards, ${cfg.mandates.length} protected-path rules, and the shape of this repo in promptwheel.lock.json.\n${strict ? '' : '  New dependencies and structure changes show as notes for now; protected paths and install scripts block. --strict blocks them all.\n'}${standingRules().length ? `  Added your ${standingRules().length} standing rules from ~/.sawbuck/rules.md to AGENTS.md.\n` : ''}${ci ? '  Added .github/workflows/sawbuck.yml, so pull requests are checked in CI. Commit it with the contract.\n' : ''}` : 'sawbuck: already signed, nothing changed.\n');
   }
 } finally { rmSync(scratch, { recursive: true, force: true }); }
 
@@ -92,5 +95,5 @@ let files = [];
 try { files = execFileSync('git', ['-C', repo, 'ls-files'], { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] }).split('\n'); } catch { /* not a repo: attach says so */ }
 const seen = new Set();
 for (const f of files) { const m = f.match(/^(.*?(?:^|\/)(?:auth|authentication|billing|payments?|migrations))\//); if (m && !/(^|\/)(node_modules|test|tests|docs?)\//.test(m[1])) seen.add(m[1]); }
-if (seen.size) process.stdout.write(`\n  To protect product code too, add these to "mandates" in promptwheel.config.json:\n${[...seen].slice(0, 5).map((d) => `    { "name": "${d.replace(/\W+/g, '-')}", "paths": ["${d}/**"], "reason": "changed by a person" }`).join('\n')}\n`);
-if (!dry) process.stdout.write('\n  Commit promptwheel.config.json, promptwheel.lock.json and .promptwheel/packs/. Then /sawbuck-reins:watch or sawbuck attach --claude arms it.\n');
+if (seen.size) process.stdout.write(`\n  To protect product code too, add these protected paths under "mandates" in promptwheel.config.json:\n${[...seen].slice(0, 5).map((d) => `    { "name": "${d.replace(/\W+/g, '-')}", "paths": ["${d}/**"], "reason": "changed by a person" }`).join('\n')}\n`);
+if (!dry) process.stdout.write('\n  Commit promptwheel.config.json, promptwheel.lock.json, AGENTS.md and .promptwheel/packs/. Then sawbuck attach --claude arms it.\n');

package/dispatch.mjs

@@ -13,7 +13,7 @@ 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) : 0;
+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); }
 

package/exclude.mjs

@@ -5,6 +5,8 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 const sh = (r, ...a) => { try { return execFileSync('git', ['-C', r, ...a], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return ''; } };
 
+export const RECORD_DIRS = ['.sawbuck/', '.promptwheel/*', '!.promptwheel/packs/', 'events.jsonl', 'annotations.jsonl', 'annotation-reviews.jsonl', 'decision-cards.jsonl', 'LOGBOOK.md', 'JOURNEY.md'];
+
 export function ensureExcluded(r) {
   try {
     // the repository's own exclude file, wherever its git dir is (a worktree or submodule keeps it elsewhere)
@@ -13,7 +15,7 @@ export function ensureExcluded(r) {
     const f = resolve(r, rel);
     // the record dirs + the logbook's root ledger cache (events.jsonl). Rewrite the block to
     // the CURRENT set rather than bail on presence, so a grown set retrofits existing repos.
-    const WANT = '# >>> sawbuck >>>\n.sawbuck/\n.promptwheel/*\n!.promptwheel/packs/\nevents.jsonl\nannotations.jsonl\nannotation-reviews.jsonl\ndecision-cards.jsonl\nLOGBOOK.md\nJOURNEY.md\n.claude/settings.local.json\n# <<< sawbuck <<<\n';
+    const WANT = `# >>> sawbuck >>>\n${[...RECORD_DIRS, '.claude/settings.local.json'].join('\n')}\n# <<< sawbuck <<<\n`;
     const body = existsSync(f) ? readFileSync(f, 'utf8') : '';
     const stripped = body.replace(/# >>> sawbuck >>>[\s\S]*?# <<< sawbuck <<<\n?/g, '');
     const next = (stripped && !stripped.endsWith('\n') ? stripped + '\n' : stripped) + WANT;

package/exposure.mjs

@@ -0,0 +1,104 @@
+// What was not said. The shape records what you pushed on; this records what the agent did, from your transcripts, so a
+// spoke can be read against its opportunity: an agent that often changes code and runs nothing, in history where you
+// rarely ask for proof, is a blind spot. Plain counting of tool calls. No model, nothing leaves this machine.
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { readHistory, typedText } from './history.mjs';
+
+const VERIFY = /\b(test|tests|pytest|vitest|jest|mocha|ava|playwright|cargo (test|check)|go (test|vet)|tsc|eslint|lint|typecheck|npm run (build|check)|curl|sawbuck check|promptwheel run|make (test|check))\b/i;
+const RISKY_PATH = /(^|\/)(\.env[^/]*|\.npmrc|\.yarnrc(\.yml)?|\.github\/workflows\/[^/]+|Dockerfile[^/]*|docker-compose[^/]*|CODEOWNERS|\.claude\/settings(\.local)?\.json|[^/]*(secret|credential)[^/]*)$/i;
+const RISKY_CMD = /(git push[^|;&]*(--force|-f\b)|git reset --hard|curl[^|]*\|\s*(sh|bash)|sudo |drop table|chmod 777)/i;
+// deleting a temp or build folder is housekeeping, not risk: on real history two thirds of rm -rf were that
+const RM = /rm -rf\s+(\S+)/i, RM_SAFE = /tmp|scratch|\$|dist|build|node_modules|cache|\.next|coverage/i;
+const SHIP = /\b(git commit|git push|npm publish|gh pr (create|merge)|gh release|vercel|deploy)\b/i;
+const UI = /\.(css|scss|sass|less|tsx|jsx|vue|svelte|astro|html|svg)$/i;
+const COPY = /\.(md|mdx|txt|rst)$/i;
+const CODE = /\.(m?[jt]sx?|py|go|rs|rb|java|kt|cs|php|c|cc|cpp|h|swift|sh)$/i;
+const BIG = 200;
+const SCRATCH = /(^|\/)(tmp|scratchpad|scratch)\/|^\/tmp\/|\/\.claude\//;   // throwaway work does not need a test run
+const DAYS = 90;   // what to work on now, not what happened last year
+
+// Rules you have already written, by spoke. A plain keyword match on your own files, so it is a hint: it finds that a
+// rule on the subject exists, not that it says the right thing.
+const WRITTEN = {
+  proof: /\b(verify|verified|run the tests?|tests? pass|prove|proof|before claiming|before trusting)\b/i,
+  safety: /\b(secrets?|credentials?|force.?push|destructive|protected paths?|never delete|before deleting)\b/i,
+  simplicity: /\b(simple|simplify|bloat|smallest|minimal|keep it short|overengineer\w*)\b/i,
+  process: /\b(commit|push|publish|release|deploy)\b/i,
+  voice: /\b(em dash\w*|plain (words|language|voice)|tone|wording|ai tells?|voice)\b/i,
+  visual: /\b(design|layout|css|ui|colou?rs?|spacing)\b/i,
+  naming: /\b(naming|names?|rename)\b/i,
+  autonomy: /\b(do not ask|don't ask|ask first|ask before|proceed without|keep going)\b/i,
+};
+export function writtenRules({ home = homedir(), repo = process.cwd() } = {}) {
+  const files = [join(home, '.claude', 'CLAUDE.md'), join(home, '.sawbuck', 'rules.md'), join(repo, 'CLAUDE.md'), join(repo, 'AGENTS.md')];
+  const root = join(home, '.claude', 'projects');
+  try { for (const d of readdirSync(root)) { const m = join(root, d, 'memory'); if (existsSync(m)) for (const f of readdirSync(m)) if (/^feedback.*\.md$/.test(f)) files.push(join(m, f)); } } catch {}
+  let text = '';
+  for (const f of files) { try { text += '\n' + readFileSync(f, 'utf8'); } catch {} }
+  return Object.fromEntries(Object.entries(WRITTEN).map(([s, re]) => [s, re.test(text)]));
+}
+
+function lines(s) { return s ? String(s).split('\n').length : 0; }
+
+export function exposure({ root = join(homedir(), '.claude', 'projects'), days = DAYS } = {}) {
+  const since = days ? Date.now() - days * 864e5 : 0;
+  const WINDOW = 3;   // a check may come a turn or two later: count code as unchecked only if none ran in the next 3 turns
+  const c = { turns: 0, working: 0, code: 0, unverified: 0, risky: 0, big: 0, shipped: 0, ui: 0, copy: 0, renames: 0, asked: 0 };
+  let turn = null, T = [];
+  const close = () => {
+    if (!turn) return;
+    c.turns++; T.push(turn);
+    if (turn.tools) {
+      c.working++;
+      if (turn.code) c.code++;
+      if (turn.risky) c.risky++; if (turn.added >= BIG) c.big++; if (turn.ship) c.shipped++; if (turn.ui) c.ui++; if (turn.copy) c.copy++; if (turn.rename) c.renames++;
+      if (/\?\s*$/.test(turn.last)) c.asked++;
+    }
+    turn = null;
+  };
+  const endSession = () => {
+    close();
+    T.forEach((t, i) => { if (t.code && !T.slice(i, i + 1 + WINDOW).some((x) => x.verified)) c.unverified++; });
+    T = [];
+  };
+  const onTool = (b) => {
+    turn.tools++;
+    const i = b.input || {};
+    if (b.name === 'Bash') {
+      const cmd = String(i.command || '');
+      if (VERIFY.test(cmd)) turn.verified = true;
+      const rm = cmd.match(RM);
+      if (RISKY_CMD.test(cmd) || (rm && !RM_SAFE.test(rm[1]))) turn.risky = true;
+      if (SHIP.test(cmd)) turn.ship = true;
+      if (/\bgit mv\b/.test(cmd)) turn.rename = true;
+    } else if (b.name === 'Edit' || b.name === 'Write' || b.name === 'MultiEdit') {
+      const p = String(i.file_path || '');
+      if (CODE.test(p) && !SCRATCH.test(p)) turn.code++;
+      if (UI.test(p)) turn.ui = true;
+      if (COPY.test(p)) turn.copy = true;
+      if (RISKY_PATH.test(p)) turn.risky = true;
+      if (i.replace_all) turn.rename = true;
+      turn.added += Math.max(0, lines(i.content || i.new_string) - lines(i.old_string));
+    }
+  };
+  readHistory(root, {
+    onSession: endSession,
+    onEvent: (e) => {
+      if (since && e.timestamp && Date.parse(e.timestamp) < since) return;
+      if (e.type === 'user') {
+        if (typedText(e.message) === null) return;
+        close();
+        turn = { tools: 0, code: 0, verified: false, risky: false, added: 0, ship: false, ui: false, copy: false, rename: false, last: '' };
+      } else if (turn && Array.isArray(e.message && e.message.content)) {
+        for (const b of e.message.content) {
+          if (b.type === 'text') turn.last = b.text || turn.last;
+          if (b.type === 'tool_use') onTool(b);
+        }
+      }
+    },
+  });
+  return c;
+}
+if (import.meta.url === `file://${process.argv[1]}`) console.log(JSON.stringify(exposure()));

package/history.mjs

@@ -0,0 +1,32 @@
+// One reader for Claude Code history on this machine, so every feature counts the same way: side threads and meta lines
+// are skipped, and a line copied by a resumed session counts once.
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function typedText(message) {
+  const c = message && message.content;
+  if (typeof c === 'string') return c;
+  if (Array.isArray(c) && c.length && c.every((b) => b.type === 'text')) return c.map((b) => b.text).join(' ');
+  return null;
+}
+
+// calls onSession() before each transcript and onEvent(e) for each line, and returns nothing
+export function readHistory(root, { onSession = () => {}, onEvent }) {
+  const seen = new Set();
+  let dirs = []; try { dirs = readdirSync(root); } catch { return; }
+  for (const d of dirs) {
+    let files = []; try { files = readdirSync(join(root, d)).filter((f) => f.endsWith('.jsonl')); } catch { continue; }
+    for (const f of files) {
+      let text = ''; try { text = readFileSync(join(root, d, f), 'utf8'); } catch { continue; }
+      onSession();
+      for (const line of text.split('\n')) {
+        if (!line.includes('"type":"user"') && !line.includes('"type":"assistant"')) continue;
+        let e; try { e = JSON.parse(line); } catch { continue; }
+        if (e.isSidechain || e.isMeta) continue;
+        if (e.uuid) { if (seen.has(e.uuid)) continue; seen.add(e.uuid); }
+        onEvent(e);
+      }
+    }
+  }
+  onSession();
+}

package/init.mjs

@@ -15,6 +15,7 @@
 //   --force           overwrite an existing promptwheel.config.json
 //   --preset <name>   pass through to `promptwheel init`
 
+import { writeAgentBlock } from './agent-block.mjs';
 import { execFileSync } from 'node:child_process';
 import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
@@ -104,29 +105,9 @@ function describeMetric(m) {
 
 function writeCfg() { writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n'); }
 
-// Write (or refresh) the agent-orienting contract block so a coding agent (or a loop not wired to the
-// `attach --claude` hook) knows the rules. AGENTS.md (the cross-tool convention; created if absent) +
-// CLAUDE.md / .cursorrules when present. Idempotent + safe: only the sentinel-delimited block is
-// touched. `--no-agent-block` skips it.
-function writeAgentBlock() {
-  const START = '<!-- sawbuck:contract -->', END = '<!-- /sawbuck:contract -->';
-  const block = `${START}\n## Sawbuck contract\n\nThis repo is under a Sawbuck contract: a change is done only when the win survives verification from the source alone. Before finishing, run \`sawbuck check\`. If it reads \`gamed\`, the green came from editing a test, config, or grader, not the source, so undo that and earn it in the source. Run \`sawbuck context\` first to see what broke in these files before (reverts, weakened tests, fragile spots). Never skip, weaken, or delete a test to go green.\n${END}\n`;
-  const targets = ['AGENTS.md', ...['CLAUDE.md', '.cursorrules'].filter((f) => existsSync(join(repo, f)))];
-  const done = [];
-  for (const f of targets) {
-    const p = join(repo, f);
-    let text = existsSync(p) ? readFileSync(p, 'utf8') : '';
-    const s = text.indexOf(START);
-    if (s > -1) { const e = text.indexOf(END, s); text = (e > -1 ? text.slice(0, s) + block + text.slice(e + END.length).replace(/^\n+/, '\n') : text.slice(0, s) + block); }
-    else { text = (text.trim() ? text.replace(/\n*$/, '\n\n') : '') + block; }
-    try { writeFileSync(p, text); done.push(f); } catch { /* best-effort */ }
-  }
-  return done;
-}
-
 function report() {
   out('sawbuck: wrote promptwheel.config.json');
-  if (!noBlock) { const w = writeAgentBlock(); if (w.length) out(`sawbuck: wrote the agent guide (the contract rules) to ${w.join(', ')}`); }
+  if (!noBlock) { const w = writeAgentBlock(repo); if (w.length) out(`sawbuck: wrote the agent guide (the contract rules) to ${w.join(', ')}`); }
   out("\n  the contract (what a win must satisfy):");
   for (const m of cfg.metrics) out('    - ' + describeMetric(m));
   if (evidence) { out('\n  investigated this repo:'); for (const l of evidenceLines()) out(l); }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sawbuck",
-  "version": "0.1.41",
-  "description": "Sign your agent to a contract: a deterministic, zero-LLM check re-proves each win from the agent's source edits alone, so a test that went green by editing the test, grader, or config is sent back. For Claude Code, with Codex support in beta.",
+  "version": "0.1.43",
+  "description": "Sign your agent to a contract: a deterministic, zero-LLM check re-proves each win from the agent's source edits alone, so a test that went green by editing the test, grader, or config is sent back. For Claude Code, with Codex untested.",
   "type": "module",
   "license": "Apache-2.0",
   "engines": {
@@ -34,12 +34,17 @@
   },
   "dependencies": {
     "@promptwheel/logbook": "0.9.10",
-    "promptwheel": "0.7.15"
+    "promptwheel": "0.7.16"
   },
   "files": [
     "sawbuck.mjs",
     "rewrites.mjs",
     "steers.mjs",
+    "rules.mjs",
+    "history.mjs",
+    "shape.mjs",
+    "exposure.mjs",
+    "agent-block.mjs",
     "exclude.mjs",
     "contract-cmd.mjs",
     "bins.mjs",

package/reflect.mjs

@@ -12,7 +12,7 @@
 //   node reflect.mjs [--repo <path>] [--base <ref>] [--head <ref>]
 //   defaults: repo=cwd, base=HEAD~1, head=HEAD   (evaluates the latest commit)
 //
-// Engines resolve to the monorepo siblings by default; PW_BIN / LB_BIN override.
+// PW_BIN / LB_BIN override the engines.
 
 import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';

package/rules.mjs

@@ -0,0 +1,67 @@
+// Find the rules you keep enforcing and never wrote down. `prepare` gathers what you typed to Claude Code, on this
+// machine, with copies and likely secrets removed. The agent proposes rules from it, each with quotes. `check` proves
+// every quote is really yours: a rule with fewer than two real quotes is dropped. Nothing is added to any file here.
+import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { readHistory, typedText } from './history.mjs';
+
+const MAX_LINES = 3000;
+const SECRET = /(sk-[a-z0-9_-]{16,}|gh[pousr]_[a-z0-9]{20,}|github_pat_\w{20,}|AKIA[0-9A-Z]{16}|xox[baprs]-[\w-]{10,}|eyJ[\w-]{20,}\.[\w-]{10,}|-----BEGIN [A-Z ]*PRIVATE KEY|\b[a-f0-9]{40,}\b|(password|passwd|secret|token|api[_-]?key)\s*[:=]\s*\S+)/i;
+const norm = (s) => s.toLowerCase().replace(/\s+/g, ' ').trim();
+const paths = (home) => ({ dir: join(home, '.sawbuck'), input: join(home, '.sawbuck', 'rule-input.txt') });
+
+export function prepareRules({ home = homedir() } = {}) {
+  const found = [];
+  const seen = new Set();
+  let secrets = 0;
+  readHistory(join(home, '.claude', 'projects'), {
+    onEvent: (e) => {
+      if (e.type !== 'user') return;
+      const t = (typedText(e.message) || '').replace(/\s+/g, ' ').trim();
+      if (t.length < 8 || t.length > 400 || /^[<[]/.test(t) || t.startsWith('Caveat:') || t.startsWith('This session is being continued')) return;
+      const k = norm(t).slice(0, 120);
+      if (seen.has(k)) return;
+      seen.add(k);
+      if (SECRET.test(t)) { secrets++; return; }
+      found.push({ t, at: e.timestamp || '' });
+    },
+  });
+  found.sort((a, b) => String(a.at).localeCompare(String(b.at)));
+  const lines = found.slice(-MAX_LINES).map((x) => x.t);
+  const { dir, input } = paths(home);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(input, lines.join('\n') + '\n', { mode: 0o600 });
+  return { input, lines: lines.length, secrets };
+}
+
+export function checkRules(file, { home = homedir() } = {}) {
+  const lines = readFileSync(paths(home).input, 'utf8').split('\n').map(norm);
+  const raw = readFileSync(file, 'utf8');
+  const m = raw.match(/\[[\s\S]*\]/);
+  const list = m ? JSON.parse(m[0]) : [];
+  const kept = [], dropped = [];
+  for (const r of list) {
+    const quotes = (r.quotes || []).filter((q) => { const n = norm(String(q)); return n.length >= 8 && lines.some((l) => l.includes(n)); });
+    (quotes.length >= 2 ? kept : dropped).push({ rule: String(r.rule), quotes });
+  }
+  return { kept, dropped };
+}
+
+export function rulesCli(args, { home = homedir() } = {}) {
+  if (args.includes('--prepare')) {
+    const r = prepareRules({ home });
+    return `🐴 ${r.lines} of your messages are ready in ${r.input}, copies removed${r.secrets ? `, ${r.secrets} that looked like secrets left out` : ''}. Stays on this machine until an agent reads it.`;
+  }
+  const i = args.indexOf('--check');
+  if (i > -1) {
+    const file = args[i + 1];
+    if (!file || !existsSync(file) || !statSync(file).isFile()) return '🐴 sawbuck: --check needs the candidates file.';
+    if (!existsSync(paths(home).input)) return '🐴 sawbuck: run sawbuck rules --prepare first.';
+    const { kept, dropped } = checkRules(file, { home });
+    const out = [`🐴 ${kept.length} rules have at least 2 quotes that are really yours${dropped.length ? `, ${dropped.length} dropped` : ''}.`];
+    kept.forEach((r, n) => { out.push('', `${n + 1}. ${r.rule}`); for (const q of r.quotes.slice(0, 3)) out.push(`     "${q.slice(0, 110)}"`); });
+    return out.join('\n');
+  }
+  return 'sawbuck rules --prepare | --check <candidates.json>';
+}

package/sawbuck-hook.mjs

@@ -32,8 +32,7 @@ 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 everyTurns = cfg.dispatch?.everyTurns ?? 5;
-const onlyOnCatch = cfg.dispatch?.onlyOnCatch ?? false;
+const EVERY_TURNS = 5;
 
 const stDir = join(repo, '.sawbuck');
 const stPath = join(stDir, 'state.json');
@@ -71,7 +70,7 @@ st.lastSha = head || st.lastSha;
 st.turns += 1;
 
 // 2) the record of what the check has charted (read above, after any re-run)
-const total = rec ? (rec.regressions || 0) + (rec.gamed || 0) : 0;
+const total = rec ? (rec.regressions || 0) + (rec.gamed || 0) + (rec.mandates || 0) : 0;
 const saveState = () => { try { mkdirSync(stDir, { recursive: true }); writeFileSync(stPath, JSON.stringify(st, null, 2) + '\n'); } catch {} };
 
 // 2b) THE WALL AT TURN LEVEL (Claude Code Stop hook only): a mandate is checked against the WORKING
@@ -123,7 +122,7 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
     const before = (st.lastViolation && st.lastViolation.before) || {};
     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 mandate in the contract or revert the path.' : '';
+    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.)';
     // 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.
@@ -138,7 +137,7 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
     if ((st.mandateBlocks || 0) < MAX_BLOCKS) {
       st.mandateBlocks = (st.mandateBlocks || 0) + 1;
       saveState();
-      process.stdout.write(JSON.stringify({ decision: 'block', reason: `Sawbuck: a mandate in the contract was violated, the turn is not done. Protected paths changed in this turn: ${desc}. Undo the changes YOU made under the protected paths and make the fix elsewhere; do not revert anything you did not change (the rule is a wall, not a reminder; the gate fails any change that touches them).${spared}${restore}${accept}${upgrade}` }));
+      process.stdout.write(JSON.stringify({ decision: 'block', reason: `Sawbuck: a protected path in the contract was touched, the turn is not done. Protected paths changed in this turn: ${desc}. Undo the changes YOU made under the protected paths and make the fix elsewhere; do not revert anything you did not change (the rule is a wall, not a reminder; the gate fails any change that touches them).${spared}${restore}${accept}${upgrade}` }));
       process.exit(0);
     }
     saveState();
@@ -191,8 +190,8 @@ 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 = everyTurns > 0 && st.turns % everyTurns === 0;
-if (freshCatch || (cadenceHit && !onlyOnCatch)) {
+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');
   st.shownTotal = total;

package/sawbuck.mjs

@@ -15,7 +15,9 @@
 import { execFileSync } from 'node:child_process';
 import { erasedBlock } from './rewrites.mjs';
 import { steersReport } from './steers.mjs';
-import { ensureExcluded } from './exclude.mjs';
+import { rulesCli } from './rules.mjs';
+import { shapeCli } from './shape.mjs';
+import { ensureExcluded, RECORD_DIRS } from './exclude.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';
@@ -46,7 +48,6 @@ const BLOCK_RE = new RegExp(`\\n?${S_START}[\\s\\S]*?${S_END}\\n?`, 'g');
 // plus the logbook's root working-set (ledger cache, digests, annotation planes). It is
 // memory, not the user's source, a user who wants LOGBOOK.md committed still can explicitly
 // (exclude only affects UNtracked files).
-const RECORD_DIRS = ['.sawbuck/', '.promptwheel/*', '!.promptwheel/packs/', 'events.jsonl', 'annotations.jsonl', 'annotation-reviews.jsonl', 'decision-cards.jsonl', 'LOGBOOK.md', 'JOURNEY.md'];
 
 const argv = process.argv.slice(2);
 const cmd = argv[0];
@@ -69,7 +70,7 @@ 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]
-                            Write the contract (promptwheel.config.json), tuned and explained by what your
+                            Customize the contract (promptwheel.config.json), with notes from what your
                             git history shows actually breaks, plus a short contract 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)
@@ -86,7 +87,7 @@ Usage:
                             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 hard rules (mandates, inherited ones included) as one compact block;
+  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
 
@@ -94,6 +95,10 @@ Usage:
   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 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 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 %)
 
@@ -182,7 +187,7 @@ switch (cmd) {
     if (!rep || !rep.verdict) { out('🐴 sawbuck: could not run the check here. Make sure this is a git repo with a commit, and a test command (or run `sawbuck init`).'); process.exit(64); }
     if (json) { out(JSON.stringify(rep)); process.exit(code); }
     const m = (rep.metrics || [])[0];
-    for (const md of rep.mandates || []) out(`🐴 ⛔ mandate "${md.name}" violated${md.reason ? ': ' + md.reason : ''}  (touched: ${(md.files || []).join(', ')})${md.removed ? '  [deleted in this same change; a mandate stays in force for the change that removes it]' : ''}`);
+    for (const md of rep.mandates || []) out(`🐴 ⛔ protected path "${md.name}" touched${md.reason ? ': ' + md.reason : ''}  (touched: ${(md.files || []).join(', ')})${md.removed ? '  [deleted in this same change; the rule stays in force for the change that removes it]' : ''}`);
     const win = (rep.metrics || []).find((x) => x.status === 'improved' && !x.tripwire);
     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.`);
@@ -232,7 +237,7 @@ switch (cmd) {
     // cannot forget them. Silent without a contract; --speak explains instead.
     const o = frameBlock(repoRoot());
     if (o) out(o);
-    else if (flags.has('--speak')) out('🐴 sawbuck frame: no mandates in promptwheel.config.json yet. Add one (a protected path) and this re-asserts it every turn and after every compaction, so a deep context cannot forget it.');
+    else if (flags.has('--speak')) out('🐴 sawbuck frame: no protected paths in promptwheel.config.json yet. Add one (a protected path) and this re-asserts it every turn and after every compaction, so a deep context cannot forget it.');
     break;
   }
   case 'turn': {
@@ -355,6 +360,8 @@ switch (cmd) {
   case 'trace': { traceRepo(repoRoot()); break; }
   case 'doctor': { if (flags.has('--all')) doctorAll(); else doctorRepo(repoRoot()); break; }
   case 'where': { whereAttached(); break; }
+  case 'rules': { out(rulesCli(rest)); break; }
+  case 'shape': { out(shapeCli(rest)); break; }
   case 'steers': { out(steersReport({ json: flags.has('--json') })); break; }
   case 'statusline': {
     // compact status-line segment for the cwd repo. Never throws; fast.
@@ -552,8 +559,14 @@ function wireClaude(repo, opts) {
   const fileExisted = existsSync(f);
   let cfg = {};
   if (fileExisted) { try { cfg = JSON.parse(readFileSync(f, 'utf8')); } catch { die(`${f} exists but is not valid JSON; I will not overwrite it. Add the hooks by hand.`); } }
-  const ctx = user ? `${nodeCmd()} ${JSON.stringify(SELF)} turn --hook` : `${nodeCmd()} ${JSON.stringify(SELF)} turn --hook ${JSON.stringify(repo)}`;
-  const chk = user ? `${nodeCmd()} ${JSON.stringify(SELF)} __hook --by claude --stop` : `${nodeCmd()} ${JSON.stringify(SELF)} __hook --repo ${JSON.stringify(repo)} --by claude --stop`;
+  // run through npx, the installed path lives in a cache that can be cleared, and a missing hook fails quietly and
+  // leaves the wall off: fall back to fetching the same version
+  const run = (args) => {
+    const direct = `${nodeCmd()} ${JSON.stringify(SELF)} ${args}`;
+    return process.platform !== 'win32' && SELF.includes('/_npx/') ? `if [ -f ${JSON.stringify(SELF)} ]; then ${direct}; else npx -y sawbuck@${version} ${args}; fi` : direct;
+  };
+  const ctx = run(user ? 'turn --hook' : `turn --hook ${JSON.stringify(repo)}`);
+  const chk = run(user ? '__hook --by claude --stop' : `__hook --repo ${JSON.stringify(repo)} --by claude --stop`);
   // attached already? "already attached" only when every hook of THIS version is present; an older
   // attachment (say, without the SessionStart[compact] hook) is upgraded in place, never left stale.
   let upgrading = false;
@@ -607,6 +620,7 @@ function wireClaude(repo, opts) {
   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}`);
+  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)');
 }
@@ -680,6 +694,8 @@ function purgeRecord(repo) {
   let n = 0;
   for (const d of RECORD_DIRS) {
     const p = join(repo, d);
+    // a committed LOGBOOK.md or JOURNEY.md is the person's file, not our record
+    try { if (execFileSync('git', ['-C', repo, 'ls-files', '--', d], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim()) continue; } catch {}
     try { if (existsSync(p)) { rmSync(p, { recursive: true, force: true }); n++; out(`sawbuck: purged ${p}`); } } catch {}
   }
   const outcomes = join(repo, '.promptwheel', 'outcomes.jsonl');   // the rest of .promptwheel/ is the signed contract: yours to keep or delete
@@ -721,7 +737,7 @@ function doctorAll() {
 
 // --- registry: know and remove every attachment -----------------------------
 function regPath() { return join(homedir(), '.sawbuck', 'registry.json'); }
-function regRead() { try { return JSON.parse(readFileSync(regPath(), 'utf8')); } catch { return { repos: [] }; } }
+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; }

package/shape.mjs

@@ -0,0 +1,110 @@
+// 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.
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } 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'] };
+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 title = (s) => s[0].toUpperCase() + s.slice(1);
+
+export function prepareShape({ home = homedir() } = {}) {
+  const r = prepareRules({ home });
+  const p = paths(home);
+  const lines = readFileSync(p.rules, 'utf8').split('\n').filter(Boolean);
+  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]++; }
+  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]));
+  // the 0 to 99 scale is relative to your own top spoke and compressed so the shape reads: shares carry the real size
+  const ratings = Object.fromEntries(SPOKES.map((s) => [s, Math.round(40 + 59 * Math.sqrt(counts[s] / top))]));
+  const shares = Object.fromEntries(SPOKES.map((s) => [s, total ? Math.round(100 * counts[s] / total) : 0]));
+  return { n: total, none, groups, ratings, shares, spokes: total >= MIN_SPOKES };
+}
+
+// What was not said: each spoke we can measure from what the agent did, read against how often you push on it.
+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 kind = 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 = []) {
+  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`;
+}
+
+export function shapeCli(args, { home = homedir() } = {}) {
+  if (args.includes('--prepare')) { const r = prepareShape({ home }); return `🐴 ${r.lines} of your messages are ready in ${r.input}${r.secrets ? `, ${r.secrets} that looked like secrets left out` : ''}.`; }
+  const i = args.indexOf('--check');
+  if (i === -1) return 'sawbuck shape --prepare | --check <labels.json>';
+  const file = args[i + 1];
+  if (!file || !existsSync(file)) return '🐴 sawbuck: --check needs the labels file.';
+  const m = readFileSync(file, 'utf8').match(/\{[\s\S]*\}/);
+  const t = tally(m ? JSON.parse(m[0]) : {});
+  if (!t.n) return '🐴 sawbuck: no usable labels in that file.';
+  const p = paths(home);
+  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));
+  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.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.');
+  out.push('', `  Card: ${p.svg}`);
+  return out.join('\n');
+}