sawbuck 0.1.27 → 0.1.28

package/contract.mjs

@@ -2,7 +2,12 @@
 // (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';
+import { join, dirname, resolve, isAbsolute, posix } from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+const gitOut = (repo, args) => execFileSync('git', args, { cwd: repo, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+const validMandate = (m) => m && Array.isArray(m.paths) && m.paths.some((s) => typeof s === 'string' && s.trim());
+const pathsOf = (m) => m.paths.filter((s) => typeof s === 'string' && s.trim());
 
 // mandates accumulate down the `extends` chain; a local mandate of the same name overrides an inherited one
 export function resolvedMandates(repo) {
@@ -16,7 +21,54 @@ export function resolvedMandates(repo) {
     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()));
+  return [...byName.values()].filter(validMandate);
+}
+
+// the mandates COMMITTED at `ref` (default HEAD), read with `git show` and following `extends` inside
+// the repo, the way promptwheel reads a gate at a ref. [] when there is no config there.
+export function resolvedMandatesAt(repo, ref = 'HEAD') {
+  const seen = new Set(); const byName = new Map();
+  const load = (p) => {
+    if (seen.has(p)) return; seen.add(p);
+    let raw = null; try { raw = gitOut(repo, ['show', `${ref}:${p}`]); } catch { return; }
+    let cfg = null; try { cfg = JSON.parse(raw); } 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' && !isAbsolute(e)) load(posix.normalize(posix.join(posix.dirname(p), e.split('\\').join('/'))));
+    for (const m of (Array.isArray(cfg.mandates) ? cfg.mandates : [])) if (m && m.name) byName.set(String(m.name), m);
+  };
+  load('promptwheel.config.json');
+  return [...byName.values()].filter(validMandate);
+}
+
+// the rules in force for a turn: the working-tree contract, plus every committed mandate the working
+// tree does not carry unchanged (same name, same paths). Editing the contract in the working tree
+// does not lift a committed rule, so a change cannot disarm the wall and break it in one turn; a
+// rule that comes only from the commit is tagged `committed`.
+export function mandatesInForce(repo, ref = 'HEAD') {
+  const wt = resolvedMandates(repo);
+  const key = (m) => JSON.stringify([String(m.name), pathsOf(m).sort()]);
+  const have = new Set(wt.map(key));
+  const committed = resolvedMandatesAt(repo, ref).filter((m) => !have.has(key(m))).map((m) => ({ ...m, committed: true }));
+  return [...wt, ...committed];
+}
+
+// a working-tree file's content hash as git would store it; 'deleted' when it is gone
+export function hashOf(repo, file) {
+  try { return gitOut(repo, ['hash-object', '--', file]).trim(); } catch { return 'deleted'; }
+}
+
+// the protected paths that are dirty right now, each with its content hash: the baseline `turn`
+// records when a prompt begins, so the Stop hook counts only what the turn itself changed and leaves
+// a person's own pre-existing edits alone. {} when nothing protected is dirty (or not a git repo).
+export function protectedDirty(repo) {
+  let changed = [];
+  try { changed = [...new Set([...gitOut(repo, ['diff', '--name-only', 'HEAD']).split('\n'), ...gitOut(repo, ['ls-files', '--others', '--exclude-standard']).split('\n')].filter(Boolean))]; }
+  catch { return {}; }
+  const res = mandatesInForce(repo).flatMap((m) => pathsOf(m).map(globToRe));
+  const out = {};
+  for (const f of changed) if (res.some((re) => re.test(f))) out[f] = hashOf(repo, f);
+  return out;
 }
 
 // the same glob dialect as promptwheel's evaluatorPaths / mandates (ported verbatim): a bare name
@@ -30,13 +82,18 @@ export function globToRe(glob) {
   return new RegExp(`${pre}${body}$`);
 }
 
-// which changed paths violate which mandate: [{ name, reason, files }]
-export function mandateHits(repo, changedPaths) {
+// which changed paths violate which mandate: [{ name, reason, files, committed? }]. The rules are the
+// working tree's plus the committed ones (mandatesInForce); pass { ref: null } for the working tree alone.
+export function mandateHits(repo, changedPaths, opts = {}) {
+  const list = opts.ref === null ? resolvedMandates(repo) : mandatesInForce(repo, opts.ref || 'HEAD');
   const out = [];
-  for (const m of resolvedMandates(repo)) {
-    const res = m.paths.filter((s) => typeof s === 'string' && s.trim()).map(globToRe);
+  for (const m of list) {
+    const res = pathsOf(m).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) });
+    if (!files.length) continue;
+    const prev = out.find((h) => h.name === String(m.name));
+    if (prev) { prev.files = [...new Set([...prev.files, ...files])].slice(0, 20); if (!prev.reason && m.reason) prev.reason = String(m.reason).slice(0, 300); continue; }
+    out.push({ name: String(m.name), reason: m.reason ? String(m.reason).slice(0, 300) : '', files: files.slice(0, 20), ...(m.committed ? { committed: true } : {}) });
   }
   return out;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sawbuck",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "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",

package/sawbuck-hook.mjs

@@ -10,7 +10,7 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
-import { mandateHits } from './contract.mjs';
+import { mandateHits, hashOf } 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
@@ -50,20 +50,28 @@ const saveState = () => { try { mkdirSync(stDir, { recursive: true }); writeFile
 // 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.
+// and send the agent back to undo its protected edits and make the fix elsewhere. The rules are the
+// working tree's AND the committed contract's (editing the config in the same turn lifts nothing),
+// and a protected file that was already dirty with the same content when the prompt began (the
+// baseline `sawbuck turn` recorded) is the person's own work and does not count.
 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 dirty = [...new Set([...git('diff', '--name-only', 'HEAD').split('\n'), ...git('ls-files', '--others', '--exclude-standard').split('\n')].filter(Boolean))];
+  const baseline = (st.turnBaseline && st.turnBaseline.files && typeof st.turnBaseline.files === 'object') ? st.turnBaseline.files : {};
+  const untouched = (f) => Object.prototype.hasOwnProperty.call(baseline, f) && hashOf(repo, f) === baseline[f];
+  const changed = dirty.filter((f) => !untouched(f));
+  const leftAlone = dirty.filter(untouched);
   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('; ');
+    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(', ')}.` : '';
     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.stdout.write(JSON.stringify({ decision: 'block', reason: `Sawbuck: a mandate in the contract was violated, 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}` }));
       process.exit(0);
     }
     saveState();

package/sawbuck.mjs

@@ -19,7 +19,7 @@ import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import { recall as memRecall, conform as memConform } from './memory.mjs';
 import { PW } from './bins.mjs';
-import { frameBlock } from './contract.mjs';
+import { frameBlock, mandatesInForce, protectedDirty } from './contract.mjs';
 
 const SELF = fileURLToPath(import.meta.url);
 const HERE = dirname(SELF);
@@ -206,6 +206,21 @@ switch (cmd) {
     // (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();
+    // When a PROMPT begins (the UserPromptSubmit hook, never the SessionStart[compact] one, which
+    // fires mid-turn), remember which protected paths were already dirty and what they held, so the
+    // Stop hook's wall counts only what this turn changes and leaves a person's own edits alone.
+    let hookEvent = '';
+    if (!process.stdin.isTTY) { try { hookEvent = String(JSON.parse(readFileSync(0, 'utf8') || '{}').hook_event_name || ''); } catch {} }
+    if (hookEvent === 'UserPromptSubmit') {
+      try {
+        if (mandatesInForce(repo).length) {
+          const stDir = join(repo, '.sawbuck'); const stPath = join(stDir, 'state.json');
+          let st = {}; try { st = JSON.parse(readFileSync(stPath, 'utf8')); } catch {}
+          st.turnBaseline = { at: new Date().toISOString(), files: protectedDirty(repo) };
+          mkdirSync(stDir, { recursive: true }); writeFileSync(stPath, JSON.stringify(st, null, 2) + '\n');
+        }
+      } catch { /* the frame never fails a prompt */ }
+    }
     const o = [frameBlock(repo), contextBlock(repo, false)].filter(Boolean).join('\n');
     if (o) out(o);
     break;
@@ -444,12 +459,19 @@ 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}`); 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`;
+  // attached already? "already attached" only when every hook of THIS version is present; an older
+  // attachment (say, without the SessionStart[compact] hook) is upgraded in place, never left stale.
+  let upgrading = false;
+  if (JSON.stringify(cfg).includes('sawbuck.mjs')) {
+    const has = (event, command, matcher) => ((cfg.hooks || {})[event] || []).some((h) => h && (matcher ? h.matcher === matcher : !h.matcher) && Array.isArray(h.hooks) && h.hooks.some((x) => x && x.command === command));
+    if (has('UserPromptSubmit', ctx) && has('SessionStart', ctx, 'compact') && has('Stop', chk)) { out(`sawbuck: already attached (${user ? 'user' : 'claude'}) in ${f}`); return; }
+    upgrading = true;
+  }
   if (dry) {
     out(dryText([
-      `${fileExisted ? 'modify' : 'create'}  ${f}  (UserPromptSubmit + SessionStart[compact] + Stop hooks: the per-turn block, and the check)`,
+      `${upgrading ? 'update' : 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)));
@@ -470,11 +492,13 @@ function wireClaude(repo, opts) {
   const mode = user ? 'user' : shared ? 'claude-shared' : 'claude';
   const mp = user ? userManifestPath() : manifestPath(repo);
   const m = readManifest(mp);
-  m.attachments = { ...m.attachments, [mode]: { file: f, fileCreated: !fileExisted, dirCreated: !dirExisted } };
+  const prev = (m.attachments || {})[mode];   // an upgrade keeps the receipt of what the first attach created
+  m.attachments = { ...m.attachments, [mode]: { file: f, fileCreated: prev ? !!prev.fileCreated : !fileExisted, dirCreated: prev ? !!prev.dirCreated : !dirExisted } };
   if (!user) syncExclude(repo, m);
   writeManifest(mp, m);
   regAdd(repo, mode);
-  out(`sawbuck: wired ${user ? 'USER-LEVEL' : shared ? 'shared project' : 'project'} Claude Code hooks in ${f}`);
+  out(upgrading ? `sawbuck: updated the ${user ? 'USER-LEVEL' : shared ? 'shared project' : 'project'} Claude Code hooks in ${f} to this version`
+                : `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)');
 }