sawbuck 0.1.36 → 0.1.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sawbuck",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "description": "Sign your agent to a contract: a deterministic, zero-LLM check re-proves each win from the agent's source edits alone, so a test that went green by editing the test, grader, or config is sent back. For Claude Code, with Codex support in beta.",
   "type": "module",
   "license": "Apache-2.0",

package/sawbuck-hook.mjs

@@ -124,7 +124,16 @@ if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
     const committedHit = hits.some((h) => h.files.some((f) => committedSince.includes(f)));
     const accept = committedHit ? ' To accept this change on purpose, change the mandate in the contract or revert the path.' : '';
     const 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.)';
-    logActivity({ kind: 'mandate', file: hits[0].files[0], reason: `mandate ${hits[0].name} violated in the working tree`, by: by || 'hook' });
+    // 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) {
+      st.mandateCountedPrompt = promptId;
+      const r = readRec() || { regressions: 0, gamed: 0, latest: null };
+      r.mandates = (r.mandates || 0) + 1;
+      r.lastMandate = { name: hits[0].name, file: hits[0].files[0], at: now };
+      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();

package/sawbuck.mjs

@@ -15,7 +15,7 @@
 import { execFileSync } from 'node:child_process';
 import { erasedBlock } from './rewrites.mjs';
 import { readFileSync, writeFileSync, existsSync, chmodSync, mkdirSync, unlinkSync, rmdirSync, rmSync, readdirSync } from 'node:fs';
-import { join, dirname, resolve } from 'node:path';
+import { basename, join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import { recall as memRecall, conform as memConform } from './memory.mjs';
@@ -190,7 +190,7 @@ switch (cmd) {
     if (!lines.length) { out('sawbuck: no activity recorded yet (the check logs here on each commit/turn).'); break; }
     const ni = rest.indexOf('-n');
     const n = ni > -1 ? (parseInt(rest[ni + 1], 10) || 20) : 20;
-    const icon = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive: '≈', allowed: '✎' };
+    const icon = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive: '≈', allowed: '✎', mandate: '⛔' };
     const recent = lines.slice(-n).reverse();
     out(`sawbuck activity (last ${recent.length}):`);
     for (const l of recent) {
@@ -344,10 +344,12 @@ switch (cmd) {
   case 'statusline': {
     // compact status-line segment for the cwd repo. Never throws; fast.
     try {
-      const repo = process.cwd();
-      if (existsSync(join(repo, '.git'))) {
+      const repo = gitTop(process.cwd());
+      if (!repo) process.stdout.write('🐴 sawbuck · no repo here');
+      if (repo) {
+        const name = basename(repo);
         let caught = 0;
-        try { const r = JSON.parse(readFileSync(join(repo, '.sawbuck', 'results.json'), 'utf8')); caught = (r.regressions || 0) + (r.gamed || 0); } catch {}
+        try { const r = JSON.parse(readFileSync(join(repo, '.sawbuck', 'results.json'), 'utf8')); caught = (r.regressions || 0) + (r.gamed || 0) + (r.mandates || 0); } catch {}
         // the last verdict from the activity feed (includes verified passes), so you see it working each turn
         let last = '';
         try { const L = readFileSync(join(repo, '.sawbuck', 'activity.jsonl'), 'utf8').trim().split('\n'); const e = JSON.parse(L[L.length - 1]); last = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive: '≈', allowed: '✎' }[e.kind] || ''; } catch {}
@@ -355,20 +357,22 @@ switch (cmd) {
         const active = existsSync(join(repo, '.sawbuck', 'state.json'));
         const armed = existsSync(join(repo, 'promptwheel.config.json')) || existsSync(join(repo, 'package.json'));
         const mem = existsSync(join(repo, 'LOGBOOK.md')) || existsSync(join(repo, 'events.jsonl'));
-        const seg = caught > 0 ? `🐴 sawbuck · ${caught} caught` : active ? `🐴 sawbuck · watching` : armed ? `🐴 sawbuck · ready` : mem ? `🐴 sawbuck · memory` : '';
-        const base = seg ? (last ? `${seg} · ${last}` : seg) : '';
+        const label = caught > 0 ? `${caught} caught` : active ? 'watching' : armed ? 'ready' : mem ? 'memory' : '';
+        const seg = label ? `🐴 sawbuck · ${label}` : '';
+        const named = label ? `🐴 sawbuck · ${name} · ${label}` : '';   // which repo it detected, in the default line
+        const base = named ? (last ? `${named} · ${last}` : named) : '';
         // live steering % from the reins engine's file (OFFLINE read; reins does the LLM work, never sawbuck)
         let st = '';
         try { const sj = JSON.parse(readFileSync(join(repo, '.sawbuck', 'steer.json'), 'utf8')); if (sj && sj.scored) { const p = Math.round(((sj.ema != null ? sj.ema : sj.steeringRate) || 0) * 100); st = `${p >= 50 ? '✊' : '🐎'} steer ${p}%`; } } catch {}
         // configurable template: SAWBUCK_STATUSLINE picks which segments show and in what order
-        // (tokens {status} {sawbuck} {verdict} {steer} plus any literal text); empty tokens collapse
+        // (tokens {status} {sawbuck} {repo} {verdict} {steer} plus any literal text); empty tokens collapse
         // so you never get a dangling separator. Unset = the default composition. Mix in other
         // 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] || '')
+          const tok = { status: base, sawbuck: seg, repo: label ? name : '', verdict: last, steer: st };
+          outp = tpl.replace(/\{(status|sawbuck|repo|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(' · ');
@@ -522,6 +526,12 @@ export function nodeCmd(execPath = process.execPath, platform = process.platform
 }
 function wireClaude(repo, opts) {
   const { user, shared } = opts;
+  // user-level hooks already cover every repo; a second set would run each check twice and spend the
+  // send-back budget twice as fast. --shared is a deliberate team file, so it is written anyway.
+  if (!user && !shared) {
+    const uf = claudeFile(repo, { user: true }).f;
+    try { if (readFileSync(uf, 'utf8').includes('sawbuck.mjs')) { out(`sawbuck: already watching here through your user-level hooks (${uf}); nothing to add`); return; } } catch {}
+  }
   const { dir, f } = claudeFile(repo, opts);
   const dirExisted = existsSync(dir);
   const fileExisted = existsSync(f);

package/status.mjs

@@ -22,17 +22,17 @@ const readJSON = (p) => { try { return JSON.parse(readFileSync(p, 'utf8')); } ca
 const readLines = (p) => { try { return readFileSync(p, 'utf8').split('\n').filter(Boolean); } catch { return []; } };
 const git = (...a) => { try { return execFileSync('git', ['-C', repo, ...a], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return ''; } };
 
-const ICON = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive: '≈', allowed: '✎' };
+const ICON = { verified: '✓', gamed: '🚩', regression: '✗', inconclusive: '≈', allowed: '✎', mandate: '⛔' };
 
 // --- 1) the outcome record: what the check has done here -------------------
 // results.json holds the all-time catch tally (gamed + regression, never trimmed); activity.jsonl is
 // the recent per-check feed (verified included, capped ~200). We read both and keep each honest.
 const results = readJSON(join(repo, '.sawbuck', 'results.json')) || {};
 const feed = readLines(join(repo, '.sawbuck', 'activity.jsonl')).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-const tally = { verified: 0, gamed: 0, regression: 0, inconclusive: 0, allowed: 0 };
+const tally = { verified: 0, gamed: 0, regression: 0, inconclusive: 0, allowed: 0, mandate: 0 };
 for (const e of feed) if (e && tally[e.kind] != null) tally[e.kind]++;
 const seen = feed.length;
-const catchesAllTime = (results.regressions || 0) + (results.gamed || 0);
+const catchesAllTime = (results.regressions || 0) + (results.gamed || 0) + (results.mandates || 0);
 const latest = results.latest || (feed.length ? feed[feed.length - 1] : null);
 const since = feed.length ? (feed[0].at || '').slice(0, 10) : null;
 // the steer rate, if the reins judge has been scoring turns here (an OFFLINE read of its file; the
@@ -89,6 +89,7 @@ if (seen || catchesAllTime) {
     const parts = [
       tally.verified ? `${ICON.verified} ${tally.verified} verified` : '',
       tally.gamed ? `${ICON.gamed} ${tally.gamed} gamed` : '',
+      tally.mandate ? `${ICON.mandate} ${tally.mandate} protected path${tally.mandate === 1 ? '' : 's'}` : '',
       tally.regression ? `${ICON.regression} ${tally.regression} regression${tally.regression === 1 ? '' : 's'}` : '',
       tally.inconclusive ? `${ICON.inconclusive} ${tally.inconclusive} inconclusive` : '',
       tally.allowed ? `${ICON.allowed} ${tally.allowed} allowed` : '',