sawbuck 0.1.46 → 0.1.48

package/shape.mjs

@@ -1,17 +1,25 @@
 // Your steering shape: what you push on, as 11 spokes in 4 groups. The model labels a sample of your messages; only the
 // totals are kept. Three models agreed on single messages about 70% of the time and on the shape at 0.87 or better, so a
 // single label is never shown. It says what you pushed on, not how good you are. Each run is saved with its date.
-import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, rmSync, copyFileSync } from 'node:fs';
+//
+// What is not said: the model also reads a sample of real turns and names habits the agent has that you never push on.
+// Nothing is counted. An earlier version counted with patterns, and reading the turns showed the counts were wrong.
+// Each habit must quote the agent from 3 turns, a plain check confirms the quotes, and the excerpts are deleted after.
+// Tested on one person: on 120 turns two models named the same two habits and differed on the third, so the output
+// calls them leads.
+import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, rmSync, copyFileSync, chmodSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
-import { prepareRules } from './rules.mjs';
+import { prepareRules, SECRET, forget } from './rules.mjs';
+import { readHistory, typedText } from './history.mjs';
 
 export const GROUPS = { Truth: ['correctness', 'proof', 'honesty'], Intent: ['scope', 'autonomy'], Craft: ['voice', 'naming', 'visual', 'simplicity'], Control: ['process', 'safety'] };
 const SPOKES = Object.values(GROUPS).flat();
 const MIN_SPOKES = 200;   // below this, spokes are noise: show the 4 groups
 const SAMPLE = 600;
-const paths = (home) => ({ dir: join(home, '.sawbuck'), rules: join(home, '.sawbuck', 'rule-input.txt'), input: join(home, '.sawbuck', 'shape-input.txt'), hist: join(home, '.sawbuck', 'shape-history.jsonl'), svg: join(home, '.sawbuck', 'shape.svg') });
+const TURNS = 120, MIN_TURNS = 20, MIN_CITES = 3;   // turns read (at 60, two reads named different habits; at 120 two models agreed on 2 of 3), fewest worth reading, turns a habit must be quoted from
+const paths = (home) => ({ dir: join(home, '.sawbuck'), rules: join(home, '.sawbuck', 'rule-input.txt'), input: join(home, '.sawbuck', 'shape-input.txt'), hist: join(home, '.sawbuck', 'shape-history.jsonl'), svg: join(home, '.sawbuck', 'shape.svg'), turns: join(home, '.sawbuck', 'shape-turns.txt'), notsaid: join(home, '.sawbuck', 'shape-notsaid.json') });
 const title = (s) => s[0].toUpperCase() + s.slice(1);
 
 export function prepareShape({ home = homedir() } = {}) {
@@ -20,8 +28,79 @@ export function prepareShape({ home = homedir() } = {}) {
   const lines = readFileSync(p.rules, 'utf8').split('\n').filter(Boolean);
   for (let i = lines.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [lines[i], lines[j]] = [lines[j], lines[i]]; }
   const pick = lines.slice(0, SAMPLE);
-  writeFileSync(p.input, pick.map((l, i) => `${i + 1}\t${l}`).join('\n') + '\n', { mode: 0o600 });
-  return { input: p.input, lines: pick.length, secrets: r.secrets };
+  const priv = (f, text) => { writeFileSync(f, text, { mode: 0o600 }); chmodSync(f, 0o600); };   // the mode alone only applies to a new file
+  priv(p.input, pick.map((l, i) => `${i + 1}\t${l}`).join('\n') + '\n');
+  const turns = sampleTurns({ home });
+  rmSync(p.notsaid, { force: true });
+  if (turns.length >= MIN_TURNS) priv(p.turns, turns.map((l, i) => `${i + 1}\t${l}`).join('\n') + '\n'); else rmSync(p.turns, { force: true });
+  return { input: p.input, lines: pick.length, secrets: r.secrets, turns: turns.length >= MIN_TURNS ? turns.length : 0, turnsFile: p.turns };
+}
+
+// One line per past turn from the last 90 days: what you asked, what the agent did, how its reply ended, what you said
+// next. Only sessions with 3 or more typed prompts: a one-prompt session is a script, not a conversation.
+export function sampleTurns({ home = homedir(), n = TURNS, days = 90 } = {}) {
+  const since = Date.now() - days * 864e5, T = [];
+  const cut = (x, k) => String(x || '').replace(/\s+/g, ' ').trim().slice(0, k);
+  const noise = (t) => /^[<[]/.test(t) || t.startsWith('Caveat:') || t.startsWith('This session is being continued');
+  let cur = null, S = [], typed = 0;
+  const close = (next) => { if (cur && cur.tools) S.push({ ...cur, next }); cur = null; };
+  const end = () => { close(''); if (typed >= 3) T.push(...S); S = []; typed = 0; };
+  readHistory(join(home, '.claude', 'projects'), {
+    onSession: end,
+    onEvent: (e) => {
+      if (e.timestamp && Date.parse(e.timestamp) < since) return;
+      if (e.type === 'user') {
+        const t = typedText(e.message);
+        if (t === null || noise(t.trim())) return;   // a tool result or a background notice is not your reply: the turn goes on
+        close(t); typed++; cur = { you: t, did: [], said: '', tools: 0 };
+      } else if (cur && Array.isArray(e.message && e.message.content)) {
+        for (const b of e.message.content) {
+          if (b.type === 'text' && b.text) cur.said = b.text;
+          if (b.type !== 'tool_use') continue;
+          cur.tools++;
+          const i = b.input || {};
+          if (cur.did.length < 8) cur.did.push(b.name === 'Bash' ? `ran: ${cut(i.command, 70)}` : /^(Edit|Write|MultiEdit)$/.test(b.name) ? `edited ${String(i.file_path || '').split('/').slice(-2).join('/')}` : b.name);
+        }
+      }
+    },
+  });
+  for (let i = T.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [T[i], T[j]] = [T[j], T[i]]; }
+  // the person's words are kept free of the line's separators, so nothing they typed can sit where the agent's side is read
+  const mine = (x, k) => cut(x, k).replace(/\|/g, '/');
+  return T.map((t) => `you: ${mine(t.you, 160)}${AGENT}(${t.tools} tool calls): ${t.did.join('; ')} | it ended: ${cut(t.said.slice(-220), 220)}${NEXT}${mine(t.next, 120) || '(session ended)'}`).filter((l) => !SECRET.test(l)).slice(0, n);
+}
+const AGENT = ' | it did ', NEXT = ' | you next: ';
+
+// Keep a habit only if it quotes the agent's side of 3 different turns, word for word. Your own messages do not count
+// as evidence and are never printed. Returns the lines to show, and removes the excerpts either way.
+function notSaid(p) {
+  let turns = null, named = null;
+  try { turns = new Map(readFileSync(p.turns, 'utf8').split('\n').filter(Boolean).map((l) => { const i = l.indexOf('\t'); return [l.slice(0, i), l.slice(i + 1)]; })); } catch {}
+  try { const m = readFileSync(p.notsaid, 'utf8').match(/\[[\s\S]*\]/); named = m ? JSON.parse(m[0]) : null; } catch {}
+  rmSync(p.turns, { force: true }); rmSync(p.notsaid, { force: true });
+  if (!turns || !Array.isArray(named)) return [];
+  const norm = (x) => String(x || '').toLowerCase().replace(/\s+/g, ' ').trim();
+  const one = (x, k) => (typeof x === 'string' ? x : '').replace(/\s+/g, ' ').trim().slice(0, k);
+  const agentSide = (l) => { const a = l.indexOf(AGENT), b = l.lastIndexOf(NEXT); return a > -1 && b > a ? norm(l.slice(a, b)) : ''; };
+  const out = [];
+  let kept = 0;
+  // the first 3 that hold up, wherever they sit in the answer; the answer is the model's, so nothing in it is trusted
+  for (const c of named.slice(0, 50)) {
+    if (kept === 3) break;
+    if (!c || typeof c !== 'object' || !one(c.what, 200)) continue;
+    const seen = new Set(), quotes = [];
+    for (const t of Array.isArray(c.turns) ? c.turns : []) {
+      if (!t || typeof t !== 'object' || typeof t.quote !== 'string') continue;
+      const q = norm(t.quote), id = String(t.n), l = turns.get(id);
+      if (typeof l !== 'string' || q.length < 12 || seen.has(id) || !agentSide(l).includes(q)) continue;
+      seen.add(id); quotes.push(one(t.quote, 80));
+    }
+    if (quotes.length < MIN_CITES) continue;
+    kept++;
+    out.push(`    ${one(c.what, 200)} (${quotes.length} turns)`, ...[...new Set(quotes)].slice(0, 3).map((q) => `      "${q}"`), ...(one(c.rule, 200) ? [`      Try: ${one(c.rule, 200)}`] : []));
+  }
+  const n = turns.size;
+  return out.length ? ['', `  Not said, from one read of ${n} past turns. Leads to check, with the agent's own words:`, ...out] : ['', `  Not said: nothing stood out in the ${n} past turns read.`];
 }
 
 export function tally(labels) {
@@ -38,7 +117,6 @@ export function tally(labels) {
   return { n: total, none, groups, ratings, shares, spokes: total >= MIN_SPOKES };
 }
 
-// What was not said: each spoke we can measure from what the agent did, read against how often you push on it.
 export function shapeSvg(t) {
   const names = t.spokes ? SPOKES : Object.keys(GROUPS);
   const vals = t.spokes ? names.map((s) => t.ratings[s] / 99) : names.map((g) => 0.25 + 0.75 * t.groups[g] / Math.max(1, ...Object.values(t.groups)));
@@ -68,18 +146,22 @@ function pngCard(svg) {
 }
 
 export function shapeCli(args, { home = homedir() } = {}) {
-  if (args.includes('--prepare')) { const r = prepareShape({ home }); return `🐴 ${r.lines} of your messages are ready in ${r.input}${r.secrets ? `, ${r.secrets} that looked like secrets left out` : ''}.`; }
+  if (args.includes('--prepare')) { const r = prepareShape({ home }); return `🐴 ${r.lines} of your messages are ready in ${r.input}${r.secrets ? `, ${r.secrets} that looked like secrets left out` : ''}.${r.turns ? `\n🐴 ${r.turns} past turns are ready in ${r.turnsFile}. They are deleted after the check.` : ''}`; }
   const i = args.indexOf('--check');
   if (i === -1) return 'sawbuck shape --prepare | --check <labels.json>';
   const file = args[i + 1];
-  if (!file || !existsSync(file)) return '🐴 sawbuck: --check needs the labels file.';
-  const m = readFileSync(file, 'utf8').match(/\{[\s\S]*\}/);
-  const t = tally(m ? JSON.parse(m[0]) : {});
-  if (!t.n) return '🐴 sawbuck: no usable labels in that file.';
   const p = paths(home);
+  // a check that cannot run still clears the excerpts: they are only for this one read
+  const stop = (msg) => { rmSync(p.turns, { force: true }); rmSync(p.notsaid, { force: true }); return msg; };
+  if (!file || !existsSync(file)) return stop('🐴 sawbuck: --check needs the labels file.');
+  let labels = {};
+  try { const m = readFileSync(file, 'utf8').match(/\{[\s\S]*\}/); labels = m ? JSON.parse(m[0]) : {}; } catch {}
+  const t = tally(labels && typeof labels === 'object' ? labels : {});
+  if (!t.n) return stop('🐴 sawbuck: no usable labels in that file.');
   mkdirSync(p.dir, { recursive: true });
   let prev = null;
-  if (existsSync(p.hist)) { const l = readFileSync(p.hist, 'utf8').trim().split('\n').filter(Boolean); if (l.length) prev = JSON.parse(l[l.length - 1]); }
+  try { const l = readFileSync(p.hist, 'utf8').trim().split('\n').filter(Boolean); if (l.length) prev = JSON.parse(l[l.length - 1]); } catch {}
+  if (!prev || typeof prev !== 'object' || !prev.groups) prev = null;
   writeFileSync(p.svg, shapeSvg(t));
   const out = [`🐴 your steering shape, from ${t.n} messages that pushed on something (${t.none} did not). What you push on, not a score.`, ''];
   for (const [g, ss] of Object.entries(GROUPS)) {
@@ -89,6 +171,8 @@ export function shapeCli(args, { home = homedir() } = {}) {
   }
   if (!t.spokes) out.push('', `  Too few messages for the 11 spokes (${t.n} of ${MIN_SPOKES}), so this shows the 4 groups.`);
   appendFileSync(p.hist, JSON.stringify({ at: new Date().toISOString(), n: t.n, groups: t.groups, shares: t.shares }) + '\n');
+  forget(home, p.input, p.rules, file);   // the sampled messages and their labels were for this one read; the totals above are what stays
+  out.push(...notSaid(p));
   out.push('', `  Card: ${p.svg}`);
   if (args.includes('--png')) { const png = pngCard(p.svg); out.push(png ? `  Image to share: ${png}` : '  No image tool here (rsvg-convert or Chrome): open the card in a browser to save an image.'); }
   return out.join('\n');

package/status.mjs

@@ -8,35 +8,34 @@
 // Read-only, zero-dep, bounded. The debt scan is best-effort (a pointer if it cannot run in time).
 // Usage: node status.mjs [--repo P] [--json]
 
+import './pipe.mjs';
 import { execFileSync } from 'node:child_process';
 import { readFileSync, existsSync } from 'node:fs';
 import { join, dirname, resolve, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { repoState } from './repo-state.mjs';
+import { readSteers, groupSteers } from './steers.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const flag = (n, d) => { const i = process.argv.indexOf(n); return i > -1 ? (process.argv[i + 1] ?? true) : d; };
 const repo = resolve(flag('--repo', process.cwd()));
 const asJson = process.argv.includes('--json');
 
-const readJSON = (p) => { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return null; } };
 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: '✎', 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, caught: catchesAllTime, state: kind, steer, armed, hasConfig } = repoState(repo);
+const { results, caught: catchesAllTime, state: kind, steer, armed, hasConfig, wired } = repoState(repo);
+const repeated = groupSteers(readSteers().steers).filter((g) => g.n >= 3 && g.sessions >= 2);
 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, mandate: 0 };
 for (const e of feed) if (e && tally[e.kind] != null) tally[e.kind]++;
 const seen = feed.length;
 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, in repoState; the
-// recent-window average over roughly the last twenty scored turns, as the band and statusline show it)
 
 // --- 2) the armed state: what it can measure here (shared with the statusline) ---
 const isGit = !!existsSync(join(repo, '.git'));
@@ -64,6 +63,7 @@ if (asJson) {
     config: hasConfig,
     outcomes: { seen, caughtAllTime: catchesAllTime, gamedAllTime: results.gamed || 0, regressionsAllTime: results.regressions || 0, recent: tally, latest, since },
     steer,
+    repeated: repeated.slice(0, 3).map((g) => ({ nudge: g.nudge, n: g.n })),
     debt: debt ? { total: debt.total, testSkips: debt.testSkips, undocumented: debt.undocumented, filesOnFragileCode: debt.filesOnFragileCode, top: (debt.files || []).slice(0, 5) } : null,
     debtError: debtErr,
   }, null, 2));
@@ -110,6 +110,12 @@ if (steer) {
   out.push('');
   out.push(`   Steer rate  ·  ${steer.rate}% of your recent turns redirected the agent (${steer.scored} scored, recent-window average)`);
 }
+// what you keep saying, across repos: a steer the judge kept 3 times in 2 sessions is a rule waiting to be written
+if (repeated.length) {
+  out.push('');
+  out.push('   You keep saying  ·  write one down if it is a rule (/sawbuck-reins:rules can help)');
+  for (const g of repeated.slice(0, 3)) out.push(`     ${g.n}x  ${g.nudge}`);
+}
 
 // Debt
 out.push('');
@@ -134,8 +140,10 @@ if (debt && debt.total) {
 out.push('');
 if (!isGit) {
   out.push(`   Not a git repo here, so there is nothing to verify or remember. cd into your project.`);
+} else if (state === 'watching' && wired === 'user' && !hasConfig) {
+  out.push('   Measuring here  ·  wired in at user level, and that check runs only in a repo that has a promptwheel.config.json. `sawbuck contract` writes one.');
 } else if (state === 'watching') {
-  out.push(`   Measuring here  ·  ${hasConfig ? '✓ wired in with a contract (promptwheel.config.json)' : '✓ wired in (zero-config auto-detect)'}. It verifies each commit/turn automatically.`);
+  out.push(`   Measuring here  ·  ${hasConfig ? '✓ wired in with a contract (promptwheel.config.json)' : '✓ wired in (zero-config auto-detect)'}. Protected paths are checked at the end of each turn, and each commit is re-proved from the source.`);
 } else if (state === 'ready') {
   out.push(`   Measuring here  ·  checkable but not wired yet. Try it now: \`sawbuck check\`  •  make it automatic: \`sawbuck attach\``);
 } else {

package/steers.mjs

@@ -14,7 +14,7 @@ export function readSteers(home = homedir()) {
   for (const f of files) {
     try {
       const d = JSON.parse(readFileSync(join(dir, f), 'utf8'));
-      if (Array.isArray(d.steers)) out.steers.push(...d.steers);
+      if (Array.isArray(d.steers)) out.steers.push(...d.steers.filter((e) => e && typeof e.nudge === 'string'));   // a null or half-written entry is not a steer
       if (d.steerStats) { out.stats.scored += d.steerStats.scored || 0; out.stats.lost += d.steerStats.lost || 0; }
     } catch {}
   }