great-cto 3.53.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.53.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

@@ -2244,6 +2244,11 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
   font-size: var(--fs-body);
 }
 .judge-status[hidden] { display: none; }
+/* The "retry" link appears only when the live key check got no answer — a
+   degraded state, so no screenshot ever carried it, and it rendered in the
+   browser's default blue until the on-system check met it on 2026-10-06. */
+.judge-status a { color: var(--accent-text); text-decoration: underline; text-underline-offset: 2px; }
+.judge-status a:focus-visible { outline: 2px solid var(--focus-ring); outline-offset: 1px; }
 
 /* What the judge CONCLUDED, under whether it is connected.
    The scores existed for weeks and no page read them: /api/scores had zero
@@ -2404,7 +2409,9 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 .usage-sub { font-size: var(--fs-caption); color: var(--text3); line-height: 1.5; }
 .usage-note { font-size: var(--fs-small); color: var(--text2); line-height: 1.55; }
 .usage-chart svg { display: block; width: 100%; height: 120px; }
-.usage-axis { display: flex; justify-content: space-between; font-family: var(--mono); font-size: var(--fs-caption); color: var(--text3); margin-top: 4px; }
+.usage-axis { display: flex; justify-content: space-between; gap: 8px; font-family: var(--mono); font-size: var(--fs-caption); color: var(--text3); margin-top: 4px; }
+.usage-axis span { white-space: nowrap; }
+.usage-axis span:nth-child(2) { overflow: hidden; text-overflow: ellipsis; min-width: 0; }
 .usage-legend { display: flex; flex-wrap: wrap; gap: 4px 14px; font-size: var(--fs-caption); color: var(--text2); margin-top: 8px; }
 .usage-legend i { display: inline-block; width: 10px; height: 10px; margin-right: 5px; vertical-align: -1px; }
 .usage-table-wrap { overflow-x: auto; }
@@ -2421,11 +2428,31 @@ 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; }
-@media (max-width: 767px) { .usage-title { max-width: 160px; } .usage-chip { min-height: 44px; } }
+.usage-line svg { display: block; width: 100%; height: 110px; overflow: visible; }
+.usage-line .ln { fill: none; stroke: var(--accent); stroke-width: 1.5; vector-effect: non-scaling-stroke; }
+.usage-line .ceil { stroke: var(--status-progress); stroke-width: 1; stroke-dasharray: 4 3; vector-effect: non-scaling-stroke; }
+.usage-line .grid { stroke: var(--border-strong); stroke-width: 1; vector-effect: non-scaling-stroke; }
+.usage-kinds { display: flex; flex-wrap: wrap; gap: 6px 14px; font-size: var(--fs-small); color: var(--text2); margin: 10px 0 4px; }
+.usage-kinds b { font-family: var(--mono); font-variant-numeric: tabular-nums; color: var(--text); font-weight: 500; margin-right: 4px; }
+.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); }
+.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;
@@ -6007,16 +6034,18 @@ 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) {
   if (minutes === 10080) return 'Weekly limit';
   if (minutes === 300) return '5-hour limit';
+  if (minutes === 43200) return 'Monthly limit';
   return minutes ? `${minutes}-minute limit` : 'Limit';
 }
 
@@ -6137,10 +6166,178 @@ 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>`;
 }
 
+// ── Limits (great_cto-egkw stage 2) ────────────────────────────────────────
+const USAGE_LIMIT_KIND = { session: '5-hour session', weekly: 'weekly', spend: 'monthly spend', model: 'per-model', credits: 'usage credits', other: 'other' };
+const USAGE_LIMIT_COLOR = { session: 'var(--status-blocked)', weekly: 'var(--status-progress)', spend: 'var(--status-gate)', model: 'var(--text2)', credits: 'var(--text2)', other: 'var(--text3)' };
+const fmtWhen = (ms) => (ms ? fmtDT(new Date(ms).toISOString()) : '—');
+function fmtHours(ms) {
+  const h = ms / 3600000;
+  return h >= 48 ? `${Math.round(h / 24)} days` : `${Math.max(1, Math.round(h))} h`;
+}
+
+/** A line over the period: points [ms, value]; marks [{t, color, title}] drawn as ticks. */
+function usageLineSvg({ from, to, points, max, marks = [], ceiling = null, label }) {
+  const W = 1000; const H = 100;
+  const x = (t) => (((t - from) / Math.max(1, to - from)) * W).toFixed(1);
+  const y = (v) => (H - (Math.min(v, max) / max) * (H - 4)).toFixed(1);
+  const path = points.map((p, i) => `${i ? 'L' : 'M'}${x(p[0])},${y(p[1])}`).join('');
+  const ticks = marks.map((m) => `<g><title>${esc(m.title)}</title><line x1="${x(m.t)}" x2="${x(m.t)}" y1="0" y2="${H}" stroke="${m.color}" stroke-width="2" vector-effect="non-scaling-stroke" opacity="0.8"></line></g>`).join('');
+  const ceil = ceiling != null ? `<line class="ceil" x1="0" x2="${W}" y1="${y(ceiling)}" y2="${y(ceiling)}"></line>` : '';
+  return `<svg viewBox="0 0 ${W} ${H}" preserveAspectRatio="none" role="img" aria-label="${esc(label)}">
+    <line class="grid" x1="0" x2="${W}" y1="${H}" y2="${H}"></line>${ceil}${ticks}<path class="ln" d="${path}"></path></svg>`;
+}
+
+function usageClaudeLimits(d) {
+  const head = `<h3><span>Claude Code limits</span><span class="muted">from refusals — no plan percentage is recorded</span></h3>`;
+  if (!d.seen || !d.seen.claude) return `<section class="usage-card" data-limits="claude">${head}<p class="usage-note">No Claude Code logs on this machine.</p></section>`;
+  const L = d.limits && d.limits.claude;
+  if (!L) return `<section class="usage-card" data-limits="claude">${head}<p class="usage-note">Not computed.</p></section>`;
+  const hits = (d.hosts.claude && d.hosts.claude.limitHits) || {};
+  const stat = (v, label) => `<div class="usage-stat"><b>${v}</b><span>${label}</span></div>`;
+  const ceilLine = (c, span) => c
+    ? `Refused at about <b>${esc(fmtUsdEq(c.median))}</b> in ${span} <span class="muted">(median of ${c.n} refused hour${c.n === 1 ? '' : 's'}, ${esc(fmtUsdEq(c.min))}–${esc(fmtUsdEq(c.max))})</span>`
+    : null;
+  const ceilings = [ceilLine(L.ceilings.session, '5 hours'), ceilLine(L.ceilings.weekly, '7 days')].filter(Boolean);
+  const kinds = Object.keys(USAGE_LIMIT_KIND).filter((k) => hits[k]).map((k) => `<span><b>${hits[k]}</b>${USAGE_LIMIT_KIND[k]}</span>`).join('');
+  const s = L.series || { usd5h: [] };
+  const to = s.from + (s.usd5h.length - 1) * s.stepMs;
+  const pts = s.usd5h.map((v, i) => [s.from + i * s.stepMs, v]);
+  const max = Math.max(1, ...s.usd5h, L.ceilings.session ? L.ceilings.session.max : 0);
+  const marks = (L.hits || []).filter((h) => h.kind !== 'server').map((h) => ({ t: h.t, color: USAGE_LIMIT_COLOR[h.kind] || 'var(--text3)', title: `${fmtWhen(h.t)} — refused by the ${USAGE_LIMIT_KIND[h.kind] || h.kind} limit ×${h.n}` }));
+  const chart = pts.length > 1 ? `<div class="usage-line">${usageLineSvg({ from: s.from, to, points: pts, max, marks, ceiling: L.ceilings.session ? L.ceilings.session.median : null, label: 'Claude Code spend in the trailing 5 hours, with refusals marked' })}</div>
+    <div class="usage-axis"><span>${esc(d.window.from)}</span><span>$ in the trailing 5 hours · peak ${esc(fmtUsdEq(max))}</span><span>${esc(d.window.to)}</span></div>` : '';
+  const last = L.lastHit ? `<p class="usage-quote" title="${esc(fmtDate(L.lastHit.at))}">${esc(L.lastHit.text)} <span class="muted">— ${esc(relTime(L.lastHit.at))} ago</span></p>` : '';
+  return `<section class="usage-card" data-limits="claude">${head}
+    <div class="usage-stats">${stat(esc(fmtUsdEq(L.fiveHour.usd)), 'last 5 hours, $ list')}${stat(esc(fmtUsdEq(L.sevenDay.usd)), 'last 7 days, $ list')}${stat(esc(String(hits.plan || 0)), `refusals in ${d.window.days} days`)}</div>
+    ${kinds ? `<div class="usage-kinds">${kinds}</div>` : `<p class="usage-note">No request was refused by a limit in this period.</p>`}
+    ${ceilings.length ? `<p class="usage-note">${ceilings.join('<br>')}. <span class="muted">An estimate from what had been spent when Claude Code refused — not a published limit.</span></p>` : ''}
+    ${chart}
+    ${hits.server ? `<p class="usage-sub">${hits.server} server-side throttles (not your limit) are not marked.</p>` : ''}
+    ${last}
+  </section>`;
+}
+
+function usageCodexLane(name, lane, d) {
+  const title = usageLimitWindow(lane.minutes);
+  const P = lane.projection;
+  const lastRead = lane.series.length ? lane.series[lane.series.length - 1][0] : null;
+  let pace = `<p class="usage-pace muted">No open window${lastRead ? ` — the last reading of it is from ${esc(fmtWhen(lastRead))}; the plan may no longer have it` : ''}.</p>`;
+  if (P && P.state === 'full') pace = `<p class="usage-pace bad">Full — resets ${esc(fmtWhen(P.resets))}.</p>`;
+  else if (P && P.state === 'will-fill') pace = `<p class="usage-pace bad">${P.used}% used. At this pace it is full by ${esc(fmtWhen(P.fullBy))} — ${esc(fmtHours(P.resets - P.fullBy))} before the reset.</p>`;
+  else if (P && P.state === 'fits') pace = `<p class="usage-pace">${P.used}% used. At this pace about ${Math.round(P.atReset)}% by the reset, ${esc(fmtWhen(P.resets))}.</p>`;
+  const from = Date.parse(`${d.window.from}T00:00:00`);
+  const to = Date.now();
+  const pts = [];
+  for (const [t, v] of lane.series) { if (pts.length) pts.push([t, pts[pts.length - 1][1]]); pts.push([t, v]); }
+  const marks = lane.windows.filter((w) => w.fullAt && w.fullAt >= from).map((w) => ({ t: w.fullAt, color: 'var(--status-blocked)', title: `filled ${fmtWhen(w.fullAt)}, ${fmtHours(w.resets - w.fullAt)} before its reset` }));
+  const chart = pts.length > 1 ? `<div class="usage-line">${usageLineSvg({ from, to, points: pts, max: 100, marks, label: `Codex ${title} percent used over the period` })}</div>
+    <div class="usage-axis"><span>${esc(d.window.from)}</span><span>% used · red = filled</span><span>${esc(d.window.to)}</span></div>` : '';
+  const touched = lane.windows.filter((w) => w.peak > 0);
+  const early = lane.windows.filter((w) => w.fullAt).map((w) => w.resets - w.fullAt);
+  const summary = touched.length
+    ? `${lane.filled} of ${touched.length} used windows filled${early.length ? `, on median ${esc(fmtHours(early.sort((a, b) => a - b)[Math.floor(early.length / 2)]))} before the reset` : ''}.`
+    : 'No window was used in this period.';
+  return `<div class="usage-limit" data-lane="${esc(name)}"><div class="usage-limit-head"><span>${esc(title)}</span></div>${pace}${chart}<p class="usage-sub">${summary}</p></div>`;
+}
+
+function usageCodexLimits(d) {
+  const head = `<h3><span>Codex limits</span><span class="muted">as Codex reported them</span></h3>`;
+  if (!d.seen || !d.seen.codex) return `<section class="usage-card" data-limits="codex">${head}<p class="usage-note">No Codex logs on this machine.</p></section>`;
+  const D = d.limits && d.limits.codex && d.limits.codex.detail;
+  if (!D) return `<section class="usage-card" data-limits="codex">${head}<p class="usage-note">No Codex session reported its plan window in this period.</p></section>`;
+  const order = ['fiveHour', 'weekly', ...Object.keys(D).filter((k) => k !== 'fiveHour' && k !== 'weekly')];
+  const lanes = order.filter((k) => D[k]).map((k) => usageCodexLane(k, D[k], d)).join('');
+  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;
@@ -6149,6 +6346,8 @@ function renderUsage(d) {
   const hostBtn = (h) => `<button type="button" class="usage-chip${usageHost === h ? ' active' : ''}" aria-pressed="${usageHost === h}" onclick="setUsageHost('${h}')">${USAGE_HOSTS[h]}</button>`;
   body.innerHTML = `
     <div class="usage-grid">${usageHostCard(d, 'claude')}${usageHostCard(d, 'codex')}</div>
+    <h2 class="mp-section-label">Limits</h2>
+    <div class="usage-grid">${usageClaudeLimits(d)}${usageCodexLimits(d)}</div>
     <h2 class="mp-section-label">By day, by kind of work</h2>
     <div class="usage-grid">${usageDayChart(d, 'claude')}${usageDayChart(d, 'codex')}</div>
     <h2 class="mp-section-label">Heaviest conversations</h2>
@@ -6162,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,19 +40,29 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { priceUsage, effectivePrices } from './cost-meter.mjs';
 
-const INDEX_VERSION = 1;
+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
 const CHUNK = 1 << 20;
 
 const home = () => os.homedir();
 export const DEFAULT_CLAUDE_DIR = () => path.join(home(), '.claude', 'projects');
 export const DEFAULT_CODEX_DIRS = () => [path.join(home(), '.codex', 'sessions'), path.join(home(), '.codex', 'archived_sessions')];
 export const DEFAULT_CODEX_TITLES = () => path.join(home(), '.codex', 'session_index.jsonl');
-export const DEFAULT_CACHE_FILE = () => path.join(home(), '.great_cto', 'session-usage-index.json');
+// The version is in the name: a board started on an older release keeps running
+// until restarted, and two versions sharing one file would rebuild it from
+// scratch on every pass, each throwing the other's away.
+export const DEFAULT_CACHE_FILE = () => path.join(home(), '.great_cto', `session-usage-index.v${INDEX_VERSION}.json`);
 
 const short = (s) => createHash('sha1').update(String(s)).digest('hex').slice(0, 16);
 
+/** Local hour (00–23) of an ISO timestamp. */
+export function hourOf(ts) {
+  const d = new Date(ts);
+  return Number.isNaN(d.getTime()) ? null : String(d.getHours()).padStart(2, '0');
+}
+
 /** Local calendar day of an ISO timestamp — the operator's day, not UTC's. */
 export function dayOf(ts) {
   const d = new Date(ts);
@@ -107,7 +117,29 @@ 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: { plan: 0, server: 0 } };
+  // 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. */
+function hourBucket(b, ts) {
+  const hh = hourOf(ts);
+  if (!hh) return null;
+  return b.h[hh] || (b.h[hh] = { m: {}, lim: {} });
+}
+
+function addUsage(entry, ts, model, t) {
+  const b = dayBucket(entry, ts);
+  if (!b) return null;
+  addTokens(b, model, t);
+  const hb = hourBucket(b, ts);
+  if (hb) {
+    const v = hb.m[model] || (hb.m[model] = [0, 0, 0, 0, 0]);
+    v[0] += t.in; v[1] += t.out; v[2] += t.cr; v[3] += t.cw; v[4] += t.cwh;
+  }
+  return b;
 }
 
 function dayBucket(entry, ts) {
@@ -159,7 +191,22 @@ function claudeFileMeta(file) {
   return { session: base, parent: null, fn: null, agentType: null };
 }
 
-const PLAN_LIMIT_TEXT = /not your usage limit/i;
+/**
+ * Which limit refused a request, from the words Claude Code shows. Seen on this
+ * machine: "session limit" (the 5-hour window), "weekly limit", "monthly spend
+ * limit", "reached your <model> limit", "out of usage credits", and the server's
+ * own throttle, which says outright that it is "not your usage limit".
+ */
+export function limitKind(text) {
+  const t = String(text || '');
+  if (/not your usage limit/i.test(t)) return 'server';
+  if (/monthly spend limit/i.test(t)) return 'spend';
+  if (/out of usage credits/i.test(t)) return 'credits';
+  if (/session limit/i.test(t)) return 'session';
+  if (/weekly limit/i.test(t)) return 'weekly';
+  if (/reached your .{1,40} limit/i.test(t)) return 'model';
+  return 'other';
+}
 
 /** `great-cto:senior-dev` and `senior-dev` are one agent; `feature-dev:code-reviewer` is not ours. */
 export function agentName(raw) {
@@ -167,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;
@@ -201,7 +318,12 @@ export function claudeLine(entry, line) {
   if (r.isApiErrorMessage && r.error === 'rate_limit') {
     const c = r.message?.content;
     const text = Array.isArray(c) ? c.map((x) => x?.text || '').join(' ') : String(c || '');
-    if (PLAN_LIMIT_TEXT.test(text)) b.lim.server += 1; else b.lim.plan += 1;
+    const kind = limitKind(text);
+    bump(b.lim, kind);
+    const hb = hourBucket(b, ts);
+    if (hb) bump(hb.lim, kind);
+    // The words carry the reset time ("resets Sep 12 at 3pm"); the latest is kept to show.
+    if (!meta.lastHit || ts > meta.lastHit.at) meta.lastHit = { at: ts, kind, text: text.replace(/\s+/g, ' ').trim().slice(0, 200) };
     return;
   }
 
@@ -228,7 +350,7 @@ export function claudeLine(entry, line) {
     cwh,
     rs: u.output_tokens_details?.thinking_tokens || 0,
   };
-  addTokens(b, u.speed === 'fast' ? `${model}@fast` : model, t);
+  addUsage(entry, ts, u.speed === 'fast' ? `${model}@fast` : model, t);
   // Older Claude Code wrote subagent turns into the parent's own file.
   if (r.isSidechain && meta.fn !== 'subagent') b.side = (b.side || 0) + t.in + t.out + t.cr + t.cw + t.cwh;
 }
@@ -292,10 +414,8 @@ export function codexLine(entry, line) {
     if (id && st.ids.includes(id)) return;
     if (id) remember(st.ids, id);
     st.records = true;
-    const b = dayBucket(entry, ts);
-    if (!b) return;
+    if (!addUsage(entry, ts, st.model || 'unknown', codexUsage(p.usage))) return;
     touchSpan(meta, ts);
-    addTokens(b, st.model || 'unknown', codexUsage(p.usage));
     return;
   }
 
@@ -308,6 +428,17 @@ export function codexLine(entry, line) {
         secondary: rl.secondary ? { used: rl.secondary.used_percent, minutes: rl.secondary.window_minutes, resets: rl.secondary.resets_at } : null,
         credits: rl.credits ? { has: !!rl.credits.has_credits, unlimited: !!rl.credits.unlimited, balance: rl.credits.balance ?? null } : null,
       };
+      // The window's history: one point per change, not per event — Codex
+      // repeats the same reading after every response.
+      const L = meta.limits;
+      const pt = [Date.parse(ts), L.primary?.used ?? null, L.primary?.minutes ?? null, L.primary?.resets ?? null,
+        L.secondary?.used ?? null, L.secondary?.minutes ?? null, L.secondary?.resets ?? null, L.reached ? 1 : 0];
+      const series = meta.series || (meta.series = []);
+      const last = series[series.length - 1];
+      if (Number.isFinite(pt[0]) && (!last || [1, 3, 4, 6, 7].some((i) => last[i] !== pt[i]))) {
+        series.push(pt);
+        if (series.length > SERIES_MAX) series.splice(0, series.length - SERIES_MAX);
+      }
     }
     // Older sessions have no token_usage_record. Their usage is the growth of
     // the cumulative total — token_count is emitted more than once per response,
@@ -324,10 +455,8 @@ export function codexLine(entry, line) {
       // A thread forked from another opens with a total and no breakdown — the
       // context it inherited, not a response. It is the base, never usage.
       if (!delta.input_tokens && !delta.output_tokens && !delta.cached_input_tokens) return;
-      const b = dayBucket(entry, ts);
-      if (!b) return;
+      if (!addUsage(entry, ts, st.model || 'unknown', codexUsage(delta))) return;
       touchSpan(meta, ts);
-      addTokens(b, st.model || 'unknown', codexUsage(delta));
     }
   }
 }
@@ -385,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;
 }
 
 /**
@@ -471,6 +622,131 @@ export function mcpLabel(server) {
   return UUID.test(server) ? `claude.ai connector ${server.slice(0, 8)}` : server;
 }
 
+const HOUR = 3600000;
+
+/** Start of the local hour for a local day + hour key. */
+function hourStart(day, hh) {
+  const [y, m, d] = day.split('-').map(Number);
+  return new Date(y, m - 1, d, Number(hh)).getTime();
+}
+
+function median(xs) {
+  if (!xs.length) return null;
+  const s = [...xs].sort((a, b) => a - b);
+  const mid = Math.floor(s.length / 2);
+  return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
+
+/**
+ * Claude Code's limits as far as its logs can say. The logs carry no plan
+ * percentage — only what was spent and when a request was refused, and by which
+ * limit. So this reports spend in the last 5 hours and 7 days, and, for every
+ * refusal, what had been spent in that window when it came: the ceiling as
+ * observed, an estimate with its count, never a stated limit.
+ */
+function claudeLimits(hourly, { fromMs, now, lastHit }) {
+  const nowH = Math.floor(now / HOUR) * HOUR;
+  const startH = Math.floor(fromMs / HOUR) * HOUR;
+  const at = (t) => hourly.get(t) || { usd: 0, tokens: 0, lim: {} };
+  const roll = (t, n) => {
+    let usd = 0; let tokens = 0;
+    for (let i = 0; i < n; i++) { const x = at(t - i * HOUR); usd += x.usd; tokens += x.tokens; }
+    return { usd, tokens };
+  };
+  const series = [];
+  const hits = [];
+  const ceilings = { session: [], weekly: [] };
+  for (let t = startH; t <= nowH; t += HOUR) {
+    series.push(Number(roll(t, 5).usd.toFixed(4)));
+    const lim = at(t).lim;
+    for (const [kind, n] of Object.entries(lim)) {
+      hits.push({ t, kind, n });
+      // One reading per refused hour: ten retries against the same wall are one wall.
+      if (kind === 'session') ceilings.session.push(roll(t, 5).usd);
+      if (kind === 'weekly') ceilings.weekly.push(roll(t, 168).usd);
+    }
+  }
+  const est = (xs) => (xs.length ? { median: median(xs), min: Math.min(...xs), max: Math.max(...xs), n: xs.length } : null);
+  return {
+    fiveHour: roll(nowH, 5),
+    sevenDay: roll(nowH, 168),
+    series: { from: startH, stepMs: HOUR, usd5h: series },
+    hits,
+    ceilings: { session: est(ceilings.session), weekly: est(ceilings.weekly) },
+    lastHit: lastHit || null,
+  };
+}
+
+/** A Codex window by its length — the field that carries it moved from `secondary` to `primary` between plans. */
+export function laneName(minutes) {
+  if (minutes === 10080) return 'weekly';
+  if (minutes === 300) return 'fiveHour';
+  return `${minutes}m`;
+}
+
+/**
+ * Codex's plan windows from its own readings: every window the period touched
+ * with its peak and when it filled, the readings to draw, and — for the window
+ * still open — where the current pace ends up by the reset.
+ *
+ * Windows are keyed by their length, not by `primary`/`secondary`: on one plan
+ * the 5-hour window was primary and the week secondary, on the next the week was
+ * primary. And `resets_at` drifts by seconds between readings of one window, so
+ * it is grouped to ten minutes — unrounded, one week read as forty windows.
+ */
+function codexLimitDetail(points, { fromMs, now }) {
+  if (!points.length) return null;
+  const pts = [...points].sort((a, b) => a[0] - b[0]);
+  const lanes = {};
+  for (const p of pts) {
+    for (const [iu, im, ir] of [[1, 2, 3], [4, 5, 6]]) {
+      const used = p[iu]; const minutes = p[im]; const resets = p[ir];
+      if (used == null || !minutes || !resets) continue;
+      const resetMs = resets * 1000;
+      if (resetMs < fromMs) continue;
+      const lane = lanes[laneName(minutes)] || (lanes[laneName(minutes)] = { minutes, windows: new Map(), series: [] });
+      if (p[0] >= fromMs) {
+        const prev = lane.series[lane.series.length - 1];
+        if (!prev || prev[1] !== used) lane.series.push([p[0], used]);
+      }
+      const key = Math.round(resets / 600);
+      const w = lane.windows.get(key) || { start: resetMs - minutes * 60000, resets: resetMs, peak: 0, fullAt: null, last: null };
+      w.resets = Math.max(w.resets, resetMs);
+      w.peak = Math.max(w.peak, used);
+      if (used >= 100 && !w.fullAt) w.fullAt = p[0];
+      if (!w.last || p[0] >= w.last[0]) w.last = [p[0], used];
+      lane.windows.set(key, w);
+    }
+  }
+  const out = {};
+  for (const [name, lane] of Object.entries(lanes)) {
+    const list = [...lane.windows.values()].sort((a, b) => a.start - b.start);
+    // The open window is the one the LATEST reading belongs to. Codex has reset a
+    // week early more than once, so an older window can still look "open" on paper.
+    const latest = list.reduce((a, w) => (!a || (w.last && w.last[0] > a.last[0]) ? w : a), null);
+    const cur = latest && latest.resets > now ? latest : null;
+    let projection = null;
+    if (cur && cur.last) {
+      const [t, used] = cur.last;
+      if (used >= 100) projection = { state: 'full', resets: cur.resets, readAt: t };
+      else if (used > 0 && t > cur.start) {
+        const fullBy = cur.start + ((t - cur.start) * 100) / used;
+        projection = fullBy < cur.resets
+          ? { state: 'will-fill', fullBy, resets: cur.resets, readAt: t, used }
+          : { state: 'fits', atReset: (used * (cur.resets - cur.start)) / (t - cur.start), resets: cur.resets, readAt: t, used };
+      }
+    }
+    out[name] = {
+      minutes: lane.minutes,
+      windows: list.map((w) => ({ start: w.start, resets: w.resets, peak: w.peak, fullAt: w.fullAt })),
+      filled: list.filter((w) => w.fullAt).length,
+      series: lane.series,
+      projection,
+    };
+  }
+  return Object.keys(out).length ? out : null;
+}
+
 /**
  * The window the board shows.
  * @param {object} index  from scanUsage
@@ -483,15 +759,23 @@ export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles
   const inWindow = new Set(dates);
   const from = dates[0];
 
-  const blank = () => ({ in: 0, out: 0, cr: 0, cw: 0, cwh: 0, rs: 0, msgs: 0, usd: 0, unpricedMsgs: 0, sessions: 0, byFn: {}, lim: { plan: 0, server: 0 } });
+  const blank = () => ({ in: 0, out: 0, cr: 0, cw: 0, cwh: 0, rs: 0, msgs: 0, usd: 0, unpricedMsgs: 0, sessions: 0, byFn: {}, lim: {} });
   const hosts = { claude: blank(), codex: blank() };
   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;
   let codexPlan = null;
+  const fromMs = hourStart(from, '00');
+  // Hours from a week before the period: a 7-day window ending on its first day needs them.
+  const hourlyFrom = dayOf(fromMs - 7 * 86400000);
+  const hourly = { claude: new Map(), codex: new Map() };
+  const codexPoints = [];
+  let lastHit = null;
 
   for (const e of Object.values(index.files || {})) {
     const host = e.host;
@@ -499,15 +783,36 @@ export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles
     const lim = host === 'codex' ? e.meta?.limits : null;
     if (lim && (!codexLimits || lim.at > codexLimits.at)) codexLimits = lim;
     if (lim?.plan && (!codexPlan || lim.at > codexPlan.at)) codexPlan = { at: lim.at, plan: lim.plan };
+    if (host === 'codex' && Array.isArray(e.meta?.series)) for (const p of e.meta.series) codexPoints.push(p);
+    if (host === 'claude' && e.meta?.lastHit && (!lastHit || e.meta.lastHit.at > lastHit.at)) lastHit = e.meta.lastHit;
+    for (const [day, b] of Object.entries(e.days || {})) {
+      if (day < hourlyFrom || !b.h) continue;
+      for (const [hh, hb] of Object.entries(b.h)) {
+        const t = hourStart(day, hh);
+        const slot = hourly[host].get(t) || { usd: 0, tokens: 0, lim: {} };
+        for (const [model, v] of Object.entries(hb.m || {})) {
+          const { usd } = priceBucket(model, { in: v[0], out: v[1], cr: v[2], cw: v[3], cwh: v[4] }, prices);
+          if (usd != null) slot.usd += usd;
+          slot.tokens += v[0] + v[1] + v[2] + v[3] + v[4];
+        }
+        for (const [k, n] of Object.entries(hb.lim || {})) bump(slot.lim, k, n);
+        hourly[host].set(t, slot);
+      }
+    }
     const fn = e.meta?.fn || 'chat';
     let touched = false;
     for (const [day, b] of Object.entries(e.days || {})) {
       if (!inWindow.has(day)) continue;
       touched = true;
       const h = hosts[host];
-      h.lim.plan += b.lim?.plan || 0;
-      h.lim.server += b.lim?.server || 0;
+      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 || {})) {
@@ -568,7 +873,9 @@ export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles
     hosts: Object.fromEntries(Object.entries(hosts).map(([k, h]) => [k, {
       tokens: tokensOf(h), input: h.in, output: h.out, cacheRead: h.cr, cacheWrite: h.cw + h.cwh, reasoning: h.rs,
       responses: h.msgs, sessions: h.sessions, usd: h.unpricedMsgs === h.msgs && h.msgs > 0 ? null : h.usd,
-      unpricedResponses: h.unpricedMsgs, byFn: h.byFn, limitHits: h.lim, ...cache(h),
+      unpricedResponses: h.unpricedMsgs, byFn: h.byFn, ...cache(h),
+      // `plan` is every refusal by a limit of the account; `server` is the API's own throttle.
+      limitHits: { ...h.lim, plan: Object.entries(h.lim).filter(([k]) => k !== 'server').reduce((a, [, n]) => a + n, 0), server: h.lim.server || 0 },
     }])),
     daily: dates.map((d) => ({ date: d, ...daily[d] })),
     models: Object.values(models).sort((a, b) => tokensOf(b) - tokensOf(a)).map((m) => ({
@@ -578,8 +885,17 @@ export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles
     lists: Object.fromEntries(Object.entries(lists).map(([host, l]) => [host, {
       tools: rank(l.tools, 15), skills: rank(l.skills, 15), agents: rank(l.agents, 15), mcp: rank(l.mcp, 15, mcpLabel),
     }])),
-    limits: { codex: codexLimits ? { ...codexLimits, plan: codexLimits.plan || codexPlan?.plan || null } : null },
+    limits: {
+      codex: codexLimits ? { ...codexLimits, plan: codexLimits.plan || codexPlan?.plan || null, detail: codexLimitDetail(codexPoints, { fromMs, now }) } : null,
+      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.53.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",