sawbuck 0.1.24 → 0.1.25

package/CONTRACT.md

@@ -2,9 +2,9 @@
 
 *Put your coding agent under contract: a win counts only if it survives verification from the source alone, not because the agent said so. The terms below are not a promise the agent makes, they are a result anyone can re-prove.*
 
-**Status:** Draft v0.1 · **License:** Apache-2.0 · **Reference implementation:** [Sawbuck](https://github.com/sawbuck-ai/sawbuck) (the saddle), [promptwheel](https://github.com/promptwheel-ai/promptwheel) (the check), [@promptwheel/logbook](https://github.com/promptwheel-ai/logbook) (the default memory provider)
+**Status:** Draft v0.1 · **License:** Apache-2.0 · **Reference implementation:** [Sawbuck](https://github.com/sawbuck-ai/sawbuck) (the CLI), [promptwheel](https://github.com/promptwheel-ai/promptwheel) (the check), [@promptwheel/logbook](https://github.com/promptwheel-ai/logbook) (the default memory provider)
 
-This is an open interface for making an AI coding harness trustworthy. It defines how a loop's wins get verified, what a verdict looks like, what counts as gaming the goalposts, and how a repo's history is carried along. Any harness can emit or consume it without using this code. Sawbuck is a reference saddle that implements it; it is not the only possible one.
+This is an open interface for making an AI coding harness trustworthy. It defines how a loop's wins get verified, what a verdict looks like, what counts as gaming the goalposts, and how a repo's history is carried along. Any harness can emit or consume it without using this code. Sawbuck is a reference implementation; it is not the only possible one.
 
 The contract has one property that holds all of it together: a verdict is **deterministic and reproducible from `(base, head, config)` alone**. No LLM is in the path, and nothing is read from the agent's trajectory, so the result cannot be obfuscated against and does not change when you ask it twice.
 
@@ -39,9 +39,7 @@ The agent consumes this as a per-turn reward it cannot inflate. The harness cons
   "head": "e4f5g6h",
   "mode": "refs",
   "repeat": 3,
-  "cohort": "ci",
   "verdict": "gamed",
-  "subsystems": ["api", "auth"],
   "metrics": [
     {
       "name": "tests_pass",
@@ -87,11 +85,11 @@ A win is **`gamed`** when it does not survive a **source-only re-run**: revert e
 
 **Protected terms (declared, optionally enforced).** `evaluatorPaths` is also the declaration surface for immutability: the files a repo names there are its fixed terms, the goalposts the agent does not get to move. The baseline is detection (a win that depended on changing a protected term reads `gamed`). A stronger conformance level *enforces* it: the audit gate (CI, or a hook the agent cannot bypass) fails any change to a protected term unless a human signs off, so the terms cannot be moved mid-game. Note the honest limit: a file cannot be made truly immutable to an agent that has write access to the repo. The guarantee comes from the un-bypassable gate, not from the filesystem.
 
-**Declared override (an intentional test change).** The check flags a win that came only from moving the goalposts, not from the source. Sometimes that move is legitimate: a test that asserted the wrong thing, an obsolete test removed, a guard intentionally retired. The sanctioned way through is to DECLARE it, not to silently weaken the gate. A `Sawbuck-Allow: <reason>` trailer on the commit (or `--allow "<reason>"` for a working-tree or CI run) acknowledges the change, so a would-be `gamed` reads `pass` with the acknowledgment recorded in `allowed` (the reason, and the metric or gate names it cleared). The check does not judge intent; it forces intent to be explicit and auditable. An UNdeclared test-only win is still `gamed`; a declared one is on the record, so a reviewer sees the reason instead of a silent green. It covers the edit, the delete, and the new file alike. The declaration lives in the commit, so it is immutable and attributable: revoking it is a review act, not a deletion, and a reasonless trailer does not override.
+**Declared override (an intentional test change).** The check flags a win that came only from moving the goalposts, not from the source. Sometimes that move is legitimate: a test that asserted the wrong thing, an obsolete test removed, a guard intentionally retired. The sanctioned way through is to DECLARE it, not to silently weaken the gate. A `Sawbuck-Allow: <reason>` trailer on the commit (`Promptwheel-Allow:` is the same thing; or `--allow "<reason>"` for a working-tree or CI run) acknowledges the change, so a would-be `gamed` reads `pass` with the acknowledgment recorded in `allowed` (the reason, and the metric or gate names it cleared). The check does not judge intent; it forces intent to be explicit and auditable. An UNdeclared test-only win is still `gamed`; a declared one is on the record, so a reviewer sees the reason instead of a silent green. It covers the edit, the delete, and the new file alike. The declaration lives in the commit, so it is immutable and attributable: revoking it is a review act, not a deletion, and a reasonless trailer does not override.
 
 ## 4. The context record (the trail knowledge)
 
-A conforming saddle also carries the repo's history as deterministic memory: a ledger derived from git (hotspots, reverted approaches, suppressed or weakened tests, fragile areas), surfaced per turn as a ranked slice for the files being touched. It is a projection of git, never a second source of truth, so it is always reconstructable and never drifts from what actually happened.
+A conforming implementation also carries the repo's history as deterministic memory: a ledger derived from git (hotspots, reverted approaches, suppressed or weakened tests, fragile areas), surfaced per turn as a ranked slice for the files being touched. It is a projection of git, never a second source of truth, so it is always reconstructable and never drifts from what actually happened.
 
 ---
 
@@ -102,7 +100,7 @@ A conforming saddle also carries the repo's history as deterministic memory: a l
 - A conforming **harness** runs the check as the audit gate (so the agent cannot self-clear its own win).
 - A conforming **context record** is a deterministic projection of git (§4).
 
-An implementation may support a subset and say so. The reference saddle (Sawbuck) implements all four.
+An implementation may support a subset and say so. The reference implementation (Sawbuck) implements all four.
 
 ## Versioning
 

package/README.md

@@ -2,7 +2,7 @@
 
 **Sign your agent to a contract so it does what you want.**
 
-A saddle for your coding harness. 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 result that only passed because the agent edited the test, mocked the grader, or loosened a rule gets flagged and reverted. Deterministic, zero-LLM, un-gameable. Break it in and it carries your repo's history along: what broke in these files before, surfaced before you touch them.
+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 result that only passed because the agent edited the test, mocked the grader, or loosened a rule 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.
 
 > Sawbuck is the reference implementation of the [Verified-Outcome Contract](CONTRACT.md): the open interface for a coding loop you can trust.
 
@@ -10,27 +10,37 @@ A saddle for your coding harness. You write the contract (what a real win looks
 # 1 · try it (no install, no commitment): verify your latest change right now
 npx sawbuck check
 
-# 2 · watch it live: attach once to this repo (a project-scoped Claude Code hook)
+# 2 · enforce it: attach once to this repo
 npm i -g sawbuck
-sawbuck attach --claude
+sawbuck attach            # every commit (a git post-commit hook)
+sawbuck attach --claude   # or every Claude Code turn (a project-scoped Stop hook)
 ```
 
 **Zero-config:** it auto-detects your test command, so there is nothing to write to start.
 On attach it tells you exactly what it can measure here (and how to fix it if it can't).
-`sawbuck init` is only for *customizing* what it measures (coverage, latency, a cost budget).
-In CI instead of a local hook? use the GitHub Action. For every project at once: `sawbuck attach --user`.
+`sawbuck init` is only for *customizing* what counts (coverage, latency, a cost budget, a protected path).
+In CI, the same check runs as the [promptwheel GitHub Action](https://github.com/promptwheel-ai/promptwheel#in-ci-and-in-claude-code) (`uses: promptwheel-ai/promptwheel@v0`); the debt gate below is this repo's own Action. For every project at once: `sawbuck attach --user`.
 
-On each change:
+One entry point each: a person types `sawbuck`; CI and libraries use `promptwheel` (the engine underneath, `import { check }`). `sawbuck check` passes every `promptwheel run` flag through, so you never need both.
+
+What a check looks like:
 
 ```
 $ sawbuck check
-sawbuck: gamed recorded on test.js       (the win came from editing the test, not the source)
+🐴 🚩 gamed: a win here came from editing the test, config, or grader, not the source.
+   It does NOT survive a source-only re-run, so it does not count.
+
+$ sawbuck check        # after fixing the source and restoring the test
+🐴 ✓ verified: your working change earned it. "tests_pass" held, and the source carried the win.
 ```
 
+Exit codes: `0` verified · `1` regression · `2` gamed · `3` inconclusive · `64` could not run (not a git repo, no commit, no test command).
+
 ## What it does
 
-- **Verifies the win.** `check` re-runs your metric from the source diff alone. A faked green (a deleted, weakened, or skipped test; a mocked grader; an edited golden file) reads `gamed`. Deterministic, zero-LLM, $0, and it cannot be obfuscated against because it never reads the trajectory (89% recall on a labeled gaming benchmark).
-- **Remembers what broke.** `context` and `rank` surface the relevant history (reverts, fragile areas, test-weakening) for the files you are touching: a ranked trail guide, before you act.
+- **Verifies the win.** `check` re-runs your metric from the source diff alone. A faked green (a deleted, weakened, or skipped test; a mocked grader; an edited golden file; a loosened config) reads `gamed`. Deterministic, zero-LLM, $0, and it cannot be argued with because it never reads the trajectory. Red-teamed across 9 language ecosystems and 26 adversarial scenarios ([promptwheel/bench/REDTEAM.md](https://github.com/promptwheel-ai/promptwheel/blob/main/bench/REDTEAM.md)).
+- **Says what it cannot see.** A cheat that lives inside the source itself (a value hardcoded to the one visible case, logic keyed to the test environment) is invisible to a source-only re-run, by construction. That limit is in [the contract](CONTRACT.md#3-the-integrity-boundary-what-counts-as-gaming), not hidden.
+- **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.** `attach` touches nothing in your worktree (the hook lives in `.git/`, the record is excluded locally); `detach` is a true inverse. `trace` shows every byte it placed, and `detach --verify` proves the repo came back unchanged.
@@ -39,16 +49,16 @@ sawbuck: gamed recorded on test.js       (the win came from editing the test, no
 
 | command | what |
 |---|---|
-| `sawbuck attach [--claude \| --user]` | wire the reflex (git post-commit / project Claude hooks / user-level for every project) |
-| `sawbuck detach [--claude \| --user]` | remove it |
-| `sawbuck check [--base R --head R]` | verify a commit; record a regression or a gamed win |
-| `sawbuck context` · `sawbuck rank` | the ranked relevant history for the current change |
-| `sawbuck debt` | the whole-repo live suppression debt: what is still silenced in HEAD now, disabled tests first, heaviest files ranked |
+| `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 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 recall` | related notes for your current change from extra memory providers you compose in (bring your own) |
-| `sawbuck run --attempt '<agent cmd>'` | thin harness: load context, run one attempt through the keep-if-verified gate |
 | `sawbuck trace` · `sawbuck doctor` · `detach --verify` | show the footprint; check the attachment resolves; prove a clean removal |
-| `sawbuck where` · `sawbuck statusline` | list every repo it is attached to; a one-line status-line segment (🐴 watching / N caught) |
+| `sawbuck where` · `sawbuck statusline` | list every repo it is attached to; a one-line status-line segment (🐴 watching / N caught / steer %) |
 
 ## Give your agent the contract
 
@@ -60,7 +70,7 @@ sawbuck: gamed recorded on test.js       (the win came from editing the test, no
     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.
 
-Each repo needs a `promptwheel.config.json` saying what to measure (your tests, lint, coverage, or an eval).
+Without a `promptwheel.config.json` the check measures your detected test command. To make it count more (coverage, lint, latency, an eval) or to protect a path with a mandate, `sawbuck init` writes the config and explains each line with evidence from your history.
 
 ## Gate debt on pull requests
 
@@ -87,7 +97,7 @@ Debt also rises on its own: once attached, the per-turn `context` hook surfaces
 
 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 un-gameable source re-proof is the fixed part. Embed it with `import { check }`, or check any tool's verdict with `promptwheel conformance`.
+- **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.

package/bins.mjs

@@ -0,0 +1,23 @@
+// bins.mjs: resolve the two engine CLIs once, for every sawbuck entry point.
+// Order: env override (PW_BIN / LB_BIN), the installed package, then the dev sibling checkout.
+// The memory engine is reached only through memory.mjs (the Memory Contract seam); LB lives
+// here so the resolver is written once, not per file.
+
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+function resolveBin(envVar, pkgSubpath, devPath) {
+  if (process.env[envVar]) return process.env[envVar];
+  // deep bin subpath (no-exports pkgs, e.g. promptwheel), then the bare package name
+  // (pkgs whose exports map "." to the bin, e.g. @promptwheel/logbook), then the dev sibling.
+  const bare = pkgSubpath.replace(/\/bin\/[^/]*$/, '');
+  for (const spec of [pkgSubpath, bare]) { try { return require.resolve(spec); } catch {} }
+  return devPath;
+}
+
+export const PW = resolveBin('PW_BIN', 'promptwheel/bin/promptwheel.mjs', join(HERE, '..', 'promptwheel', 'bin', 'promptwheel.mjs'));
+export const LB = resolveBin('LB_BIN', '@promptwheel/logbook/bin/logbook.mjs', join(HERE, '..', 'logbook', 'bin', 'logbook.mjs'));

package/init.mjs

@@ -17,23 +17,9 @@
 
 import { execFileSync } from 'node:child_process';
 import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
 import { createInterface } from 'node:readline';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-const engineBin = (envVar, pkgSubpath, devPath) => {
-  if (process.env[envVar]) return process.env[envVar];
-  // deep bin subpath (no-exports pkgs, e.g. promptwheel), then the bare package name
-  // (pkgs whose exports map "." to the bin, e.g. @promptwheel/logbook), then the dev sibling.
-  const bare = pkgSubpath.replace(/\/bin\/[^/]*$/, '');
-  for (const spec of [pkgSubpath, bare]) { try { return require.resolve(spec); } catch {} }
-  return devPath;
-};
-const PW = engineBin('PW_BIN', 'promptwheel/bin/promptwheel.mjs', join(HERE, '..', 'promptwheel', 'bin', 'promptwheel.mjs'));
-const LB = engineBin('LB_BIN', '@promptwheel/logbook/bin/logbook.mjs', join(HERE, '..', 'logbook', 'bin', 'logbook.mjs'));
+import { PW, LB } from './bins.mjs';
 
 const argv = process.argv.slice(2);
 const has = (f) => argv.includes(f);
@@ -145,7 +131,7 @@ function report() {
   for (const m of cfg.metrics) out('    - ' + describeMetric(m));
   if (evidence) { out('\n  investigated this repo:'); for (const l of evidenceLines()) out(l); }
   out('\n  next:  sawbuck attach           # enforce the contract every commit');
-  out('         sawbuck run --working    # gate your uncommitted changes now');
+  out('         sawbuck check            # verify your uncommitted changes now');
 }
 
 function runWizard() {

package/memory.mjs

@@ -14,28 +14,21 @@
 // never by printing []. git-truth stays authoritative; other providers add supplementary notes.
 
 import { execFileSync } from 'node:child_process';
-import { createRequire } from 'node:module';
 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 require = createRequire(import.meta.url);
 
-function logbookBin() {
-  if (process.env.SAWBUCK_MEMORY_BIN) return process.env.SAWBUCK_MEMORY_BIN; // back-compat single-provider override
-  if (process.env.LB_BIN) return process.env.LB_BIN;
-  for (const spec of ['@promptwheel/logbook/bin/logbook.mjs', '@promptwheel/logbook']) { try { return require.resolve(spec); } catch {} }
-  return join(HERE, '..', 'logbook', 'bin', 'logbook.mjs');
-}
 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: logbookBin(), dialect: 'logbook' };
+    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
   });

package/package.json

@@ -1,13 +1,31 @@
 {
   "name": "sawbuck",
-  "version": "0.1.24",
-  "description": "Sign your agent to a contract so it does what you want: a deterministic, zero-LLM check that re-proves every win from the agent's source edits alone, so a green that came from editing the test is caught and reverted. A saddle for your coding harness.",
+  "version": "0.1.25",
+  "description": "Sign your agent to a contract: a deterministic, zero-LLM check re-proves every win from the agent's source edits alone, so a green that came from editing the test, grader, or config is caught and sent back. Works in Claude Code, Codex, git hooks, and CI.",
   "type": "module",
   "license": "Apache-2.0",
+  "engines": {
+    "node": ">=18"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sawbuck-ai/sawbuck.git"
   },
+  "homepage": "https://sawbuck.ai",
+  "bugs": {
+    "url": "https://github.com/sawbuck-ai/sawbuck/issues"
+  },
+  "keywords": [
+    "ai-agents",
+    "claude-code",
+    "codex",
+    "reward-hacking",
+    "code-quality",
+    "ci",
+    "git-hooks",
+    "developer-tools",
+    "promptwheel"
+  ],
   "scripts": {
     "test": "node --test"
   },
@@ -15,11 +33,12 @@
     "sawbuck": "sawbuck.mjs"
   },
   "dependencies": {
-    "promptwheel": "^0.7.0",
-    "@promptwheel/logbook": "^0.9.0"
+    "@promptwheel/logbook": "^0.9.6",
+    "promptwheel": "^0.7.5"
   },
   "files": [
     "sawbuck.mjs",
+    "bins.mjs",
     "init.mjs",
     "reflect.mjs",
     "dispatch.mjs",
@@ -28,14 +47,11 @@
     "debt.mjs",
     "status.mjs",
     "memory.mjs",
-    "yank.mjs",
     "providers/obsidian.mjs",
     "providers/mem0.mjs",
     "providers/local.mjs",
     "providers/claude.mjs",
-    "run.mjs",
     "README.md",
-    "GLOSSARY.md",
     "CONTRACT.md"
   ]
 }

package/rank.mjs

@@ -45,7 +45,7 @@ const codeish = (p) => /\.(m?[jt]sx?|cjs|py|go|rs|rb|java|kt|c|cc|cpp|h|hpp|php|
 // eslint-disable). The relevance lead: sharpen the signal, don't flatten it.
 const isTest = (p) => /(^|\/)(tests?|__tests__|specs?)\//i.test(p) || /[._-](test|spec)\.[a-z0-9]+$/i.test(p) || /(^|\/)test_[^/]+\.py$/i.test(p);
 
-// Per-language suppression normalization. The 100-repo study (STUDY-100.md) found a suppression's
+// Per-language suppression normalization. A 100-repo study found a suppression's
 // raw count is an idiom artifact, not a risk level: a `# noqa` is background noise in Python (141
 // markers/repo) but a `t.Skip` is notable in Go. So a hit is discounted by how ubiquitous its
 // idiom is in the FILE's language. Discount-only [0.4, 1]: common idioms shrink, rare ones stay at
@@ -80,7 +80,7 @@ const normMult = (p, kind) => {
 // with SAWBUCK_DEBT_MIN. This is how debt rises by itself in the per-turn context, no command run.
 const DEBT_MIN = Math.max(1, +(process.env.SAWBUCK_DEBT_MIN) || 6);
 
-// Still-live filter (lead #4) + ambient debt, via the memory adapter (the Memory Contract's `debt`
+// 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

package/reflect.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// reflect.mjs, the Sawbuck feedback edge (M0).
+// reflect.mjs, the Sawbuck feedback edge.
 //
 // Run the check (the promptwheel engine) on the latest commit; on a gamed or
 // regression result, deterministic ground truth, record a finding in the
@@ -18,23 +18,12 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
 import { record as memRecord } from './memory.mjs';
+import { PW } from './bins.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-// Resolve the check engine CLI: env override, then the installed package (published
-// install), then the monorepo sibling (dev checkout). The MEMORY engine is reached only
-// through memory.mjs (the Memory Contract seam), never resolved or shelled directly here.
-const engineBin = (envVar, pkgSubpath, devPath) => {
-  if (process.env[envVar]) return process.env[envVar];
-  // deep bin subpath (no-exports pkgs, e.g. promptwheel), then the bare package name
-  // (pkgs whose exports map "." to the bin, e.g. @promptwheel/logbook), then the dev sibling.
-  const bare = pkgSubpath.replace(/\/bin\/[^/]*$/, '');
-  for (const spec of [pkgSubpath, bare]) { try { return require.resolve(spec); } catch {} }
-  return devPath;
-};
-const PW = engineBin('PW_BIN', 'promptwheel/bin/promptwheel.mjs', join(HERE, '..', 'promptwheel', 'bin', 'promptwheel.mjs'));
+// The MEMORY engine is reached only through memory.mjs (the Memory Contract seam), never
+// resolved or shelled directly here.
 
 const flag = (name, def) => { const i = process.argv.indexOf(name); return i > -1 ? process.argv[i + 1] : def; };
 const repo = flag('--repo', process.cwd());
@@ -83,8 +72,8 @@ const reason = kind === 'gamed'
 
 // --- 3) record the finding in memory (unreviewed, machine-authored note) ----
 // The Memory Contract's `record` capability, through the adapter (no direct engine shell here).
-// M0 keeps it simple: a commit-attached digest note. M1 adds --span grounding
-// + true coupling (the fix diff -> "change X also needs Y").
+// Kept simple: a commit-attached digest note. A later pass could add --span grounding
+// and true coupling (the fix diff -> "change X also needs Y").
 memRecord(repo, { sha, reason: reason.slice(0, 280), side: 'diff', evidenceFile, by: 'sawbuck' });
 
 // --- 4) tick the results record (the visible proof-of-work) -----------------

package/sawbuck-hook.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// sawbuck-hook.mjs: the Sawbuck Claude Code Stop-hook entry (M0).
+// 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.
 // Zero-dep. Usage (wired as a Stop hook): node sawbuck-hook.mjs --repo <path>

package/sawbuck.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// sawbuck, the saddle CLI. Zero-dep.
+// sawbuck, the CLI. Zero-dep.
 // `attach` wires Sawbuck's reflex into a repo (a git post-commit hook by default,
 // or Claude Code hooks); `detach` removes it and leaves the repo exactly as it
 // was. Isolation invariant: the repo never imports Sawbuck, and detach is a true
@@ -17,18 +17,12 @@ import { readFileSync, writeFileSync, existsSync, chmodSync, mkdirSync, unlinkSy
 import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
-import { createRequire } from 'node:module';
 import { recall as memRecall, conform as memConform } from './memory.mjs';
-import { tally, resolveSessionPath } from './yank.mjs';
+import { PW } from './bins.mjs';
 
 const SELF = fileURLToPath(import.meta.url);
 const HERE = dirname(SELF);
 const HOOK = join(HERE, 'sawbuck-hook.mjs');
-const require = createRequire(import.meta.url);
-// resolve the promptwheel engine bin: env override, installed package, then the dev sibling
-const PW = process.env.PW_BIN
-  || ['promptwheel/bin/promptwheel.mjs', 'promptwheel'].reduce((r, s) => { try { return r || require.resolve(s); } catch { return r; } }, '')
-  || join(HERE, '..', 'promptwheel', 'bin', 'promptwheel.mjs');
 // run the engine and parse its JSON verdict (it prints JSON even when it exits nonzero)
 function gateReport(repo, a) {
   let o = '', code = 0;
@@ -61,51 +55,45 @@ const dry = flags.has('--dry-run');
 let version = '0.0.0';
 try { version = JSON.parse(readFileSync(join(HERE, 'package.json'), 'utf8')).version; } catch {}
 
-const help = `sawbuck ${version}: a saddle for your repo
+const help = `sawbuck ${version}: sign your agent to a contract
 
 Usage:
+  sawbuck check [repo] [--base R --head R] [--repeat N] [--allow "<reason>"] [--json]
+                            Verify your latest change right now (working tree if dirty, else the last
+                            commit, or the range you name). Zero-config, no attach, no hook. The
+                            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]
-                            Generate the contract (promptwheel.config.json): a stack starter, tuned and
-                            explained by what your git history shows actually breaks. Also writes a short
-                            contract guide into AGENTS.md so your agent knows the rules (--no-agent-block
-                            to skip). Wizard in a terminal, non-interactive in a pipe/CI/agent (or --yes).
-  sawbuck attach [repo]     Wire Sawbuck into a repo (default: a git post-commit hook)
-      --claude              instead wire project Claude Code hooks (writes .claude/settings.local.json)
+                            Write the contract (promptwheel.config.json), tuned and explained by 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                wire USER-LEVEL Claude hooks that profile-switch by cwd (attach once, every project)
+      --user                user-level Claude hooks that follow your cwd (attach once, every project)
       --dry-run             print the exact footprint it would leave, and write nothing
   sawbuck detach [repo] [--claude | --user] [--all] [--verify] [--purge]
-                            Remove Sawbuck and restore the repo; --verify proves it came back clean;
-                            --purge also deletes the record (.sawbuck/, zero trace); --all does every repo
-  sawbuck trace [repo]      Show exactly what Sawbuck has placed in this repo (the footprint)
-  sawbuck doctor [repo]     Check attachments are healthy (hook still resolves to a live sawbuck); --all for every repo
+                            Remove it and restore the repo (no flag: whatever is attached here); --verify
+                            proves it came back clean; --purge also deletes the record (.sawbuck/)
+  sawbuck status [repo]     The inventory: caught over time + debt accruing now + whether it is armed. --json
+  sawbuck log [repo] [-n N] Recent checks, newest first (verified / gamed / regression)
+  sawbuck debt [repo] [--since REF] [--fail-on undocumented|test|any|N]
+                            The live suppression debt in HEAD, risk-ranked, undocumented flagged. --since REF
+                            shows only what a branch adds; --fail-on exits nonzero (a CI gate)
+  sawbuck context [repo]    Relevant history for the files you are changing (reverts, weakened tests, hot spots)
+
+  sawbuck trace [repo]      Show every file Sawbuck has placed in this repo (the footprint)
+  sawbuck doctor [repo]     Check the attachment still resolves to a live sawbuck; --all for every repo
   sawbuck where             List every repo Sawbuck is attached to
-  sawbuck statusline        One-line segment for your status line (🐴 watching | N caught)
-  sawbuck status [repo]     The inventory: everything it has accumulated here, in one view, caught
-                            over time + debt accruing now + whether it is armed. --json for the feed
-  sawbuck log [repo] [-n N] Recent activity, newest first: every check (verified / gamed / regression)
-  sawbuck check [repo]      Try it: verify your latest change right now (working tree if dirty, else the
-                            last commit). Zero-config, no attach, no hook. The fastest way to see it work.
-  sawbuck rank [--base R --head R] [--file P ...]
-                            Show the relevant past findings for the paths a change touches
-  sawbuck context [repo]    Ranked relevant history for your current working changes (the read face)
-  sawbuck recall [repo]     Related notes for your current changes from extra memory providers
-                            (SAWBUCK_MEMORY=logbook,obsidian + OBSIDIAN_VAULT); supplementary to context
+  sawbuck statusline        One-line segment for your status line (🐴 watching | N caught | steer %)
+
+  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 debt [repo] [--since REF] [--fail-on undocumented|test|any|N]
-                            The whole-repo live suppression debt: what is still silenced in HEAD now,
-                            risk-ranked (severity x file fragility), undocumented flagged. --since REF
-                            shows only the debt a branch adds; --fail-on exits nonzero for a CI gate
-  sawbuck run --attempt '<cmd>' [--loops N]
-                            Thin harness: load context, run one attempt through the keep-if-verified gate
-  sawbuck yank [--session <path>] [--json]
-                            The steering meter: how much you had to steer (yank the reins) this session,
-                            read from your Claude Code transcript. The check guards the turns you did not
-                            steer — a miss there is the risk. Yank rate falling = the reins getting looser.
   sawbuck --help | --version
 
-Rides two engines: promptwheel (the check) + @promptwheel/logbook (memory).`;
+Engines: promptwheel (the check) + @promptwheel/logbook (memory). Zero-LLM, offline, free.`;
 
 const die = (msg) => { process.stderr.write(`sawbuck: ${msg}\n`); process.exit(1); };
 const out = (s) => process.stdout.write(s.endsWith('\n') ? s : s + '\n');
@@ -130,22 +118,42 @@ switch (cmd) {
     // one-shot: gate your latest change right now (working tree if dirty, else the last commit),
     // zero-config (the engine auto-detects your test command), and say plainly whether the win was
     // earned. No attach, no hook, no record. The try-it-first on-ramp.
-    const repo = repoArg();
+    // `sawbuck check` IS `promptwheel run` with a plain-spoken verdict: every engine flag passes
+    // through (--base/--head/--repeat/--allow/--json/--no-detect-gaming), so there is one entry
+    // point for a person and the engine stays the one for CI and libraries.
+    const VALUE_FLAGS = new Set(['--base', '--head', '--repeat', '--allow']);
+    const pass = []; const pos = []; let json = false, base = null, head = null;
+    for (let i = 0; i < rest.length; i++) {
+      const a = rest[i];
+      if (a === '--json') { json = true; continue; }
+      if (VALUE_FLAGS.has(a)) { const v = rest[++i]; if (v == null) die(`${a} needs a value`); if (a === '--base') base = v; else if (a === '--head') head = v; else pass.push(a, v); continue; }
+      if (a.startsWith('--')) { pass.push(a); continue; }
+      pos.push(a);
+    }
+    const repo = resolve(pos[0] || '.');
     // stderr ignored so a benign failing probe (e.g. rev-parse HEAD~1 on a one-commit repo) does not
     // leak a scary "fatal:" line before sawbuck's own message.
     const g = (...a) => { try { return execFileSync('git', ['-C', repo, ...a], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return ''; } };
-    const dirty = g('status', '--porcelain').length > 0;
+    // 64 (EX_USAGE) for every "could not run" below, never a verdict code: a script or CI must not read it as gamed (2).
+    if (!g('rev-parse', '--git-dir')) { out(`🐴 sawbuck: ${repo} is not a git repo. The check re-proves a change against git history, so run it inside one (git init, then commit).`); process.exit(64); }
+    if (!g('rev-parse', '--verify', 'HEAD')) { out('🐴 sawbuck: no commit yet. Make one, then `sawbuck check` verifies your next change against it.'); process.exit(64); }
+    const dirty = !base && !head && g('status', '--porcelain').length > 0;
     // nothing to verify yet: a clean tree with no previous commit to diff against (a fresh repo). Say so
     // plainly instead of the generic "could not run" below, so the first run is not a dead end.
-    if (!dirty && !g('rev-parse', '--verify', 'HEAD~1')) { out('🐴 sawbuck: nothing to verify yet, the working tree is clean and this is the only commit. Make a change (or add one more commit), then `sawbuck check` re-proves the win from your source edits alone.'); process.exit(2); }
-    const where = dirty ? 'working' : 'last';
-    const { rep, code } = gateReport(repo, dirty ? ['run', '--working'] : ['run', '--base', 'HEAD~1', '--head', 'HEAD']);
-    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(2); }
+    if (!dirty && !base && !g('rev-parse', '--verify', 'HEAD~1')) { out('🐴 sawbuck: nothing to verify yet, the working tree is clean and this is the only commit. Make a change (or add one more commit), then `sawbuck check` re-proves the win from your source edits alone.'); process.exit(64); }
+    const where = dirty ? 'working' : (base || head) ? `${base || 'HEAD~1'}..${head || 'HEAD'}` : 'last';
+    const args = dirty ? ['run', '--working'] : ['run', '--base', base || 'HEAD~1', '--head', head || 'HEAD'];
+    const { rep, code } = gateReport(repo, [...args, ...pass]);
+    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]' : ''}`);
     if (rep.verdict === 'pass') out(`🐴 ✓ verified: your ${where} change earned it. ${m ? '"' + m.name + '"' : 'The metric'} held, and the source carried the win (it survives a source-only re-run).`);
     else if (rep.verdict === 'gamed') out('🐴 🚩 gamed: a win here came from editing the test, config, or grader, not the source. It does NOT survive a source-only re-run, so it does not count.');
+    else if (rep.verdict === 'fail' && (rep.mandates || []).length) out('🐴 ✗ sent back: a hard rule in the contract was broken, however green the rest is.');
     else if (rep.verdict === 'fail') out(`🐴 ✗ regression: a guarded metric got worse (${(rep.metrics || []).filter((x) => x.guard && !x.ok).map((x) => x.name).join(', ') || 'a guard'}).`);
     else out('🐴 ≈ inconclusive: the check ran but could not measure your metric (it did not run in isolation). Point it at your real test command: `sawbuck init`, or set setup/linkDirs in promptwheel.config.json.');
+    if (rep.gate && rep.gate.changed) out(`🐴 ⚠ the gate definition changed in this change (fingerprint ${rep.gate.fingerprint.base} -> ${rep.gate.fingerprint.head}): a metric, guard, evaluatorPath or mandate was added, removed or edited.`);
     process.exit(code);
   }
   case 'log': {
@@ -223,11 +231,6 @@ switch (cmd) {
     out(r.pass ? '   ✓ conforms to the Memory Contract.' : '   ✗ does not conform (see above).');
     process.exit(r.pass ? 0 : 1);
   }
-  case 'run': {
-    try { execFileSync(process.execPath, [join(HERE, 'run.mjs'), ...rest], { stdio: 'inherit' }); }
-    catch (e) { process.exit(e.status || 1); }
-    break;
-  }
   case '__hook': {
     try { execFileSync(process.execPath, [HOOK, ...rest], { stdio: 'inherit' }); } catch (e) { process.exit(e.status || 0); }
     break;
@@ -246,7 +249,14 @@ switch (cmd) {
     const repo = repoArg();
     if (flags.has('--user')) unwireClaude(repo, { user: true });
     else if (flags.has('--claude')) unwireClaude(repo, {});
-    else unwireGit(repo);
+    else {
+      // no flag: reverse whatever this repo's receipt says is attached (git and/or project Claude
+      // hooks), so a bare `detach` is always the inverse of the `attach` you ran.
+      const a = readManifest(manifestPath(repo)).attachments || {};
+      const hasClaude = !!(a.claude || a['claude-shared']);
+      if (hasClaude) unwireClaude(repo, {});
+      if (a.git || !hasClaude) unwireGit(repo);
+    }
     if (purge) purgeRecord(repo);
     if (flags.has('--verify')) verifyClean(repo);
     break;
@@ -270,40 +280,27 @@ switch (cmd) {
         const mem = existsSync(join(repo, 'LOGBOOK.md')) || existsSync(join(repo, 'events.jsonl'));
         const seg = caught > 0 ? `🐴 sawbuck · ${caught} caught` : active ? `🐴 sawbuck · watching` : armed ? `🐴 sawbuck · ready` : mem ? `🐴 sawbuck · memory` : '';
         const base = seg ? (last ? `${seg} · ${last}` : seg) : '';
-        // the live steering readout, when the wrapper forwards the session transcript path
-        let yk = '';
-        const ti = rest.findIndex((a) => a === '--transcript' || a === '--session');
-        if (ti > -1 && rest[ti + 1]) { try { const { yanks, turns } = tally(readFileSync(rest[ti + 1], 'utf8')); if (turns) yk = `🪢 ${yanks}/${turns} yanks`; } catch {} }
         // 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.steeringRate || 0) * 100); st = `${p >= 50 ? '🪢' : '🐎'} steer ${p}%`; } } catch {}
-        const outp = [base, yk, st].filter(Boolean).join(' · ');
+        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 {}
+        // configurable template: SAWBUCK_STATUSLINE picks which segments show and in what order
+        // (tokens {status} {sawbuck} {verdict} {steer} plus any literal text); empty tokens collapse
+        // so you never get a dangling separator. Unset = the default composition. Mix in other
+        // tools (git branch, model, your own adapters) by composing in your statusline script.
+        const tpl = process.env.SAWBUCK_STATUSLINE;
+        let outp;
+        if (tpl && tpl.trim()) {
+          const tok = { status: base, sawbuck: seg, verdict: last, steer: st };
+          outp = tpl.replace(/\{(status|sawbuck|verdict|steer)\}/g, (_, k) => tok[k] || '')
+                    .replace(/\s*·\s*·\s*/g, ' · ').replace(/^\s*·\s*/, '').replace(/\s*·\s*$/, '').replace(/\s{2,}/g, ' ').trim();
+        } else {
+          outp = [base, st].filter(Boolean).join(' · ');
+        }
         if (outp) process.stdout.write(outp);
       }
     } catch {}
     break;
   }
-  case 'yank': {
-    // the live steering meter (the reins hook): how much did you have to steer this session?
-    // A MIRROR read from the Claude Code transcript; the check guards the turns you did NOT steer.
-    const si = rest.findIndex((a) => a === '--session' || a === '--transcript');
-    const sess = resolveSessionPath(si > -1 ? rest[si + 1] : null, process.cwd());
-    if (!sess) { out('🐴 sawbuck: no session transcript found to read (pass --session <path.jsonl>).'); process.exit(2); }
-    let text = ''; try { text = readFileSync(sess, 'utf8'); } catch { out('🐴 sawbuck: could not read the session transcript.'); process.exit(2); }
-    const { turns, yanks, rate, recent } = tally(text);
-    if (flags.has('--json')) { out(JSON.stringify({ turns, yanks, rate, recent })); break; }
-    const pct = Math.round(rate * 100);
-    out('🐴 reins: steering this session');
-    if (yanks === 0) {
-      out(`   0 hard yanks across ${turns} turns — you did not have to pull the reins hard.`);
-    } else {
-      out(`   ${yanks} hard yank${yanks === 1 ? '' : 's'} across ${turns} turns (${pct}%) — times you pulled me back hard.`);
-      if (turns - yanks > 0) out(`   the check guards the other ${turns - yanks} turns you trusted me with — a miss there is the risk.`);
-      if (recent.length) out(`   recent: ${recent.map((r) => '"' + r + '"').join(' · ')}`);
-    }
-    out('   (terse course-corrections only; the full steer rate, incl. discursive redirects, is the harvest layer.)');
-    break;
-  }
   default: die(`unknown command '${cmd}'\n\n${help}`);
 }
 
@@ -371,7 +368,7 @@ function wireGit(repo) {
   const pc = join(repo, '.git', 'hooks', 'post-commit');
   const existed = existsSync(pc);
   let body = existed ? readFileSync(pc, 'utf8') : '#!/bin/sh\n';
-  if (body.includes(S_START)) { out(`sawbuck: already attached (git) in ${repo}`); warnNoConfig(repo); return; }
+  if (body.includes(S_START)) { out(`sawbuck: already attached (git) in ${repo}`); return; }
   if (!body.startsWith('#!')) body = '#!/bin/sh\n' + body;
   if (!body.endsWith('\n')) body += '\n';
   if (dry) {
@@ -390,7 +387,6 @@ function wireGit(repo) {
   writeManifest(manifestPath(repo), m);
   regAdd(repo, 'git');
   out(`sawbuck: attached (git post-commit) in ${repo}`);
-  warnNoConfig(repo);
 }
 function unwireGit(repo) {
   const pc = join(repo, '.git', 'hooks', 'post-commit');
@@ -426,7 +422,7 @@ 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.`); } }
-  if (JSON.stringify(cfg).includes('sawbuck.mjs')) { out(`sawbuck: already attached (${user ? 'user' : 'claude'}) in ${f}`); if (!user) warnNoConfig(repo); return; }
+  if (JSON.stringify(cfg).includes('sawbuck.mjs')) { out(`sawbuck: already attached (${user ? 'user' : 'claude'}) in ${f}`); return; }
   const ctx = user ? `node ${JSON.stringify(SELF)} context` : `node ${JSON.stringify(SELF)} context ${JSON.stringify(repo)}`;
   const chk = user ? `node ${JSON.stringify(SELF)} __hook --by claude --stop` : `node ${JSON.stringify(SELF)} __hook --repo ${JSON.stringify(repo)} --by claude --stop`;
   if (dry) {
@@ -456,7 +452,6 @@ function wireClaude(repo, opts) {
   out(`sawbuck: wired ${user ? 'USER-LEVEL' : shared ? 'shared project' : 'project'} Claude Code hooks in ${f}`);
   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)');
-  if (!user) warnNoConfig(repo);
 }
 function unwireClaude(repo, { user }) {
   const mp = user ? userManifestPath() : manifestPath(repo);
@@ -595,7 +590,3 @@ function detachAll(purge) {
 
 // --- shared helpers ---------------------------------------------------------
 function dryText(plan) { return ['sawbuck --dry-run: would leave this footprint (writing nothing):', ...plan.map((p) => '  ' + p), '  all of it reversible with `detach`.'].join('\n'); }
-function warnNoConfig() {
-  // superseded by verifyAttach, which runs after every attach and reports exactly what the check
-  // can measure (zero-config now auto-detects your test command, so a missing config is not an error).
-}

package/GLOSSARY.md

@@ -1,73 +0,0 @@
-# Sawbuck: Glossary & Controlled Vocabulary
-
-Sawbuck is a saddle: an isolated layer you attach to a repo that fits its shape
-and responds when the repo moves. It reads the history (via its memory provider,
-logbook by default) and a small config of what to measure, runs the check when a
-change lands, and surfaces the relevant past finding before the agent repeats a
-known mistake.
-
-## The rule: one plain surface
-
-Earlier drafts split terms into a "brand/human" surface (a mining metaphor) and a
-plain "agent-facing" surface. That split is retired. There is now ONE surface, and
-it is plain and scientific. The saddle is the brand and the architecture spine
-(the name, `attach`, `fit`); it is NOT a vocabulary for every concept.
-
-Why plain wins everywhere: an LLM has strong trained priors on words like
-`regression`, `verified`, `gamed`. Metaphor jargon in the model's context forces
-a gloss every session (token cost) and risks a misread (trajectory drift). Plain,
-high-prior words serve the human reader and the agent equally, so we do not keep
-two vocabularies.
-
-## Canonical terms
-
-| concept | term | notes |
-|---|---|---|
-| the product | **Sawbuck** | the only brand word |
-| the memory (the role) | **memory**; default provider **Logbook** | the relevant history + live debt for what you touch. logbook (a lab logbook: plain, scientific) is a standalone product and the default fill; the role is a socket, swap your own via the Memory Contract |
-| the verifier | **the check** (verb: *verify*) | runs the metrics on a change |
-| a change that improved and holds | **verified** | |
-| a change that made a guarded metric worse | **regression** | do-not-retry |
-| a change that passed by faking the metric | **gamed** | the win came from editing the test, config, or grader, not the source (the engine verdict, and the word every Sawbuck surface uses) |
-| the accumulated record of outcomes | **results** | `results.json` |
-| what Sawbuck leaves you | **verified history** | the findings you can trust |
-| a surfaced past outcome | **finding** | |
-| mounting Sawbuck to a repo | **attach** / **cinch** | `sawbuck attach <repo>` |
-| reading the repo's shape | **fit** | history + config; a concept, not a command (it is what `attach` reads to decide what it can measure) |
-| code still silenced in HEAD now | **debt** (suppression debt) | disabled/weakened tests + lint/type suppressions still live; `sawbuck debt` ranks it by severity and file fragility |
-| the one-view accumulation | **inventory** | `sawbuck status`: what it has caught over time + the debt accruing now + whether it is armed here |
-
-## The two interfaces (a socket and a standard)
-
-Sawbuck composes two roles, and they are open in opposite directions. Keeping them
-straight is what stops "Sawbuck, then logbook?" confusion: logbook is not a second
-brand bolted on, it is the default fill for one of the two roles.
-
-- **the check** is a *standard we publish* (the Verified-Outcome Contract, see
-  CONTRACT.md): other tools conform to it, or embed it. promptwheel is the reference
-  implementation. It is not swappable, because the un-gameable source re-proof is the
-  asset; what you plug in is *what to measure*.
-- **the memory** is a *socket we expose*: you fill it with any provider. logbook is
-  the default, carried along so it works out of the box, and it is its own product you
-  can also run on its own.
-
-In one line: the check is a standard for others to meet; the memory is a socket for
-others to fill.
-
-## The one humility rule
-
-Findings are **leads, not conclusions**, verify against the diff before acting.
-
-## Dispatch template
-
-```
-Sawbuck · {N} regressions charted · {N} gamed changes caught
-   🆕 just learned: {reason} ({file})
-```
-
-## Note on engine verdicts
-
-The check engine emits verdicts (`gamed`, `fail`, `pass`); the surface keeps **gamed**
-as-is (it is vivid and used on every surface) and maps `fail` → **regression** and
-`pass` → **verified**. ("Invalid" was an earlier softening of `gamed` that no surface
-adopted; `gamed` is canonical.)

package/run.mjs

@@ -1,47 +0,0 @@
-#!/usr/bin/env node
-// run.mjs, the thin reference harness. Each loop: load context, run ONE attempt
-// through the keep-if-verified gate, repeat. It loops primitives that already
-// exist (sawbuck context + promptwheel improve + YOUR agent); it is NOT an
-// orchestrator (no planning, routing, or queue, that is the platform's job).
-// Usage:  node run.mjs --attempt '<agent cmd>' [--loops N] [--repo P]
-//   the attempt cmd can read $SAWBUCK_CONTEXT (a file of the ranked relevant history).
-
-import { execFileSync } from 'node:child_process';
-import { createRequire } from 'node:module';
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-const bin = (envVar, pkg, dev) => { if (process.env[envVar]) return process.env[envVar]; const bare = pkg.replace(/\/bin\/[^/]*$/, ''); for (const s of [pkg, bare]) { try { return require.resolve(s); } catch {} } return dev; };
-const PW = bin('PW_BIN', 'promptwheel/bin/promptwheel.mjs', join(HERE, '..', 'promptwheel', 'bin', 'promptwheel.mjs'));
-
-const arg = (n, d) => { const i = process.argv.indexOf(n); return i > -1 ? process.argv[i + 1] : d; };
-const repo = arg('--repo', process.cwd());
-const attempt = arg('--attempt', null);
-const loops = Math.max(1, parseInt(arg('--loops', '1'), 10) || 1);
-if (!attempt) { process.stderr.write("sawbuck run: --attempt '<agent cmd>' is required\n"); process.exit(2); }
-
-const context = () => { try { return execFileSync(process.execPath, [join(HERE, 'sawbuck.mjs'), 'context', repo], { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }); } catch (e) { return (e.stdout || '').toString(); } };
-const parseResult = (s) => { try { return JSON.parse(s.slice(s.indexOf('{'), s.lastIndexOf('}') + 1)).result || 'error'; } catch { return 'error'; } };
-
-const scratch = mkdtempSync(join(tmpdir(), 'sawbuck-run-'));
-let kept = 0;
-try {
-  for (let i = 1; i <= loops; i++) {
-    const ctxFile = join(scratch, `context-${i}.md`);
-    writeFileSync(ctxFile, context() || 'no prior findings yet.\n');   // load the trajectory
-    let result;
-    try {
-      const out = execFileSync(process.execPath, [PW, 'improve', '--attempt', attempt, '--json'],
-        { cwd: repo, encoding: 'utf8', env: { ...process.env, SAWBUCK_CONTEXT: ctxFile, PW_PLAYBOOK: ctxFile }, timeout: 600000, stdio: ['ignore', 'pipe', 'ignore'] });
-      result = parseResult(out);
-    } catch (e) { result = parseResult((e.stdout || '').toString()); }
-    if (result === 'kept') kept++;
-    process.stdout.write(`sawbuck run: loop ${i}/${loops} -> ${result}\n`);
-    if (result === 'plateau' || result === 'error') break;   // nothing left to improve, or it broke
-  }
-} finally { rmSync(scratch, { recursive: true, force: true }); }
-process.stdout.write(`sawbuck run: ${kept} verified improvement${kept === 1 ? '' : 's'} kept\n`);

package/yank.mjs

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-// yank.mjs — the live steering meter (the "reins" hook). Reads the current Claude
-// Code session transcript and counts YANKS: turns where you corrected or redirected
-// the agent. Deterministic, zero-dep, with a transparent definition shown in the
-// output. It is a MIRROR — a number about how much you had to steer this session —
-// and it pairs with the check: the check guards the turns you did NOT steer, where
-// a miss is the real risk. The yank rate falling over time is the reins getting
-// looser (the agent learning your cues).
-//
-// A yank is counted CONSERVATIVELY (precision over recall): a human turn, after the
-// agent has acted, that OPENS by correcting or redirecting ("no", "don't",
-// "actually", "stop", "undo", "instead", ...). Discursive steers buried mid-
-// paragraph are deliberately NOT counted here — that is the LLM-harvest layer's job;
-// this stays cheap, instant, and honest (an undercount with a clear definition beats
-// an inflated guess).
-
-import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-
-// leading correction/redirect markers at the START of the turn (case-insensitive)
-const LEAD = /^\s*["'(]?\s*(no\b|no,|nope\b|don'?t\b|do not\b|actually\b|wait\b|stop\b|undo\b|revert\b|instead\b|nah\b|hold on|rather\b|not (that|like|quite|what|really)|that'?s (not|wrong)|hmm,? ?no|why (did|are) you|you (shouldn'?t|weren'?t))/i;
-
-function humanText(o) {
-  if (!o || o.type !== 'user' || o.isMeta) return null;
-  if (o.userType && o.userType !== 'external') return null;
-  const c = o.message && o.message.content;
-  if (typeof c === 'string') return c;
-  if (Array.isArray(c)) {
-    if (c.some((b) => b && b.type === 'tool_result')) return null;      // tool output, not you
-    const t = c.filter((b) => b && b.type === 'text').map((b) => b.text || '').join(' ');
-    return t || null;
-  }
-  return null;
-}
-const isNoise = (t) => {
-  const s = t.trim();
-  if (s.includes('<task-notification>') || s.startsWith('<task-id>')) return true; // injected
-  if (s.replace(/\[Image #\d+\]/g, '').trim().length < 3) return true;             // image-only
-  return false;
-};
-
-// tally(transcriptText) -> { turns, yanks, rate, recent } over YOUR typed turns.
-export function tally(text) {
-  let turns = 0, yanks = 0, seenHuman = false, prevAssistantActed = false;
-  const recent = [];
-  for (const line of String(text).split('\n')) {
-    if (!line.trim()) continue;
-    let o; try { o = JSON.parse(line); } catch { continue; }
-    if (o.type === 'assistant') { prevAssistantActed = true; continue; }
-    const t = humanText(o);
-    if (t === null || isNoise(t)) continue;
-    const opener = !seenHuman; seenHuman = true;
-    turns++;
-    if (!opener && prevAssistantActed && LEAD.test(t)) {
-      yanks++;
-      recent.push(t.replace(/\s+/g, ' ').trim().slice(0, 48));
-    }
-    prevAssistantActed = false;
-  }
-  return { turns, yanks, rate: turns ? yanks / turns : 0, recent: recent.slice(-5) };
-}
-
-// Resolve the newest session transcript for a cwd. Claude Code stores transcripts
-// under ~/.claude/projects/<encoded-cwd>/<id>.jsonl (path separators -> dashes).
-// Best-effort: prefer the dir matching this cwd, else the newest across all. Never throws.
-export function resolveSessionPath(explicit, cwd = process.cwd()) {
-  if (explicit) return existsSync(explicit) ? explicit : null;
-  const root = join(homedir(), '.claude', 'projects');
-  if (!existsSync(root)) return null;
-  const key = cwd.replace(/[^A-Za-z0-9]/g, '-');
-  let dirs = [];
-  try { dirs = readdirSync(root).map((d) => join(root, d)).filter((p) => { try { return statSync(p).isDirectory(); } catch { return false; } }); }
-  catch { return null; }
-  const matched = dirs.filter((p) => p.endsWith('/' + key));
-  const pool = matched.length ? matched : dirs;
-  let best = null, bestT = 0;
-  for (const full of pool) {
-    let files = []; try { files = readdirSync(full); } catch { continue; }
-    for (const f of files) {
-      if (!f.endsWith('.jsonl')) continue;
-      const p = join(full, f);
-      try { const st = statSync(p); if (st.mtimeMs > bestT) { bestT = st.mtimeMs; best = p; } } catch {}
-    }
-  }
-  return best;
-}