great-cto 3.64.0 → 3.65.0

package/board/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "great-cto",
   "description": "You already have the agent. This is everything around it. great_cto runs Claude Code as a pipeline of 72 specialist agents \u2014 an independent model checks each stage before the next builds on it, spending caps refuse rather than warn, and three decisions stay yours: what gets built, how, and whether it ships.",
-  "version": "3.64.0",
+  "version": "3.65.0",
   "author": {
     "name": "Alexander Velikiy",
     "url": "https://hashnode.com/@Greatcto"

package/board/agents/continuous-learner.md

@@ -1,6 +1,6 @@
 ---
 name: continuous-learner
-description: Use at session end (auto-triggered by SessionEnd hook) or via /crystallize learn. Extracts repeatable patterns, decisions, and cost outliers from the session and writes structured entries to .great_cto/lessons.md. Promotes high-confidence patterns to ~/.great_cto/decisions.md after ≥3 occurrences.
+description: Use at session end (auto-triggered by SessionEnd hook) or via /crystallize learn. Extracts repeatable patterns, decisions, and cost outliers from the session and writes structured entries to .great_cto/lessons.md. Lessons seen in ≥3 projects become candidates; only an A/B-measured one reaches ~/.great_cto/decisions.md (ADR-037).
 model: claude-haiku-4-5
 authority: proposes
 tools: Read, Write, Edit, Glob, Grep, Bash(git:*), Bash(bd:*), Bash(ls:*), Bash(cat:*), Bash(grep:*), Bash(head:*), Bash(tail:*), Bash(wc:*), Bash(date:*), Bash(printf:*), Bash(echo:*), Bash(mkdir:*), Bash(node:*), WebFetch, WebSearch, memory_20250929
@@ -20,7 +20,7 @@ You are the **Continuous Learner** — a low-cost, low-noise pattern extractor.
 Read the session context (transcript, git state, beads, cost log, recent files written) and emit:
 
 1. **Append 0-3 new lesson entries** to `.great_cto/lessons.md` (project-local memory)
-2. **Promote patterns seen across enough projects** to `~/.great_cto/decisions.md` (cross-project memory) — `scripts/lessons-merge.mjs` owns the threshold and counts distinct projects, not raw occurrences (Step 4)
+2. **Hand cross-project candidates to `scripts/lessons-merge.mjs`** — it counts distinct projects (3 make a candidate) and writes to `~/.great_cto/decisions.md` only a lesson whose A/B eval did not show harm (Step 4, ADR-037)
 3. **Reject everything else.** Silence > noise.
 
 You are graded on **precision, not recall**. False positives erode trust; misses are recoverable.
@@ -192,6 +192,7 @@ archetype: <from PROJECT.md>
 project: <basename of cwd>
 confidence: medium|high     # YOUR OWN rating. Never authoritative — see below
 shape: A|B|C|D|E
+eval: EVAL-<name>.md        # optional — the eval whose agent this lesson changes
 ---
 
 **Two axes, and only one of them is earned.** `support:` is written by
@@ -242,6 +243,15 @@ node "$_LM" --dry-run
 node "$_LM"
 ```
 
+**Recurrence is not evidence (ADR-037).** Three projects make a lesson a
+*candidate*. It is written to `decisions.md` only with an eval stamp that is not
+a regression — measured by `node "$_LM" --measure <slug>` (prints the cost;
+`--yes` spends it), which runs the lesson's `eval:` with and without the lesson.
+A lesson with no `eval:` stays in its projects. Never write `eval_delta:` or
+`eval_confidence:` yourself: `lessons-write.mjs` discards them, and a lesson
+cannot vouch for itself. Do not run `--measure` or `--no-eval` on your own — they
+spend money or bypass evidence, and that is the operator's call.
+
 Flags: `--dry-run` previews without writing, `--force` re-promotes a slug already
 present. The threshold and entry format live in the script; if either needs to
 change, change it there so both paths move together.

package/board/packages/board/lib/beads.mjs

@@ -108,7 +108,10 @@ function bd(args, opts = {}) {
   // — so the default cap sat BELOW the known worst case, and every call site that
   // did not name its own timeout inherited a cap the machine could exceed while
   // working correctly. What came back was indistinguishable from beads failing.
-  return spawnSync(BD_BIN, args, { encoding: 'utf8', timeout: 20000, ...opts, env: { ...bdEnv(), ...(opts.env || {}) } });
+  // SIGKILL: a synchronous timeout sends its signal and then waits for the child
+  // to exit. bd holding a dolt lock ignored SIGTERM and held the board's whole
+  // event loop — four minutes without even /api/heartbeat. SIGKILL cannot wait.
+  return spawnSync(BD_BIN, args, { encoding: 'utf8', timeout: 20000, killSignal: 'SIGKILL', ...opts, env: { ...bdEnv(), ...(opts.env || {}) } });
 }
 // Turn a failed bd result into an actionable message (the bare "bd update failed" hid ENOENT).
 function bdErr(r, what) {

package/board/packages/board/lib/receipt-read-worker.mjs

@@ -4,12 +4,26 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { treeReceipt, latestApproval, compareReceipts, mergeBase } from '../../../scripts/lib/receipt.mjs';
 import { secondOpinionForTree } from '../../../scripts/lib/second-opinion-for-tree.mjs';
+import { affectedTests } from '../../../scripts/lib/affected-tests.mjs';
 const entry = fileURLToPath(import.meta.url);
 export const receiptReadEntry = entry;
+
+// The tree a gate token is bound to. Null only outside Git: a real repository
+// whose receipt could not be read fails, so it never reads as "not a repo".
+function bindingTree() {
+  let dir = process.cwd(), gitMetadata = false;
+  for (;;) {
+    try { fs.lstatSync(path.join(dir, '.git')); gitMetadata = true; break; } catch (e) { if (e.code !== 'ENOENT') throw e; }
+    const parent = path.dirname(dir); if (parent === dir) break; dir = parent;
+  }
+  const receipt = treeReceipt(process.cwd(), { exclude: ['.great_cto', '.beads'], hashFilesInProcess: true });
+  if (!receipt && gitMetadata) throw Error('Repository receipt unavailable');
+  return receipt;
+}
 if (process.argv[1] === entry) {
   try {
     const mode = process.argv[2] || 'binding';
-    if (!['binding', 'approval', 'second-opinion'].includes(mode) || process.argv.length > 3) throw Error('Invalid evidence operation');
+    if (!['binding', 'approval', 'second-opinion', 'touches'].includes(mode) || process.argv.length > 3) throw Error('Invalid evidence operation');
     let receipt;
     if (mode === 'second-opinion') {
       receipt = secondOpinionForTree(process.cwd());
@@ -21,16 +35,17 @@ if (process.argv[1] === entry) {
         const current = treeReceipt(process.cwd(), { base: approval.receipt.base || mergeBase(process.cwd()), hashFilesInProcess: true });
         receipt = { ...compareReceipts(approval.receipt, current, { cwd: process.cwd() }), agent: approval.agent, ts: approval.ts };
       }
+    } else if (mode === 'touches') {
+      // The gate brief (ADR-036): the change set plus the tests it maps to. The
+      // test mapping walks the repository, so it runs here, off the board's
+      // request thread, and its failure is reported rather than read as "none".
+      const binding = bindingTree();
+      let tests;
+      try { tests = binding ? { ok: true, value: affectedTests({ cwd: process.cwd(), changed: Object.keys(binding.files || {}) }) } : { ok: true, value: null }; }
+      catch (e) { tests = { ok: false, why: String(e?.message || e) }; }
+      receipt = { binding, tests };
     } else {
-      let dir = process.cwd(), gitMetadata = false;
-      for (;;) {
-        try { fs.lstatSync(path.join(dir, '.git')); gitMetadata = true; break; } catch (e) { if (e.code !== 'ENOENT') throw e; }
-        const parent = path.dirname(dir); if (parent === dir) break; dir = parent;
-      }
-      receipt = treeReceipt(process.cwd(), { exclude: ['.great_cto', '.beads'], hashFilesInProcess: true });
-      // Preserve explicit non-Git binding, but never mint an unbound token when
-      // a real repository's evidence read failed.
-      if (!receipt && gitMetadata) throw Error('Repository receipt unavailable');
+      receipt = bindingTree();
     }
     process.stdout.write(JSON.stringify({ receipt }), error => process.exit(error ? 1 : 0));
   } catch { process.exit(1); }

package/board/packages/board/lib/receipt-read.mjs

@@ -12,6 +12,9 @@ export function readApprovalReceipt(cwd, { timeoutMs = 20000 } = {}) {
 export function readSecondOpinion(cwd, { timeoutMs = 20000 } = {}) {
   return readEvidence(cwd, 'second-opinion', timeoutMs);
 }
+export function readTouches(cwd, { timeoutMs = 20000 } = {}) {
+  return readEvidence(cwd, 'touches', timeoutMs);
+}
 function readEvidence(cwd, mode, timeoutMs) {
   cwd = path.resolve(cwd);
   const key = JSON.stringify([cwd, mode]);
@@ -53,7 +56,9 @@ function readEvidence(cwd, mode, timeoutMs) {
           const value = JSON.parse(out);
           if (!value || !Object.hasOwn(value, 'receipt')) throw Error();
           const evidence = value.receipt;
-          if (mode === 'binding') {
+          if (mode === 'touches') {
+            if (!evidence || !Object.hasOwn(evidence, 'binding') || typeof evidence.tests?.ok !== 'boolean') throw Error();
+          } else if (mode === 'binding') {
             if (evidence !== null && (!evidence?.head || !evidence.files)) throw Error();
           } else {
             const states = mode === 'approval' ? ['no-receipt', 'unreadable', 'differs', 'extended', 'matches'] : ['not-run', 'unmeasured', 'unreadable', 'ok'];

package/board/packages/board/lib/routes.mjs

@@ -32,7 +32,8 @@ import { log } from './log.mjs';
 import { bdCacheInvalidate, checkBeadsAvailable, bdWriteSerialised, bd, bdErr, getTasks, getTasksAsync, setTaskStatusInTasksMd, getReadDegradation } from './beads.mjs';
 import { getMetrics } from './metrics.mjs';
 import { agentActivity, agentActivitySince } from './agent-activity.mjs';
-import { issueTokensAsync, checkToken, checkBinding, consumeToken, approvalSnapshot, beginGateDecision } from './gate-tokens.mjs';
+import { issueTokensAsync, checkToken, checkBinding, consumeToken, approvalSnapshot, beginGateDecision, readTokens } from './gate-tokens.mjs';
+import { gateBrief, settle, readVerdictLogs } from '../../../scripts/lib/gate-brief.mjs';
 import { readTurns, turnPatch } from '../../../scripts/lib/turn-snapshot.mjs';
 import { appendEvent } from '../../../scripts/lib/agent-events.mjs';
 
@@ -63,7 +64,7 @@ import { upsertCapability, capabilitiesFromProjectMd } from '../../../scripts/li
 // Moved to scripts/lib so the cross-review Stop hook can ask the same question
 // without importing a server. Re-exported here: this module's callers are unchanged.
 import { secondOpinionForTree } from '../../../scripts/lib/second-opinion-for-tree.mjs';
-import { readApprovalReceipt, readSecondOpinion } from './receipt-read.mjs';
+import { readApprovalReceipt, readSecondOpinion, readTouches } from './receipt-read.mjs';
 import { getAgentsFleet, getAgentProfile, retireAgent, restoreAgent, appendDecisionLog, readDecisionsLog } from './fleet.mjs';
 import { getResume, getShareState, toggleShare } from './share.mjs';
 import { listSessions, readSession, editedFiles, searchSessions } from './transcripts.mjs';
@@ -926,6 +927,47 @@ async function dispatch(req, res, url, cwd) {
     return true;
   }
 
+  // Gate brief (ADR-036) — one page of what this gate approves.
+  //
+  // A projection over evidence already recorded: the tree the token was issued
+  // for, the change and its tier, reversibility, verdicts, the second model and
+  // what the diff touches. It never approves and never writes. Each source is
+  // read on its own; one that fails makes its section `unknown`, not empty.
+  const briefPath = req.method === 'GET' && pathname.match(/^\/api\/gates\/([^/]+)\/brief$/);
+  if (briefPath) {
+    const c = url.searchParams.get('project') ? resolveProjectCwd(url.searchParams.get('project')) : cwd;
+    const id = decodeURIComponent(briefPath[1]);
+    let inbox;
+    try { inbox = await getInboxAsync(c); }
+    catch {
+      res.writeHead(503, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+      res.end(JSON.stringify({ error: 'Task snapshot is unavailable; retry', state: 'unreadable' }));
+      return true;
+    }
+    const gate = (inbox.pending_gates || []).find((g) => g.id === id);
+    if (!gate) {
+      res.writeHead(404, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+      res.end(JSON.stringify({ error: 'not a pending gate', id }));
+      return true;
+    }
+    // Sequential: the evidence reader runs at most two workers at once, and the
+    // inbox poll may hold one.
+    const touches = await settle(readTouches(c));
+    const secondOpinion = await settle(readSecondOpinion(c));
+    const brief = gateBrief({
+      gate,
+      token: readTokens(c).tokens[id] || null,
+      binding: touches.ok ? { ok: true, value: touches.value.binding } : touches,
+      tests: touches.ok ? touches.value.tests : touches,
+      verdictLogs: await settle(() => readVerdictLogs(c)),
+      secondOpinion,
+      tier: await settle(() => getChangeTier(c)),
+    });
+    res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(brief));
+    return true;
+  }
+
   // Receipt — does the approval still apply to what is in the tree?
   //
   // The reviewing agents already record a hash-bound receipt of the bytes they

package/board/packages/board/public/index.html

@@ -2147,6 +2147,11 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 .dot-orange { background: var(--dot-orange); }
 .dot-amber  { background: var(--status-progress); }
 
+.gate-brief { margin: -2px 0 8px 0; padding: 10px 14px; border-left: 3px solid var(--status-gate); background: var(--bg-muted); font-size: var(--fs-small, 12px); display: grid; gap: 4px; }
+.gate-brief .brief-sec { display: grid; grid-template-columns: 110px 1fr; gap: 10px; align-items: baseline; }
+.gate-brief .brief-k { color: var(--text3); }
+.gate-brief .brief-v { min-width: 0; overflow-wrap: anywhere; }
+.gate-brief .brief-moved { color: var(--status-blocked); margin-bottom: 4px; }
 .inbox-row {
   display: grid;
   grid-template-columns: 110px 1fr auto;
@@ -4735,6 +4740,75 @@ function ageHours(ts) {
   return Number.isFinite(ms) ? ms / 36e5 : null;
 }
 
+// Gate brief (ADR-036) — what this gate approves, on one panel.
+//
+// The inbox row says which gate is waiting; this says what approving it means:
+// whether the tree moved since the token was issued, what changed and its tier,
+// how expensive it is to undo, which reviewers saw THESE bytes, what the second
+// model said, and which parts of the system and which tests the change touches.
+// A section the server could not read says "unknown" — it is never drawn as an
+// empty, reassuring list. The panel stays open across inbox refreshes.
+const OPEN_BRIEFS = new Map();   // gate id → rendered html
+const BRIEF_TONE = { recorded: 'var(--text2)', empty: 'var(--status-blocked)', unknown: 'var(--status-blocked)' };
+function briefList(xs, max = 12) {
+  const shown = (xs || []).slice(0, max).map(esc).join(', ');
+  return (xs || []).length > max ? `${shown} … +${xs.length - max}` : shown;
+}
+function renderGateBrief(d) {
+  if (!d || d.error || !Array.isArray(d.sections)) {
+    return `<div class="muted">Brief unavailable — ${esc((d && (d.error || d.state)) || 'no response')}. This is not the same as nothing to review.</div>`;
+  }
+  const row = (label, s, body) => `<div class="brief-sec"><span class="brief-k">${label}</span>`
+    + `<span class="brief-v" style="color:${BRIEF_TONE[s.state] || 'inherit'}">${s.state === 'unknown' ? `unknown — ${esc(s.why || '')}` : body}</span></div>`;
+  const by = Object.fromEntries(d.sections.map((s) => [s.key, s]));
+  const t = by.tree, c = by.change, r = by.risk, v = by.reviews, o = by.second, x = by.touches;
+  const head = t.moved
+    ? `<div class="brief-moved"><b>The tree moved after this gate was shown</b> — ${[
+        [...(t.changed || []), ...(t.removed || [])].length ? `changed: ${briefList([...(t.changed || []), ...(t.removed || [])])}` : '',
+        (t.added || []).length ? `added: ${briefList(t.added)}` : '',
+      ].filter(Boolean).join('; ')}. Approving now approves bytes nobody on this page has seen.</div>`
+    : '';
+  const reviews = v.state === 'empty'
+    ? 'no reviewer has recorded a verdict — nobody has looked'
+    : (v.verdicts || []).map((x) => `<span class="${x.onThisTree ? '' : 'muted'}" title="${x.onThisTree ? 'recorded over these exact bytes' : 'saw other bytes, or recorded no receipt'}">${esc(x.agent)} ${esc(x.verdict)}${x.onThisTree ? ' ✓ this tree' : ' · other tree'}</span>`).join(' · ')
+      + (v.rejected ? ` · <span style="color:var(--status-blocked)">${v.rejected} unreadable line(s)</span>` : '');
+  const second = o.opinion === 'ok' ? `${esc(o.provider || '')} ${esc(o.verdict || '')}${o.p0 ? ` · P0 ${o.p0}` : ''}` : `${esc(o.opinion || '')}${o.why ? ` — ${esc(o.why)}` : ''}`;
+  const touches = (x.containers || []).map((g) => `<b>${esc(g.name)}</b> ${g.total}`).join(' · ')
+    + (x.tests ? ` · tests: ${x.tests.length ? briefList(x.tests, 6) : 'none mapped'}` : ` · tests unknown — ${esc(x.testsWhy || '')}`)
+    + (x.unmapped?.length ? ` · <span style="color:var(--status-blocked)">${x.unmapped.length} file(s) without a test</span>` : '');
+  return head
+    + row('Tree', t, t.moved ? 'moved' : 'same as when the gate was shown')
+    + row('Change', c, `${c.total} file(s)${c.tier ? ` · tier ${esc(c.tier)}` : ` · tier unknown${c.tierWhy ? ` — ${esc(c.tierWhy)}` : ''}`}${c.files?.length ? `<details><summary class="muted">files</summary>${briefList(c.files, 100)}</details>` : ''}`)
+    + row('Undo', r, `${esc(r.reversibility)}${r.categories?.length ? ` · ${esc(r.categories.join(', '))}` : ''}`)
+    + row('Reviews', v, reviews)
+    + row('Second model', o, second)
+    + row('Touches', x, touches);
+}
+async function toggleGateBrief(id, btn) {
+  const row = btn.closest('.inbox-row');
+  const open = row && row.nextElementSibling;
+  if (open && open.classList.contains('gate-brief') && open.dataset.gate === id) { open.remove(); OPEN_BRIEFS.delete(id); return; }
+  const box = document.createElement('div');
+  box.className = 'gate-brief'; box.dataset.gate = id;
+  box.innerHTML = '<span class="muted">Reading the evidence…</span>';
+  row.after(box);
+  OPEN_BRIEFS.set(id, box.innerHTML);
+  const d = await api(`/api/gates/${encodeURIComponent(id)}/brief${pqs()}`);
+  const html = renderGateBrief(d);
+  OPEN_BRIEFS.set(id, html);
+  for (const el of document.querySelectorAll('.gate-brief')) if (el.dataset.gate === id) el.innerHTML = html;
+}
+function reattachGateBriefs(root) {
+  if (!OPEN_BRIEFS.size || !root) return;
+  for (const row of root.querySelectorAll('.inbox-row[data-gate-id]')) {
+    const id = row.dataset.gateId;
+    if (!OPEN_BRIEFS.has(id)) continue;
+    const box = document.createElement('div');
+    box.className = 'gate-brief'; box.dataset.gate = id; box.innerHTML = OPEN_BRIEFS.get(id);
+    row.after(box);
+  }
+}
+
 function renderInboxList(rootId, items, countId, opts = {}) {
   const root = document.getElementById(rootId);
   const cnt = document.getElementById(countId);
@@ -4843,6 +4917,7 @@ function renderInboxList(rootId, items, countId, opts = {}) {
     const guardedGate = canDecide && t.reversibility && t.reversibility.state !== 'routine';
     const actions = canDecide
       ? `<div class="actions${guardedGate ? ' gate-actions-stack' : ''}" onclick="event.stopPropagation()">
+           <button type="button" class="gate-btn" title="What this gate approves: the change, the reviews on this tree, what it touches" onclick="event.stopPropagation(); toggleGateBrief('${esc(t.id)}', this)">Brief</button>
            <button class="gate-btn gate-reject" onclick="event.stopPropagation(); gateAction('${esc(t.id)}', 'reject')">Reject…</button>
            <button class="gate-btn gate-approve" title="${guardedGate ? 'expensive to undo — you will be asked to type the gate name' : 'one confirm names the consequence'}" onclick="event.stopPropagation(); gateAction('${esc(t.id)}', 'approve')">${guardedGate ? 'Approve…' : 'Approve'}</button>
          </div>`
@@ -4885,13 +4960,14 @@ function renderInboxList(rootId, items, countId, opts = {}) {
       ? `<span class="why why-${tone}">${esc(t.__reason)}</span>`
       : '';
     return `
-      <div class="inbox-row${aged ? ' row-aged' : ''}" tabindex="0" role="button" aria-label="${esc(t.title || t.id)}" onkeydown='if(event.key==="Enter"||event.key===" "){event.preventDefault();this.click();}' onclick='openSide(${JSON.stringify(t).replace(/'/g, "&apos;")})'>
+      <div class="inbox-row${aged ? ' row-aged' : ''}"${canDecide ? ` data-gate-id="${esc(t.id)}"` : ''} tabindex="0" role="button" aria-label="${esc(t.title || t.id)}" onkeydown='if(event.key==="Enter"||event.key===" "){event.preventDefault();this.click();}' onclick='openSide(${JSON.stringify(t).replace(/'/g, "&apos;")})'>
         ${canDecide ? gateChip(t) : `<span class="id">${esc(t.id || '')}</span>`}
         <span class="ttl">${canDecide ? '' : reasonChip}${esc(canDecide ? String(t.title || '').replace(/^gate:[a-z-]+\s*[—–-]?\s*/, '') : t.title)}${desc}<span class="meta">${meta}</span>${tierNote}</span>
         ${canDecide ? reviewerCells(t) : ''}
         ${actions}${unblock}${rerun}${diffBtn}
       </div>`;
   }).join('');
+  reattachGateBriefs(root);
 }
 
 // Sessions waiting on a person (scripts/lib/session-status.mjs). `blocked` is a

package/board/scripts/lib/affected-tests.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+/**
+ * affected-tests — the test command for the files you changed, so the TDD loop runs
+ * those tests and the full suite runs once, before the verdict.
+ *
+ * Why this exists
+ * ---------------
+ * senior-dev ran the whole suite after each edit: `flutter test` 1,029 times, `cargo
+ * test` 454, on the projects measured (PLAN-2026-09-23-agent-speed). A red-green loop
+ * needs the test that covers the edit, not every test in the repository.
+ *
+ * Mapping, by stack, from the changed files (tracked changes vs HEAD + untracked):
+ *   JS/TS    a changed test file itself; else a sibling or any tests-dir file named
+ *            <base>.test.* / <base>.spec.*        → vitest | jest | node --test
+ *   Rust     the crate owning the file (nearest Cargo.toml [package] name) → cargo test -p
+ *   Dart     lib/a/b.dart → test/a/b_test.dart (or the changed _test.dart) → flutter/dart test
+ *   Python   pkg/mod.py → a test_mod.py anywhere in the tree (or the changed test_*.py) → pytest
+ *   Go       the package directory                  → go test ./dir
+ * A changed source file with no test found is reported, never silently dropped — and
+ * when nothing maps, the answer is `full`: the honest command is the whole suite.
+ *
+ * Usage: node scripts/lib/affected-tests.mjs [--cwd DIR] [--json]
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname, basename, extname, relative, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Dependency, build and tool-state directories: they hold no test of the project's
+// own code, and walking them (node_modules alone can be 100k files) is the slow part.
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'target', '.dart_tool', '.venv', 'venv', '__pycache__', '.great_cto']);
+
+function changedFiles(cwd) {
+  const run = (args) => spawnSync('git', args, { cwd, encoding: 'utf8' }).stdout.split('\n').filter(Boolean);
+  const set = new Set([...run(['diff', '--name-only', 'HEAD']), ...run(['ls-files', '--others', '--exclude-standard'])]);
+  return [...set].filter((f) => existsSync(join(cwd, f)));
+}
+
+function walk(dir, out = [], depth = 0) {
+  if (depth > 8) return out;
+  let entries = [];
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const e of entries) {
+    if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) walk(join(dir, e.name), out, depth + 1); }
+    else out.push(join(dir, e.name));
+  }
+  return out;
+}
+
+const JS = /\.(m?[jt]sx?|cjs)$/;
+const isJsTest = (f) => /\.(test|spec)\.(m?[jt]sx?|cjs)$/.test(f);
+
+function jsRunner(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps.vitest) return (files) => `npx vitest run ${files.join(' ')}`;
+    if (deps.jest) return (files) => `npx jest ${files.join(' ')}`;
+  } catch { /* no package.json: node's own runner */ }
+  return (files) => `node --test ${files.join(' ')}`;
+}
+
+function crateOf(cwd, file) {
+  let d = dirname(join(cwd, file));
+  while (d.startsWith(cwd)) {
+    const t = join(d, 'Cargo.toml');
+    if (existsSync(t)) {
+      const m = readFileSync(t, 'utf8').match(/\[package\][^[]*?name\s*=\s*"([^"]+)"/);
+      if (m) return m[1];
+    }
+    if (d === cwd) break;
+    d = dirname(d);
+  }
+  return null;
+}
+
+/**
+ * @returns {{mode:'targeted'|'full'|'none', commands:string[], tests:string[], unmapped:string[]}}
+ */
+export function affectedTests({ cwd = process.cwd(), changed } = {}) {
+  const files = (changed || changedFiles(cwd)).map((f) => f.split(sep).join('/'));
+  if (!files.length) return { mode: 'none', commands: [], tests: [], unmapped: [] };
+  let all = null;
+  const allFiles = () => (all ||= walk(cwd).map((f) => relative(cwd, f).split(sep).join('/')));
+  const js = new Set(); const dart = new Set(); const py = new Set(); const go = new Set(); const crates = new Set();
+  const unmapped = [];
+  for (const f of files) {
+    const base = basename(f).replace(/\.[^.]+$/, '');
+    if (JS.test(f)) {
+      if (isJsTest(f)) { js.add(f); continue; }
+      const hit = allFiles().filter((t) => isJsTest(t) && basename(t).replace(/\.(test|spec)\.[^.]+$/, '') === base);
+      if (hit.length) hit.forEach((t) => js.add(t)); else unmapped.push(f);
+    } else if (f.endsWith('.rs')) {
+      const c = crateOf(cwd, f); if (c) crates.add(c); else unmapped.push(f);
+    } else if (f.endsWith('.dart')) {
+      if (f.endsWith('_test.dart')) { dart.add(f); continue; }
+      const t = f.replace(/^lib\//, 'test/').replace(/\.dart$/, '_test.dart');
+      if (existsSync(join(cwd, t))) dart.add(t); else unmapped.push(f);
+    } else if (f.endsWith('.py')) {
+      if (/(^|\/)test_[^/]+\.py$|_test\.py$/.test(f)) { py.add(f); continue; }
+      const hit = allFiles().filter((t) => basename(t) === `test_${base}.py` || basename(t) === `${base}_test.py`);
+      if (hit.length) hit.forEach((t) => py.add(t)); else unmapped.push(f);
+    } else if (f.endsWith('.go')) {
+      go.add(`./${dirname(f)}`);
+    }
+    // Other files (docs, config, assets) carry no test mapping and are not code.
+  }
+  const commands = [];
+  if (js.size) commands.push(jsRunner(cwd)([...js]));
+  if (crates.size) commands.push(`cargo test ${[...crates].map((c) => `-p ${c}`).join(' ')}`);
+  if (dart.size) commands.push(`${existsSync(join(cwd, 'pubspec.yaml')) && /flutter:/.test(readFileSync(join(cwd, 'pubspec.yaml'), 'utf8')) ? 'flutter' : 'dart'} test ${[...dart].join(' ')}`);
+  if (py.size) commands.push(`pytest ${[...py].join(' ')}`);
+  if (go.size) commands.push(`go test ${[...go].join(' ')}`);
+  const tests = [...js, ...dart, ...py];
+  return { mode: commands.length ? 'targeted' : 'full', commands, tests, unmapped };
+}
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isMain) {
+  const a = process.argv.slice(2);
+  const i = a.indexOf('--cwd');
+  const r = affectedTests({ cwd: i >= 0 ? a[i + 1] : process.cwd() });
+  if (a.includes('--json')) process.stdout.write(`${JSON.stringify(r, null, 2)}\n`);
+  else {
+    if (r.mode === 'none') process.stdout.write('affected-tests: nothing changed\n');
+    else if (r.mode === 'full') process.stdout.write('affected-tests: full — no test maps to the changed files; run the whole suite\n');
+    else r.commands.forEach((c) => process.stdout.write(`${c}\n`));
+    if (r.unmapped.length) process.stderr.write(`affected-tests: no test found for ${r.unmapped.join(', ')} — cover them, or run the full suite\n`);
+  }
+}

package/board/scripts/lib/gate-brief.mjs

@@ -0,0 +1,157 @@
+// One brief per gate (ADR-036) — what the approver is actually approving.
+//
+// Everything a gate decision needs was already recorded, in six places: the
+// tree receipt, the change tier, the reversibility of the gate, the reviewers'
+// verdicts, the second model's opinion, and which parts of the system the diff
+// touches. The inbox showed a title. So a gate was approved on its title, or
+// after reading logs by hand in a terminal.
+//
+// This is a projection, never an authority. It does not approve, does not
+// write, and changes nothing about the token, the binding or who may approve.
+// Three rules carry its weight:
+//
+//   • unknown is not pass — a source that could not be read gives a section
+//     `unknown` with the reason; it never becomes an empty list;
+//   • bound to the tree — the receipt the token was issued for is compared
+//     with the tree now, and a move is the first thing said;
+//   • a verdict counts only for the tree it saw — an approval of other bytes is
+//     shown, and marked as such.
+//
+// Every input arrives already read, as `{ok, value}` or `{ok:false, why}`
+// (see `settle`), so `gateBrief` does no I/O and each rule is testable alone.
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { compareReceipts } from './receipt.mjs';
+import { reversibilityOf } from './gate-reversibility.mjs';
+import { groupOf } from './system-map.mjs';
+import { parseVerdictLog } from './verdict-record.mjs';
+
+/** A read, whatever happened to it, as a value or a reason. Never throws. */
+export async function settle(read) {
+  try {
+    const value = await (typeof read === 'function' ? read() : read);
+    return { ok: true, value };
+  } catch (e) {
+    return { ok: false, why: String(e?.message || e) };
+  }
+}
+
+const MAX_FILES_SHOWN = 100;
+
+function treeSection(token, binding, digest) {
+  if (!binding.ok) return { key: 'tree', state: 'unknown', moved: null, why: binding.why };
+  if (binding.value === null) return { key: 'tree', state: 'unknown', moved: null, why: 'not a git repository — there is no tree to bind an approval to' };
+  if (!token?.receipt) return { key: 'tree', state: 'unknown', moved: null, why: 'no approval token was issued for this gate yet' };
+  const cmp = compareReceipts(token.receipt, binding.value, { digest });
+  // `landed` is committed-since and byte-identical: the same bytes, not a move.
+  const moved = cmp.state !== 'matches';
+  return { key: 'tree', state: 'recorded', moved, changed: cmp.changed || [], added: cmp.added || [], removed: cmp.removed || [], why: cmp.why };
+}
+
+function changeSection(binding, tier) {
+  if (!binding.ok) return { key: 'change', state: 'unknown', why: binding.why };
+  if (binding.value === null) return { key: 'change', state: 'unknown', why: 'not a git repository — no change set to show' };
+  const all = Object.keys(binding.value.files || {}).sort();
+  const out = { key: 'change', state: 'recorded', total: all.length, files: all.slice(0, MAX_FILES_SHOWN),
+    head: binding.value.head || null, base: binding.value.base || null, dirty: binding.value.dirty ?? null,
+    tier: null, tierReasons: [] };
+  if (tier.ok && tier.value?.tier && !tier.value.error) { out.tier = tier.value.tier; out.tierReasons = tier.value.reasons || []; }
+  else out.tierWhy = tier.ok ? String(tier.value?.error || 'no tier was computed') : tier.why;
+  return out;
+}
+
+function riskSection(gate) {
+  const r = gate?.reversibility || reversibilityOf(gate);
+  return { key: 'risk', state: 'recorded', reversibility: r.state, categories: r.categories || [], why: r.why || '' };
+}
+
+function reviewsSection(verdictLogs, binding, digest) {
+  if (!verdictLogs.ok) return { key: 'reviews', state: 'unknown', why: verdictLogs.why, verdicts: [] };
+  const latest = new Map();
+  let rejected = 0;
+  for (const [agent, text] of Object.entries(verdictLogs.value || {})) {
+    const { records, rejected: bad } = parseVerdictLog(text, { agent });
+    rejected += bad.length;
+    for (const rec of records) {
+      const prev = latest.get(rec.agent);
+      if (!prev || String(rec.ts) > String(prev.ts)) latest.set(rec.agent, rec);
+    }
+  }
+  const current = binding.ok ? binding.value : null;
+  const verdicts = [...latest.values()]
+    .sort((a, b) => a.agent.localeCompare(b.agent))
+    .map((rec) => ({
+      agent: rec.agent, verdict: rec.verdict, ts: rec.ts,
+      // Only a recorded receipt of these exact bytes counts. No receipt, or no
+      // readable tree to compare with, is "not shown to be this tree".
+      onThisTree: Boolean(rec.receipt && current && compareReceipts(rec.receipt, current, { digest }).state === 'matches'),
+    }));
+  return { key: 'reviews', state: verdicts.length ? 'recorded' : 'empty', verdicts, rejected,
+    ...(verdicts.length ? {} : { why: 'no reviewer has recorded a verdict in this project' }) };
+}
+
+function secondSection(secondOpinion) {
+  if (!secondOpinion.ok) return { key: 'second', state: 'unknown', why: secondOpinion.why };
+  const v = secondOpinion.value || {};
+  return { key: 'second', state: 'recorded', opinion: v.state, provider: v.provider || null,
+    verdict: v.verdict || null, p0: v.p0 ?? null, why: v.why || null };
+}
+
+function touchesSection(binding, tests) {
+  if (!binding.ok) return { key: 'touches', state: 'unknown', why: binding.why };
+  if (binding.value === null) return { key: 'touches', state: 'unknown', why: 'not a git repository — nothing to group' };
+  const groups = new Map();
+  for (const f of Object.keys(binding.value.files || {}).sort()) {
+    const name = groupOf(f) || (f.includes('/') ? f.split('/')[0] : '(root)');
+    if (!groups.has(name)) groups.set(name, []);
+    groups.get(name).push(f);
+  }
+  const out = { key: 'touches', state: 'recorded',
+    containers: [...groups].map(([name, files]) => ({ name, files: files.slice(0, MAX_FILES_SHOWN), total: files.length })),
+    tests: null, unmapped: [] };
+  if (tests.ok && tests.value) { out.tests = tests.value.tests || []; out.unmapped = tests.value.unmapped || []; out.testsMode = tests.value.mode; }
+  else out.testsWhy = tests.ok ? 'no test mapping was computed' : tests.why;
+  return out;
+}
+
+/**
+ * @param {object} p
+ * @param {object} p.gate            pending gate as the inbox returns it
+ * @param {object|null} p.token      the token store entry ({receipt, receiptHash}) or null
+ * @param {{ok:boolean}} p.binding   the current tree receipt (null outside git)
+ * @param {{ok:boolean}} p.verdictLogs  {agent: log text}
+ * @param {{ok:boolean}} p.secondOpinion
+ * @param {{ok:boolean}} p.tier
+ * @param {{ok:boolean}} p.tests     affectedTests() result
+ * @param {Function} [p.digest]      file digest for compareReceipts (injected in tests)
+ */
+export function gateBrief({ gate, token = null, binding, verdictLogs, secondOpinion, tier, tests, digest = undefined }) {
+  const tree = treeSection(token, binding, digest);
+  return {
+    gate: { id: gate?.id || null, title: gate?.title || '', gate: gate?.gate || null },
+    moved: tree.moved,
+    sections: [
+      tree,
+      changeSection(binding, tier),
+      riskSection(gate),
+      reviewsSection(verdictLogs, binding, digest),
+      secondSection(secondOpinion),
+      touchesSection(binding, tests),
+    ],
+  };
+}
+
+/**
+ * The project's verdict logs as `{agent: text}`. No directory is "nothing
+ * recorded" — a real answer. Any other failure throws, so `settle` turns it
+ * into `unknown` instead of an empty list.
+ */
+export function readVerdictLogs(cwd) {
+  const dir = join(cwd, '.great_cto', 'verdicts');
+  let names;
+  try { names = readdirSync(dir); }
+  catch (e) { if (e?.code === 'ENOENT') return {}; throw e; }
+  const out = {};
+  for (const n of names) if (n.endsWith('.log')) out[n.slice(0, -4)] = readFileSync(join(dir, n), 'utf8');
+  return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "great-cto",
-  "version": "3.64.0",
+  "version": "3.65.0",
   "description": "One command install for the great_cto Claude Code plugin. Auto-detects your stack, picks the right archetype, bootstraps PROJECT.md.",
   "keywords": [
     "claude-code",