crewforth 3.1.1 → 3.2.0-rc.10

package/kit/eval/lib/review-prepass/prepass.mjs

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+// prepass.mjs — the review's deterministic first pass: cheap checks over the lines a change ADDS, run before the
+// review agent reads the diff, written as a findings document (crewforth.findings/1) the agent starts from.
+//
+//   node prepass.mjs [--root DIR] [--base REF] [--stdout]
+//       default   the staged change (git diff --cached), what the next commit will hold
+//       --base    the working tree against REF (a branch under review: --base origin/next)
+//       --stdout  print the document, write nothing; otherwise .crewforth/review-prepass.json, through findings.mjs
+//   rc 0 = written (or printed), whatever it found · 1 = the document did not verify, nothing written ·
+//   2 = usage, or not a git repository
+//
+// The checks are chosen by the file, and kept narrow on purpose: a first pass that cries wolf trains the reader to
+// skip it. Each one either reads the added line alone (proven) or one fact next to it (inferred):
+//
+//   prepass-secret        a secret-blocklist.txt pattern on an added line (the pre-commit gate's own list and
+//                         .secret-allowlist.txt). Cited by sha256 only: the value is never quoted.
+//   prepass-debug-call    console.log / debugger (JS, TS), breakpoint() / pdb (Python), print( (Dart), outside a
+//                         test and outside a command-line script (a shebang, or a bin/, scripts/ or tool/ folder).
+//   prepass-todo          a TODO, FIXME, XXX or HACK opening a comment added in code, outside tests
+//                         (Markdown is prose, not a promise; the word in a string or a pattern is not a marker).
+//   prepass-shellcheck    shellcheck's own findings on a shell file, kept to the added lines. Without shellcheck
+//                         the shell files are listed as not measured: nothing is installed.
+//   prepass-lockfile      a lock file changed and the manifest beside it did not (inferred: a regenerated lock
+//                         can be on purpose).
+//   prepass-large-change  one file gains more than 500 lines (generated files, locks and snapshots aside).
+//
+// What it does not do: judge. A finding here says a line is there; whether it matters is the reviewer's call, and
+// the reviewer writes its own findings beside these (.crewforth/review.json), in the same shape.
+// Host-independent like findings.mjs: git, Node's standard library, and shellcheck when it is there.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { loadSecretPatterns, isTestPath } from '../crew-map/project.mjs';
+import { SCHEMA_ID, validate, write, serialize } from '../findings/findings.mjs';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+export const NAME = 'review-prepass';
+const LARGE = 500;
+const QUOTE = 200;
+
+const DEBUG = [
+  { files: /\.(m?[jt]sx?|cjs|cts|vue|svelte)$/, re: /\bconsole\.(log|debug|trace)\(|^\s*debugger\s*;?\s*$/, what: 'a console call or debugger statement' },
+  { files: /\.py$/, re: /\bbreakpoint\(\)|\bpdb\.set_trace\(|^\s*import\s+pdb\b/, what: 'a debugger breakpoint' },
+  { files: /\.dart$/, re: /^\s*print\(/, what: 'a print call' },
+];
+const SCRIPT_DIR = /(^|\/)(bin|scripts?|tools?|tool)\//;
+// A marker opens a comment; the word inside a string, a pattern or prose that names it is not one.
+const TODO = /(?:\/\/|#|\/\*|^\s*\*|--|<!--)\s*(TODO|FIXME|XXX|HACK)\b/;
+const PROSE = /\.(md|markdown|txt|rst|adoc)$/i;
+const SHELL = /\.(sh|bash)$/;
+const SECRET_LISTS = /(^|\/)secret-(block|allow)list\.txt$/;
+// A lock file and the manifest that declares what it pins, in the same folder.
+const LOCKS = {
+  'package-lock.json': 'package.json', 'npm-shrinkwrap.json': 'package.json', 'yarn.lock': 'package.json',
+  'pnpm-lock.yaml': 'package.json', 'bun.lockb': 'package.json', 'pubspec.lock': 'pubspec.yaml',
+  'poetry.lock': 'pyproject.toml', 'uv.lock': 'pyproject.toml', 'Pipfile.lock': 'Pipfile', 'go.sum': 'go.mod',
+  'Cargo.lock': 'Cargo.toml', 'composer.lock': 'composer.json', 'Gemfile.lock': 'Gemfile',
+};
+const GENERATED = /(^|\/)(dist|build|vendor|node_modules|__snapshots__)\/|\.(g|freezed|gr|pb)\.dart$|\.min\.(js|css)$|\.snap$|\.lock$|-lock\.(json|yaml)$/;
+
+const sha = (s) => crypto.createHash('sha256').update(s).digest('hex');
+const git = (root, args) => spawnSync('git', ['-C', root, '-c', 'core.quotePath=false', ...args], { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+
+// The added lines of a unified diff with no context: { file, line, text }[] and the files it touches.
+export function addedLines(diff) {
+  const added = []; const files = new Set(); const binary = new Set();
+  let file = null; let n = 0;
+  for (const raw of diff.split('\n')) {
+    if (raw.startsWith('diff --git ')) { file = null; continue; }
+    if (raw.startsWith('+++ ')) { file = raw === '+++ /dev/null' ? null : raw.slice(6).replace(/\t$/, ''); if (file) files.add(file); continue; }
+    if (raw.startsWith('Binary files ')) { const b = / and b\/(.*) differ$/.exec(raw); if (b) binary.add(b[1]); continue; }
+    const h = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(raw);
+    if (h) { n = Number(h[1]); continue; }
+    if (file && raw.startsWith('+')) { added.push({ file, line: n, text: raw.slice(1).replace(/\r$/, '') }); n++; }
+  }
+  return { added, files: [...files].sort(), binary: [...binary].sort() };
+}
+
+// A finding id from a rule, a file and a line: lower case, the schema's characters only, unique in the document.
+function idOf(seen, rule, file, line) {
+  let id = `${rule}:${file.toLowerCase().replace(/[^a-z0-9._-]+/g, '-')}:${line}`.slice(0, 190);
+  if (seen.has(id)) { let k = 2; while (seen.has(`${id}.${k}`)) k++; id = `${id}.${k}`; }
+  seen.add(id); return id;
+}
+
+export function prepass(root = '.', { base = null } = {}) {
+  const rootReal = fs.realpathSync(root);
+  const top = git(rootReal, ['rev-parse', '--show-toplevel']);
+  if (top.status !== 0) throw new Error('not a git repository');
+  const diffArgs = ['diff', '--no-ext-diff', '--no-textconv', '--no-color', '-U0', '--diff-filter=AMR'];
+  const d = git(rootReal, base ? [...diffArgs, base, '--'] : [...diffArgs, '--cached', '--']);
+  if (d.status !== 0) throw new Error(`git diff failed: ${(d.stderr || '').trim().split('\n')[0]}`);
+  const { added, files, binary } = addedLines(d.stdout);
+
+  const doc = { schema: SCHEMA_ID, producer: { name: NAME, version: '1' }, findings: [], notMeasured: [] };
+  const seen = new Set();
+  const machine = [rootReal, os.homedir()].filter((p) => p && p.length > 1);
+  const add = (rule, severity, confidence, title, at, detail, quote = true) => {
+    // A line that carries this machine's directory, or must not be quoted, is cited by its hash.
+    const ev = { file: at.file, line: at.line };
+    if (quote && !machine.some((m) => at.text.includes(m)) && at.text.trim()) ev.text = at.text.trim().slice(0, QUOTE);
+    else ev.sha256 = sha(at.text);
+    doc.findings.push({ id: idOf(seen, rule, at.file, at.line), rule, title, confidence, severity, ...(detail ? { detail } : {}), evidence: [ev] });
+  };
+
+  // A staged line the working tree no longer has cannot be cited (the citation is checked against the tree).
+  const tree = new Map();
+  const linesOf = (f) => { if (!tree.has(f)) { let t = null; try { t = fs.readFileSync(path.join(rootReal, f), 'utf8').split('\n').map((l) => l.replace(/\r$/, '')); } catch { /* gone */ } tree.set(f, t); } return tree.get(f); };
+  const stale = new Set();
+  const lines = added.filter((a) => { const t = linesOf(a.file); if (t && t[a.line - 1] === a.text) return true; stale.add(a.file); return false; });
+  for (const f of [...stale].sort()) doc.notMeasured.push({ what: f, reason: 'edited again after it was staged: its staged lines are not the ones on disk, so they were not read' });
+  for (const f of binary) doc.notMeasured.push({ what: f, reason: 'a binary file: no line to read' });
+
+  // ---- secrets: the pre-commit gate's list, minus the project's allowlist ----
+  let allow = new Set();
+  try { allow = new Set(fs.readFileSync(path.join(rootReal, '.secret-allowlist.txt'), 'utf8').split('\n').map((l) => l.replace(/\r$/, '')).filter(Boolean)); } catch { /* none */ }
+  const patterns = loadSecretPatterns(path.join(HERE, '..', 'crew-map'), allow);
+  if (!patterns) doc.notMeasured.push({ what: 'prepass-secret', reason: 'secret-blocklist.txt was not found beside the hooks, so no line was checked for a secret' });
+  const byFile = new Map();
+  for (const a of lines) { if (!byFile.has(a.file)) byFile.set(a.file, []); byFile.get(a.file).push(a); }
+
+  for (const [f, list] of [...byFile].sort((x, y) => (x[0] < y[0] ? -1 : 1))) {
+    const test = isTestPath(f);
+    const first = linesOf(f)?.[0] ?? '';
+    const script = first.startsWith('#!') || SCRIPT_DIR.test(f);
+    const debug = DEBUG.find((x) => x.files.test(f));
+    for (const a of list) {
+      if (patterns && !SECRET_LISTS.test(f) && patterns.some((re) => re.test(a.text))) {
+        add('prepass-secret', 'high', 'proven', 'A secret pattern on an added line', a, 'It matches a pattern of secret-blocklist.txt, the list the pre-commit gate refuses; the value is not quoted here.', false);
+        continue;
+      }
+      if (debug && !test && !script && debug.re.test(a.text)) add('prepass-debug-call', 'low', 'proven', `An added ${debug.what}`, a);
+      if (!PROSE.test(f) && !test && TODO.test(a.text)) add('prepass-todo', 'info', 'proven', `An added ${TODO.exec(a.text)[1]}`, a);
+    }
+    if (list.length > LARGE && !GENERATED.test(f)) add('prepass-large-change', 'low', 'proven', `${list.length} lines added to one file`, list[0], 'A change this size is hard to review in one pass; split it, or say in the description what to read first.');
+  }
+
+  // ---- lock files: the manifest beside them should have changed too ----
+  const changed = new Set(files);
+  for (const f of files) {
+    const want = LOCKS[path.posix.basename(f)]; if (!want) continue;
+    const dir = path.posix.dirname(f); const manifest = dir === '.' ? want : `${dir}/${want}`;
+    if (changed.has(manifest) || !fs.existsSync(path.join(rootReal, manifest))) continue;
+    const at = byFile.get(f)?.[0]; if (!at) continue;
+    add('prepass-lockfile', 'low', 'inferred', `${path.posix.basename(f)} changed and ${want} did not`, at, 'A lock file that moves on its own pins different versions than the manifest asks for; regenerate it from the manifest, or say why it moved.');
+  }
+
+  // ---- shell: shellcheck's findings on the added lines ----
+  const shells = [...byFile.keys()].filter((f) => SHELL.test(f) || /^#!.*\b(ba|z|da)?sh\b/.test(linesOf(f)?.[0] ?? '')).sort();
+  if (shells.length) {
+    // CREW_SHELLCHECK names another shellcheck. One ending in .mjs is run with this Node: the self-check's stand-in,
+    // which a Windows runner could not start as a `#!/bin/sh` script (spawnSync runs no interpreter line there).
+    const sc = process.env.CREW_SHELLCHECK || 'shellcheck';
+    const run = (args, opts) => (sc.endsWith('.mjs') ? spawnSync(process.execPath, [sc, ...args], opts) : spawnSync(sc, args, opts));
+    const v = run(['--version'], { encoding: 'utf8' });
+    if (v.status !== 0) doc.notMeasured.push({ what: `prepass-shellcheck (${shells.length} shell file${shells.length === 1 ? '' : 's'})`, reason: 'shellcheck is not installed here, so the shell files were not linted; nothing was installed' });
+    else {
+      for (const f of shells) {
+        const r = run(['-f', 'json1', '-x', f], { cwd: rootReal, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+        let out; try { out = JSON.parse(r.stdout || '{}'); } catch { doc.notMeasured.push({ what: f, reason: 'shellcheck gave no output this pass can read' }); continue; }
+        const at = new Map(byFile.get(f).map((a) => [a.line, a]));
+        for (const c of out.comments ?? []) {
+          const a = at.get(c.line); if (!a) continue;
+          const sev = { error: 'medium', warning: 'low' }[c.level] ?? 'info';
+          add('prepass-shellcheck', sev, 'proven', `SC${c.code}: ${String(c.message).slice(0, 180)}`, a);
+        }
+      }
+    }
+  }
+  doc.findings.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  return doc;
+}
+
+function main(argv) {
+  let root = '.'; let base = null; let stdout = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--root') root = argv[++i];
+    else if (a === '--base') base = argv[++i];
+    else if (a === '--stdout') stdout = true;
+    else { console.error(`prepass: unknown argument ${a}\nusage: prepass.mjs [--root DIR] [--base REF] [--stdout]`); return 2; }
+    if (root === undefined || base === undefined) { console.error('prepass: --root and --base need a value'); return 2; }
+  }
+  let doc;
+  try { doc = prepass(root, { base }); } catch (e) { console.error(`prepass: ${e.message}`); return 2; }
+  const count = (s) => doc.findings.filter((f) => f.severity === s).length;
+  const line = `review-prepass: ${doc.findings.length} finding(s) · high ${count('high')} · medium ${count('medium')} · low ${count('low')} · info ${count('info')} · ${doc.notMeasured.length} not measured`;
+  if (stdout) {
+    const r = validate(doc, root);
+    if (!r.ok) { for (const p of r.problems) console.error(`prepass: ${p.at} ${p.code}: ${p.message}`); return 1; }
+    process.stdout.write(serialize(doc)); console.error(line); return 0;
+  }
+  const r = write(doc, root, NAME);
+  if (!r.ok) { for (const p of r.problems) console.error(`prepass: ${p.at} ${p.code}: ${p.message}`); return 1; }
+  console.log(`${line} → ${r.file}`);
+  return 0;
+}
+
+if (process.argv[1] && fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) process.exitCode = main(process.argv.slice(2));

package/kit/eval/lib/review-prepass/prepass.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# prepass.sh — the shell entry to prepass.mjs, the review's deterministic first pass. It finds a Node that RUNS
+# and hands over; the arguments and exit codes are prepass.mjs's (0, 1, 2).
+#
+#   bash prepass.sh [--root DIR] [--base REF] [--stdout]
+#       rc 3 = no usable Node here, so nothing was checked. Not a pass: the review then reads the diff without it.
+#
+# The Node is found the way findings.sh finds it (one rule): asked for its version, never trusted by name.
+set -u
+d="${BASH_SOURCE%[/\\]*}"; [ "$d" = "${BASH_SOURCE}" ] && d=.
+FLOOR=18
+usable(){ local v; v="$("$1" -p 'process.versions.node.split(".")[0]' 2>/dev/null)" || return 1
+  case "$v" in ''|*[!0-9]*) return 1 ;; esac; [ "$v" -ge "$FLOOR" ]; }
+NODE=""
+if usable node; then NODE=node
+elif [ -f "$d/../../../studio/ensure-node.sh" ]; then
+  n="$(bash "$d/../../../studio/ensure-node.sh" 2>/dev/null)" && [ -n "$n" ] && usable "$n" && NODE="$n"
+fi
+if [ -z "$NODE" ]; then
+  echo "review-prepass: no Node $FLOOR+ that runs was found, so nothing was checked (this is not a pass)" >&2
+  exit 3
+fi
+exec "$NODE" "$d/prepass.mjs" "$@"

package/kit/eval/lib/settings-default.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# settings-default.sh — put one of Crewforth's defaults into the project's .claude/settings.json, only where nothing
+# sets it yet. The project's settings win over the user's, so writing a default over a user's own choice would
+# silently replace it: a value set in the project's settings, its local settings or the user's own is kept.
+#
+#   bash settings-default.sh --install <path> <defaults.json> [ENV_VAR]     from the project root
+#     <path>           the setting, as a dot path: statusLine, env.CLAUDE_CODE_SUBAGENT_MODEL
+#     <defaults.json>  a JSON object holding just that setting (data beside the caller: one definition)
+#     ENV_VAR          also kept when this variable is set in the environment (a value exported in the shell)
+#
+# Prints one word: installed · kept (it is set) · none (no settings.json) · failed (the file is left as it was).
+# A managed settings layer is not read. The merge is Crewforth's own JSON reader.
+set -u
+_here="${BASH_SOURCE%[/\\]*}"; [ "$_here" = "${BASH_SOURCE}" ] && _here=.
+
+[ "${1:-}" = --install ] && [ -n "${2:-}" ] && [ -n "${3:-}" ] || { echo "usage: settings-default.sh --install <path> <defaults.json> [ENV_VAR]" >&2; exit 2; }
+KEY="$2"; K="$3"; VAR="${4:-}"
+P=".claude/settings.json"; SJ="$_here/settings-json.awk"
+[ -f "$P" ] && [ -f "$SJ" ] || { echo none; exit 0; }
+case "$VAR" in '') ;; [A-Za-z_]*) case "$VAR" in *[!A-Za-z0-9_]*) echo failed; exit 0 ;; esac; [ -n "${!VAR:-}" ] && { echo kept; exit 0; } ;; *) echo failed; exit 0 ;; esac
+for f in "$P" ".claude/settings.local.json" "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/settings.json"; do
+  [ -f "$f" ] && awk -v op=get -v path="$KEY" -f "$SJ" "$f" >/dev/null 2>&1 && { echo kept; exit 0; }
+done
+[ -f "$K" ] || { echo failed; exit 0; }
+t="$P.default.$$"
+r=failed
+# The project's file goes FIRST: the merge refreshes the first file's .claude/hooks/ entries from the first file,
+# so put second it would lose every Crewforth hook (measured: the installed project's own smoke failed 30 checks).
+# The second file holds only the default, which the first lacks: that is the one change (an object such as env is
+# merged member by member, the project's own members kept). Written through the file, so a symlink and its mode
+# survive.
+if awk -v op=merge -v retired= -f "$SJ" "$P" "$K" > "$t" 2>/dev/null && [ -s "$t" ] \
+   && awk -v op=validate -f "$SJ" "$t" 2>/dev/null && awk -v op=get -v path="$KEY" -f "$SJ" "$t" >/dev/null 2>&1; then
+  cat "$t" > "$P" && r=installed
+fi
+rm -f "$t"; echo "$r"

package/kit/eval/lib/settings-json.awk

@@ -4,10 +4,16 @@
 #   awk -v op=validate -f settings-json.awk FILE              rc 0 = FILE is a JSON object, 1 = it is not
 #   awk -v op=get -v path=hooks.Stop.0 -f settings-json.awk FILE   the value there, as the merge would print it
 #   awk -v op=len -v path=hooks.Stop -f settings-json.awk FILE     how many entries an array/object holds
+#   awk -v op=gets -v path='a.b|c.d' -f settings-json.awk FILE   several values in one read, tab-separated, "" if absent
 #   awk -v op=strings -v path=permissions.deny -f settings-json.awk FILE   each string element of that array, one per
 #       line, quotes off, escapes as written (rc 1 = not an array)
+#   awk -v op=keys [-v path=P] -f settings-json.awk FILE   the member names of the object there, one per line, quotes
+#       off, in file order (rc 1 = not an object)
 #       path = dot-separated keys, a number indexes an array (0-based), empty = the root. rc 1 = no such path
 #       (or, for len, a scalar there), 10 = FILE is not a JSON object.
+#   awk -v op=get -v path=P -v setk=M -v setv=RAWJSON -f settings-json.awk FILE   the object at P with member M set
+#       to RAWJSON (added when absent): a payload rewritten in one field, every other field and escape kept
+#       (rc 1 = nothing at P, or not an object)
 #   awk -v op=overlay -v key=K [-v setk=M -v setv=RAWJSON] -f settings-json.awk FILE1 FILE2
 #       FILE1 with FILE1.K shallow-merged from FILE2.K (FILE2 wins, FILE1's other members and order kept), then
 #       member M set to RAWJSON. rc 10 = FILE1 (or its K) is not an object, 11 = FILE2 has no object at K.
@@ -69,6 +75,10 @@ function at(id,path,  n,sg,i){ n=split(path,sg,".")
   return id }
 function mk(t){ NN++; T[NN]=t; N[NN]=0; return NN }
 function add(o,k,c){ N[o]++; K[o,N[o]]=k; C[o,N[o]]=c }
+# Member k of object o set to the raw JSON v, added at the end when o has none (overlay and get share it).
+function setm(o,k,v,  sn,i,x){ sn=mk("s"); V[sn]=v; x=0
+  for(i=1;i<=N[o];i++) if(K[o,i]=="\"" k "\""){ C[o,i]=sn; x=1 }
+  if(!x) add(o,"\"" k "\"",sn) }
 function canon(id,  i,j,n,s,t,ord){
   if(T[id]=="s") return V[id]
   if(T[id]=="a"){ s="["; for(i=1;i<=N[id];i++) s=s (i>1 ? "," : "") canon(C[id,i]); return s "]" }
@@ -124,18 +134,23 @@ END{
       print (it && !isnull(it) ? V[it] : 0) + V[cr] + (cc && !isnull(cc) ? V[cc] : 0); exit 0 }
     exit 0 }
   if(op=="validate") exit !doc(1)
+  # gets: several paths in one read (path = "a.b|c.d"), their values on one line, tab-separated; an absent one is
+  # empty. One process for what a hot caller (the status line) would otherwise read with one awk per field.
+  if(op=="gets"){ if(!(r=doc(1))) exit 10; n=split(path,pp,"|"); o=""
+    for(i=1;i<=n;i++){ x=at(r,pp[i]); o=o (i>1?"\t":"") (x ? put(x,"") : "") } print o; exit 0 }
   if(op=="get" || op=="len"){ if(!(r=doc(1))) exit 10; if(!(r=at(r,path))) exit 1
-    if(op=="get"){ print put(r,""); exit 0 } if(T[r]=="s") exit 1; print N[r]; exit 0 }
+    if(op=="get"){ if(setk!=""){ if(T[r]!="o") exit 1; setm(r,setk,setv) } print put(r,""); exit 0 }
+    if(T[r]=="s") exit 1; print N[r]; exit 0 }
   if(op=="strings"){ if(!(r=doc(1))) exit 10; if(!(r=at(r,path))) exit 1; if(T[r]!="a") exit 1
     for(i=1;i<=N[r];i++){ c=C[r,i]; if(T[c]=="s" && substr(V[c],1,1)=="\"") print substr(V[c],2,length(V[c])-2) }
     exit 0 }
+  if(op=="keys"){ if(!(r=doc(1))) exit 10; if(!(r=at(r,path))) exit 1; if(T[r]!="o") exit 1
+    for(i=1;i<=N[r];i++){ k=K[r,i]; print substr(k,2,length(k)-2) } exit 0 }
   if(op=="overlay"){ if(!(t=doc(1))) exit 10; if(!(q=doc(2))) exit 11; kk="\"" key "\""
     qv=get(q,kk); if(T[qv]!="o") exit 11; tv=get(t,kk); if(tv && T[tv]!="o") exit 10
     nv=mk("o"); for(i=1;i<=N[tv];i++){ x=get(qv,K[tv,i]); add(nv,K[tv,i], x ? x : C[tv,i]) }
     for(i=1;i<=N[qv];i++) if(!get(nv,K[qv,i])) add(nv,K[qv,i],C[qv,i])
-    if(setk!=""){ sn=mk("s"); V[sn]=setv; x=0
-      for(i=1;i<=N[nv];i++) if(K[nv,i]=="\"" setk "\""){ C[nv,i]=sn; x=1 }
-      if(!x) add(nv,"\"" setk "\"",sn) }
+    if(setk!="") setm(nv,setk,setv)
     x=0; for(i=1;i<=N[t];i++) if(K[t,i]==kk){ C[t,i]=nv; x=1 }
     if(!x) add(t,kk,nv)
     print put(t,""); exit 0 }

package/kit/eval/lib/star.sh

@@ -1,10 +1,13 @@
 #!/usr/bin/env bash
 # The one "leave a star" line. Single source of its URL, its text in both languages, and when it stays quiet.
 #
-#   star.sh --once <project>   ONCE PER KIT VERSION per clone. The installers (first install, and every update)
-#                              and doctor.sh on a healthy verdict all call it this way and share one marker, so a
-#                              version shows the line once — whichever of them reaches it first — and never again
-#                              until the Crewforth version changes. The marker holds the version it was shown for.
+#   star.sh --once <project> [doctor]
+#                              ONCE PER KIT VERSION per clone and per caller. The installers (first install, and
+#                              every update) share one marker; doctor (doctor.sh on a healthy verdict, and the
+#                              plugin's /crew-doctor) keeps its own, `doctor`. So a version shows the line at most
+#                              twice, once where it was installed and once where it was checked, and never again
+#                              until the Crewforth version changes. A marker holds the version it was shown for.
+#                              /crew-update runs its doctor with CREW_NO_STAR=1, so one command never shows it twice.
 #   star.sh                    unconditional (tests, and anyone who wants to see it).
 #
 # Nothing else prints it: not a hook, not a session start. Cost: one line (~30 tokens) per version, and only when
@@ -31,11 +34,21 @@ if [ "${1:-}" = --once ]; then
   # Builtin reads, not `head | tr` in a $( ): on Git Bash those two pipelines were 4 of ~11 processes and ~250 ms
   # of ~395 ms per call (measured on stock Windows). `read` takes the first line; the CR is stripped by expansion.
   # The braces matter: a failed `<` reports before a trailing 2>/dev/null applies (measured: 450 bytes of stderr).
-  VER=""; { IFS= read -r VER < "$_dir/.claude/VERSION"; } 2>/dev/null; VER="${VER%$'\r'}"; VER="${VER:-unknown}"
+  VER=""; { IFS= read -r VER < "$_dir/.claude/VERSION"; } 2>/dev/null; VER="${VER%$'\r'}"
+  # The plugin edition has no .claude/VERSION: its version is the manifest's, beside this file at ../../.
+  if [ -z "$VER" ]; then
+    _here="${BASH_SOURCE%[/\\]*}"; [ "$_here" = "${BASH_SOURCE}" ] && _here=.
+    [ -f "$_here/../../.claude-plugin/plugin.json" ] && [ -f "$_here/settings-json.awk" ] && \
+      VER="$(awk -v op=get -v path=version -f "$_here/settings-json.awk" "$_here/../../.claude-plugin/plugin.json" 2>/dev/null)"
+    VER="${VER#\"}"; VER="${VER%\"}"            # the reader prints a JSON string with its quotes
+    case "$VER" in *[!0-9A-Za-z.-]*) VER="" ;; esac
+  fi
+  VER="${VER:-unknown}"
+  _key=crewforth-star; [ "${3:-}" = doctor ] && _key=crewforth-star-doctor
   # GIT_DIR/GIT_WORK_TREE dropped: exported by a caller (a hook), they would point the marker at another repo.
-  MARK="$(cd "$_dir" 2>/dev/null && env -u GIT_DIR -u GIT_WORK_TREE git rev-parse --git-path crewforth-star 2>/dev/null)" || MARK=""
+  MARK="$(cd "$_dir" 2>/dev/null && env -u GIT_DIR -u GIT_WORK_TREE git rev-parse --git-path "$_key" 2>/dev/null)" || MARK=""
   case "$MARK" in
-    '') MARK="$_dir/.claude/star-shown" ;;
+    '') MARK="$_dir/.claude/star-shown"; [ "$_key" = crewforth-star ] || MARK="$MARK-doctor" ;;
     /*|[A-Za-z]:*) ;;                          # absolute (POSIX or a Windows drive path from git)
     *) MARK="$_dir/$MARK" ;;                   # git answers relative to the directory it was asked in
   esac
@@ -65,6 +78,9 @@ _mt() {
 _mt '⭐ If Crewforth saves you a review round, a star helps others find it: %s' "$CREW_REPO_URL"
 # The marker only after the line actually went out: a closed stdout must not record "shown".
 if printf '%s\n' "$_M" && [ -n "$MARK" ]; then
+  # A plugin project may have no .claude/ yet: without one the marker would never be written and the line would
+  # come back on every run.
+  [ -d "${MARK%/*}" ] || mkdir -p "${MARK%/*}" 2>/dev/null
   { printf '%s\n' "$VER" > "$MARK"; } 2>/dev/null
 fi
 exit 0

package/kit/eval/lib/statusline.settings.json

@@ -0,0 +1,6 @@
+{
+  "statusLine": {
+    "type": "command",
+    "command": "cd \"$CLAUDE_PROJECT_DIR\" 2>/dev/null; bash .claude/eval/lib/statusline.sh"
+  }
+}

package/kit/eval/lib/statusline.sh

@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+# statusline.sh — Crewforth's status line: one line, from what Claude Code hands it on stdin and what the hooks
+# have already written. It decides nothing and blocks nothing; it only says.
+#
+#   🛡 BLOCK §4.2 · ✓ commit approved 24m · ⚙ 2 crew agents · 🔋 34% · ~$1.20
+#
+# Each part is shown only when there is something to say, and only for THIS session:
+#   🛡  the gate's last word in this session: the last line of the gate log, if it was written after the session's
+#       first status line (the log carries no time, so a line from last week must not read as now)
+#   ✓   an approval the user gave for a commit or a push that still holds (the record prompt-approval.sh keeps in
+#       the git directory, 30 minutes, emptied at the user's next message)
+#   ⚙   crew agents started in this session that have not stopped yet (model routing's records)
+#   🔋  the context fill Claude Code measured (context_window.used_percentage), never an estimate
+#   ~$  what Claude Code puts the session's cost at (cost.total_cost_usd), at API list price
+#
+# Wired by the installers only where no status line is set already (theirs is never replaced), from
+# statusline.settings.json beside this file.
+# COST. Claude Code runs this after every change, debounced at 300 ms. Measured: awk (the stdin JSON) and tail (the
+# gate log), and on bash older than 4.2 one date; the rest is builtins. No git, no jq, no python.
+set -u
+_here="${BASH_SOURCE%[/\\]*}"; [ "$_here" = "${BASH_SOURCE}" ] && _here=.
+
+# --install, from the project root: put this status line into .claude/settings.json only where NO status line is
+# set (the project's settings, its local settings, or the user's own); a user's line is never replaced, because
+# the project's setting would win over it. Prints one word: installed · kept (one is set) · none (no settings.json)
+# · failed (the file is left as it was). A managed settings layer is not read. The merge is Crewforth's own JSON reader.
+if [ "${1:-}" = --install ]; then
+  # The setting itself is data beside this file (statusline.settings.json); the rule for putting a default in is
+  # one helper, shared with the subagent model's default.
+  exec bash "$_here/settings-default.sh" --install statusLine "$_here/statusline.settings.json"
+fi
+
+IFS= read -r -d '' IN || true
+[ -n "$IN" ] || exit 0
+# One read of the four values the line needs.
+F="$(printf '%s' "$IN" | awk -v op=gets -v 'path=session_id|context_window.used_percentage|cost.total_cost_usd|workspace.project_dir' -f "$_here/settings-json.awk" - 2>/dev/null)" || F=""
+IFS=$'\t' read -r SID PCT COST PDIR <<< "$F"
+# The reader prints a string with its quotes; taken off by expansion, not a subshell (this runs every few seconds).
+SID="${SID:-}"; SID="${SID#\"}"; SID="${SID%\"}"; PDIR="${PDIR:-}"; PDIR="${PDIR#\"}"; PDIR="${PDIR%\"}"
+case "$SID" in ''|*[!A-Za-z0-9._-]*) SID="" ;; esac
+[ -n "$PDIR" ] && [ -d "$PDIR/.claude" ] && cd "$PDIR" 2>/dev/null
+
+OUT=()
+# The session's baseline: made on its first status line. What is newer than it happened in this session.
+BASE=""
+if [ -n "$SID" ] && [ -d .claude ]; then
+  BASE=".claude/state/statusline/$SID"
+  if [ ! -e "$BASE" ]; then
+    mkdir -p .claude/state/statusline 2>/dev/null
+    : > "$BASE" 2>/dev/null || BASE=""
+  fi
+fi
+
+# 🛡 The gate's last word in this session.
+GL=""; [ -f "$_here/gate-log.sh" ] && { . "$_here/gate-log.sh"; crew_gate_log_read; GL="$_CREW_GL"; }   # one rule (gate-log.sh)
+if [ -n "$BASE" ] && [ -f "$GL" ] && [ "$GL" -nt "$BASE" ]; then
+  last="$(tail -n 1 "$GL" 2>/dev/null)"
+  IFS=$'\t' read -r verdict section _ <<< "$last"
+  case "$verdict" in BLOCK|ASK|ALLOW|NOTE) OUT+=("🛡 $verdict ${section:-}") ;; esac
+fi
+
+# ✓ An approval that still holds: the record is in the git directory (a worktree's .git is a file naming it).
+G=""
+if [ -d .git ]; then G=".git"
+elif [ -f .git ]; then IFS= read -r l < .git 2>/dev/null; case "$l" in "gitdir: "*) G="${l#gitdir: }"; G="${G%$'\r'}" ;; esac; fi
+if [ -n "$G" ] && [ -s "$G/crewforth-approval" ]; then
+  op=""; ts=""
+  while IFS='=' read -r k v; do v="${v%$'\r'}"; case "$k" in op) op="$v" ;; ts) ts="$v" ;; esac; done < "$G/crewforth-approval"
+  if [ "${BASH_VERSINFO[0]}" -ge 5 ] || { [ "${BASH_VERSINFO[0]}" -eq 4 ] && [ "${BASH_VERSINFO[1]}" -ge 2 ]; }; then printf -v now '%(%s)T' -1; else now="$(date +%s)"; fi
+  case "$ts" in ''|*[!0-9]*) ;; *)
+    left=$(( (1800 - (now - ts)) / 60 ))
+    case "$op" in commit|push|commit+push) [ "$left" -ge 0 ] && [ "$((now - ts))" -le 1800 ] && OUT+=("✓ $op approved ${left}m") ;; esac ;;
+  esac
+fi
+
+# ⚙ Crew agents started in this session and not stopped: a record under agents/ with no result beside it.
+if [ -n "$BASE" ] && [ -d .claude/state/crew-model/agents ]; then
+  n=0
+  for a in .claude/state/crew-model/agents/*; do
+    [ -f "$a" ] || continue
+    case "$a" in *.claim|*.used) continue ;; esac
+    [ "$a" -nt "$BASE" ] || continue
+    [ -e ".claude/state/crew-model/results/${a##*/}" ] && continue
+    n=$((n + 1))
+  done
+  pl=s; [ "$n" -eq 1 ] && pl=""
+  [ "$n" -gt 0 ] && OUT+=("⚙ $n crew agent$pl")
+fi
+
+# 🔋 and ~$: Claude Code's own numbers, shown as they are.
+case "${PCT:-}" in ''|null|*[!0-9.]*) ;; *) OUT+=("🔋 ${PCT%%.*}%") ;; esac
+case "${COST:-}" in ''|null|*[!0-9.]*) ;; *)
+  printf -v c '%.2f' "$COST" 2>/dev/null && OUT+=("~\$$c") ;;
+esac
+
+[ "${#OUT[@]}" -gt 0 ] || exit 0
+line="${OUT[0]}"
+for p in "${OUT[@]:1}"; do line="$line · $p"; done
+printf '%s\n' "$line"
+exit 0

package/kit/eval/lib/verify-cmd.sh

@@ -0,0 +1,17 @@
+# Sourced, not run. How a card's verify command is read: one definition, for the gate that runs it
+# (hooks/guard-agent-model.sh) and for doctor, which offers the line that would allow it.
+#
+# A verify command in a sub-folder: `cd apps/mobile && flutter test`, the usual shape in a repository of several
+# projects (measured on one: 41 of 71 refused verify commands had it). Split into the folder and the one command,
+# so the command is judged alone and run in that folder with no chain; a `verify <command>` rule names the command
+# alone. Only a relative folder inside the project, with no .. step, that exists; anything else is left whole, and
+# is refused as a chain.
+crew_verify_split(){  # $1 = the command, $2 = the project root -> _AMVD the folder ("" = the root), _AMVC the command
+  local c="$1" d r root="${2:-.}"
+  _AMVD=""; _AMVC="$c"
+  case "$c" in 'cd '*' && '*) ;; *) return 0 ;; esac
+  d="${c#cd }"; d="${d%% && *}"; r="${c#cd "$d" && }"
+  case "$d" in ''|/*|~*|*[!A-Za-z0-9._/-]*|..|../*|*/..|*/../*) return 0 ;; esac
+  [ -n "$r" ] && [ -d "$root/$d" ] || return 0
+  _AMVD="$d"; _AMVC="$r"
+}

package/kit/eval/lib/version.sh

@@ -0,0 +1,41 @@
+# Sourced, not run. The ONE definition of how Crewforth reads and orders its own version numbers.
+#
+# An install's VERSION holds X.Y.Z, or X.Y.Z-rc.N when it came from a release candidate. An rc comes before its
+# final (3.2.0-rc.1 < 3.2.0), so someone who tried the rc is offered the final when it ships. Read by the update
+# check (hooks/session-update-check.sh), doctor and adopt.sh; each used to split on "." and read 3.2.0-rc.1 as 3.2.0.
+#
+# Builtins only: sourcing this costs no process, which matters in hooks on Git Bash.
+
+# The version an install may hold in its own VERSION file: X.Y.Z or X.Y.Z-rc.N, nothing else; printed, or rc 1.
+# A value off the network is not read with this: the update check holds that to X.Y.Z alone.
+crew_local_version(){
+  local v="${1:-}" base n
+  v="${v//[!0-9A-Za-z.-]/}"
+  base="${v%%-rc.*}"
+  case "$base" in
+    *[!0-9.]*|'')           return 1 ;;
+    [0-9]*.[0-9]*.[0-9]*.*) return 1 ;;
+    [0-9]*.[0-9]*.[0-9]*)   ;;
+    *)                      return 1 ;;
+  esac
+  if [ "$base" != "$v" ]; then
+    n="${v#"$base"-rc.}"
+    case "$n" in ''|*[!0-9]*) return 1 ;; esac
+  fi
+  printf '%s' "$v"
+}
+
+# vcmp(a, b): 1 when a is newer, -1 when older, 0 when the same. Prepended to an awk program:
+#   awk -v a="$X" -v b="$Y" "$CREW_VCMP_AWK"' BEGIN { exit !(vcmp(a, b) > 0) }'
+CREW_VCMP_AWK='
+function vrc(v) { return match(v, /-rc\.[0-9]+$/) ? substr(v, RSTART + 4) + 0 : -1 }
+function vcmp(a, b,   x, y, i, ra, rb) {
+  ra = vrc(a); rb = vrc(b); sub(/-.*/, "", a); sub(/-.*/, "", b)
+  split(a, x, "."); split(b, y, ".")
+  for (i = 1; i <= 3; i++) { if (x[i] + 0 > y[i] + 0) return 1; if (x[i] + 0 < y[i] + 0) return -1 }
+  if (ra == rb) return 0
+  if (ra < 0) return 1
+  if (rb < 0) return -1
+  return ra > rb ? 1 : -1
+}
+'

package/kit/eval/review-bench.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# review-bench.sh — how right the review is, on labelled cases: precision, recall and every false alarm by name.
+# The shell entry to eval/lib/review-bench/bench.mjs; it finds a Node that RUNS and hands over.
+#
+#   bash review-bench.sh --cases DIR [--arm prepass|agent] [--split all|train|holdout] [--only id,id]
+#                        [--model sonnet] [--advisor opus] [--case-budget 0.75] [--max-cost 12] [--floors FILE]
+#                        [--out FILE] [--no-tools]
+#
+# --arm prepass (the default) runs no model and costs nothing. --arm agent runs Claude Code headless as
+# crew-review-agent on every case and SPENDS TOKENS: each case is capped by --case-budget (US dollars) and the run
+# by --max-cost; ask the person paying before running it. rc 3 = no usable Node here (not a pass).
+set -u
+d="${BASH_SOURCE%[/\\]*}"; [ "$d" = "${BASH_SOURCE}" ] && d=.
+FLOOR=18
+usable(){ local v; v="$("$1" -p 'process.versions.node.split(".")[0]' 2>/dev/null)" || return 1
+  case "$v" in ''|*[!0-9]*) return 1 ;; esac; [ "$v" -ge "$FLOOR" ]; }
+NODE=""
+if usable node; then NODE=node
+elif [ -f "$d/../studio/ensure-node.sh" ]; then
+  n="$(bash "$d/../studio/ensure-node.sh" 2>/dev/null)" && [ -n "$n" ] && usable "$n" && NODE="$n"
+fi
+if [ -z "$NODE" ]; then
+  echo "review-bench: no Node $FLOOR+ that runs was found, so nothing was measured (this is not a pass)" >&2
+  exit 3
+fi
+exec "$NODE" "$d/lib/review-bench/bench.mjs" "$@"