@sawbuck/reins 0.1.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+reins (@sawbuck/reins)
+Copyright 2026 Matthew Owens

package/README.md

@@ -7,8 +7,8 @@ and prints a seismograph of the session plus the distribution.
 
 This is the LLM half of reins. The deterministic brake-slam counter (`sawbuck yank`)
 lives in sawbuck's offline core; the continuous pressure judge needs a model, so it
-lives here, keeping sawbuck's core model-free. (The reins *plugin* — the Claude Code
-surface — lives alongside this in `plugins/sawbuck-reins/`.)
+lives here, keeping sawbuck's core model-free. (The reins *plugin*, the Claude Code
+surface, lives alongside this in `plugins/sawbuck-reins/`.)
 
 ```
 $ reins
@@ -25,13 +25,13 @@ $ reins
 
 The judge model is a socket. Set `SAWBUCK_JUDGE` (default `ollama:qwen2.5:7b`):
 
-- `ollama:<model>` — local, free, private (nothing leaves your box). `OLLAMA_HOST`
+- `ollama:<model>`, local, free, private (nothing leaves your box). `OLLAMA_HOST`
   overrides the endpoint. Benchmarked default `qwen2.5:7b`: fastest, smallest, and
-  tied-best accuracy against an opus-labeled gold — model size did not help.
-- `haiku` — Anthropic `claude-haiku-5-5` (needs `ANTHROPIC_API_KEY`); zero VRAM,
+  tied-best accuracy against an opus-labeled gold, model size did not help.
+- `haiku`, Anthropic `claude-haiku-5-5` (needs `ANTHROPIC_API_KEY`); zero VRAM,
   about $0.00005 per turn.
-- `anthropic:<model>` — any Anthropic model.
-- `openai:<model>` — any OpenAI-compatible endpoint (`OPENAI_BASE_URL`,
+- `anthropic:<model>`, any Anthropic model.
+- `openai:<model>`, any OpenAI-compatible endpoint (`OPENAI_BASE_URL`,
   `OPENAI_API_KEY`).
 
 Output is constrained to a JSON schema where the backend supports it (ollama
@@ -41,7 +41,7 @@ structured outputs), so a thinking model can't break the parse.
 
 `--write [path]` writes the summary JSON (default `.sawbuck/steer.json`). The
 offline `sawbuck statusline` reads that file and shows `🤠 steer 76%` next to its
-own segment — the LLM work happens here, sawbuck's core stays model-free (it only
+own segment, the LLM work happens here, sawbuck's core stays model-free (it only
 reads a file). Keep it fresh by running `reins --write` on a cadence (a `/loop`, a
 watch, or a post-turn hook):
 
@@ -58,6 +58,22 @@ reins [--session <path.jsonl>] [--judge <backend>] [-n N] [--json] [--write [pat
 Defaults to your newest Claude Code session. `-n` scores only the most recent N
 turns. `--json` is machine-readable. Zero-dep, Node 18+.
 
+## The wizard: harvest your cues
+
+```
+reins wizard [--sessions N] [--max N] [--since DAYS] [--judge <backend>] [--json] [--write [path]] [--yes]
+```
+
+Reads your old Claude Code chats, finds the steers you keep giving (a correction of HOW
+the agent works, not a new task), and ranks them into a cue inventory, so a fresh saddle
+already knows your style. It writes `.sawbuck/cues.json` and prints your top cues, ranked by
+how many distinct sessions they span, then how generalizable they are.
+
+It reads every turn-pair with a model, so on the default local ollama it is free (just
+compute); a hosted backend (`haiku`, `openai:`) costs a little, and the command asks for
+`--yes` before it spends. `--max` caps the pairs scored (default 400). The cues are LEADS,
+candidates from your history to review, not rules it adopts for you.
+
 ## Honest limits
 
 A single-turn judge: it sees the agent action and your reply, not the whole thread.

package/bin/reins.mjs

@@ -6,12 +6,113 @@
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { scan, resolveSessionPath, pairs } from "../scan.mjs";
-import { score, backend } from "../judge.mjs";
+import { score, backend, harvestScore } from "../judge.mjs";
+import { harvest, resolveSessions, aggregateCues } from "../wizard.mjs";
 
 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);
 
+// ---- `reins wizard` / `reins harvest`: read your old chats, rank the cues you keep giving ----
+if (argv[0] === "wizard" || argv[0] === "harvest") {
+  if (has("--help") || has("-h")) {
+    process.stdout.write(`reins wizard: harvest your old Claude Code chats into a cue inventory
+
+Usage: reins wizard [--judge <backend>] [--sessions N] [--max N] [--since DAYS] [--json] [--write [path]] [--yes]
+
+  --sessions N   scan the N most recent sessions (default: all)
+  --max N        cap the turn-pairs scored, for cost/time control (default 400)
+  --since DAYS   only sessions touched in the last DAYS days
+  --judge <b>    ollama:<model> (default, free, local) | haiku | anthropic:<model> | openai:<model>
+  --yes          proceed without the confirm on a HOSTED (paid) backend
+  --write [path] write the cue inventory (default .sawbuck/cues.json)
+  --json         machine-readable output
+
+It reads every turn-pair with a model. On the local ollama default that is free; a hosted backend costs a little.
+`);
+    process.exit(0);
+  }
+  if (flag("--judge")) process.env.SAWBUCK_JUDGE = flag("--judge");
+  const b = backend();
+  const sessionsN = parseInt(flag("--sessions"), 10) || 0;
+  const maxPairs = parseInt(flag("--max"), 10) || 400;
+  const sinceDays = parseInt(flag("--since"), 10) || 0;
+  const sinceMs = sinceDays > 0 ? Date.now() - sinceDays * 86400000 : 0;
+  const sessions = resolveSessions({ limit: sessionsN, sinceMs });
+  if (!sessions.length) { process.stderr.write("reins wizard: no Claude Code sessions found under ~/.claude/projects\n"); process.exit(2); }
+  const hosted = !b.startsWith("ollama:");
+  if (hosted && !has("--yes")) {
+    process.stderr.write(`reins wizard: ${b} is a HOSTED backend and will make up to ${maxPairs} calls (a small cost).\n  re-run with --yes to proceed, or use the free local default (omit --judge).\n`);
+    process.exit(2);
+  }
+  process.stderr.write(`reins wizard: harvesting up to ${maxPairs} turn-pairs from ${sessions.length} session(s) via ${b}${hosted ? " (hosted, paid)" : " (local, free)"}...\n`);
+  const rw = await harvest(harvestScore, { sessions, maxPairs });
+  const wf = flag("--write");
+  const out = wf && !wf.startsWith("--") ? wf : join(process.cwd(), ".sawbuck", "cues.json");
+  if (has("--write") || !has("--json")) {
+    try { mkdirSync(dirname(out), { recursive: true }); writeFileSync(out, JSON.stringify({ at: new Date().toISOString(), backend: b, ...rw }, null, 2) + "\n"); }
+    catch { process.stderr.write("reins wizard: could not write " + out + "\n"); }
+  }
+  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`);
+  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); }
+  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.exit(0);
+}
+
+// ---- `reins cues`: real-time cue inventory. Classify THIS session's turns into the cue
+// structure and accumulate .sawbuck/cues.json. --append scores only the new turns since last
+// run (the per-turn path), and carries cues across sessions in this repo. One judge call per
+// new turn; free on local ollama. The batch cross-session cold-start is `reins wizard`. ----
+if (argv[0] === "cues") {
+  if (has("--help") || has("-h")) {
+    process.stdout.write(`reins cues: accumulate your cue inventory as you work
+
+Usage: reins cues [--append] [--session <path>] [--judge <b>] [--max N] [--json]
+
+  --append    score only the new turns since the last run, merge into .sawbuck/cues.json
+              (the per-turn path; carries cues across sessions in this repo)
+  --max N     without --append, cap the turns scored (default 400)
+  --judge <b> ollama:<model> (default, free, local) | haiku | anthropic:<model> | openai:<model>
+
+Free on the local ollama default. Seed from your whole history once with: reins wizard.
+`);
+    process.exit(0);
+  }
+  if (flag("--judge")) process.env.SAWBUCK_JUDGE = flag("--judge");
+  const b = backend();
+  const sess = resolveSessionPath(flag("--session"));
+  if (!sess) { process.stderr.write("reins cues: no session transcript found\n"); process.exit(2); }
+  let ctext = ""; try { ctext = readFileSync(sess, "utf8"); } catch { process.stderr.write("reins cues: cannot read " + sess + "\n"); process.exit(2); }
+  const allC = pairs(ctext);
+  const cout = join(process.cwd(), ".sawbuck", "cues.json");
+  let prior = { session: "", lastPairs: 0, items: [] };
+  if (has("--append")) { try { const p = JSON.parse(readFileSync(cout, "utf8")); if (p && Array.isArray(p.items)) prior = { session: p.session || "", lastPairs: p.lastPairs || 0, items: p.items }; } catch { /* fresh */ } }
+  const startIdx = has("--append") && prior.session === sess ? prior.lastPairs : 0;   // same session = resume; new session = score all its pairs
+  let fresh = allC.slice(startIdx);
+  if (!has("--append")) { const m = parseInt(flag("--max"), 10) || 400; if (fresh.length > m) fresh = fresh.slice(-m); }
+  const items = has("--append") ? prior.items.slice() : [];
+  const sid = sess.split("/").pop();
+  for (const { prior: a, user: u } of fresh) { let r = null; try { r = await harvestScore(a, u); } catch {} items.push({ session: sid, result: r }); }
+  const capped = items.slice(-1500);
+  const agg = aggregateCues(capped);
+  const rec = { at: new Date().toISOString(), backend: b, session: sess, lastPairs: allC.length, pairs: capped.length, ...agg, items: capped };
+  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.exit(0);
+}
+
 if (has("--help") || has("-h")) {
   process.stdout.write(`reins: measure how much you steer your agent this session
 

package/judge.mjs

@@ -1,25 +1,20 @@
-// judge.mjs - the steering-PRESSURE judge's backend socket.
+// judge.mjs - the steering judge's backend socket.
 //
-// score(prior, user) -> {pressure 0-3, axis, nudge}, via the backend SAWBUCK_JUDGE
-// selects. This file does network/LLM calls ON PURPOSE - it is a STANDALONE tool,
-// never imported into sawbuck's offline core (which is stabilizer-enforced
-// model-free). The deterministic yank meter lives in sawbuck; this LLM judge lives
-// here, the way steering lives in the harness layer, not the git core.
+//   score(prior, user)        -> {pressure 0-3, axis, nudge}   (the per-turn seismograph)
+//   harvestScore(prior, user) -> {steer, axis, magnitude, generalizable, cue}   (the wizard's cue finder)
+//
+// Both run through the backend SAWBUCK_JUDGE selects. This file does network/LLM calls ON
+// PURPOSE - it is a STANDALONE tool, never imported into sawbuck's offline core.
 //
 // Backends (SAWBUCK_JUDGE):
-//   ollama:<model>     local, free, private - the default (ollama:qwen2.5:7b),
-//                      "put your GPU to work"; OLLAMA_HOST overrides the endpoint.
-//   haiku              Anthropic claude-haiku-5-5 (needs ANTHROPIC_API_KEY); cheap
-//                      hosted, zero VRAM (~$0.00005/turn).
+//   ollama:<model>     local, free, private - the default (ollama:qwen2.5:7b). OLLAMA_HOST overrides.
+//   haiku              Anthropic claude-haiku-5-5 (needs ANTHROPIC_API_KEY); cheap hosted, zero VRAM.
 //   anthropic:<model>  any Anthropic model.
 //   openai:<model>     any OpenAI-compatible endpoint (OPENAI_BASE_URL + OPENAI_API_KEY).
 //
-// Benchmarked default = qwen2.5:7b: tied-best accuracy vs an opus gold, fastest
-// (0.2s/turn), smallest, 0 parse-fails; model size did not help (see the bench).
+// Benchmarked default = qwen2.5:7b: tied-best accuracy vs an opus gold, fastest, smallest.
 
-// JSON Schema that constrains the model's output (ollama structured outputs). This
-// is the robust fix for valid JSON - a grammar, not a prayer - so no backend
-// parse-fails the way free-form prompting did (qwen3's <think> truncation, etc.).
+// ---- schemas (ollama structured outputs: a grammar, not a prayer, so no parse-fails) ----
 const PRESSURE_SCHEMA = {
   type: "object",
   properties: {
@@ -29,6 +24,17 @@ const PRESSURE_SCHEMA = {
   },
   required: ["pressure", "axis", "nudge"],
 };
+const HARVEST_SCHEMA = {
+  type: "object",
+  properties: {
+    steer: { type: "boolean" },
+    axis: { type: "string" },
+    magnitude: { type: "string", enum: ["refine", "redirect", "hard-stop"] },
+    generalizable: { type: "boolean" },
+    cue: { type: "string" },
+  },
+  required: ["steer", "axis", "magnitude", "generalizable", "cue"],
+};
 
 const PROMPT = (a, u) =>
 `You rate how much a developer's message STEERS an AI coding agent's current work.
@@ -38,67 +44,89 @@ AGENT just did: ${a}
 USER replied: ${u}
 JSON:`;
 
+const HARVEST_PROMPT = (a, u) =>
+`You analyze a developer's message to an AI coding agent to find a repeated STEER: a correction of HOW the agent works, not a new task.
+Output ONLY one JSON object: {"steer":true|false,"axis":"one-word","magnitude":"refine|redirect|hard-stop","generalizable":true|false,"cue":"<=6 words"}
+steer: true if the message corrects or redirects the current work; false for a brand-new task, a pure question, or plain approval.
+axis: the dimension - rigor, scope, approach, correctness, format, process, tone, naming, or constraint.
+magnitude: refine (small adjustment) | redirect (change the approach) | hard-stop (reject or undo).
+generalizable: true if it is a STANDING preference that would apply to future work, false if specific to this one case.
+cue: a short imperative naming the rule, e.g. "verify before claiming done".
+AGENT just did: ${String(a).slice(0, 600)}
+USER replied: ${String(u).replace(/\s+/g, " ").slice(0, 800)}
+JSON:`;
+
 // lenient parse: strip reasoning-model <think> blocks, take the last JSON object.
-// (With a constrained-output backend the response is already clean; this is a net.)
-export function parse(txt) {
+function lastJson(txt) {
   txt = String(txt).replace(/<think>[\s\S]*?<\/think>/g, "");
   const cands = txt.match(/\{[^{}]*\}/g) || [];
-  for (const c of cands.reverse()) {
-    try {
-      const j = JSON.parse(c);
-      if (j && j.pressure != null) {
-        return {
-          pressure: Math.max(0, Math.min(3, parseInt(j.pressure, 10) || 0)),
-          axis: String(j.axis || "").slice(0, 16),
-          nudge: String(j.nudge || "").slice(0, 48),
-        };
-      }
-    } catch { /* keep scanning */ }
-  }
+  for (const c of cands.reverse()) { try { return JSON.parse(c); } catch { /* keep scanning */ } }
   return null;
 }
+export function parse(txt) {
+  const j = lastJson(txt);
+  if (!j || j.pressure == null) return null;
+  return {
+    pressure: Math.max(0, Math.min(3, parseInt(j.pressure, 10) || 0)),
+    axis: String(j.axis || "").slice(0, 16),
+    nudge: String(j.nudge || "").slice(0, 48),
+  };
+}
+export function parseHarvest(txt) {
+  const j = lastJson(txt);
+  if (!j || j.steer == null) return null;
+  const mags = ["refine", "redirect", "hard-stop"];
+  return {
+    steer: j.steer === true,
+    axis: String(j.axis || "other").toLowerCase().slice(0, 20),
+    magnitude: mags.includes(j.magnitude) ? j.magnitude : "refine",
+    generalizable: j.generalizable === true,
+    cue: String(j.cue || "").trim().slice(0, 60),
+  };
+}
+
+// one backend call -> RAW text (the caller parses). schema is used where the backend supports it (ollama).
+async function complete(promptStr, schema) {
+  const b = backend();
+  if (b === "haiku") return anthropic("claude-haiku-5-5", promptStr);
+  if (b.startsWith("anthropic:")) return anthropic(b.slice(10), promptStr);
+  if (b.startsWith("ollama:")) return ollama(b.slice(7), promptStr, schema);
+  if (b.startsWith("openai:")) return openai(b.slice(7), promptStr);
+  throw new Error("unknown SAWBUCK_JUDGE backend: " + b + " (use ollama:<model> | haiku | anthropic:<model> | openai:<model>)");
+}
 
-async function ollama(model, a, u) {
+async function ollama(model, promptStr, schema) {
   const host = process.env.OLLAMA_HOST || "http://localhost:11434";
   const res = await fetch(host + "/api/generate", {
     method: "POST", headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ model, prompt: PROMPT(a, u), stream: false, format: PRESSURE_SCHEMA, options: { temperature: 0, num_predict: 800 } }),
+    body: JSON.stringify({ model, prompt: promptStr, stream: false, format: schema, options: { temperature: 0, num_predict: 800 } }),
   });
   const j = await res.json();
-  return parse(j.response || "");
+  return j.response || "";
 }
-
-async function anthropic(model, a, u) {
+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)");
   const res = await fetch("https://api.anthropic.com/v1/messages", {
     method: "POST", headers: { "Content-Type": "application/json", "x-api-key": key, "anthropic-version": "2023-06-01" },
-    body: JSON.stringify({ model, max_tokens: 200, messages: [{ role: "user", content: PROMPT(a, u) }] }),
+    body: JSON.stringify({ model, max_tokens: 200, messages: [{ role: "user", content: promptStr }] }),
   });
   const j = await res.json();
-  const t = (j.content || []).filter((b) => b.type === "text").map((b) => b.text).join("");
-  return parse(t);
+  return (j.content || []).filter((x) => x.type === "text").map((x) => x.text).join("");
 }
-
-async function openai(model, a, u) {
+async function openai(model, promptStr) {
   const base = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
   const key = process.env.OPENAI_API_KEY;
   if (!key) throw new Error("OPENAI_API_KEY not set");
   const res = await fetch(base.replace(/\/$/, "") + "/chat/completions", {
     method: "POST", headers: { "Content-Type": "application/json", Authorization: "Bearer " + key },
-    body: JSON.stringify({ model, temperature: 0, max_tokens: 200, response_format: { type: "json_object" }, messages: [{ role: "user", content: PROMPT(a, u) }] }),
+    body: JSON.stringify({ model, temperature: 0, max_tokens: 200, response_format: { type: "json_object" }, messages: [{ role: "user", content: promptStr }] }),
   });
   const j = await res.json();
-  return parse(j.choices?.[0]?.message?.content || "");
+  return j.choices?.[0]?.message?.content || "";
 }
 
 export function backend() { return process.env.SAWBUCK_JUDGE || "ollama:qwen2.5:7b"; }
 
-export async function score(prior, user) {
-  const b = backend();
-  if (b === "haiku") return anthropic("claude-haiku-5-5", prior, user);
-  if (b.startsWith("anthropic:")) return anthropic(b.slice(10), prior, user);
-  if (b.startsWith("ollama:")) return ollama(b.slice(7), prior, user);
-  if (b.startsWith("openai:")) return openai(b.slice(7), prior, user);
-  throw new Error("unknown SAWBUCK_JUDGE backend: " + b + " (use ollama:<model> | haiku | anthropic:<model> | openai:<model>)");
-}
+export async function score(prior, user) { return parse(await complete(PROMPT(prior, user), PRESSURE_SCHEMA)); }
+export async function harvestScore(prior, user) { return parseHarvest(await complete(HARVEST_PROMPT(prior, user), HARVEST_SCHEMA)); }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@sawbuck/reins",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "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": "MIT",
+  "license": "Apache-2.0",
   "bin": {
     "reins": "bin/reins.mjs"
   },
@@ -14,6 +14,9 @@
     "bin/reins.mjs",
     "judge.mjs",
     "scan.mjs",
-    "README.md"
+    "wizard.mjs",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
   ]
 }

package/scan.mjs

@@ -101,3 +101,26 @@ export function resolveSessionPath(explicit, cwd = process.cwd()) {
   }
   return best;
 }
+
+// Enumerate recent Claude Code session transcripts across ALL projects, newest first.
+// For the wizard's harvest ("read my old chats"). { limit } caps the count; { sinceMs }
+// drops anything older. Best-effort; returns [] if the projects dir is missing.
+export function resolveSessions({ limit = 0, sinceMs = 0 } = {}) {
+  const root = join(homedir(), ".claude", "projects");
+  if (!existsSync(root)) return [];
+  let dirs = [];
+  try { dirs = readdirSync(root).map((d) => join(root, d)).filter((p) => { try { return statSync(p).isDirectory(); } catch { return false; } }); }
+  catch { return []; }
+  const found = [];
+  for (const d of dirs) {
+    let files = []; try { files = readdirSync(d); } catch { continue; }
+    for (const f of files) {
+      if (!f.endsWith(".jsonl")) continue;
+      const p = join(d, f);
+      try { const st = statSync(p); if (sinceMs && st.mtimeMs < sinceMs) continue; found.push({ path: p, mtime: st.mtimeMs }); } catch {}
+    }
+  }
+  found.sort((a, b) => b.mtime - a.mtime);
+  const sliced = limit > 0 ? found.slice(0, limit) : found;
+  return sliced.map((f) => f.path);
+}

package/wizard.mjs

@@ -0,0 +1,62 @@
+// wizard.mjs - the harvest: read your old Claude Code chats, find the STEERS you keep
+// giving, and rank them into a cue inventory, so a fresh saddle already knows your style.
+//
+// Token honesty: every turn-pair is read by a model. On the default local ollama that is
+// free (just compute); on a hosted backend it costs a little. The CLI prints the count and
+// the backend before it runs. The scorer is injected here so the aggregation is testable
+// without a model.
+
+import { readFileSync } from "node:fs";
+import { pairs, resolveSessions } from "./scan.mjs";
+
+// aggregateCues(items) -> ranked cue inventory. items = [{ session, result }], where
+// result = { steer, axis, magnitude, generalizable, cue } | null. Pure + deterministic.
+// Rank = distinct-session support, then generalizable count, then raw frequency (so a
+// one-session spike never outranks a cue you give across many sessions - the study's lesson).
+export function aggregateCues(items) {
+  const clusters = new Map();
+  let scored = 0, steers = 0, fails = 0;
+  for (const { session, result } of items) {
+    if (!result) { fails++; continue; }
+    scored++;
+    if (!result.steer) continue;
+    steers++;
+    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++;
+    if (result.generalizable) c.gen++;
+    if (result.magnitude && c.mag[result.magnitude] != null) c.mag[result.magnitude]++;
+    if (session) c.sessions.add(session);
+    // keep the most specific non-empty cue text seen for this cluster
+    if (!c.cue && result.cue) c.cue = result.cue;
+    clusters.set(key, c);
+  }
+  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 };
+}
+
+// harvest(scoreFn, { sessions, maxPairs }) -> aggregateCues over the pairs in those session
+// files, newest first, capped at maxPairs (cost control). scoreFn(prior, user) -> result | null.
+export async function harvest(scoreFn, { sessions = [], maxPairs = 400 } = {}) {
+  const items = [];
+  const gathered = [];
+  for (const path of sessions) {
+    let text = ""; try { text = readFileSync(path, "utf8"); } catch { continue; }
+    for (const p of pairs(text)) {
+      gathered.push({ ...p, session: path });
+      if (gathered.length >= maxPairs) break;
+    }
+    if (gathered.length >= maxPairs) break;
+  }
+  for (const { prior, user, session } of gathered) {
+    let result = null;
+    try { result = await scoreFn(prior, user); } catch { result = null; }
+    items.push({ session, result });
+  }
+  const agg = aggregateCues(items);
+  return { pairs: gathered.length, sessionsRead: sessions.length, ...agg };
+}
+
+export { resolveSessions };