sawbuck 0.1.42 → 0.1.44

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) |
 
 ## Give your agent the contract
 
@@ -113,15 +111,13 @@ jobs:
 
 `--fail-on` takes `undocumented` (a bare `# type: ignore` / `# noqa` with no code), `test` (a newly disabled test), `any`, or a number of new suppressions. Exit 1 fails the check; add `--json` for the machine-readable delta. This repo is also a composite action: `uses: sawbuck-ai/sawbuck@v0` with `base` and `fail-on` inputs.
 
-Debt also rises on its own: once attached, the per-turn `context` hook surfaces the live suppression debt on the files your agent is touching when it is the suspect kind (undocumented, a disabled test, or on code that keeps breaking), so you do not have to run anything.
+Debt is on demand: `sawbuck debt`, and `sawbuck context` for the files in hand. To have history added to every turn, set `{"turn":{"context":true}}` in `sawbuck.config.json`. It is off by default because a written rule did the work in every bench, and context spent on each prompt is context lost.
 
 ## The engines
 
 Sawbuck is thin glue over two roles, each behind an open interface that points in opposite directions:
 
 - **the check** : the deterministic outcome gate, a published standard (the [Verified-Outcome Contract](CONTRACT.md)) that others conform to. Reference implementation: **promptwheel**. You plug in *what* to measure (your tests, lint, coverage, an eval); the source re-proof is the fixed part. Embed it with `import { check }`, or check any tool's verdict with `promptwheel conformance`.
-- **the memory** : the relevant history for the files you touch, plus the live debt. A socket you can fill. Default provider: **@promptwheel/logbook** (git history as agent memory; also ships an MCP server). Sawbuck reads it through one adapter, so you can *compose in your own* memory: `SAWBUCK_MEMORY=logbook,obsidian` keeps logbook as the git-truth + debt provider and adds your notes, then `sawbuck recall`. Four reference providers ship in `providers/`: **obsidian** (local notes vault; set `OBSIDIAN_VAULT`), **local** (a plain JSON file, zero setup), **claude** (read-only: your project's `CLAUDE.md` / `.claude` memory, already there, nothing to configure), and **mem0** (semantic memory; the one that reaches the network, so it needs a `MEM0_API_KEY` or a `~/.mem0` key file, unlike the offline default; verified against Mem0's v3 API). Any bin that speaks the three contract verbs works; `sawbuck memory-conformance <bin>` checks one. Composed providers are **folder-scoped and isolated by default**: each repo sees only its own memory, never a sibling's. Drop a `.sawbuck-root` marker (or set `SAWBUCK_MEMORY_ROOT`) in a parent folder to let repos under it inherit that folder's shared memory, top down. logbook is the default, not a hard requirement of the idea.
-
-In one line: the check is a standard we publish for others to meet; the memory is a socket we expose for others to fill. Sawbuck composes the two.
+- **the memory** : the relevant history for the files you touch, plus the live debt, from **@promptwheel/logbook** (git history as agent memory; also ships an MCP server).
 
 Apache 2.0.

package/agent-block.mjs

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+// 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 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);
+      // a section someone wrote inside the block stays: this refreshes our paragraph, never their words
+      const kept = e > -1 ? (text.slice(s, e).match(/\n### Standing rules[\s\S]*$/) || [''])[0].replace(/\n+$/, '\n') : '';
+      const body = kept ? block.replace(END, `${kept}${END}`) : block;
+      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') : '') + block;
+    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 } 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');
@@ -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,20 +5,28 @@ 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 function ensureExcluded(r) {
+export const RECORD_DIRS = ['.sawbuck/', '.promptwheel/*', '!.promptwheel/packs/', 'events.jsonl', 'annotations.jsonl', 'annotation-reviews.jsonl', 'decision-cards.jsonl', 'LOGBOOK.md', 'JOURNEY.md'];
+
+// everything the block hides, under any attach mode
+export const EXCLUDED = [...RECORD_DIRS, '.claude/settings.local.json'];
+
+// The one writer of the block, in the repository's own exclude file wherever its git dir is (a worktree or
+// submodule keeps it elsewhere). Rewrites to the current set, so a grown set retrofits existing repos; no lines
+// strips it. Returns whether the file changed.
+function writeBlock(r, lines) {
   try {
-    // the repository's own exclude file, wherever its git dir is (a worktree or submodule keeps it elsewhere)
     const rel = sh(r, 'rev-parse', '--git-path', 'info/exclude');
-    if (!rel) return;
+    if (!rel) return false;
     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 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;
-    if (next === body) return;
+    const block = lines.length ? `# >>> sawbuck >>>\n${lines.join('\n')}\n# <<< sawbuck <<<\n` : '';
+    const next = (block && stripped && !stripped.endsWith('\n') ? stripped + '\n' : stripped) + block;
+    if (next === body) return false;
     mkdirSync(dirname(f), { recursive: true });
     writeFileSync(f, next);
-  } catch {}
+    return true;
+  } catch { return false; }
 }
+export const ensureExcluded = (r) => writeBlock(r, EXCLUDED);
+export const clearExcluded = (r) => writeBlock(r, []);

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.42",
-  "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.44",
+  "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,14 +34,19 @@
   },
   "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",
+    "repo-state.mjs",
     "contract-cmd.mjs",
     "bins.mjs",
     "contract.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/repo-state.mjs

@@ -0,0 +1,22 @@
+// One read of what Sawbuck has here, shared by the statusline and `sawbuck status`. Files only, no git and no model.
+// state: watching (wired in), ready (checkable, not wired yet), memory (history only), or empty.
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const WEEK = 7 * 864e5;
+
+export function repoState(repo) {
+  const record = (f) => { try { return JSON.parse(readFileSync(join(repo, '.sawbuck', f), 'utf8')); } catch { return null; } };
+  const has = (f) => existsSync(join(repo, f));
+  const results = record('results.json') || {};
+  const caught = (results.regressions || 0) + (results.gamed || 0) + (results.mandates || 0);
+  const hasConfig = has('promptwheel.config.json');
+  const armed = hasConfig || has('package.json');
+  const state = has('.sawbuck/state.json') ? 'watching' : armed ? 'ready' : (has('LOGBOOK.md') || has('events.jsonl')) ? 'memory' : '';
+  // the reins engine's file; reins does the model work, never sawbuck. A rate nobody has updated for a week is
+  // history, not a reading, and the judge is off unless someone turned it on.
+  const s = record('steer.json');
+  const live = s && s.scored && !(s.at && Date.now() - Date.parse(s.at) > WEEK);
+  const steer = live ? { rate: Math.round(((s.ema != null ? s.ema : s.steeringRate) || 0) * 100), scored: s.scored } : null;
+  return { results, caught, hasConfig, armed, state, steer };
+}

package/rules.mjs

@@ -1,47 +1,32 @@
 // 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 { readdirSync, readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from 'node:fs';
+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') });
 
-function typed(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 '';
-}
-
 export function prepareRules({ home = homedir() } = {}) {
-  const root = join(home, '.claude', 'projects');
   const found = [];
   const seen = new Set();
   let secrets = 0;
-  let dirs = []; try { dirs = readdirSync(root); } catch {}
-  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) {
-      const p = join(root, d, f);
-      let text = ''; try { text = readFileSync(p, 'utf8'); } catch { continue; }
-      for (const line of text.split('\n')) {
-        if (!line.includes('"type":"user"')) continue;
-        let e; try { e = JSON.parse(line); } catch { continue; }
-        if (e.type !== 'user' || e.isMeta || e.isSidechain) continue;
-        const t = typed(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')) continue;
-        const k = norm(t).slice(0, 120);
-        if (seen.has(k)) continue;   // a resumed session copies its history
-        seen.add(k);
-        if (SECRET.test(t)) { secrets++; continue; }
-        found.push({ t, at: e.timestamp || '' });
-      }
-    }
-  }
+  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);

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,8 +70,22 @@ 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 {} };
+// the budget is per prompt: prompt_id when the harness sends one, else the prompt's own timestamp (written by
+// `sawbuck turn --hook`), never a constant that would spend it for good
+const promptId = hookInput.prompt_id || st.lastPromptAt || 'none';
+// Send the turn back, at most enforce.maxBlocks times per prompt, then let it end with a warning: it can never
+// loop, because the harness's own block cap resets on every tool call.
+const sendBack = (idKey, countKey, reason, stillOpen) => {
+  const max = +(cfg.enforce?.maxBlocks) || 3;
+  if (st[idKey] !== promptId) { st[idKey] = promptId; st[countKey] = 0; }
+  const spent = (st[countKey] || 0) >= max;
+  if (!spent) st[countKey] = (st[countKey] || 0) + 1;
+  saveState();
+  process.stdout.write(JSON.stringify(spent ? { systemMessage: `Sawbuck stopped blocking after ${max} tries: ${stillOpen}` } : { decision: 'block', reason }));
+  process.exit(0);
+};
 
 // 2b) THE WALL AT TURN LEVEL (Claude Code Stop hook only): a mandate is checked against the WORKING
 // tree on every stop, not only on commits, because an agent usually ends a turn with uncommitted
@@ -113,17 +126,12 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
   } else if (st.lastViolation) { delete st.lastViolation; }
   saveState();
   if (hits.length) {
-    const MAX_BLOCKS = +(cfg.enforce?.maxBlocks) || 3;
-    // the budget is per prompt: prompt_id when the harness sends one, else the prompt's own timestamp
-    // (written by `sawbuck turn --hook`), never a constant that would spend the budget for good
-    const promptId = hookInput.prompt_id || st.lastPromptAt || 'none';
-    if (st.mandatePromptId !== promptId) { st.mandatePromptId = promptId; st.mandateBlocks = 0; }
     const desc = hits.map((h) => `"${h.name}"${h.reason ? ' (' + h.reason + ')' : ''}: ${h.files.join(', ')}${h.committed ? ' [this rule is in the committed contract; editing promptwheel.config.json in the working tree does not lift it]' : ''}`).join('; ');
     const spared = leftAlone.length ? ` Edits that were already there before this prompt were left out of this check and must stay as they are: ${leftAlone.join(', ')}.` : '';
     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.
@@ -135,15 +143,7 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
       writeRec(r);
       logActivity({ kind: 'mandate', file: hits[0].files[0], reason: `mandate ${hits[0].name} violated in the working tree`, by: by || 'hook' });
     }
-    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.exit(0);
-    }
-    saveState();
-    process.stdout.write(JSON.stringify({ systemMessage: `Sawbuck stopped blocking after ${MAX_BLOCKS} tries: protected paths are still changed (${desc}).` }));
-    process.exit(0);
+    sendBack('mandatePromptId', 'mandateBlocks', `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}`, `protected paths are still changed (${desc}).`);
   }
 }
 
@@ -153,21 +153,9 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
 // bound a tool-using agent on its own. Opt out with SAWBUCK_NO_ENFORCE=1 (falls back to a flag).
 const gamedThisTurn = rec && rec.latest && rec.latest.kind === 'gamed' && rec.latest.sha === (head || '').slice(0, 8);
 if (stop && gamedThisTurn && !process.env.SAWBUCK_NO_ENFORCE) {
-  const MAX_BLOCKS = +(cfg.enforce?.maxBlocks) || 3;
-  const promptId = hookInput.prompt_id || st.lastPromptAt || 'none';
-  if (st.blockPromptId !== promptId) { st.blockPromptId = promptId; st.blockCount = 0; }
   st.shownTotal = total;
   const where = rec.latest.file;
-  if ((st.blockCount || 0) < MAX_BLOCKS) {
-    st.blockCount = (st.blockCount || 0) + 1;
-    saveState();
-    const reason = `Sawbuck: the win on ${where} was gamed. It came from editing the test or config, not the source, so it did not survive a source-only re-run. The turn is not done: fix the source so the metric passes on its own, then finish.`;
-    process.stdout.write(JSON.stringify({ decision: 'block', reason }));
-    process.exit(0);
-  }
-  saveState();   // budget spent: let the turn end, but warn loudly so it never loops forever
-  process.stdout.write(JSON.stringify({ systemMessage: `Sawbuck stopped blocking after ${MAX_BLOCKS} tries: the win on ${where} is still gamed and needs a real source fix.` }));
-  process.exit(0);
+  sendBack('blockPromptId', 'blockCount', `Sawbuck: the win on ${where} was gamed. It came from editing the test or config, not the source, so it did not survive a source-only re-run. The turn is not done: fix the source so the metric passes on its own, then finish.`, `the win on ${where} is still gamed and needs a real source fix.`);
 }
 
 // 3b) THE LOCK AT TURN LEVEL: tell the person the moment a turn changes the repo's structure or its resolved
@@ -191,8 +179,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

@@ -13,10 +13,12 @@
 // proves the repo came back clean; `doctor` checks the attachment still resolves.
 
 import { execFileSync } from 'node:child_process';
-import { erasedBlock } from './rewrites.mjs';
+import { erasedBlock, erasedCommits } from './rewrites.mjs';
 import { steersReport } from './steers.mjs';
 import { rulesCli } from './rules.mjs';
-import { ensureExcluded } from './exclude.mjs';
+import { shapeCli } from './shape.mjs';
+import { ensureExcluded, clearExcluded, EXCLUDED, RECORD_DIRS } from './exclude.mjs';
+import { repoState } from './repo-state.mjs';
 import { readFileSync, writeFileSync, existsSync, chmodSync, mkdirSync, unlinkSync, rmdirSync, rmSync, readdirSync } from 'node:fs';
 import { basename, join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -47,7 +49,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];
@@ -70,14 +71,12 @@ 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)
-      --claude              instead on every Claude Code turn (project hooks in .claude/settings.local.json)
-      --shared              with --claude, write the tracked .claude/settings.json (team-shared, visible in git)
-      --user                user-level Claude hooks that follow your cwd (attach once, every project)
-      --dry-run             print the exact footprint it would leave, and write nothing
+  sawbuck 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]
                             Remove it and restore the repo (no flag: whatever is attached here); --verify
                             proves it came back clean; --purge also deletes the record (.sawbuck/)
@@ -87,9 +86,9 @@ 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
+  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
@@ -97,13 +96,11 @@ Usage:
   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 (--png for an image)
   sawbuck steers            What you keep correcting, from the plugin's scratchpad on this machine (--json)
-  sawbuck statusline        One-line segment for your status line (🐴 watching | N caught | steer %)
+  sawbuck statusline        One-line segment for your status line (🐴 watching | N caught)
 
-  sawbuck recall [repo]     Related notes for your changes from extra memory providers
-                            (SAWBUCK_MEMORY=logbook,obsidian + OBSIDIAN_VAULT), alongside context
-  sawbuck memory-conformance <bin>
-                            Check a provider bin speaks the Memory Contract (recall/debt/record)
   sawbuck --help | --version
 
 Engines: promptwheel (the check) + @promptwheel/logbook (memory). Zero-LLM, offline, free.`;
@@ -185,7 +182,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.`);
@@ -235,13 +232,14 @@ 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': {
-    // the ONE per-prompt hook: the contract frame (forward: what must hold) and the relevant history
-    // (backward: what broke here before) in a single block, one process per prompt. Silent when
-    // there is nothing to say. Wired by `attach --claude` on UserPromptSubmit and after a compaction.
+    // the ONE per-prompt hook. The agent gets the contract frame once a session and again after a compaction: one
+    // written statement held in every bench, so saying it on each prompt only spends context. The relevant history
+    // is on demand (`sawbuck context`), and per turn only with {"turn":{"context":true}} in sawbuck.config.json.
+    // Wired by `attach --claude` 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());
@@ -256,8 +254,8 @@ switch (cmd) {
     // a file still carrying the content the last violation flagged is never baselined; and the
     // baseline's commit does not advance past a flagged commit until a clean stop or a commit the
     // person made between turns that no longer carries the flagged content.
-    let hookEvent = '';
-    if (flags.has('--hook') && !process.stdin.isTTY) { try { hookEvent = String(JSON.parse(readFileSync(0, 'utf8') || '{}').hook_event_name || ''); } catch {} }
+    let hookEvent = '', session = '', framed = false;
+    if (flags.has('--hook') && !process.stdin.isTTY) { try { const h = JSON.parse(readFileSync(0, 'utf8') || '{}'); hookEvent = String(h.hook_event_name || ''); session = String(h.session_id || ''); } catch {} }
     if (hookEvent === 'UserPromptSubmit' && top) {
       try {
         ensureExcluded(repo);   // before the first write: under user-level hooks nothing else has done it yet
@@ -288,11 +286,16 @@ switch (cmd) {
             st.turnBaseline = { at: now, sha: ((!moved || stillInHead) && pin && st.lastViolation.sha) || sha, files, lock: lockState(repo), rules: mandatesInForce(repo) };
           }
         }
+        framed = !!session && st.framedSession === session;
+        if (session) st.framedSession = session;
         st.lastPromptAt = now;   // every prompt, mandates or not: the walls key their block budgets on it when the harness sends no prompt_id
         mkdirSync(stDir, { recursive: true }); writeFileSync(stPath, JSON.stringify(st, null, 2) + '\n');
       } catch { /* the frame never fails a prompt */ }
     }
-    const o = [frameBlock(repo), contextBlock(repo, false)].filter(Boolean).join('\n');
+    let history = false;
+    try { history = JSON.parse(readFileSync(join(repo, 'sawbuck.config.json'), 'utf8')).turn?.context === true; } catch {}
+    if (!history && top) erasedCommits(repo);   // the ledger outlives the reflog whether or not it is printed
+    const o = [framed ? '' : frameBlock(repo), history ? contextBlock(repo, false) : ''].filter(Boolean).join('\n');
     if (o) out(o);
     break;
   }
@@ -359,6 +362,7 @@ switch (cmd) {
   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.
@@ -367,22 +371,16 @@ switch (cmd) {
       if (!repo) process.stdout.write('🐴 sawbuck · no repo here');
       if (repo) {
         const name = basename(repo);
-        let caught = 0;
-        try { const r = JSON.parse(readFileSync(join(repo, '.sawbuck', 'results.json'), 'utf8')); caught = (r.regressions || 0) + (r.gamed || 0) + (r.mandates || 0); } catch {}
+        const { caught, state, steer } = repoState(repo);
         // the last verdict from the activity feed (includes verified passes), so you see it working each turn
         let last = '';
         try { const L = readFileSync(join(repo, '.sawbuck', 'activity.jsonl'), 'utf8').trim().split('\n'); const e = JSON.parse(L[L.length - 1]); last = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive: '≈', allowed: '✎' }[e.kind] || ''; } catch {}
-        // one state model, shared with the Reins band: watching (wired in) / ready (checkable, not wired yet) / memory (history only)
-        const active = existsSync(join(repo, '.sawbuck', 'state.json'));
-        const armed = existsSync(join(repo, 'promptwheel.config.json')) || existsSync(join(repo, 'package.json'));
-        const mem = existsSync(join(repo, 'LOGBOOK.md')) || existsSync(join(repo, 'events.jsonl'));
-        const label = caught > 0 ? `${caught} caught` : active ? 'watching' : armed ? 'ready' : mem ? 'memory' : '';
+        const label = caught > 0 ? `${caught} caught` : state;
         const seg = label ? `🐴 sawbuck · ${label}` : '';
         const named = label ? `🐴 sawbuck · ${name} · ${label}` : '';   // which repo it detected, in the default line
         const base = named ? (last ? `${named} · ${last}` : named) : '';
         // live steering % from the reins engine's file (OFFLINE read; reins does the LLM work, never sawbuck)
-        let st = '';
-        try { const sj = JSON.parse(readFileSync(join(repo, '.sawbuck', 'steer.json'), 'utf8')); if (sj && sj.scored) { const p = Math.round(((sj.ema != null ? sj.ema : sj.steeringRate) || 0) * 100); st = `${p >= 50 ? '✊' : '🐎'} steer ${p}%`; } } catch {}
+        const st = steer ? `${steer.rate >= 50 ? '✊' : '🐎'} steer ${steer.rate}%` : '';
         // configurable template: SAWBUCK_STATUSLINE picks which segments show and in what order
         // (tokens {status} {sawbuck} {repo} {verdict} {steer} plus any literal text); empty tokens collapse
         // so you never get a dangling separator. Unset = the default composition. Mix in other
@@ -404,7 +402,7 @@ switch (cmd) {
   default: die(`unknown command '${cmd}'\n\n${help}`);
 }
 
-// --- the per-turn block: frame (forward, from contract.mjs) + context (backward) ---------------
+// --- context: the ranked history for the files in hand, on demand ---------------------------
 // the read face: ranked relevant history for what you're working on right now. Silent when there is
 // nothing to say, so it is safe on every UserPromptSubmit (that hook's stdout is injected into context;
 // "nothing notable" every turn would be noise). `speak` forces a reply for the explicit command.
@@ -453,26 +451,9 @@ function delFile(p) { try { if (existsSync(p)) unlinkSync(p); } catch {} }
 function rmIfEmptyDir(d) { try { if (existsSync(d) && readdirSync(d).length === 0) rmdirSync(d); } catch {} }
 
 // --- .git/info/exclude: keep the worktree clean without touching .gitignore --
-// Rewrites a single marked block to the union of excludes the current
-// attachments need. Never deletes the file (an empty one is git's own default).
+// Any attachment keeps the block, the last one out takes it. Returns whether the file changed.
 function excludeFile(repo) { return gitPath(repo, 'info/exclude'); }
-function syncExclude(repo, manifest) {
-  const need = new Set();
-  const a = manifest.attachments || {};
-  if (Object.keys(a).length) for (const d of RECORD_DIRS) need.add(d);     // any attach → the check may write the record dirs
-  if (a.claude) need.add('.claude/settings.local.json');                    // default claude settings are local; hide them too
-  const lines = [...need];
-  const f = excludeFile(repo);
-  let body = (existsSync(f) ? readFileSync(f, 'utf8') : '').replace(BLOCK_RE, '\n').replace(/\n{3,}/g, '\n\n');
-  if (lines.length) {
-    if (body && !body.endsWith('\n')) body += '\n';
-    body += `${S_START}\n${lines.join('\n')}\n${S_END}\n`;
-    mkdirSync(dirname(f), { recursive: true });
-    writeFileSync(f, body);
-  } else if (existsSync(f)) {
-    writeFileSync(f, body);                                                 // strip our block, leave the rest
-  }
-}
+function syncExclude(repo, manifest) { return Object.keys(manifest.attachments || {}).length ? ensureExcluded(repo) : clearExcluded(repo); }
 
 // --- git post-commit --------------------------------------------------------
 // The hook prefers a `sawbuck` on PATH (so it survives a reinstall/upgrade) and
@@ -495,7 +476,7 @@ function wireGit(repo) {
   if (dry) {
     out(dryText([
       `${existed ? 'modify' : 'create'}  ${pc}  (post-commit hook block)`,
-      `exclude ${excludeFile(repo)}  (${RECORD_DIRS.join(', ')})`,
+      `exclude ${excludeFile(repo)}  (${EXCLUDED.join(', ')})`,
       `create  ${manifestPath(repo)}  (attach receipt)`,
     ]));
     return;
@@ -513,7 +494,8 @@ function unwireGit(repo) {
   const pc = gitPath(repo, 'hooks/post-commit');
   const m = readManifest(manifestPath(repo));
   const hasReceipt = !!m.attachments?.git;
-  if (!existsSync(pc) && !hasReceipt) { out('sawbuck: nothing to detach'); return; }
+  // signing with no attach still hides the record, so a repo with no receipt can have a block to take back
+  if (!existsSync(pc) && !hasReceipt) { out(syncExclude(repo, m) ? `sawbuck: removed the record lines from ${excludeFile(repo)}` : 'sawbuck: nothing to detach'); return; }
   if (existsSync(pc)) {
     const stripped = readFileSync(pc, 'utf8').replace(BLOCK_RE, '\n').replace(/\n{3,}/g, '\n\n');
     const created = m.attachments?.git?.pc?.created;
@@ -556,8 +538,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;
@@ -569,7 +557,7 @@ function wireClaude(repo, opts) {
   if (dry) {
     out(dryText([
       `${upgrading ? 'update' : fileExisted ? 'modify' : 'create'}  ${f}  (UserPromptSubmit + SessionStart[compact] + Stop hooks: the per-turn block, and the check)`,
-      user ? null : `exclude ${excludeFile(repo)}  (${RECORD_DIRS.join(', ')}${shared ? '' : ', .claude/settings.local.json'})`,
+      user ? null : `exclude ${excludeFile(repo)}  (${EXCLUDED.join(', ')})`,
       `create  ${user ? userManifestPath() : manifestPath(repo)}  (attach receipt)`,
     ].filter(Boolean)));
     return;
@@ -580,8 +568,8 @@ function wireClaude(repo, opts) {
     cfg.hooks[event].push({ ...(matcher ? { matcher } : {}), hooks: [{ type: 'command', command }] });
   };
   put('UserPromptSubmit', ctx);
-  // right after a compaction the summary has just dropped detail: re-impress the contract frame and the
-  // relevant history there too (SessionStart with the `compact` source injects stdout into context).
+  // right after a compaction the summary has just dropped detail: re-impress the contract frame there too
+  // (SessionStart with the `compact` source injects stdout into context).
   put('SessionStart', ctx, 'compact');
   put('Stop', chk);
   mkdirSync(dir, { recursive: true });
@@ -611,6 +599,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)');
 }
@@ -684,6 +673,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
@@ -725,7 +716,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,134 @@
+// 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, 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'] };
+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 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 = []) {
+  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`;
+}
+
+// A PNG of the card, with what is already on the machine: sawbuck ships no image library. A snap browser sees neither
+// a hidden folder nor the real /tmp, so it works in a plain folder in home and the result is copied over.
+function pngCard(svg) {
+  const png = svg.replace(/\.svg$/, '.png');
+  rmSync(png, { force: true });
+  const run = (bin, args) => { try { execFileSync(bin, args, { stdio: 'ignore', timeout: 30000 }); return true; } catch { return false; } };
+  if (run('rsvg-convert', ['-w', '1200', '-o', png, svg]) && existsSync(png)) return png;
+  const tmp = join(dirname(dirname(svg)), `sawbuck-shape-${process.pid}`);
+  try {
+    mkdirSync(tmp, { recursive: true });
+    const a = join(tmp, 'shape.svg'), b = join(tmp, 'shape.png');
+    copyFileSync(svg, a);
+    for (const bin of ['google-chrome', 'chromium', 'chromium-browser']) {
+      if (run(bin, ['--headless', '--disable-gpu', '--hide-scrollbars', '--window-size=1000,1000', `--screenshot=${b}`, `file://${a}`]) && existsSync(b)) { copyFileSync(b, png); return png; }
+    }
+  } catch {} finally { rmSync(tmp, { recursive: true, force: true }); }
+  return '';
+}
+
+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.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.');
+  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

@@ -12,6 +12,7 @@ import { execFileSync } from 'node:child_process';
 import { readFileSync, existsSync } from 'node:fs';
 import { join, dirname, resolve, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { repoState } from './repo-state.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const flag = (n, d) => { const i = process.argv.indexOf(n); return i > -1 ? (process.argv[i + 1] ?? true) : d; };
@@ -27,26 +28,19 @@ const ICON = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive:
 // --- 1) the outcome record: what the check has done here -------------------
 // results.json holds the all-time catch tally (gamed + regression, never trimmed); activity.jsonl is
 // the recent per-check feed (verified included, capped ~200). We read both and keep each honest.
-const results = readJSON(join(repo, '.sawbuck', 'results.json')) || {};
+const { results, caught: catchesAllTime, state: kind, steer, armed, hasConfig } = repoState(repo);
 const feed = readLines(join(repo, '.sawbuck', 'activity.jsonl')).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
 const tally = { verified: 0, gamed: 0, regression: 0, inconclusive: 0, allowed: 0, mandate: 0 };
 for (const e of feed) if (e && tally[e.kind] != null) tally[e.kind]++;
 const seen = feed.length;
-const catchesAllTime = (results.regressions || 0) + (results.gamed || 0) + (results.mandates || 0);
 const latest = results.latest || (feed.length ? feed[feed.length - 1] : null);
 const since = feed.length ? (feed[0].at || '').slice(0, 10) : null;
-// the steer rate, if the reins judge has been scoring turns here (an OFFLINE read of its file; the
+// the steer rate, if the reins judge has been scoring turns here (an OFFLINE read of its file, in repoState; the
 // recent-window average over roughly the last twenty scored turns, as the band and statusline show it)
-const steerRec = readJSON(join(repo, '.sawbuck', 'steer.json'));
-const steer = steerRec && steerRec.scored ? { rate: Math.round(((steerRec.ema != null ? steerRec.ema : steerRec.steeringRate) || 0) * 100), scored: steerRec.scored } : null;
 
-// --- 2) the armed state: what it can measure here (mirror of statusline) ---
+// --- 2) the armed state: what it can measure here (shared with the statusline) ---
 const isGit = !!existsSync(join(repo, '.git'));
-const hasConfig = existsSync(join(repo, 'promptwheel.config.json'));
-const watching = existsSync(join(repo, '.sawbuck', 'state.json'));
-const armed = hasConfig || existsSync(join(repo, 'package.json'));
-const mem = existsSync(join(repo, 'LOGBOOK.md')) || existsSync(join(repo, 'events.jsonl'));
-const state = watching ? 'watching' : armed ? 'ready' : mem ? 'memory' : 'unarmed';
+const state = kind || 'unarmed';
 
 // --- 3) the live debt ledger: best-effort, bounded -------------------------
 // A full-repo HEAD grep + gating; fast on normal repos, can be heavy on a giant one. Bounded so

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 yet. They appear here as you work with the plugin\'s judge on.';
+  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.';
   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:');