great-cto 3.54.0 → 3.55.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.55.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,90 @@ 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`)}"` : '';
+    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"${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="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.${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 +6361,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,195 @@
+/**
+ * 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] = { agent, runs: 0, pass: 0, stopped: 0, failed: 0, skipped: 0, unknown: 0, needImplementer: 0, needDecision: 0, last: null, projects: new Set() });
+        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);
+      }
+    }
+  }
+  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 - x.runs);
+  return { agents: rows, other: { runs: other.runs, names: [...other.names].sort().slice(0, 20) }, unreadable };
+}
+
+/** 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.55.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",