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

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; }
@@ -2425,6 +2432,15 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 .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; }
+.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); }
 @media (max-width: 767px) { .usage-title { max-width: 160px; } .usage-chip { min-height: 44px; } }
 .mp-section-label {
   font-family: var(--mono); font-size: var(--fs-caption);
@@ -6017,6 +6033,7 @@ function setUsageHost(host) {
 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';
 }
 
@@ -6141,6 +6158,90 @@ function usageList(title, rows, empty) {
   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>`;
+}
+
 function renderUsage(d) {
   const body = document.getElementById('usage-body');
   if (!body) return;
@@ -6149,6 +6250,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>

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 = 2;          // 2: hourly buckets, limit kinds, Codex limit series
 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,26 @@ 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 } };
+  return { in: 0, out: 0, cr: 0, cw: 0, cwh: 0, rs: 0, msgs: 0, models: {}, tools: {}, skills: {}, agents: {}, mcp: {}, lim: {}, h: {} };
+}
+
+/** 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 +188,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) {
@@ -201,7 +245,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 +277,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 +341,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 +355,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 +382,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));
     }
   }
 }
@@ -471,6 +527,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,7 +664,7 @@ 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 = {};
@@ -492,6 +673,12 @@ export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles
   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,14 +686,29 @@ 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);
       let dayUsd = 0;
       let dayUnpriced = false;
@@ -568,7 +770,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,7 +782,10 @@ 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(),
   };
 }

package/package.json

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