sawbuck 0.1.24 → 0.1.26

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,18 @@ 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 frame` | the contract's hard rules (mandates, inherited ones included) as one compact block; silent without a contract |
+| `sawbuck turn` | frame + context in one block: what `attach --claude` runs on every prompt and again right after a compaction |
 | `sawbuck recall` | related notes for your current change from extra memory providers you compose in (bring your own) |
-| `sawbuck 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 +72,9 @@ 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).
+**Measured, not assumed.** On a scenario whose natural fix sits inside a protected module, driven past two forced compactions (and again on Haiku, and under "urgent hotfix" pressure): with no rule the agent edited the protected file 17 of 17 times; with a rule in any form, including a mandate, 0 of 45. The model honors a rule it was told. The gate is for the rule nobody told it, the session that outlived the summary, and the proof that it held: `attach --claude` re-reads the mandates from the repo on every turn, re-impresses them after a compaction (`sawbuck turn`), and blocks a turn that leaves a protected path changed. Numbers and method: [sawbuck.ai/contracts](https://sawbuck.ai/contracts).
+
+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 +101,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/contract.mjs

@@ -0,0 +1,50 @@
+// contract.mjs: the contract's hard rules, read the way promptwheel reads them. Shared by the CLI
+// (frame / turn) and the Stop hook (the turn-level wall), so there is one resolver and one renderer.
+// Read-only, never throws, zero-dep.
+import { readFileSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+
+// mandates accumulate down the `extends` chain; a local mandate of the same name overrides an inherited one
+export function resolvedMandates(repo) {
+  const seen = new Set(); const byName = new Map();
+  const load = (file) => {
+    const p = resolve(file); if (seen.has(p)) return; seen.add(p);
+    let cfg = null; try { cfg = JSON.parse(readFileSync(p, 'utf8')); } catch { return; }
+    if (!cfg || typeof cfg !== 'object') return;
+    const ext = cfg.extends == null ? [] : Array.isArray(cfg.extends) ? cfg.extends : [cfg.extends];
+    for (const e of ext) if (typeof e === 'string') load(resolve(dirname(p), e));
+    for (const m of (Array.isArray(cfg.mandates) ? cfg.mandates : [])) if (m && m.name) byName.set(String(m.name), m);
+  };
+  load(join(repo, 'promptwheel.config.json'));
+  return [...byName.values()].filter((m) => Array.isArray(m.paths) && m.paths.some((s) => typeof s === 'string' && s.trim()));
+}
+
+// the same glob dialect as promptwheel's evaluatorPaths / mandates (ported verbatim): a bare name
+// matches that basename at any depth; a pattern with "/" is anchored at the repo root; "*" stops at
+// "/", "**" crosses it, "?" is one char; a leading "/" anchors to the root explicitly.
+export function globToRe(glob) {
+  let g = glob; const anchored = g.startsWith('/'); if (anchored) g = g.slice(1);
+  const body = g.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*/g, '\x00').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]').replace(/\x00/g, '.*');
+  const pre = (anchored || glob.includes('/')) ? '^' : '(^|/)';
+  return new RegExp(`${pre}${body}$`);
+}
+
+// which changed paths violate which mandate: [{ name, reason, files }]
+export function mandateHits(repo, changedPaths) {
+  const out = [];
+  for (const m of resolvedMandates(repo)) {
+    const res = m.paths.filter((s) => typeof s === 'string' && s.trim()).map(globToRe);
+    const files = changedPaths.filter((f) => res.some((re) => re.test(f)));
+    if (files.length) out.push({ name: String(m.name), reason: m.reason ? String(m.reason).slice(0, 300) : '', files: files.slice(0, 20) });
+  }
+  return out;
+}
+
+// the prompt face of the contract: one compact block, or '' when there is no contract
+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');
+}

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
   });
@@ -103,7 +96,7 @@ const classify = (r, source) => ({
   file: r.file, line: r.line, kind: String(r.kind ?? '').trim(), content: r.content ?? '',
   since: r.since ?? null, sha: r.sha ?? null,
   documented: r.content ? isDocumented(r.content) : false,
-  testSkip: isTestSkip(r.kind ?? r.content ?? ''),
+  testSkip: typeof r.testSkip === 'boolean' ? r.testSkip : isTestSkip(r.kind ?? r.content ?? ''),   // logbook >=0.9.8 classifies it; the regex is the fallback for older providers
   source,
 });
 

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.26",
+  "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,13 @@
     "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",
+    "contract.mjs",
     "init.mjs",
     "reflect.mjs",
     "dispatch.mjs",
@@ -28,14 +48,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,15 +1,16 @@
 #!/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>
 
 import { execFileSync } from 'node:child_process';
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, appendFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
+import { mandateHits } from './contract.mjs';
 const flag = (n, d) => { const i = process.argv.indexOf(n); return i > -1 ? process.argv[i + 1] : d; };
 const repo = flag('--repo', process.cwd());
 const by = flag('--by', '');   // attribution from the harness wiring: the Claude hook passes 'claude', the raw-git hook passes nothing
@@ -46,6 +47,31 @@ try { rec = JSON.parse(readFileSync(join(stDir, 'results.json'), 'utf8')); } cat
 const total = rec ? (rec.regressions || 0) + (rec.gamed || 0) : 0;
 const saveState = () => { try { mkdirSync(stDir, { recursive: true }); writeFileSync(stPath, JSON.stringify(st, null, 2) + '\n'); } catch {} };
 
+// 2b) THE WALL AT TURN LEVEL (Claude Code Stop hook only): a mandate is checked against the WORKING
+// tree on every stop, not only on commits, because an agent usually ends a turn with uncommitted
+// edits. A deterministic path match, milliseconds, no metric run. Block the stop (bounded per prompt)
+// and send the agent back to revert the protected files and make the fix elsewhere.
+if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
+  const changed = [...new Set([...git('diff', '--name-only', 'HEAD').split('\n'), ...git('ls-files', '--others', '--exclude-standard').split('\n')].filter(Boolean))];
+  const hits = changed.length ? mandateHits(repo, changed) : [];
+  if (hits.length) {
+    const MAX_BLOCKS = +(cfg.enforce?.maxBlocks) || 3;
+    const promptId = hookInput.prompt_id || 'none';
+    if (st.mandatePromptId !== promptId) { st.mandatePromptId = promptId; st.mandateBlocks = 0; }
+    const desc = hits.map((h) => `"${h.name}"${h.reason ? ' (' + h.reason + ')' : ''}: ${h.files.join(', ')}`).join('; ');
+    try { mkdirSync(stDir, { recursive: true }); appendFileSync(join(stDir, 'activity.jsonl'), JSON.stringify({ at: new Date().toISOString(), kind: 'mandate', file: hits[0].files[0], reason: `mandate ${hits[0].name} violated in the working tree`, by: by || 'hook' }) + '\n'); } catch {}
+    if ((st.mandateBlocks || 0) < MAX_BLOCKS) {
+      st.mandateBlocks = (st.mandateBlocks || 0) + 1;
+      saveState();
+      process.stdout.write(JSON.stringify({ decision: 'block', reason: `Sawbuck: a mandate in the contract was violated, the turn is not done. Protected paths changed: ${desc}. Revert every change under the protected paths and make the fix elsewhere (the rule is a wall, not a reminder; the gate fails any change that touches them).` }));
+      process.exit(0);
+    }
+    saveState();
+    process.stdout.write(JSON.stringify({ systemMessage: `Sawbuck stopped blocking after ${MAX_BLOCKS} tries: protected paths are still changed (${desc}).` }));
+    process.exit(0);
+  }
+}
+
 // 3) CONTRACT ENFORCEMENT (Claude Code Stop hook only): if THIS turn's commit was gamed,
 // block the stop and send the agent back to earn the green in the source. Bounded per
 // prompt, because Claude Code's built-in block cap resets on every tool call and so cannot

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,13 @@ 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';
+import { frameBlock } from './contract.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 +56,48 @@ 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 frame [repo]      The contract's hard rules (mandates, inherited ones included) as one compact block;
+                            silent without a contract (--speak explains)
+  sawbuck turn [repo]       frame + context in one block: what attach --claude runs on every prompt
+
+  sawbuck 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 +122,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': {
@@ -178,23 +190,23 @@ switch (cmd) {
     catch (e) { process.exit(e.status || 1); }
     break;
   }
-  case 'context': {
-    // the read face: ranked relevant history for what you're working on right now.
+  case 'context': { const o = contextBlock(repoArg(), flags.has('--speak')); if (o) out(o); break; }
+  case 'frame': {
+    // the prompt face of the contract: re-impress the hard rules (mandates, resolved through `extends`)
+    // as one compact block at the live end of the context, so a deep or freshly compacted session
+    // cannot forget them. Silent without a contract; --speak explains instead.
+    const o = frameBlock(repoArg());
+    if (o) out(o);
+    else if (flags.has('--speak')) out('🐴 sawbuck frame: no mandates in promptwheel.config.json yet. Add one (a protected path) and this re-asserts it every turn and after every compaction, so a deep context cannot forget it.');
+    break;
+  }
+  case 'turn': {
+    // the ONE per-prompt hook: the contract frame (forward: what must hold) and the relevant history
+    // (backward: what broke here before) in a single block, one process per prompt. Silent when
+    // there is nothing to say. Wired by `attach --claude` on UserPromptSubmit and after a compaction.
     const repo = repoArg();
-    const g = (...a) => { try { return execFileSync('git', ['-C', repo, ...a], { encoding: 'utf8' }).trim(); } catch { return ''; } };
-    // Silent when there is nothing to say, so it is safe on every UserPromptSubmit (that
-    // hook's stdout is injected into context; "nothing notable" every turn would be noise).
-    // --speak forces a reply, for an explicit `sawbuck context` / the /sawbuck-context command.
-    const speak = flags.has('--speak');
-    let changed = g('diff', '--name-only', 'HEAD').split('\n').filter(Boolean);
-    if (!changed.length) changed = g('diff', '--name-only', 'HEAD~1', 'HEAD').split('\n').filter(Boolean);
-    if (!changed.length) { if (speak) out('🐴 sawbuck: nothing changed to look up (no working edits, and no previous commit to read).'); break; }
-    const fileArgs = changed.flatMap((f) => ['--file', f]);
-    let o = '';
-    try { o = execFileSync(process.execPath, [join(HERE, 'rank.mjs'), '--repo', repo, ...fileArgs, '--top', '3'], { encoding: 'utf8' }); }
-    catch (e) { o = (e.stdout || '').toString(); }
-    if (/relevant history/.test(o)) out(o);
-    else if (speak) out('🐴 sawbuck: no notable history for the files you are touching (a clean trail).');
+    const o = [frameBlock(repo), contextBlock(repo, false)].filter(Boolean).join('\n');
+    if (o) out(o);
     break;
   }
   case 'recall': {
@@ -223,11 +235,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 +253,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,43 +284,47 @@ 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}`);
 }
 
+// --- the per-turn block: frame (forward, from contract.mjs) + context (backward) ---------------
+// the read face: ranked relevant history for what you're working on right now. Silent when there is
+// nothing to say, so it is safe on every UserPromptSubmit (that hook's stdout is injected into context;
+// "nothing notable" every turn would be noise). `speak` forces a reply for the explicit command.
+function contextBlock(repo, speak) {
+  const g = (...a) => { try { return execFileSync('git', ['-C', repo, ...a], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return ''; } };
+  let changed = g('diff', '--name-only', 'HEAD').split('\n').filter(Boolean);
+  if (!changed.length) changed = g('diff', '--name-only', 'HEAD~1', 'HEAD').split('\n').filter(Boolean);
+  if (!changed.length) return speak ? '🐴 sawbuck: nothing changed to look up (no working edits, and no previous commit to read).' : '';
+  const fileArgs = changed.flatMap((f) => ['--file', f]);
+  let o = '';
+  try { o = execFileSync(process.execPath, [join(HERE, 'rank.mjs'), '--repo', repo, ...fileArgs, '--top', '3'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }); }
+  catch (e) { o = (e.stdout || '').toString(); }
+  if (/relevant history/.test(o)) return o.trimEnd();
+  return speak ? '🐴 sawbuck: no notable history for the files you are touching (a clean trail).' : '';
+}
+
 // after attach, prove the check can actually measure something here (the inert-metric trap):
 // run the gate on the last commit and say what it can or cannot measure, so you never attach
 // into silent nothing. Best-effort and bounded; the wire already succeeded regardless.
@@ -371,7 +389,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 +408,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,23 +443,26 @@ 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; }
-  const ctx = user ? `node ${JSON.stringify(SELF)} context` : `node ${JSON.stringify(SELF)} context ${JSON.stringify(repo)}`;
+  if (JSON.stringify(cfg).includes('sawbuck.mjs')) { out(`sawbuck: already attached (${user ? 'user' : 'claude'}) in ${f}`); return; }
+  const ctx = user ? `node ${JSON.stringify(SELF)} turn` : `node ${JSON.stringify(SELF)} turn ${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) {
     out(dryText([
-      `${fileExisted ? 'modify' : 'create'}  ${f}  (UserPromptSubmit + Stop hooks)`,
+      `${fileExisted ? 'modify' : 'create'}  ${f}  (UserPromptSubmit + SessionStart[compact] + Stop hooks: the per-turn block, and the check)`,
       user ? null : `exclude ${excludeFile(repo)}  (${RECORD_DIRS.join(', ')}${shared ? '' : ', .claude/settings.local.json'})`,
       `create  ${user ? userManifestPath() : manifestPath(repo)}  (attach receipt)`,
     ].filter(Boolean)));
     return;
   }
   cfg.hooks = cfg.hooks || {};
-  const put = (event, command) => {
+  const put = (event, command, matcher) => {
     cfg.hooks[event] = (cfg.hooks[event] || []).filter((h) => !JSON.stringify(h).includes('sawbuck.mjs'));
-    cfg.hooks[event].push({ hooks: [{ type: 'command', command }] });
+    cfg.hooks[event].push({ ...(matcher ? { matcher } : {}), hooks: [{ type: 'command', command }] });
   };
   put('UserPromptSubmit', ctx);
+  // right after a compaction the summary has just dropped detail: re-impress the contract frame and the
+  // relevant history there too (SessionStart with the `compact` source injects stdout into context).
+  put('SessionStart', ctx, 'compact');
   put('Stop', chk);
   mkdirSync(dir, { recursive: true });
   writeFileSync(f, JSON.stringify(cfg, null, 2) + '\n');
@@ -456,7 +476,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);
@@ -487,7 +506,7 @@ function unwireClaude(repo, { user }) {
 }
 function removeClaudeEntries(cfg) {
   if (!cfg.hooks) return;
-  for (const ev of ['UserPromptSubmit', 'Stop']) {
+  for (const ev of ['UserPromptSubmit', 'SessionStart', 'Stop']) {
     if (!Array.isArray(cfg.hooks[ev])) continue;
     cfg.hooks[ev] = cfg.hooks[ev].filter((h) => !JSON.stringify(h).includes('sawbuck.mjs'));
     if (!cfg.hooks[ev].length) delete cfg.hooks[ev];     // no empty [] residue
@@ -595,7 +614,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;
-}