sawbuck 0.1.43 → 0.1.45

package/rank.mjs

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

package/reflect.mjs

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

package/repo-state.mjs

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

package/rules.mjs

@@ -7,7 +7,7 @@ import { homedir } from 'node:os';
 import { readHistory, typedText } from './history.mjs';
 
 const MAX_LINES = 3000;
-const SECRET = /(sk-[a-z0-9_-]{16,}|gh[pousr]_[a-z0-9]{20,}|github_pat_\w{20,}|AKIA[0-9A-Z]{16}|xox[baprs]-[\w-]{10,}|eyJ[\w-]{20,}\.[\w-]{10,}|-----BEGIN [A-Z ]*PRIVATE KEY|\b[a-f0-9]{40,}\b|(password|passwd|secret|token|api[_-]?key)\s*[:=]\s*\S+)/i;
+export const SECRET = /(sk-[a-z0-9_-]{16,}|gh[pousr]_[a-z0-9]{20,}|github_pat_\w{20,}|AKIA[0-9A-Z]{16}|xox[baprs]-[\w-]{10,}|eyJ[\w-]{20,}\.[\w-]{10,}|-----BEGIN [A-Z ]*PRIVATE KEY|\b[a-f0-9]{40,}\b|(password|passwd|secret|token|api[_-]?key)\s*[:=]\s*\S+)/i;
 const norm = (s) => s.toLowerCase().replace(/\s+/g, ' ').trim();
 const paths = (home) => ({ dir: join(home, '.sawbuck'), input: join(home, '.sawbuck', 'rule-input.txt') });
 

package/sawbuck-hook.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 import { ensureExcluded } from './exclude.mjs';
 // sawbuck-hook.mjs: the Sawbuck Claude Code Stop-hook entry.
-// Each turn: if a new commit landed, run reflect on it; then render the dispatch
-// on a fresh catch OR every N turns (config). State in .sawbuck/state.json.
+// Each turn: if a new commit landed, run reflect on it; then say so once on a fresh catch. State in .sawbuck/state.json.
 // Zero-dep. Usage (wired as a Stop hook): node sawbuck-hook.mjs --repo <path>
 
 import { execFileSync } from 'node:child_process';
@@ -32,7 +31,6 @@ const node = (f, a) => { try { return execFileSync(process.execPath, [f, ...a],
 
 let cfg = {};
 try { cfg = JSON.parse(readFileSync(join(repo, 'sawbuck.config.json'), 'utf8')); } catch {}
-const EVERY_TURNS = 5;
 
 const stDir = join(repo, '.sawbuck');
 const stPath = join(stDir, 'state.json');
@@ -72,6 +70,20 @@ st.turns += 1;
 // 2) the record of what the check has charted (read above, after any re-run)
 const total = rec ? (rec.regressions || 0) + (rec.gamed || 0) + (rec.mandates || 0) : 0;
 const saveState = () => { try { mkdirSync(stDir, { recursive: true }); writeFileSync(stPath, JSON.stringify(st, null, 2) + '\n'); } catch {} };
+// the budget is per prompt: prompt_id when the harness sends one, else the prompt's own timestamp (written by
+// `sawbuck turn --hook`), never a constant that would spend it for good
+const promptId = hookInput.prompt_id || st.lastPromptAt || 'none';
+// Send the turn back, at most enforce.maxBlocks times per prompt, then let it end with a warning: it can never
+// loop, because the harness's own block cap resets on every tool call.
+const sendBack = (idKey, countKey, reason, stillOpen) => {
+  const max = +(cfg.enforce?.maxBlocks) || 3;
+  if (st[idKey] !== promptId) { st[idKey] = promptId; st[countKey] = 0; }
+  const spent = (st[countKey] || 0) >= max;
+  if (!spent) st[countKey] = (st[countKey] || 0) + 1;
+  saveState();
+  process.stdout.write(JSON.stringify(spent ? { systemMessage: `Sawbuck stopped blocking after ${max} tries: ${stillOpen}` } : { decision: 'block', reason }));
+  process.exit(0);
+};
 
 // 2b) THE WALL AT TURN LEVEL (Claude Code Stop hook only): a mandate is checked against the WORKING
 // tree on every stop, not only on commits, because an agent usually ends a turn with uncommitted
@@ -112,18 +124,13 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
   } else if (st.lastViolation) { delete st.lastViolation; }
   saveState();
   if (hits.length) {
-    const MAX_BLOCKS = +(cfg.enforce?.maxBlocks) || 3;
-    // the budget is per prompt: prompt_id when the harness sends one, else the prompt's own timestamp
-    // (written by `sawbuck turn --hook`), never a constant that would spend the budget for good
-    const promptId = hookInput.prompt_id || st.lastPromptAt || 'none';
-    if (st.mandatePromptId !== promptId) { st.mandatePromptId = promptId; st.mandateBlocks = 0; }
     const desc = hits.map((h) => `"${h.name}"${h.reason ? ' (' + h.reason + ')' : ''}: ${h.files.join(', ')}${h.committed ? ' [this rule is in the committed contract; editing promptwheel.config.json in the working tree does not lift it]' : ''}`).join('; ');
     const spared = leftAlone.length ? ` Edits that were already there before this prompt were left out of this check and must stay as they are: ${leftAlone.join(', ')}.` : '';
     const before = (st.lastViolation && st.lastViolation.before) || {};
     const restore = Object.keys(before).length ? ' To put back what you overwrote: ' + Object.entries(before).map(([f, h]) => `restore ${f} to the content it had when the prompt began: git cat-file -p ${h} > ${f}`).join('; ') + '.' : '';
     const committedHit = hits.some((h) => h.files.some((f) => committedSince.includes(f)));
     const accept = committedHit ? ' To accept this change on purpose, change the rule in the contract or revert the path.' : '';
-    const upgrade = base ? '' : ' (No prompt baseline is recorded in this repo, so edits a person made before the prompt cannot be told apart from yours: ask them to run sawbuck attach --claude again, which upgrades the hooks.)';
+    const upgrade = base ? '' : ' (No prompt baseline is recorded in this repo, so edits a person made before the prompt cannot be told apart from yours: ask them to run sawbuck attach again, which upgrades the hooks.)';
     // one catch per prompt, however many times the turn is sent back. Kept beside rec.latest, never in it:
     // a block must not replace a gamed verdict that is still standing.
     if (st.mandateCountedPrompt !== promptId) {
@@ -134,15 +141,7 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
       writeRec(r);
       logActivity({ kind: 'mandate', file: hits[0].files[0], reason: `mandate ${hits[0].name} violated in the working tree`, by: by || 'hook' });
     }
-    if ((st.mandateBlocks || 0) < MAX_BLOCKS) {
-      st.mandateBlocks = (st.mandateBlocks || 0) + 1;
-      saveState();
-      process.stdout.write(JSON.stringify({ decision: 'block', reason: `Sawbuck: a protected path in the contract was touched, the turn is not done. Protected paths changed in this turn: ${desc}. Undo the changes YOU made under the protected paths and make the fix elsewhere; do not revert anything you did not change (the rule is a wall, not a reminder; the gate fails any change that touches them).${spared}${restore}${accept}${upgrade}` }));
-      process.exit(0);
-    }
-    saveState();
-    process.stdout.write(JSON.stringify({ systemMessage: `Sawbuck stopped blocking after ${MAX_BLOCKS} tries: protected paths are still changed (${desc}).` }));
-    process.exit(0);
+    sendBack('mandatePromptId', 'mandateBlocks', `Sawbuck: a protected path in the contract was touched, the turn is not done. Protected paths changed in this turn: ${desc}. Undo the changes YOU made under the protected paths and make the fix elsewhere; do not revert anything you did not change (the rule is a wall, not a reminder; the gate fails any change that touches them).${spared}${restore}${accept}${upgrade}`, `protected paths are still changed (${desc}).`);
   }
 }
 
@@ -152,21 +151,9 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
 // bound a tool-using agent on its own. Opt out with SAWBUCK_NO_ENFORCE=1 (falls back to a flag).
 const gamedThisTurn = rec && rec.latest && rec.latest.kind === 'gamed' && rec.latest.sha === (head || '').slice(0, 8);
 if (stop && gamedThisTurn && !process.env.SAWBUCK_NO_ENFORCE) {
-  const MAX_BLOCKS = +(cfg.enforce?.maxBlocks) || 3;
-  const promptId = hookInput.prompt_id || st.lastPromptAt || 'none';
-  if (st.blockPromptId !== promptId) { st.blockPromptId = promptId; st.blockCount = 0; }
   st.shownTotal = total;
   const where = rec.latest.file;
-  if ((st.blockCount || 0) < MAX_BLOCKS) {
-    st.blockCount = (st.blockCount || 0) + 1;
-    saveState();
-    const reason = `Sawbuck: the win on ${where} was gamed. It came from editing the test or config, not the source, so it did not survive a source-only re-run. The turn is not done: fix the source so the metric passes on its own, then finish.`;
-    process.stdout.write(JSON.stringify({ decision: 'block', reason }));
-    process.exit(0);
-  }
-  saveState();   // budget spent: let the turn end, but warn loudly so it never loops forever
-  process.stdout.write(JSON.stringify({ systemMessage: `Sawbuck stopped blocking after ${MAX_BLOCKS} tries: the win on ${where} is still gamed and needs a real source fix.` }));
-  process.exit(0);
+  sendBack('blockPromptId', 'blockCount', `Sawbuck: the win on ${where} was gamed. It came from editing the test or config, not the source, so it did not survive a source-only re-run. The turn is not done: fix the source so the metric passes on its own, then finish.`, `the win on ${where} is still gamed and needs a real source fix.`);
 }
 
 // 3b) THE LOCK AT TURN LEVEL: tell the person the moment a turn changes the repo's structure or its resolved
@@ -188,12 +175,10 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE && st.turnBaseline && st.turnBaselin
   }
 }
 
-// 4) otherwise, surface a catch on a fresh catch or on cadence (a flag; never blocks)
-const freshCatch = total > (st.shownTotal || 0);
-const cadenceHit = st.turns % EVERY_TURNS === 0;
-if (freshCatch || cadenceHit) {
-  const out = node(join(HERE, 'dispatch.mjs'), ['--repo', repo]);
-  if (out.trim()) process.stdout.write(out.endsWith('\n') ? out : out + '\n');
+// 4) otherwise, say a fresh catch once (a flag; never blocks). The band and statusline carry the rest.
+if (total > (st.shownTotal || 0)) {
+  const L = rec && rec.latest;
+  process.stdout.write(`🐴 Sawbuck caught a ${L && L.kind === 'gamed' ? 'gamed change' : 'problem'}${L && L.file ? ` in ${L.file}` : ''}${L && L.reason ? `: ${L.reason}` : ''}\n`);
   st.shownTotal = total;
 }
 saveState();