sawbuck 0.1.28 → 0.1.29

package/contract.mjs

@@ -92,7 +92,12 @@ export function mandateHits(repo, changedPaths, opts = {}) {
     const files = changedPaths.filter((f) => res.some((re) => re.test(f)));
     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; }
+    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);
+      if (m.committed) prev.committed = true;   // the committed version of the rule hit too: say so
+      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.28",
+  "version": "0.1.29",
   "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

@@ -46,6 +46,23 @@ let rec = null;
 try { rec = JSON.parse(readFileSync(join(stDir, 'results.json'), 'utf8')); } catch {}
 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 {} };
+// when the last prompt of this session was typed, from the transcript the hook names (null when unknown):
+// the newest user row that carries text, not a tool result; the tail of the file is enough
+function lastPromptTime(transcriptPath) {
+  try {
+    if (!transcriptPath || !existsSync(transcriptPath)) return null;
+    const text = readFileSync(transcriptPath, 'utf8'); const tail = text.length > 524288 ? text.slice(-524288) : text;
+    const lines = tail.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      let o; try { o = JSON.parse(lines[i]); } catch { continue; }
+      if (!o || o.type !== 'user' || !o.timestamp) continue;
+      const c = o.message && o.message.content;
+      const isText = typeof c === 'string' || (Array.isArray(c) && c.some((p) => p && p.type === 'text') && !c.some((p) => p && p.type === 'tool_result'));
+      if (isText) { const t = Date.parse(o.timestamp); return Number.isFinite(t) ? t : null; }
+    }
+  } catch {}
+  return null;
+}
 
 // 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
@@ -56,11 +73,20 @@ const saveState = () => { try { mkdirSync(stDir, { recursive: true }); writeFile
 // baseline `sawbuck turn` recorded) is the person's own work and does not count.
 if (stop && !process.env.SAWBUCK_NO_ENFORCE) {
   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];
+  // the baseline `sawbuck turn --hook` recorded when the prompt began; one recorded well AFTER the
+  // transcript's last prompt was not the prompt's (something re-ran `turn` mid-turn) and is ignored
+  let baseline = (st.turnBaseline && st.turnBaseline.files && typeof st.turnBaseline.files === 'object') ? st.turnBaseline.files : {};
+  const promptAt = lastPromptTime(hookInput.transcript_path);
+  const baseAt = Date.parse(st.turnBaseline && st.turnBaseline.at);
+  if (promptAt && baseAt && baseAt > promptAt + 30000) baseline = {};
+  const hashNow = {}; for (const f of dirty) if (Object.prototype.hasOwnProperty.call(baseline, f)) hashNow[f] = hashOf(repo, f);
+  const untouched = (f) => Object.prototype.hasOwnProperty.call(baseline, f) && hashNow[f] === baseline[f];
   const changed = dirty.filter((f) => !untouched(f));
   const leftAlone = dirty.filter(untouched);
   const hits = changed.length ? mandateHits(repo, changed) : [];
+  // remember what was flagged and what it held, so the next prompt's baseline cannot adopt it
+  if (hits.length) { const files = {}; for (const h of hits) for (const f of h.files) files[f] = hashOf(repo, f); st.lastViolation = { at: new Date().toISOString(), files }; }
+  else if (st.lastViolation) { delete st.lastViolation; saveState(); }
   if (hits.length) {
     const MAX_BLOCKS = +(cfg.enforce?.maxBlocks) || 3;
     const promptId = hookInput.prompt_id || 'none';

package/sawbuck.mjs

@@ -209,14 +209,21 @@ switch (cmd) {
     // 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.
+    // Only under --hook (the wiring passes it) is stdin read for the hook's JSON, so a plain
+    // `sawbuck turn` never waits on a pipe. Two rules keep the baseline honest: a file still carrying
+    // the content the last violation flagged is the agent's, not the person's, and is never
+    // baselined; and the Stop hook ignores a baseline recorded well after the prompt began.
     let hookEvent = '';
-    if (!process.stdin.isTTY) { try { hookEvent = String(JSON.parse(readFileSync(0, 'utf8') || '{}').hook_event_name || ''); } catch {} }
+    if (flags.has('--hook') && !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) };
+          const flagged = (st.lastViolation && st.lastViolation.files && typeof st.lastViolation.files === 'object') ? st.lastViolation.files : {};
+          const files = protectedDirty(repo);
+          for (const f of Object.keys(files)) if (flagged[f] === files[f]) delete files[f];   // the agent's un-reverted edit stays on the wall
+          st.turnBaseline = { at: new Date().toISOString(), files };
           mkdirSync(stDir, { recursive: true }); writeFileSync(stPath, JSON.stringify(st, null, 2) + '\n');
         }
       } catch { /* the frame never fails a prompt */ }
@@ -459,7 +466,7 @@ function wireClaude(repo, opts) {
   const fileExisted = existsSync(f);
   let cfg = {};
   if (fileExisted) { try { cfg = JSON.parse(readFileSync(f, 'utf8')); } catch { die(`${f} exists but is not valid JSON; I will not overwrite it. Add the hooks by hand.`); } }
-  const ctx = user ? `node ${JSON.stringify(SELF)} turn` : `node ${JSON.stringify(SELF)} turn ${JSON.stringify(repo)}`;
+  const ctx = user ? `node ${JSON.stringify(SELF)} turn --hook` : `node ${JSON.stringify(SELF)} turn --hook ${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.