sawbuck 0.1.44 → 0.1.45

package/CONTRACT.md

@@ -10,9 +10,9 @@ The contract has one property that holds all of it together: a verdict is **dete
 
 A corollary worth stating as an invariant: **the gate is defined only by in-repo, versioned config.** External systems (a dashboard, an issue tracker, a memory provider) may *report on* a verdict, but they must never *define* the guardrail. A guardrail that lives outside the repo is one the check cannot see in the diff, so it cannot be fingerprinted, so loosening it leaves no trace to catch as gamed. Memory (the input) is a pluggable socket; the gate (the output) stays in-repo and fingerprinted.
 
-> This contract covers the check. Sawbuck pairs it with the other half, **memory** (the relevant history for what you touch, plus the live debt), as the mirror idea: where the check is a standard others *conform to*, memory is a socket others *fill*. The default memory provider is @promptwheel/logbook, carried along so it works out of the box, but it is swappable; logbook is a default, not a requirement of the idea.
+> This contract covers the check. Sawbuck pairs it with the other half, **memory**: the relevant history for what you touch, plus the live debt, from @promptwheel/logbook.
 >
-> Both halves nest with your folders, so policy and memory flow top-down and isolate across siblings. A parent `promptwheel.config.json` passes its guardrails down via `extends` (repos inherit the base gate; local metrics override by name), and memory inherits a parent folder's shared scope the same way (a repo sees itself and its ancestors, never a sibling). One model for both: the directory tree is the scope.
+> Policy nests with your folders: a parent `promptwheel.config.json` passes its guardrails down via `extends` (repos inherit the base gate; local metrics override by name).
 
 ---
 

package/README.md

@@ -1,8 +1,8 @@
 # sawbuck
 
-**Sign your agent to a contract so it does what you want.**
+**Agents follow written rules. Most repos have none.** Sawbuck turns what you keep telling your agent into written rules, and re-runs your tests to prove they held.
 
-You write the contract (what a real win looks like); Sawbuck enforces it, re-proving every win from the agent's **source** edits alone, so a test that went from red to green only because the agent edited the test, mocked the grader, or loosened a declared config reads `gamed` and goes back. Deterministic and zero-LLM: no model in the verdict, nothing read from the agent's trajectory. Attach it and it carries your repo's history along: what broke in these files before, surfaced before you touch them.
+It re-proves every win from the agent's **source** edits alone, so a test that went from red to green only because the agent edited the test reads as gamed.
 
 > Sawbuck is the reference implementation of the [Verified-Outcome Contract](CONTRACT.md): the open interface for a coding loop you can trust.
 
@@ -13,7 +13,7 @@ In Claude Code, install the plugin and keep working:
 /plugin install sawbuck-reins@sawbuck
 ```
 
-The first time you open a git repository with no contract, Claude finishes your task and offers once to sign it. Say yes: every turn checks protected paths, and every commit is re-proved.
+The first time you open a git repository with no rules, Claude finishes your task and offers once to add them. Say yes: it writes the rule, sets your protected paths, and checks every turn.
 
 Or from the command line:
 
@@ -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 · sign this repo: the written rule, your tests, protected paths, CI
+# 2 · give this repo its rules: the written rule, your tests, protected paths
 npm i -g sawbuck
-sawbuck contract
-sawbuck attach --claude   # then watch every Claude Code turn
+sawbuck contract          # --full adds supply-chain guards, a repo lock and a CI check
+sawbuck attach            # check every Claude Code turn
 ```
 
 **Zero-config:** it auto-detects your test command, so there is nothing to write to start.
@@ -54,35 +54,36 @@ Exit codes: `0` verified · `1` regression · `2` gamed · `3` inconclusive · `
 - **Remembers what broke.** `context` surfaces the relevant history (reverts, fragile areas, test-weakening) for the files you are touching: a ranked trail guide, before you act.
 - **Shows you everything.** `status` is the inventory: what it has caught for you over time, the debt accruing now, and whether it is armed here, in one view. On-demand, so it is quiet until you go looking.
 - **Rides on, does not replace.** Sawbuck is the verify + memory layer. Your agent and your loop stay yours.
-- **Clean on and off.** the default `attach` touches nothing in your worktree (the hook lives in `.git/`, the record is excluded locally); `--claude` writes one git-excluded settings file; `detach` removes what it wired. Signed contract files stay because they are yours to review; `--purge` deletes the record. `trace` shows every byte it placed, and `detach --verify` proves the wiring is gone.
+- **Clean on and off.** `attach` writes one git-excluded settings file; `detach` removes what it wired. Signed contract files stay because they are yours to review; `--purge` deletes the record. `trace` shows every byte it placed, and `detach --verify` proves the wiring is gone.
 
 ## Commands
 
 | 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 contract` | gives a repo its rules: keeps what is there, adds your tests if there are none, protected paths, and the written rule. `--full` adds supply-chain guards, a repo lock and a CI check. `--dry-run` previews |
 | `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 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 attach [--user]` | check every Claude Code turn, here or in every repo |
+| `sawbuck detach [--user]` | remove it; no flag reverses whatever is attached here |
+| `/sawbuck-reins:audit` | finds rules in your agent files that can pull against each other, and proposes which wins. No history needed |
 | `/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 status` | the inventory (caught over time + debt now + armed state), in one view; `--log` for 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 trace` · `sawbuck doctor` · `detach --verify` | show the footprint; check the attachment resolves; prove a clean removal |
+| `sawbuck doctor` · `detach --verify` | check the attachment resolves; prove a clean removal |
 | `sawbuck statusline` | a one-line status-line segment (🐴 watching / N caught) |
 
-## Give your agent the contract
+## Give your agent the rule
 
-`sawbuck init` writes this block into your `AGENTS.md` for you (and `CLAUDE.md` / `.cursorrules` if present; `--no-agent-block` to skip), and `sawbuck attach --claude` enforces it through the hook: every turn checks protected paths, and every commit is re-proved. Here it is to paste yourself if you want:
+`sawbuck init` writes this block into your `AGENTS.md` for you (and `CLAUDE.md` / `.cursorrules` if present; `--no-agent-block` to skip), and `sawbuck attach` enforces it through the hook: every turn checks protected paths, and every commit is re-proved. Here it is to paste yourself if you want:
 
-    This repo is under a Sawbuck contract: a change is done only when the win survives verification
+    In this repo 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.
 
-**After you sign.** A new contract starts by watching: protected paths, new install scripts and sources outside the registry block from day one, and new dependencies and structure changes show as notes. `sawbuck contract --strict` blocks them all. When something fails, the check says what changed in words. If your tests can't run in CI, the check says so and doesn't fail the job, and protected paths are still enforced. To accept it on a pull request, someone with write access comments `sawbuck-allow: <reason>` and re-runs the check; the reason stays on the record. An agent signed in as that person could post the same comment, so branch protection and review still matter. Locally, use `--allow "<reason>"`.
+**With `--full`.** It starts by watching: protected paths, new install scripts and sources outside the registry block from day one, and new dependencies and structure changes show as notes. `sawbuck contract --strict` blocks them all. When something fails, the check says what changed in words. If your tests can't run in CI, the check says so and doesn't fail the job, and protected paths are still enforced. To accept it on a pull request, someone with write access comments `sawbuck-allow: <reason>` and re-runs the check; the reason stays on the record. An agent signed in as that person could post the same comment, so branch protection and review still matter. Locally, use `--allow "<reason>"`.
 
 **Rewritten history.** Logbook reads git, so a squash or a rebase takes a revert with it. `sawbuck context` also reads the reflog for commits no branch reaches any more and shows them for the files in hand, and once attached it keeps them in `.sawbuck/rewritten.jsonl` after the reflog expires. It stays local: a clone does not get it, nothing older than the reflog comes back, and work that was never committed is not in git at all. Your steering is separate: `reins` reads your agent transcripts, not git.
 

package/agent-block.mjs

@@ -1,12 +1,12 @@
 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) +
+// `attach` 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 block = `${START}\n## Sawbuck rules\n\nIn this repo 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) {

package/contract-cmd.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-// sawbuck contract: one command that signs a repo to a working contract. Keeps whatever contract is already
-// here, adds your tests and tripwires if there is none, then the supply-chain protections and the architecture
-// lock. Zero-LLM. Re-running changes nothing. Protected product code (auth, billing) is suggested, never added:
-// freezing those is a person's decision.
+// sawbuck contract: give a repo its first rules with one command. Keeps whatever is already here, adds your tests if
+// there is none, the protected paths, and the written rule, which is what changes the agent (the pressure bench: 11 of
+// 20 to 0 of 20). --full adds the supply-chain guards, the repo lock and a CI check. 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';
@@ -16,7 +16,7 @@ const HERE = dirname(fileURLToPath(import.meta.url));
 const repo = process.argv[2] || process.cwd();
 const dry = process.argv.includes('--dry-run');
 const strict = process.argv.includes('--strict');
-const noCi = process.argv.includes('--no-ci');
+const full = process.argv.includes('--full') || strict;
 // a new contract starts by watching: everyday change shows as a note. Protected paths, install scripts and sources
 // outside the registry still fail from day one. --strict holds them all, and an existing contract is left as it is.
 const REPORT = new Set(['dependency_entries', 'lock_drift', 'pins_changed', 'unpinned_execution', 'install_policy_gaps']);
@@ -49,29 +49,35 @@ try {
   run([PW, 'init', '--preset', 'supply-chain', '--no-agent-block'], scratch);
   const preset = JSON.parse(readFileSync(join(scratch, 'promptwheel.config.json'), 'utf8'));
   const had = existsSync(cfgPath);
+  // without --full, the paths that exist only for the lock and the scanners do not apply
+  const mandates = preset.mandates.filter((m) => full || !JSON.stringify(m.paths || []).match(/packs|promptwheel\.lock/));
   if (dry) {
-    process.stdout.write(`sawbuck contract would ${had ? 'add to' : 'write'} ${cfgPath}: ${preset.metrics.length} guards and ${preset.mandates.length} protected-path rules, the scanners under .promptwheel/packs/, and promptwheel.lock.json.\n`);
+    process.stdout.write(`sawbuck contract would ${had ? 'add to' : 'write'} ${cfgPath}: ${mandates.length} protected paths${full ? `, ${preset.metrics.length} guards, the scanners under .promptwheel/packs/, and promptwheel.lock.json` : ''}.\n`);
   } else {
     if (!had) run([join(HERE, 'init.mjs'), '-y', '--no-investigate'], repo);
     const cfg = existsSync(cfgPath) ? JSON.parse(readFileSync(cfgPath, 'utf8')) : { repeat: 1, metrics: [] };
     const before = { m: (cfg.mandates || []).length, g: (cfg.metrics || []).length };
     const names = (l) => new Set((l || []).map((x) => x && x.name));
     const hasM = names(cfg.mandates), hasG = names(cfg.metrics);
-    cfg.mandates = [...(cfg.mandates || []), ...preset.mandates.filter((m) => !hasM.has(m.name))];
-    cfg.metrics = [...(cfg.metrics || []), ...preset.metrics.filter((m) => !hasG.has(m.name)).map((m) => (!strict && REPORT.has(m.name) ? { ...m, report: true } : m))];
-    cfg.evaluatorPaths = [...new Set([...(cfg.evaluatorPaths || []), ...(preset.evaluatorPaths || [])])];
+    cfg.mandates = [...(cfg.mandates || []), ...mandates.filter((m) => !hasM.has(m.name))];
+    if (full) {
+      cfg.metrics = [...(cfg.metrics || []), ...preset.metrics.filter((m) => !hasG.has(m.name)).map((m) => (!strict && REPORT.has(m.name) ? { ...m, report: true } : m))];
+      cfg.evaluatorPaths = [...new Set([...(cfg.evaluatorPaths || []), ...(preset.evaluatorPaths || [])])];
+    }
     cfg.allowTrailer = false;
     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, 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())]) {
-      if (!existsSync(f)) continue;
-      const text = readFileSync(f, 'utf8');
-      const next = text.replace(/^\.promptwheel\/?[ \t]*$/gm, '.promptwheel/*\n!.promptwheel/packs/');
-      if (next !== text) writeFileSync(f, next);
+    if (full) {
+      mkdirSync(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())]) {
+        if (!existsSync(f)) continue;
+        const text = readFileSync(f, 'utf8');
+        const next = text.replace(/^\.promptwheel\/?[ \t]*$/gm, '.promptwheel/*\n!.promptwheel/packs/');
+        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
@@ -82,11 +88,14 @@ try {
     let remote = ''; try { remote = execFileSync('git', ['-C', repo, 'remote', 'get-url', 'origin'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }); } catch {}
     const realTests = !(cfg.metrics || []).some((m) => /set your test command/.test(String(m.cmd)));
     let ci = '';
-    if (!noCi && /github\.com/.test(remote) && realTests && !existsSync(wf)) { mkdirSync(dirname(wf), { recursive: true }); writeFileSync(wf, workflow(existsSync(join(repo, 'package-lock.json')))); ci = wf; }
+    if (full && /github\.com/.test(remote) && realTests && !existsSync(wf)) { mkdirSync(dirname(wf), { recursive: true }); writeFileSync(wf, workflow(existsSync(join(repo, 'package-lock.json')))); ci = wf; }
     const locked = existsSync(join(repo, 'promptwheel.lock.json'));
-    if (!locked) run([join(pack, 'lock.mjs'), 'write', repo], repo);
+    if (full && !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');
+    const fresh = added || (full && !locked);
+    process.stdout.write(!fresh ? 'sawbuck: already signed, nothing changed.\n' : full
+      ? `sawbuck: signed. ${cfg.mandates.length} protected paths, ${cfg.metrics.length} guards, 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 rest.\n' : ''}`
+      : `sawbuck: signed. ${cfg.mandates.length} protected paths, and the rule in AGENTS.md.\n  --full adds supply-chain guards, a repo lock and a CI check.\n`);
   }
 } finally { rmSync(scratch, { recursive: true, force: true }); }
 
@@ -96,4 +105,4 @@ try { files = execFileSync('git', ['-C', repo, 'ls-files'], { encoding: 'utf8',
 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 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');
+if (!dry) process.stdout.write(`\n  Commit promptwheel.config.json and AGENTS.md${full ? ', promptwheel.lock.json and .promptwheel/packs/' : ''}. Then sawbuck attach checks every turn.\n`);

package/contract.mjs

@@ -122,7 +122,7 @@ export function frameBlock(repo) {
   const mandates = resolvedMandates(repo);
   if (!mandates.length) return '';
   const lines = mandates.map((m) => `  ${m.paths.filter((s) => typeof s === 'string' && s.trim()).join(' · ')}${m.reason ? `  (${String(m.reason).slice(0, 160)})` : ''}`);
-  return '▣ contract (sawbuck) · hard rules in force this session, enforced by the gate on every turn:\n  protected, do not touch:\n' + lines.join('\n');
+  return '▣ rules (sawbuck) · checked on every turn:\n  protected, do not touch:\n' + lines.join('\n');
 }
 
 // the repo's architecture lock, if the supply-chain preset is installed: structure the lock has not seen, and a

package/debt.mjs

@@ -18,15 +18,15 @@ const failRaw = flag('--fail-on', null); // undocumented | test | any | <N>; bar
 const failMode = failRaw === true ? 'undocumented' : (failRaw ? String(failRaw).toLowerCase() : null);
 const asJson = process.argv.includes('--json');
 
-// events give fragility + fall-back dates (the memory provider's recall facts). Best-effort.
+// events give fragility + fall-back dates (Logbook's facts). Best-effort.
 const events = memEvents(repo);
 
 // the live suppression ledger via the memory adapter (the Memory Contract's `debt` capability). Each
 // item arrives classified (documented/testSkip) and with its line content and blame date (`since`),
-// so this file no longer imports the provider's pattern or gating. null = the provider FAILED
+// so this file does not import Logbook's pattern or gating. null = Logbook FAILED
 // (unmeasurable is NOT clean, refuse and exit nonzero); [] = a genuinely clean tree.
 const live = memDebt(repo);
-if (live === null) { console.error('sawbuck debt: could not read the suppression ledger (the memory provider failed)'); process.exit(1); }
+if (live === null) { console.error('sawbuck debt: could not read the suppression ledger (Logbook failed)'); process.exit(1); }
 const bare = live.filter((it) => !it.documented && it.content).length;
 
 // --since REF: the DELTA. Suppressions in HEAD but not at REF = debt this branch/PR adds.

package/exclude.mjs

@@ -5,7 +5,7 @@ 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 const RECORD_DIRS = ['.sawbuck/', '.promptwheel/*', '!.promptwheel/packs/', 'events.jsonl', 'annotations.jsonl', 'LOGBOOK.md', 'JOURNEY.md'];
 
 // everything the block hides, under any attach mode
 export const EXCLUDED = [...RECORD_DIRS, '.claude/settings.local.json'];

package/memory.mjs

@@ -1,74 +1,9 @@
-// memory.mjs, Sawbuck's memory adapter: the single seam between the glue and the memory provider(s).
-// It speaks the Memory Contract (recall / debt / record) over a provider's CLI, so no other glue file
-// imports a provider's internals. Zero-dep.
-//
-// Providers: SAWBUCK_MEMORY is an ordered, comma-separated list (default "logbook"). An entry is
-// either the built-in "logbook" (the reference provider, adapted to its native query/audit/annotate
-// verbs) or another provider that speaks the clean contract verbs: `recall --file P --json`,
-// `debt [--since REF] --json`, `record --ref SHA --summary S [--side X] [--evidence-file F] --by WHO`.
-// The shipped reference non-git provider is "obsidian" (providers/obsidian.mjs); point at any other
-// with SAWBUCK_MEMORY_<NAME>_BIN or a path entry.
-//
-// Degradation is explicit: a read returns null when its PRIMARY (git-truth) source failed, [] when it
-// ran clean. A provider that does not support a capability signals it by exiting nonzero (we skip it),
-// never by printing []. git-truth stays authoritative; other providers add supplementary notes.
-
+// memory.mjs, Sawbuck's adapter to Logbook, the one place that calls it: history, live debt, and a note on a catch. Zero-dep.
+// A read returns null when Logbook failed, [] when it ran clean, so unmeasurable never reads as clean.
 import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import { LB } from './bins.mjs';
-import { join, dirname, relative, resolve, basename, sep } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { homedir } from 'node:os';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-
-const envKey = (name) => 'SAWBUCK_MEMORY_' + name.toUpperCase().replace(/[^A-Z0-9]/g, '_') + '_BIN';
-// the ordered provider list. Each: { name, bin, dialect: 'logbook' | 'contract' }.
-const SHIPPED = new Set(['obsidian', 'mem0', 'local', 'claude']); // reference contract providers that ship in providers/
-export function providers() {
-  const spec = (process.env.SAWBUCK_MEMORY || 'logbook').split(',').map((s) => s.trim()).filter(Boolean);
-  return spec.map((name) => {
-    if (name === 'logbook') return { name, bin: LB, dialect: 'logbook' };
-    if (SHIPPED.has(name)) return { name, bin: process.env[envKey(name)] || join(HERE, 'providers', name + '.mjs'), dialect: 'contract' };
-    return { name, bin: process.env[envKey(name)] || name, dialect: 'contract' }; // a bin path, or a name with an env-set bin
-  });
-}
-
-// scopeChain(): the folder-based scope chain for a repo, most-specific first: the repo, then each
-// ancestor up to the memory root, then the root ("" = the shared/global scope). ISOLATION BY DEFAULT:
-// with no configured root the chain is just the leaf, so a repo sees only itself and never a sibling.
-// A root is SAWBUCK_MEMORY_ROOT, or the nearest ancestor holding a `.sawbuck-root` marker; with one,
-// a repo also inherits its ancestors' shared memory. Ids are paths relative to the root (forward
-// slashes), so sibling repos with the same basename never collide and never leak into each other.
-export function scopeChain(repo) {
-  const start = resolve(repo);
-  let root = process.env.SAWBUCK_MEMORY_ROOT ? resolve(process.env.SAWBUCK_MEMORY_ROOT) : null;
-  if (!root) {
-    let d = start; const stop = resolve(homedir());
-    for (let i = 0; i < 64; i++) {
-      if (existsSync(join(d, '.sawbuck-root'))) { root = d; break; }
-      const up = dirname(d);
-      if (up === d || d === stop) break;
-      d = up;
-    }
-  }
-  if (root && (start === root || start.startsWith(root + sep))) {
-    const idOf = (dir) => relative(root, dir).split(sep).join('/'); // "" for the root itself
-    const chain = [];
-    let d = start;
-    for (let i = 0; i < 64; i++) {
-      chain.push(idOf(d));
-      if (d === root) break;
-      const up = dirname(d);
-      if (up === d) break;
-      d = up;
-    }
-    return chain; // leaf-first, ending with "" (root = shared/global)
-  }
-  return [basename(start) || '.']; // no root in play: an isolated leaf, no inheritance
-}
 
-// run a provider bin; null on a real failure / unsupported-capability (nonzero exit), stdout otherwise.
+// null on a real failure, stdout otherwise
 function run(bin, repo, args, maxBuffer = 512 * 1024 * 1024) {
   try { return execFileSync(process.execPath, [bin, ...args], { cwd: repo, encoding: 'utf8', maxBuffer, stdio: ['ignore', 'pipe', 'ignore'] }); }
   catch { return null; }
@@ -80,7 +15,7 @@ function parseArray(out) {
 }
 
 // --- debt sub-classification (Sawbuck policy; applied once so the ledger and the per-turn surface
-// agree). Exported so the conformance checker can reuse them.
+// agree).
 export const isTestSkip = (m) => /\bit\.skip\b|\btest\.skip\b|xit\(|xdescribe\(|\bdescribe\.skip\b|pytest\.mark\.skip|unittest\.skip|\bt\.Skip\b|@Disabled\b|@Ignore\b|^\[Ignore\b|^Skip\s*=|^#\[ignore|markTestSkipped|markTestIncomplete/.test(String(m).trim());
 export const isDocumented = (c) => {
   c = String(c || '');
@@ -100,101 +35,26 @@ const classify = (r, source) => ({
   source,
 });
 
-// events(): the raw git event record (the ranking input), from the logbook-dialect provider only
-// (events with revert/fix/suppression semantics are git-truth; a note provider does not produce them).
-// [] when there is no such provider or it fails, exactly as "no history".
+// events(): the raw git event record, the ranking input. [] on failure, exactly as "no history".
 export function events(repo) {
-  const lb = providers().find((p) => p.dialect === 'logbook');
-  if (!lb) return [];
-  const out = run(lb.bin, repo, ['query', '--json'], 256 * 1024 * 1024);
+  const out = run(LB, repo, ['query', '--json', '--limit', '100000'], 256 * 1024 * 1024);
   if (out === null) return [];
   return out.split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
 }
 
-// the per-provider debt call, dialect-aware.
-function debtRaw(p, repo, { paths, ref }) {
-  const args = p.dialect === 'logbook'
-    ? ['audit', '--json', ...(ref ? ['--ref', ref] : []), ...((paths || []).flatMap((f) => ['--file', f]))]
-    : ['debt', '--json', ...(ref ? ['--since', ref] : []), ...((paths || []).flatMap((f) => ['--file', f]))];
-  return run(p.bin, repo, args);
-}
-
-// debt(): live suppressions still in the tree, each classified. Fans out across providers that SUPPORT
-// debt (git-truth); a provider that does not implement it exits nonzero and is skipped. Returns null
-// only when NO provider answered (unmeasurable, not clean); [] when a provider ran and the tree is
-// clean. Default (logbook-only) is byte-identical to the single-provider behavior.
+// debt(): live suppressions still in the tree, each classified. null when Logbook could not answer.
 export function debt(repo, { paths = null, ref = null } = {}) {
-  let answered = false;
-  const rows = [];
-  for (const p of providers()) {
-    const out = debtRaw(p, repo, { paths, ref });
-    if (out === null) continue;              // failed or unsupported -> skip
-    answered = true;
-    for (const r of parseArray(out)) rows.push(classify(r, p.name));
-  }
-  return answered ? rows : null;
-}
-
-// recall(): supplementary relevant NOTES for the touched paths, from providers that produce them
-// (contract-dialect; logbook's own history is surfaced via rank, not here). Each is a Finding of kind
-// note/decision, source-tagged. [] when nothing relevant. git-truth is never diluted by these.
-const normText = (s) => String(s || '').toLowerCase().replace(/\s+/g, ' ').replace(/[^\w ]+/g, '').trim();
-export function recall(repo, paths) {
-  const scopeArgs = scopeChain(repo).flatMap((id) => ['--scope', id]); // leaf-first: self + ancestors, never siblings
-  const raw = [];
-  for (const p of providers()) {
-    if (p.dialect !== 'contract') continue;
-    const r = run(p.bin, repo, ['recall', '--json', ...((paths || []).flatMap((f) => ['--file', f])), ...scopeArgs]);
-    if (r === null) continue;
-    for (const it of parseArray(r)) raw.push({ kind: String(it.kind || 'note'), path: it.path ?? null, ref: it.ref ?? null, date: it.date ?? null, summary: String(it.summary || '').slice(0, 280), source: p.name, scope: it.scope ?? null, score: typeof it.score === 'number' ? it.score : null });
-  }
-  // Cross-provider dedup + unified ordering. The same note surfaced by two providers collapses to one
-  // (keep the higher score; record that both knew it). Ordering is best-effort by the providers' own
-  // relevance scores: these are SUPPLEMENTARY leads, never git-truth, so a fuzzy order is fine.
-  const byKey = new Map();
-  for (const f of raw) {
-    const k = (f.path ? normText(f.path) + '\u0000' : '') + normText(f.summary);
-    const prev = byKey.get(k);
-    if (!prev) { byKey.set(k, f); continue; }
-    const keep = (f.score ?? 0) > (prev.score ?? 0) ? f : prev, other = keep === f ? prev : f;
-    if (other.source && !String(keep.source).split('+').includes(other.source)) keep.source = `${keep.source}+${other.source}`;
-    byKey.set(k, keep);
-  }
-  return [...byKey.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, 8);
-}
-
-// conform(): read-only conformance probe of a contract-dialect provider bin. Checks recall returns a
-// JSON array (or errors cleanly) and that debt either returns an array (git-truth) or signals
-// unsupported by exiting nonzero (never a bare []). Does not write, so record is validated elsewhere
-// (the record fan-out). Returns a report the `memory-conformance` command prints.
-export function conform(bin, repo, probePath = 'README.md') {
-  const probe = (args) => { try { return { out: execFileSync(process.execPath, [bin, ...args], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }), code: 0 }; } catch (e) { return { out: (e.stdout || '').toString(), code: e.status || 1 }; } };
-  const isArray = (s) => { s = (s || '').trim(); if (!s.startsWith('[')) return false; try { return Array.isArray(JSON.parse(s)); } catch { return false; } };
-  const r = probe(['recall', '--json', '--file', probePath]);
-  const recall = r.code !== 0 ? 'error (nonzero exit on recall)' : (isArray(r.out) ? 'ok (Finding[])' : 'bad shape (recall must print a JSON array)');
-  const d = probe(['debt', '--json']);
-  const debt = d.code !== 0 ? 'unsupported (exits nonzero, ok for a non-git provider)' : (isArray(d.out) ? 'supported (Suppression[])' : 'bad shape (debt must print a JSON array or exit nonzero)');
-  const pass = /^ok/.test(recall) && !/bad shape/.test(debt);
-  return { bin, recall, debt, pass };
+  const out = run(LB, repo, ['audit', '--json', ...(ref ? ['--ref', ref] : []), ...((paths || []).flatMap((f) => ['--file', f]))]);
+  return out === null ? null : parseArray(out).map((r) => classify(r, 'logbook'));
 }
 
-// record(): persist a machine finding to every WRITABLE provider (the write-back). Best-effort; never
-// throws into the caller. Returns true if at least one provider accepted it.
+// record(): keep a machine finding as an annotation. Best-effort, never throws into the caller.
 export function record(repo, { sha, reason, side, evidenceFile, by = 'sawbuck' }) {
   const text = String(reason).slice(0, 280);
-  const leaf = scopeChain(repo)[0]; // a finding belongs to the most-specific scope that produced it
-  let ok = false;
-  for (const p of providers()) {
-    const exec = (a) => execFileSync(process.execPath, [p.bin, ...a], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-    try {
-      if (p.dialect === 'logbook') {
-        const full = ['annotate', sha, text, ...(side ? ['--side', side] : []), ...(evidenceFile ? ['--evidence-file', evidenceFile] : []), '--by', by];
-        try { exec(full); } catch { exec(['annotate', sha, text, '--by', by]); }
-      } else {
-        exec(['record', '--ref', sha, '--summary', text, ...(side ? ['--side', side] : []), ...(evidenceFile ? ['--evidence-file', evidenceFile] : []), '--scope', leaf, '--by', by]);
-      }
-      ok = true;
-    } catch { /* this provider declined; others may still accept */ }
-  }
-  return ok;
+  const exec = (a) => execFileSync(process.execPath, [LB, ...a], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  try {
+    try { exec(['annotate', sha, text, ...(side ? ['--side', side] : []), ...(evidenceFile ? ['--evidence-file', evidenceFile] : []), '--by', by]); }
+    catch { exec(['annotate', sha, text, '--by', by]); }
+    return true;
+  } catch { return false; }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sawbuck",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "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",
@@ -33,7 +33,7 @@
     "sawbuck": "sawbuck.mjs"
   },
   "dependencies": {
-    "@promptwheel/logbook": "0.9.10",
+    "@promptwheel/logbook": "0.11.0",
     "promptwheel": "0.7.16"
   },
   "files": [
@@ -43,7 +43,6 @@
     "rules.mjs",
     "history.mjs",
     "shape.mjs",
-    "exposure.mjs",
     "agent-block.mjs",
     "exclude.mjs",
     "repo-state.mjs",
@@ -52,16 +51,11 @@
     "contract.mjs",
     "init.mjs",
     "reflect.mjs",
-    "dispatch.mjs",
     "sawbuck-hook.mjs",
     "rank.mjs",
     "debt.mjs",
     "status.mjs",
     "memory.mjs",
-    "providers/obsidian.mjs",
-    "providers/mem0.mjs",
-    "providers/local.mjs",
-    "providers/claude.mjs",
     "README.md",
     "CONTRACT.md"
   ]

package/rank.mjs

@@ -28,8 +28,8 @@ let paths = multi('--file');
 if (!paths.length) paths = git('diff', '--name-only', base, head).split('\n').filter(Boolean);
 if (!paths.length) { console.log(asJson ? '[]' : 'rank: no paths to rank'); process.exit(0); }
 
-// the full event record (the memory provider's recall facts), ranked client-side below
-// (the provider's --file does not narrow the record, so we pull it once and filter by path here).
+// the full event record (Logbook's facts), ranked client-side below
+// (Logbook's --file does not narrow the record, so we pull it once and filter by path here).
 const EVENTS = memEvents(repo);
 
 const resolveRename = (f) => f.replace(/\{[^}]*=>\s*([^}]*)\}/g, '$1').replace(/\/{2,}/g, '/');
@@ -83,9 +83,9 @@ const DEBT_MIN = Math.max(1, +(process.env.SAWBUCK_DEBT_MIN) || 6);
 // Still-live filter + ambient debt, via the memory adapter (the Memory Contract's `debt`
 // capability), scoped to the touched paths so the per-turn hook stays cheap. A suppression on a path
 // now CLEAN of suppressions is churn, not current risk (the study: AutoMapper carries 4 live
-// `[Ignore]` vs ~158/repo across C# history). The adapter runs the provider's own detection + gating
-// and returns classified suppressions, so the glue never imports the provider's pattern. null = the
-// provider failed -> treat all as live (do not penalize); [] = genuinely clean. --raw turns it off.
+// `[Ignore]` vs ~158/repo across C# history). The adapter runs Logbook's own detection + gating
+// and returns classified suppressions, so the glue never imports its pattern. null = the
+// Logbook failed -> treat all as live (do not penalize); [] = genuinely clean. --raw turns it off.
 let liveSet = null;
 const liveDebt = new Map(); // path -> { n, skips, bare }: live suppressions, for ambient surfacing
 if (!raw && paths.length) {

package/reflect.mjs

@@ -4,7 +4,7 @@
 // Run the check (the promptwheel engine) on the latest commit; on a gamed or
 // regression result, deterministic ground truth, record a finding in the
 // memory (the logbook engine) on the touched source paths, and tick the results
-// record. Quiet by default; the dispatch surfaces catches on a cadence.
+// record. Quiet by default; the Stop hook says a fresh catch once.
 //
 // Zero-dep, Node ESM. Orchestrates the engine CLIs behind a clean layer
 // boundary, never reaching into their source.
@@ -113,7 +113,7 @@ if (!repeatOfStanding) { if (kind === 'gamed') rec.gamed += 1; else rec.regressi
 rec.latest = { sha: sha.slice(0, 8), kind, base: baseSha || null, file: evidenceFile, reason: reason.replace(/^sawbuck: /, '').slice(0, 140), at: new Date().toISOString(), by: by || null };
 writeRec();
 
-// --- 5) quiet by default (dispatch surfaces on cadence); one line to stderr -
+// --- 5) quiet by default; one line to stderr -
 process.stderr.write(`sawbuck: ${kind} recorded on ${evidenceFile}\n`);
 
 // --- the activity feed: one line per check so you can watch it work, verified

package/rules.mjs

@@ -7,7 +7,7 @@ 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;
+export 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') });
 

package/sawbuck-hook.mjs

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