great-cto 3.54.0 → 3.56.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.54.0",
+  "version": "3.56.0",
   "author": {
     "name": "Alexander Velikiy",
     "url": "https://hashnode.com/@Greatcto"

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

@@ -14,6 +14,7 @@ import { autoRegisterProject, listProjects, resolveProjectCwd, resolveProjectInf
 import { readVerdictsWithHealth } from './verdicts.mjs';
 import { agentUsage, usageSnapshot } from '../../../scripts/lib/agent-usage.mjs';
 import { usageIndexSnapshot, summarizeUsage, readCodexTitles } from '../../../scripts/lib/session-usage.mjs';
+import { outcomes as computeOutcomes } from '../../../scripts/lib/outcomes.mjs';
 import { reviewerStatus } from '../../../scripts/lib/required-reviewers.mjs';
 import { readSessionStatus } from '../../../scripts/lib/session-status.mjs';
 import { readScores, summarizeScores } from '../../../scripts/lib/scores.mjs';
@@ -1511,6 +1512,14 @@ async function dispatch(req, res, url, cwd) {
       for (const host of Object.keys(sum.lists)) {
         sum.lists[host].agents = sum.lists[host].agents.map((a) => ({ ...a, ours: ours.has(a.name) }));
       }
+      // Which hooks are great_cto's: a guard that names itself, a status message
+      // from our plugin.json, or a script in our scripts/hooks.
+      const mine = boardHookNames();
+      const tag = (rows, kind) => rows.map((r) => ({
+        ...r,
+        ours: kind === 'blocks' ? !r.name.startsWith('other: ') : mine.has(r.name.replace(/^[A-Za-z]+:\s*/, '')),
+      }));
+      for (const k of ['blocks', 'stopBlocks', 'errors', 'timeouts']) sum.hooks[k] = tag(sum.hooks[k], k);
       body = { ...sum, seen: snap.seen, files: snap.files };
     }
     res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
@@ -1518,6 +1527,18 @@ async function dispatch(req, res, url, cwd) {
     return true;
   }
 
+  // What the agents concluded and what reviews found, across every registered
+  // project (scripts/lib/outcomes.mjs): verdicts per agent, Beads bugs by
+  // priority. Counts only — no bug title leaves the server. Answers at once:
+  // `computing` until the first read of every project's Beads lands.
+  if (pathname === '/api/outcomes') {
+    const rawDays = parseInt(url.searchParams.get('days') || '30', 10);
+    const days = Number.isFinite(rawDays) && rawDays > 0 ? Math.min(rawDays, 365) : 30;
+    res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(boardOutcomes(days)));
+    return true;
+  }
+
   // Domain reviewers this project's PROJECT.md requires (archetype, packs,
   // compliance), each with whether a verdict exists — the list gate:ship refuses on.
   // Sessions in this project that wait for a person — written by the
@@ -2181,6 +2202,44 @@ function boardUsage() {
   return _usageSnap;
 }
 
+let _hookNames = null;
+function boardHookNames() {
+  if (_hookNames) return _hookNames;
+  const root = path.join(path.dirname(new URL(import.meta.url).pathname), '..', '..', '..');
+  const names = new Set();
+  try {
+    const text = fs.readFileSync(path.join(root, '.claude-plugin', 'plugin.json'), 'utf8');
+    for (const m of text.matchAll(/"statusMessage"\s*:\s*"([^"]+)"/g)) names.add(m[1]);
+  } catch { /* no manifest: only scripts count */ }
+  try {
+    for (const f of fs.readdirSync(path.join(root, 'scripts', 'hooks'))) {
+      names.add(f.replace(/\.(mjs|js|py|sh)$/, ''));
+      // A Stop hook that sends the turn back opens its message with a label —
+      // "PIPELINE-NEXT: senior-dev succeeded …"; the labels our hooks write are ours.
+      try {
+        const src = fs.readFileSync(path.join(root, 'scripts', 'hooks', f), 'utf8');
+        for (const m of src.matchAll(/['"`]([A-Z][A-Z0-9_-]{2,40}):\s/g)) names.add(m[1]);
+      } catch { /* a directory or unreadable: its name is enough */ }
+    }
+  } catch { /* none */ }
+  _hookNames = names;
+  return names;
+}
+
+const _outcomes = new Map();
+const OUTCOMES_TTL = 5 * 60 * 1000;
+function boardOutcomes(days) {
+  const slot = _outcomes.get(days) || {};
+  const fresh = slot.value && Date.now() - slot.at < OUTCOMES_TTL;
+  if (!fresh && !slot.running) {
+    slot.running = computeOutcomes({ days, roster: boardAgentNames() })
+      .then((v) => { slot.value = v; }, (e) => { slot.value = slot.value || { state: 'unavailable', why: `outcomes could not be read: ${e?.message || e}` }; })
+      .finally(() => { slot.at = Date.now(); slot.running = null; });
+    _outcomes.set(days, slot);
+  }
+  return slot.value || { state: 'computing', why: 'reading every project\'s verdicts and Beads' };
+}
+
 let _sessionUsageSnap = null;
 function boardSessionUsage() {
   if (!_sessionUsageSnap) _sessionUsageSnap = usageIndexSnapshot();

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

@@ -2428,7 +2428,10 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 .usage-lists { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 220px), 1fr)); gap: 12px; margin-bottom: 20px; }
 .usage-list { list-style: none; margin: 0; padding: 0; }
 .usage-list li { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 8px; font-size: var(--fs-small); padding: 4px 0; position: relative; }
-.usage-list li .nm { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--text); }
+.usage-list li .nm { display: flex; align-items: baseline; min-width: 0; color: var(--text); }
+.usage-list li .nm .t { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; min-width: 0; }
+.usage-list li .nm .usage-tag { flex-shrink: 0; }
+[data-outcomes="agents"] .usage-table td:first-child { white-space: nowrap; }
 .usage-list li .n { font-family: var(--mono); font-variant-numeric: tabular-nums; color: var(--text2); }
 .usage-list li .bar { grid-column: 1 / -1; height: 3px; background: var(--bg-muted); }
 .usage-list li .bar > span { display: block; height: 100%; background: var(--accent); opacity: 0.7; }
@@ -2441,7 +2444,15 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 .usage-quote { font-size: var(--fs-small); color: var(--text2); border-left: 2px solid var(--border-strong); padding: 2px 0 2px 10px; margin: 10px 0 0; overflow-wrap: anywhere; }
 .usage-pace { font-size: var(--fs-small); color: var(--text); margin: 4px 0 8px; }
 .usage-pace.bad { color: var(--status-blocked-ink); }
-@media (max-width: 767px) { .usage-title { max-width: 160px; } .usage-chip { min-height: 44px; } }
+.usage-prios { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 8px; margin-bottom: 12px; }
+.usage-prio { border: 1px solid var(--border); padding: 8px 10px; min-width: 0; }
+.usage-prio b { display: block; font-family: var(--display); font-size: var(--fs-num-s); font-variant-numeric: tabular-nums; color: var(--text); line-height: 1.1; }
+.usage-prio .k { font-family: var(--mono); font-size: var(--fs-caption); color: var(--text2); }
+.usage-prio.hot { border-color: var(--status-blocked); }
+.usage-prio.hot .k { color: var(--status-blocked-ink); }
+.usage-rate { display: inline-block; width: 44px; height: 6px; background: var(--bg-muted); margin-right: 6px; vertical-align: 1px; }
+.usage-rate > span { display: block; height: 100%; background: var(--status-blocked); }
+@media (max-width: 767px) { .usage-title { max-width: 160px; } .usage-chip { min-height: 44px; } .usage-prios { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
 .mp-section-label {
   font-family: var(--mono); font-size: var(--fs-caption);
   letter-spacing: 0.1em; text-transform: uppercase;
@@ -6023,11 +6034,12 @@ async function loadUsage(days) {
   }
   usageData = d;
   renderUsage(d);
+  loadOutcomes();
 }
 
 function setUsageHost(host) {
   usageHost = host;
-  if (usageData) renderUsage(usageData);
+  if (usageData) { renderUsage(usageData); loadOutcomes(); }
 }
 
 function usageLimitWindow(minutes) {
@@ -6154,7 +6166,7 @@ function usageModels(d) {
 function usageList(title, rows, empty) {
   if (!rows || !rows.length) return `<section class="usage-card"><h3><span>${title}</span></h3><p class="usage-note">${empty}</p></section>`;
   const max = Math.max(...rows.map((r) => r.n));
-  const items = rows.map((r) => `<li><span class="nm" title="${esc(r.name)}">${esc(r.name)}${r.ours ? '<span class="usage-tag">great_cto</span>' : ''}</span><span class="n">${r.n.toLocaleString('en-US')}</span><span class="bar" aria-hidden="true"><span style="width:${Math.max(2, Math.round((r.n / max) * 100))}%"></span></span></li>`).join('');
+  const items = rows.map((r) => `<li><span class="nm" title="${esc(r.name)}"><span class="t">${esc(r.name)}</span>${r.ours ? '<span class="usage-tag">great_cto</span>' : ''}</span><span class="n">${r.n.toLocaleString('en-US')}</span><span class="bar" aria-hidden="true"><span style="width:${Math.max(2, Math.round((r.n / max) * 100))}%"></span></span></li>`).join('');
   return `<section class="usage-card"><h3><span>${title}</span></h3><ul class="usage-list">${items}</ul></section>`;
 }
 
@@ -6242,6 +6254,93 @@ function usageCodexLimits(d) {
   return `<section class="usage-card" data-limits="codex">${head}${lanes}<p class="usage-sub">A window Codex reset early shows as its own window.</p></section>`;
 }
 
+// ── Agents and reviews (great_cto-egkw stage 3) ────────────────────────────
+// Outcomes come from /api/outcomes (verdicts of every registered project, Beads
+// bugs by priority); hook refusals and failures from /api/usage (Claude Code's
+// own logs). Counts only — no bug title reaches the page.
+let _outcomesTimer = null;
+function fmtSpan(days) {
+  if (days == null) return '—';
+  const h = days * 24;
+  if (h < 1) return `${Math.max(1, Math.round(h * 60))} min`;
+  if (h < 48) return `${Math.round(h)} h`;
+  return `${Math.round(days)} days`;
+}
+
+async function loadOutcomes() {
+  clearTimeout(_outcomesTimer);
+  if (!document.getElementById('usage-outcomes')) return;
+  const d = await api(`/api/outcomes?days=${usageDays}`);
+  // Looked up AFTER the answer: Usage may have re-rendered while it was on the
+  // way, and an answer written into the replaced element is an answer nobody sees.
+  const el = document.getElementById('usage-outcomes');
+  if (!el) return;
+  if (!d || d.error) { el.className = 'usage-note'; el.textContent = `Outcomes could not be read: ${(d && d.error) || 'the board is not reachable'}`; return; }
+  if (d.state === 'computing') {
+    el.className = 'usage-note';
+    el.textContent = `Counting — ${d.why}`;
+    _outcomesTimer = setTimeout(() => { if (currentTab === 'usage') loadOutcomes(); }, 2000);
+    return;
+  }
+  if (d.state !== 'counted') { el.className = 'usage-note'; el.textContent = `Outcomes are not available: ${d.why || d.state}`; return; }
+  el.className = 'usage-grid';
+  el.innerHTML = usageAgentsCard(d) + usageFindingsCard(d);
+}
+
+function usageAgentsCard(d) {
+  const A = d.agents || { agents: [] };
+  const head = `<h3><span>Agents: what they concluded</span><span class="muted">${d.projects} projects · ${esc(d.window.from)} → ${esc(d.window.to)}</span></h3>`;
+  if (!A.agents.length) return `<section class="usage-card" data-outcomes="agents">${head}<p class="usage-note">No great_cto agent recorded a verdict in this period.</p></section>`;
+  const dispatched = Object.fromEntries(((usageData && usageData.lists && usageData.lists.claude && usageData.lists.claude.agents) || []).map((a) => [a.name, a.n]));
+  const rows = A.agents.map((a) => {
+    const rate = a.stopRate == null ? absent('none', 'no run of this agent reached a conclusion in this period') : `<span class="usage-rate" aria-hidden="true"><span style="width:${Math.round(a.stopRate * 100)}%"></span></span>${Math.round(a.stopRate * 100)}%`;
+    const disp = dispatched[a.agent];
+    const gap = disp != null && disp > a.runs ? ` title="${esc(`dispatched ${disp} times in Claude Code, ${a.runs} verdicts recorded — the rest ran without one`)}"` : '';
+    const nv = a.noVerdictTotal || 0;
+    const why = Object.entries(a.noVerdict || {}).map(([k, n]) => `${n} ${k === 'reported' ? 'finished without recording one' : k === 'cut-off' ? 'cut off mid-run' : 'ended, shape unknown'}`).join(', ');
+    const noVerdict = nv ? `<span title="${esc(why)}">${nv}</span>` : '0';
+    return `<tr><td>${esc(a.agent)}</td><td class="num">${a.runs}</td><td class="num">${a.pass}</td><td class="num">${a.stopped}</td><td class="num">${a.failed}</td><td class="num">${rate}</td><td class="num">${noVerdict}</td><td class="num"${gap}>${disp == null ? '—' : disp}</td></tr>`;
+  }).join('');
+  const notes = [];
+  if (A.agents.some((a) => a.unknown)) notes.push(`${A.agents.reduce((n, a) => n + a.unknown, 0)} verdicts used a word no rule classifies — counted as runs, not as passes.`);
+  if (A.other && A.other.runs) notes.push(`${A.other.runs} verdicts from names outside great_cto's roster (${esc(A.other.names.slice(0, 4).join(', '))}) are not shown.`);
+  if (A.unreadable) notes.push(`${A.unreadable} verdict files could not be read.`);
+  return `<section class="usage-card" data-outcomes="agents">${head}<div class="usage-table-wrap"><table class="usage-table">
+    <thead><tr><th>Agent</th><th class="num">Verdicts</th><th class="num">Pass</th><th class="num">Stopped</th><th class="num">Failed</th><th class="num">Stop rate</th><th class="num" title="Runs the completion check saw end with no verdict — hover a number for how they ended">No verdict</th><th class="num" title="Agent dispatches seen in Claude Code's logs in the same period">Dispatched</th></tr></thead>
+    <tbody>${rows}</tbody></table></div>
+    <p class="usage-sub">Stopped = BLOCKED, REWORK, REJECTED, ESCALATED — the pipeline halted on the agent's word. Stop rate is of the verdicts that concluded. No verdict counts runs that ended without one, as the completion check recorded them (from 3.56).${notes.length ? ` ${notes.join(' ')}` : ''}</p></section>`;
+}
+
+function usageFindingsCard(d) {
+  const F = d.findings;
+  const head = `<h3><span>Findings by priority</span><span class="muted">Beads bugs — reviewers file every P0/P1</span></h3>`;
+  if (!F) return `<section class="usage-card" data-outcomes="findings">${head}<p class="usage-note">Not read.</p></section>`;
+  const tiles = ['P0', 'P1', 'P2', 'P3'].map((p) => {
+    const hot = (p === 'P0' || p === 'P1') && F.openNow[p] > 0;
+    const close = F.daysToClose[p];
+    return `<div class="usage-prio${hot ? ' hot' : ''}"><span class="k">${p} filed</span><b>${F.filed[p]}</b><span class="usage-sub">${F.openNow[p]} open now${close ? ` · closed in ${esc(fmtSpan(close.median))} (median of ${close.n})` : ''}</span></div>`;
+  }).join('');
+  const rows = (F.projects || []).slice(0, 10).map((r) => `<tr><td>${esc(r.project)}</td><td class="num">${r.open.P0 || 0}</td><td class="num">${r.open.P1 || 0}</td><td class="num">${r.open.P2 || 0}</td><td class="num">${(r.filed.P0 || 0) + (r.filed.P1 || 0) + (r.filed.P2 || 0) + (r.filed.P3 || 0)}</td></tr>`).join('');
+  const table = rows ? `<div class="usage-table-wrap"><table class="usage-table"><thead><tr><th>Project</th><th class="num">P0 open</th><th class="num">P1 open</th><th class="num">P2 open</th><th class="num">Filed in period</th></tr></thead><tbody>${rows}</tbody></table></div>` : '<p class="usage-note">No project has a bug filed or open.</p>';
+  const unread = (F.unread || []).length
+    ? `<p class="usage-sub">Not read, so not counted: ${F.unread.map((u) => `<span title="${esc(u.why)}">${esc(u.project)}</span>`).join(', ')} — hover for the reason.</p>` : '';
+  return `<section class="usage-card" data-outcomes="findings">${head}<div class="usage-prios">${tiles}</div>${table}${unread}</section>`;
+}
+
+function usageHooksCards(d) {
+  const H = d.hooks;
+  if (!d.seen || !d.seen.claude) return '<p class="usage-note">No Claude Code logs on this machine — hook outcomes are read from them.</p>';
+  if (!H) return '';
+  const total = (rows) => (rows || []).reduce((n, r) => n + r.n, 0);
+  return `<div class="usage-lists">
+    ${usageList(`Guards refused a call · ${total(H.blocks)}`, H.blocks, 'No guard refused a tool call in this period.')}
+    ${usageList(`Stop hooks sent the turn back · ${total(H.stopBlocks)}`, H.stopBlocks, 'No Stop hook sent a turn back.')}
+    ${usageList(`Hooks that failed · ${total(H.errors)}`, H.errors, 'No hook failed in this period.')}
+    ${usageList(`Hooks that timed out · ${total(H.timeouts)}`, H.timeouts, 'No hook timed out in this period.')}
+  </div>
+  <p class="usage-sub">From Claude Code's logs; Codex does not write hook outcomes. A refusal is counted only where Claude Code marked the result an error — a command that merely prints one is not a refusal.</p>`;
+}
+
 function renderUsage(d) {
   const body = document.getElementById('usage-body');
   if (!body) return;
@@ -6265,6 +6364,10 @@ function renderUsage(d) {
       ${usageList('Agents', l.agents, 'No subagents were dispatched in this window.')}
       ${usageList('MCP servers', l.mcp, 'No MCP tools were called in this window.')}
     </div>
+    <h2 class="mp-section-label">Agents and reviews</h2>
+    <div id="usage-outcomes" class="usage-note" role="status">Reading every project's verdicts and Beads.</div>
+    <h2 class="mp-section-label">Guards and hooks</h2>
+    ${usageHooksCards(d)}
     <p class="usage-note">Read on this machine from ${USAGE_LOGS.claude} and ${USAGE_LOGS.codex}; nothing is sent anywhere. Tokens include cache reads. <b>$ list</b> is the API list-price equivalent from great_cto's price table, not a subscription bill — Claude Code's own estimate can differ for some models. A model without a price shows n/a, never $0.</p>`;
 }
 

package/board/scripts/lib/outcomes.mjs

@@ -0,0 +1,219 @@
+/**
+ * outcomes — what great_cto's agents concluded and what reviews found, across
+ * every project on this machine.
+ *
+ *   agent outcomes  every verdict line of every registered project (and the
+ *                   global layer), classified pass / stopped / failed / skipped
+ *   findings        bugs in each project's Beads, by priority: filed in the
+ *                   window, open now, and how long the closed ones took. Every
+ *                   reviewer files its P0/P1 findings as Beads bugs, so this is
+ *                   where they land — the review files were written once on this
+ *                   machine; the bugs were filed a hundred times.
+ *
+ * Rules:
+ *  - A verdict nobody can classify is `unknown`, not a pass. A project whose
+ *    Beads cannot be read is listed as unread, not as a project with no bugs.
+ *  - The same line can sit in a project log and in the global layer; it is
+ *    counted once.
+ *  - Titles and descriptions of bugs never leave this module — counts only.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { parseVerdictLine } from './verdict-record.mjs';
+import { dayOf } from './session-usage.mjs';
+
+const DAY = 86400000;
+
+/** pass · stopped · failed · skipped · unknown — what a verdict means for the pipeline. */
+export function outcomeOf(verdict) {
+  const v = String(verdict || '').toUpperCase();
+  if (['APPROVED', 'PASS', 'DONE', 'TASK_DONE'].includes(v)) return 'pass';
+  if (['BLOCKED', 'REWORK', 'ESCALATED', 'REJECTED', 'CHANGES_REQUESTED'].includes(v)) return 'stopped';
+  if (v === 'FAIL') return 'failed';
+  if (v === 'SKIPPED') return 'skipped';
+  return 'unknown';
+}
+
+/**
+ * The agent a verdict belongs to. `great-cto:senior-dev` is senior-dev; a legacy
+ * file named `devops-2026-09-15-123328.log` is devops.
+ */
+export function verdictAgent(raw) {
+  return String(raw || '').replace(/^great[-_]cto:/, '').replace(/-\d{4}-\d{2}-\d{2}.*$/, '').trim();
+}
+
+/** Project directories from the board registry, plus the global layer's home. */
+export function registeredProjects(file = path.join(os.homedir(), '.great_cto', 'projects.json')) {
+  try {
+    const list = JSON.parse(fs.readFileSync(file, 'utf8')).projects || [];
+    return list.map((p) => ({ name: p.name || path.basename(p.path || ''), path: p.path })).filter((p) => p.path && fs.existsSync(p.path));
+  } catch { return []; }
+}
+
+function verdictFiles(dir) {
+  try { return fs.readdirSync(dir).filter((f) => f.endsWith('.log')).map((f) => path.join(dir, f)); } catch { return []; }
+}
+
+/**
+ * Per-agent outcomes in the window.
+ * @param {{projects:{name:string,path:string}[], globalDir?:string, days?:number, now?:number, roster?:string[]}} opts
+ */
+export function agentOutcomes({ projects, globalDir = path.join(os.homedir(), '.great_cto', 'verdicts'), days = 30, now = Date.now(), roster = [] }) {
+  const from = now - days * DAY;
+  const known = new Set(roster);
+  const seen = new Set();
+  const agents = {};
+  const other = { runs: 0, names: new Set() };
+  let unreadable = 0;
+  const sources = [...projects.map((p) => ({ project: p.name, dir: path.join(p.path, '.great_cto', 'verdicts') })), { project: null, dir: globalDir }];
+  for (const { project, dir } of sources) {
+    for (const file of verdictFiles(dir)) {
+      let text;
+      try { text = fs.readFileSync(file, 'utf8'); } catch { unreadable++; continue; }
+      const fileAgent = verdictAgent(path.basename(file, '.log'));
+      for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        const p = parseVerdictLine(line);
+        if (!p.ok) continue;
+        const rec = p.rec;
+        const t = Date.parse(rec.ts);
+        if (!Number.isFinite(t) || t < from || t > now) continue;
+        const key = line.trim();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const agent = verdictAgent(rec.agent || fileAgent) || fileAgent;
+        if (known.size && !known.has(agent)) { other.runs++; other.names.add(agent); continue; }
+        const a = agents[agent] || (agents[agent] = blankAgent(agent));
+        a.runs++;
+        a[outcomeOf(rec.verdict)]++;
+        if (rec.meta?.need === 'implementer') a.needImplementer++;
+        if (rec.meta?.need === 'decision') a.needDecision++;
+        if (!a.last || rec.ts > a.last) a.last = rec.ts;
+        const proj = rec.project || project;
+        if (proj) a.projects.add(proj);
+      }
+    }
+  }
+  // How runs ENDED, from the completion hook's agent-stop events: a run that
+  // recorded nothing leaves no verdict line, so only these can count it.
+  for (const p of projects) {
+    let text = '';
+    try { text = fs.readFileSync(path.join(p.path, '.great_cto', 'events.jsonl'), 'utf8'); } catch { continue; }
+    for (const line of text.split('\n')) {
+      if (!line.includes('"agent-stop"') || !line.includes('no-verdict')) continue;
+      let e;
+      try { e = JSON.parse(line); } catch { continue; }
+      const t = Date.parse(e.ts);
+      if (!Number.isFinite(t) || t < from || t > now || !/^no-verdict-/.test(e.outcome || '')) continue;
+      const agent = verdictAgent(e.agent);
+      if (!agent || (known.size && !known.has(agent))) continue;
+      const a = agents[agent] || (agents[agent] = blankAgent(agent));
+      const why = e.outcome.slice('no-verdict-'.length);
+      a.noVerdict[why] = (a.noVerdict[why] || 0) + 1;
+      a.noVerdictTotal++;
+      a.projects.add(p.name);
+    }
+  }
+  const rows = Object.values(agents).map((a) => ({
+    ...a,
+    projects: a.projects.size,
+    // Of the runs that reached a conclusion, how many stopped the pipeline.
+    stopRate: a.pass + a.stopped + a.failed ? (a.stopped + a.failed) / (a.pass + a.stopped + a.failed) : null,
+  })).sort((x, y) => (y.runs + y.noVerdictTotal) - (x.runs + x.noVerdictTotal));
+  return { agents: rows, other: { runs: other.runs, names: [...other.names].sort().slice(0, 20) }, unreadable };
+}
+
+function blankAgent(agent) {
+  return { agent, runs: 0, pass: 0, stopped: 0, failed: 0, skipped: 0, unknown: 0, needImplementer: 0, needDecision: 0, noVerdict: {}, noVerdictTotal: 0, last: null, projects: new Set() };
+}
+
+/** Run `bd` in a project; resolves to parsed JSON or a reason it could not. */
+function bdJson(cwd, args, { timeoutMs = 20000, bin = 'bd' } = {}) {
+  return new Promise((resolve) => {
+    execFile(bin, args, { cwd, timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, BD_NO_DAEMON: '1' } }, (err, stdout, stderr) => {
+      if (err) {
+        if (err.code === 'ENOENT') return resolve({ ok: false, why: 'bd is not installed' });
+        if (err.killed) return resolve({ ok: false, why: `bd took longer than ${timeoutMs / 1000}s` });
+        // bd prints warnings first (".beads has permissions 0750"); the reason is the error line.
+        const lines = String(stderr || '').split('\n').map((x) => x.trim()).filter(Boolean);
+        const said = lines.find((x) => /^error/i.test(x)) || lines[lines.length - 1];
+        return resolve({ ok: false, why: (said || String(err.message || err).split('\n')[0]).split(os.homedir()).join('~').slice(0, 160) });
+      }
+      try { return resolve({ ok: true, data: JSON.parse(stdout || '[]') }); } catch { return resolve({ ok: false, why: 'bd did not answer JSON' }); }
+    });
+  });
+}
+
+const PRIOS = ['P0', 'P1', 'P2', 'P3'];
+const prio = (n) => (Number.isInteger(n) && n >= 0 && n <= 3 ? `P${n}` : 'P?');
+
+function median(xs) {
+  if (!xs.length) return null;
+  const s = [...xs].sort((a, b) => a - b);
+  const m = Math.floor(s.length / 2);
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+
+/**
+ * Bugs by priority across the projects that keep Beads.
+ * @param {{projects:{name:string,path:string}[], days?:number, now?:number, list?:(cwd:string)=>Promise<{ok:boolean,data?:object[],why?:string}>}} opts
+ */
+export async function bugFindings({ projects, days = 30, now = Date.now(), list = (cwd) => bdJson(cwd, ['list', '--json', '--type', 'bug', '--all']) }) {
+  const from = now - days * DAY;
+  const blank = () => Object.fromEntries([...PRIOS, 'P?'].map((p) => [p, 0]));
+  const filed = blank();
+  const openNow = blank();
+  const closedIn = blank();
+  const toClose = Object.fromEntries([...PRIOS, 'P?'].map((p) => [p, []]));
+  const daily = {};
+  const perProject = [];
+  const unread = [];
+  for (const p of projects) {
+    if (!fs.existsSync(path.join(p.path, '.beads'))) continue;
+    const r = await list(p.path);
+    if (!r.ok) { unread.push({ project: p.name, why: r.why }); continue; }
+    const row = { project: p.name, filed: blank(), open: blank() };
+    for (const b of Array.isArray(r.data) ? r.data : []) {
+      const pr = prio(b.priority);
+      const created = Date.parse(b.created_at);
+      const closed = b.closed_at ? Date.parse(b.closed_at) : NaN;
+      if (Number.isFinite(created) && created >= from && created <= now) {
+        filed[pr]++; row.filed[pr]++;
+        const d = dayOf(created);
+        const slot = daily[d] || (daily[d] = blank());
+        slot[pr]++;
+      }
+      if (b.status !== 'closed' && b.status !== 'tombstone') { openNow[pr]++; row.open[pr]++; }
+      if (Number.isFinite(closed) && closed >= from && closed <= now) {
+        closedIn[pr]++;
+        if (Number.isFinite(created) && closed >= created) toClose[pr].push((closed - created) / DAY);
+      }
+    }
+    const any = (o) => Object.values(o).some(Boolean);
+    if (any(row.filed) || any(row.open)) perProject.push(row);
+  }
+  perProject.sort((a, b) => (b.open.P0 - a.open.P0) || (b.open.P1 - a.open.P1) || (sum(b.filed) - sum(a.filed)));
+  return {
+    filed, openNow, closedIn,
+    daysToClose: Object.fromEntries(Object.entries(toClose).map(([k, xs]) => [k, xs.length ? { median: median(xs), n: xs.length } : null])),
+    daily,
+    projects: perProject,
+    unread,
+  };
+}
+
+const sum = (o) => Object.values(o).reduce((a, n) => a + n, 0);
+
+/** Both, for the board. */
+export async function outcomes({ days = 30, now = Date.now(), roster = [], projects = registeredProjects(), globalDir, list } = {}) {
+  const findings = await bugFindings({ projects, days, now, list });
+  return {
+    state: 'counted',
+    window: { days, from: dayOf(now - (days - 1) * DAY), to: dayOf(now) },
+    projects: projects.length,
+    agents: agentOutcomes({ projects, globalDir, days, now, roster }),
+    findings,
+  };
+}

package/board/scripts/lib/session-usage.mjs

@@ -40,7 +40,7 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { priceUsage, effectivePrices } from './cost-meter.mjs';
 
-const INDEX_VERSION = 2;          // 2: hourly buckets, limit kinds, Codex limit series
+const INDEX_VERSION = 3;          // 2: hourly buckets, limit kinds, Codex limit series · 3: hook blocks, errors, timeouts
 const RING = 256;                 // recent response ids remembered across reads
 const KEEP_GONE_DAYS = 400;       // how long a vanished file's days are kept
 const SERIES_MAX = 4000;          // Codex limit readings kept per file
@@ -117,7 +117,10 @@ function isDir(p) { try { return fs.statSync(p).isDirectory(); } catch { return
 // ── shared accumulation ───────────────────────────────────────────────────────
 
 function emptyDay() {
-  return { in: 0, out: 0, cr: 0, cw: 0, cwh: 0, rs: 0, msgs: 0, models: {}, tools: {}, skills: {}, agents: {}, mcp: {}, lim: {}, h: {} };
+  // g: a guard hook refused a tool call · sb: a Stop hook sent the turn back ·
+  // he: a hook failed · ht: a hook timed out. Keyed by the guard's name or the
+  // hook's status message — the only name a transcript gives a hook.
+  return { in: 0, out: 0, cr: 0, cw: 0, cwh: 0, rs: 0, msgs: 0, models: {}, tools: {}, skills: {}, agents: {}, mcp: {}, lim: {}, h: {}, g: {}, sb: {}, he: {}, ht: {} };
 }
 
 /** The hour inside a day: tokens per model as [in, out, cacheRead, cacheWrite5m, cacheWrite1h], and limit refusals. */
@@ -211,17 +214,87 @@ export function agentName(raw) {
   return raw.replace(/^great[-_]cto:/, '');
 }
 
+/**
+ * A hook that refused a tool call, from the tool result Claude Code wrote:
+ *   "PreToolUse:Bash hook error: [<cmd>]: great_cto shared-tree guard blocked …"
+ * Named by the guard when the hook names itself, else by the event and tool.
+ */
+export function guardOf(text) {
+  const m = String(text || '').trimStart().match(/^(PreToolUse|PostToolUse|PermissionRequest|UserPromptSubmit):?([^\s]*) hook (?:error|blocking error)/);
+  if (!m) return null;
+  const g = text.match(/great_cto ([a-z0-9-]+(?: [a-z0-9-]+)?) guard\b/);
+  if (g) return { name: g[1], ours: true };
+  return { name: `${m[1]}${m[2] ? `:${m[2]}` : ''}`, ours: /\bgreat_cto\b/.test(text) };
+}
+
+/** A Stop-hook continuation: "PIPELINE-NEXT: senior-dev succeeded …" → PIPELINE-NEXT. */
+export function stopBlockName(event, text) {
+  const m = String(text || '').match(/^\s*([A-Z][A-Z0-9_-]{2,40}):/);
+  return m ? `${event}: ${m[1]}` : event || 'hook';
+}
+
+/**
+ * A short name for a hook. Claude Code records a hook by its status message
+ * ("Safety check...") or, when it has none, by its whole shell command — a
+ * 200-character `PLUGIN_DIR=$(ls -d …)` line. The script it runs is the name.
+ */
+export function hookLabel(command) {
+  const c = String(command || '').trim();
+  const m = c.match(/scripts\/hooks\/([A-Za-z0-9_.-]+?)(?:\.(?:mjs|js|py|sh))?(?=["'\s]|$)/);
+  if (m) return m[1];
+  return c.length > 60 ? `${c.slice(0, 57)}…` : c || 'hook';
+}
+
+function hookRecord(entry, r) {
+  const a = r.attachment || {};
+  const ts = typeof r.timestamp === 'string' ? r.timestamp : null;
+  if (!ts) return;
+  const b = dayBucket(entry, ts);
+  if (!b) return;
+  for (const k of ['g', 'sb', 'he', 'ht']) if (!b[k]) b[k] = {};
+  if (a.type === 'hook_blocking_error') {
+    const text = a.blockingError?.blockingError ?? a.blockingError ?? '';
+    bump(b.sb, stopBlockName(a.hookEvent || a.hookName, typeof text === 'string' ? text : ''));
+  } else if (a.type === 'hook_non_blocking_error') {
+    bump(b.he, `${a.hookEvent || a.hookName}: ${hookLabel(a.command || a.hookName)}`);
+  } else if (a.type === 'hook_cancelled' && a.timedOut) {
+    bump(b.ht, `${a.hookEvent || a.hookName}: ${hookLabel(a.command || a.hookName)}`);
+  }
+}
+
 export function claudeLine(entry, line) {
   // Most bytes in a transcript are tool RESULTS in user lines. They carry no
-  // usage, so they are not parsed — except to name a session that has no title.
+  // usage, so they are not parsed — except to name a session that has no title,
+  // and when a hook refused the call the result answers.
   const isAssistant = line.includes('"type":"assistant"');
   const isTitle = line.includes('"custom-title"');
   const wantsPrompt = !entry.meta.prompt && !entry.meta.title && line.includes('"type":"user"');
-  if (!isAssistant && !isTitle && !wantsPrompt) return;
+  const isHookResult = line.includes(' hook error') && line.includes('"tool_result"');
+  const isHookRecord = line.includes('"hook_blocking_error"') || line.includes('"hook_non_blocking_error"') || line.includes('"hook_cancelled"');
+  if (!isAssistant && !isTitle && !wantsPrompt && !isHookResult && !isHookRecord) return;
   let r;
   try { r = JSON.parse(line); } catch { return; }
   const meta = entry.meta;
 
+  if (r.type === 'attachment') { if (isHookRecord) hookRecord(entry, r); return; }
+  if (r.type === 'user' && isHookResult) {
+    const ts = typeof r.timestamp === 'string' ? r.timestamp : null;
+    const b = ts && dayBucket(entry, ts);
+    for (const block of Array.isArray(r.message?.content) ? r.message.content : []) {
+      // Only a result Claude Code marked as an error: a command whose OUTPUT
+      // quotes a refusal (a grep over these logs, say) is not one.
+      if (block?.type !== 'tool_result' || block.is_error !== true) continue;
+      const c = block.content;
+      const text = typeof c === 'string' ? c : Array.isArray(c) ? c.map((x) => x?.text || '').join(' ') : '';
+      const g = guardOf(text);
+      if (g && b) {
+        if (!b.g) b.g = {};
+        bump(b.g, g.ours ? g.name : `other: ${g.name}`);
+      }
+    }
+    if (!wantsPrompt) return;
+  }
+
   if (r.type === 'custom-title' && r.customTitle) { meta.title = String(r.customTitle).slice(0, 160); return; }
   if (r.type === 'user') {
     if (r.isCompactSummary || r.isMeta) return;
@@ -441,6 +514,28 @@ function saveIndex(cacheFile, index) {
     fs.writeFileSync(tmp, JSON.stringify(index));
     fs.renameSync(tmp, cacheFile);
   } catch { /* unsaved: the next pass re-reads, nothing else is lost */ }
+  removeOlderIndexes(cacheFile);
+}
+
+/**
+ * An index of an older format is a copy nothing current reads — megabytes each.
+ * Only names this module writes, only versions below the current one, and only
+ * next to the default file: a caller's own cache path is the caller's business.
+ */
+export function removeOlderIndexes(cacheFile, version = INDEX_VERSION) {
+  if (path.basename(cacheFile) !== `session-usage-index.v${version}.json`) return [];
+  const dir = path.dirname(cacheFile);
+  const removed = [];
+  let names = [];
+  try { names = fs.readdirSync(dir); } catch { return removed; }
+  for (const name of names) {
+    const m = name.match(/^session-usage-index(?:\.v(\d+))?\.json$/);
+    if (!m) continue;
+    const v = m[1] ? Number(m[1]) : 1;
+    if (v >= version) continue;
+    try { fs.rmSync(path.join(dir, name)); removed.push(name); } catch { /* in use or gone: next save tries again */ }
+  }
+  return removed;
 }
 
 /**
@@ -669,6 +764,8 @@ export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles
   const daily = Object.fromEntries(dates.map((d) => [d, { claude: { tokens: 0, usd: 0, byFn: {} }, codex: { tokens: 0, usd: 0, byFn: {} } }]));
   const models = {};
   const lists = { claude: { tools: {}, skills: {}, agents: {}, mcp: {} }, codex: { tools: {}, skills: {}, agents: {}, mcp: {} } };
+  const hooks = { blocks: {}, stopBlocks: {}, errors: {}, timeouts: {} };
+  const hookDaily = Object.fromEntries(dates.map((d) => [d, { blocks: 0, stopBlocks: 0 }]));
   const sessions = {};
   const unpriced = new Set();
   let codexLimits = null;
@@ -710,6 +807,12 @@ export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles
       const h = hosts[host];
       for (const [k, n] of Object.entries(b.lim || {})) bump(h.lim, k, n);
       for (const kind of ['tools', 'skills', 'agents', 'mcp']) for (const [k, n] of Object.entries(b[kind] || {})) bump(lists[host][kind], k, n);
+      for (const [field, key] of [['g', 'blocks'], ['sb', 'stopBlocks'], ['he', 'errors'], ['ht', 'timeouts']]) {
+        for (const [k, n] of Object.entries(b[field] || {})) {
+          bump(hooks[key], k, n);
+          if (key === 'blocks' || key === 'stopBlocks') hookDaily[day][key] += n;
+        }
+      }
       let dayUsd = 0;
       let dayUnpriced = false;
       for (const [model, m] of Object.entries(b.models || {})) {
@@ -787,6 +890,12 @@ export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles
       claude: claudeLimits(hourly.claude, { fromMs, now, lastHit }),
     },
     unpricedModels: [...unpriced].sort(),
+    // Claude Code only: Codex does not write hook outcomes to its session logs.
+    hooks: {
+      blocks: rank(hooks.blocks, 20), stopBlocks: rank(hooks.stopBlocks, 15),
+      errors: rank(hooks.errors, 15), timeouts: rank(hooks.timeouts, 15),
+      daily: dates.map((d) => ({ date: d, ...hookDaily[d] })),
+    },
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "great-cto",
-  "version": "3.54.0",
+  "version": "3.56.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",