@sawbuck/reins 0.4.0 → 0.4.1

package/bin/reins.mjs

@@ -4,13 +4,17 @@
 // the seismograph + distribution. The check guards the turns you did not steer.
 
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, relative } from "node:path";
 import * as claudeHarness from "../scan.mjs";
 import * as codexHarness from "../codex.mjs";
 import { scan } from "../scan.mjs";
 import { score, backend, harvestScore } from "../judge.mjs";
 import { harvest, aggregateCues } from "../wizard.mjs";
 
+// show a path relative to the cwd when it lives under it (clean output, no leaked home dir);
+// fall back to the absolute path for anything outside the tree.
+const rel = (p) => { const r = relative(process.cwd(), p); return r && !r.startsWith("..") ? r : p; };
+
 const argv = process.argv.slice(2);
 const flag = (n) => { const i = argv.indexOf(n); return i > -1 ? argv[i + 1] : null; };
 const has = (n) => argv.includes(n);
@@ -60,14 +64,16 @@ It reads every turn-pair with a model. On the local ollama default that is free;
   if (has("--json")) { process.stdout.write(JSON.stringify({ backend: b, ...rw }, null, 2) + "\n"); process.exit(0); }
   const pct = rw.scored ? Math.round((rw.steers / rw.scored) * 100) : 0;
   process.stdout.write(`\n  reins · wizard   (judge: ${b})\n`);
-  process.stdout.write(`  read ${rw.pairs} turn-pairs from ${rw.sessionsRead} session(s) · ${rw.steers} steers (${pct}%)\n\n`);
+  process.stdout.write(`  read ${rw.pairs} turn-pairs from ${rw.sessionsRead} session(s) · ${rw.steers} steers (${pct}%)\n`);
+  if (rw.axes && rw.axes.length) process.stdout.write(`  you steer most on: ${rw.axes.slice(0, 5).map((a) => `${a.axis} (${a.count})`).join(" · ")}\n`);
+  process.stdout.write("\n");
   const top = rw.cues.filter((c) => c.count >= 2 || c.gen > 0).slice(0, 12);
-  if (!top.length) { process.stdout.write("  no repeated cues surfaced yet - harvest more sessions (--sessions, --since).\n\n"); process.exit(0); }
+  if (!top.length) { process.stdout.write("  no repeated specific cues yet (the axis fingerprint above is the durable signal) - harvest more with --sessions / --since.\n\n"); process.exit(0); }
   process.stdout.write("  your top cues (candidates from your history, review before trusting):\n");
   for (const c of top) {
     process.stdout.write(`    ${("[" + c.axis + "]").padEnd(13)} ${(c.cue || "(unnamed)").padEnd(34)} · ${c.sessions} sess · gen ${c.genShare} · ${c.count}x\n`);
   }
-  process.stdout.write(`\n  wrote ${out}\n  these are LEADS. Promote the ones that are really you; the check still guards the rest.\n\n`);
+  process.stdout.write(`\n  wrote ${rel(out)}\n  these are LEADS. Promote the ones that are really you; the check still guards the rest.\n\n`);
   process.exit(0);
 }
 
@@ -115,9 +121,10 @@ Free on the local ollama default. Seed from your whole history once with: reins
   try { mkdirSync(dirname(cout), { recursive: true }); writeFileSync(cout, JSON.stringify(rec, null, 2) + "\n"); } catch { process.stderr.write("reins cues: could not write " + cout + "\n"); }
   if (has("--json")) { const { items: _omit, ...pub } = rec; process.stdout.write(JSON.stringify(pub, null, 2) + "\n"); process.exit(0); }
   const top = agg.cues.filter((c) => c.count >= 2 || c.gen > 0).slice(0, 10);
-  process.stdout.write(`\n  reins · cues   (judge: ${b})\n  ${agg.steers} steers over ${agg.scored} scored turns · ${top.length} cues\n`);
-  for (const c of top) process.stdout.write(`    ${("[" + c.axis + "]").padEnd(12)} ${(c.cue || "(unnamed)").padEnd(32)} · ${c.sessions} sess · ${c.count}x\n`);
-  process.stdout.write(`  wrote ${cout}\n\n`);
+  process.stdout.write(`\n  reins · cues   (judge: ${b})\n  ${agg.steers} steers over ${agg.scored} scored turns\n`);
+  if (agg.axes && agg.axes.length) process.stdout.write(`  you steer most on: ${agg.axes.slice(0, 4).map((a) => `${a.axis} (${a.count})`).join(" · ")}\n`);
+  if (top.length) { process.stdout.write(`  candidate cues (review before trusting):\n`); for (const c of top) process.stdout.write(`    ${("[" + c.axis + "]").padEnd(12)} ${(c.cue || "(unnamed)").padEnd(32)} · ${c.count}x\n`); }
+  process.stdout.write(`  wrote ${rel(cout)}\n\n`);
   process.exit(0);
 }
 
@@ -217,10 +224,10 @@ if (has("--share")) {
   ${r.seismograph}
   · let it ride   - nudge   + redirect   # hard pull
 
-I steered ${r.steering} of ${r.scored} turns (${pct}%) — ${grip}, ${texture}.
+I steered ${r.steering} of ${r.scored} turns (${pct}%): ${grip}, ${texture}.
 The ${r.scored - r.steering} I let ride, the check had my back.
 
-— measured with reins · sawbuck
+measured with reins · sawbuck
 `);
   process.exit(0);
 }

package/judge.mjs

@@ -95,15 +95,25 @@ async function complete(promptStr, schema) {
   throw new Error("unknown SAWBUCK_JUDGE backend: " + b + " (use ollama:<model> | haiku | anthropic:<model> | openai:<model>)");
 }
 
-async function ollama(model, promptStr, schema) {
-  const host = process.env.OLLAMA_HOST || "http://localhost:11434";
+async function ollamaCall(host, model, promptStr, format) {
+  const body = { model, prompt: promptStr, stream: false, options: { temperature: 0, num_predict: 800 } };
+  if (format) body.format = format;
   const res = await fetch(host + "/api/generate", {
     method: "POST", headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ model, prompt: promptStr, stream: false, format: schema, options: { temperature: 0, num_predict: 800 } }),
+    body: JSON.stringify(body),
   });
   const j = await res.json();
   return j.response || "";
 }
+async function ollama(model, promptStr, schema) {
+  const host = process.env.OLLAMA_HOST || "http://localhost:11434";
+  // Grammar-constrained first: clean JSON on most models (qwen2.5, llama). But reasoning models
+  // (gpt-oss, deepseek-r1) spend their budget in a hidden channel and return an EMPTY response
+  // under a format grammar - so on empty we retry free-form; the parser lifts JSON from raw text.
+  let out = await ollamaCall(host, model, promptStr, schema);
+  if (!out.trim()) out = await ollamaCall(host, model, promptStr, null);
+  return out;
+}
 async function anthropic(model, promptStr) {
   const key = process.env.ANTHROPIC_API_KEY;
   if (!key) throw new Error("ANTHROPIC_API_KEY not set (SAWBUCK_JUDGE=haiku needs it)");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sawbuck/reins",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Reins: measure how much you steer your AI coding agent. A per-turn steering-pressure judge over your session transcript, pluggable backend (Haiku / local ollama / any OpenAI-compatible). The LLM half of the reins steering layer; keeps sawbuck's core offline.",
   "type": "module",
   "license": "Apache-2.0",

package/wizard.mjs

@@ -15,12 +15,16 @@ import { pairs, resolveSessions } from "./scan.mjs";
 // one-session spike never outranks a cue you give across many sessions - the study's lesson).
 export function aggregateCues(items) {
   const clusters = new Map();
+  const axisTally = new Map();   // the robust signal: WHICH axes you steer on (research: the fingerprint
+                                  // replicates across judges; exact cue text does not, so it rarely clusters)
   let scored = 0, steers = 0, fails = 0;
   for (const { session, result } of items) {
     if (!result) { fails++; continue; }
     scored++;
     if (!result.steer) continue;
     steers++;
+    const ax = result.axis || "other";
+    axisTally.set(ax, (axisTally.get(ax) || 0) + 1);
     const key = (result.axis || "other") + "|" + String(result.cue || "").toLowerCase().replace(/\s+/g, " ").trim().slice(0, 40);
     const c = clusters.get(key) || { axis: result.axis || "other", cue: result.cue || "", count: 0, gen: 0, sessions: new Set(), mag: { refine: 0, redirect: 0, "hard-stop": 0 } };
     c.count++;
@@ -34,7 +38,8 @@ export function aggregateCues(items) {
   const cues = [...clusters.values()]
     .map((c) => ({ axis: c.axis, cue: c.cue, count: c.count, gen: c.gen, genShare: c.count ? +(c.gen / c.count).toFixed(2) : 0, sessions: c.sessions.size, magnitude: c.mag }))
     .sort((a, b) => (b.sessions - a.sessions) || (b.gen - a.gen) || (b.count - a.count));
-  return { scored, steers, fails, steerRate: scored ? +(steers / scored).toFixed(3) : 0, cues };
+  const axes = [...axisTally.entries()].map(([axis, count]) => ({ axis, count })).sort((a, b) => b.count - a.count);
+  return { scored, steers, fails, steerRate: scored ? +(steers / scored).toFixed(3) : 0, axes, cues };
 }
 
 // harvest(scoreFn, { sessions, maxPairs }) -> aggregateCues over the pairs in those session