great-cto 3.57.0 → 3.58.1

package/assets/statusline.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * great_cto status line — your status line, plus a record of Claude's plan use.
+ *
+ * Claude Code hands the status line command a JSON object on stdin, and for a
+ * subscription it carries `rate_limits`: the 5-hour window, the week, the
+ * per-model weeks, each with a used percentage and a reset time. Nothing else
+ * on the machine records them — not the transcripts, not any hook payload — so
+ * the board could only say "Claude Code does not record plan use". This script
+ * keeps one line per CHANGE of those numbers in ~/.great_cto/claude-limits.jsonl
+ * and then prints the status line you had before (`great-cto statusline
+ * install` saved it), or a short one of its own.
+ *
+ * Installed by copying this file to ~/.great_cto/statusline.mjs: the status line
+ * runs often, and `npx` would add its start-up to every refresh. Zero
+ * dependencies; never fails the status line over the record.
+ */
+import { readFileSync, appendFileSync, writeFileSync, mkdirSync, statSync, renameSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { resolve } from 'node:path';
+
+const DIR = process.env.GREAT_CTO_HOME || join(homedir(), '.great_cto');
+const LOG = join(DIR, 'claude-limits.jsonl');
+const LAST = join(DIR, '.claude-limits-last');
+const CONF = join(DIR, 'statusline.json');
+const MAX_BYTES = 5 * 1024 * 1024;
+
+/** Seconds since the epoch, from a number (seconds or milliseconds) or a date string. */
+export function resetSeconds(v) {
+  if (typeof v === 'number' && Number.isFinite(v)) return Math.round(v > 1e12 ? v / 1000 : v);
+  if (typeof v === 'string' && v.trim()) {
+    const n = Number(v);
+    if (Number.isFinite(n)) return resetSeconds(n);
+    const t = Date.parse(v);
+    if (Number.isFinite(t)) return Math.round(t / 1000);
+  }
+  return null;
+}
+
+/** `rate_limits` → { window: { used, resets } }, only windows that carry a number. */
+export function windowsOf(rateLimits) {
+  const out = {};
+  if (!rateLimits || typeof rateLimits !== 'object') return out;
+  for (const [name, w] of Object.entries(rateLimits)) {
+    if (!w || typeof w !== 'object') continue;
+    const used = Number(w.used_percentage ?? w.utilization ?? w.used_percent);
+    if (!Number.isFinite(used)) continue;
+    out[name] = { used: Math.round(used * 10) / 10, resets: resetSeconds(w.resets_at ?? w.resetsAt) };
+  }
+  return out;
+}
+
+export function record(rateLimits, { now = Date.now() } = {}) {
+  const windows = windowsOf(rateLimits);
+  if (!Object.keys(windows).length) return false;
+  const key = JSON.stringify(windows);
+  let last = '';
+  try { last = readFileSync(LAST, 'utf8'); } catch { /* first reading */ }
+  if (last === key) return false;
+  mkdirSync(DIR, { recursive: true });
+  try { if (statSync(LOG).size > MAX_BYTES) renameSync(LOG, `${LOG}.1`); } catch { /* no log yet */ }
+  appendFileSync(LOG, `${JSON.stringify({ ts: new Date(now).toISOString(), windows })}\n`);
+  writeFileSync(LAST, key);
+  return true;
+}
+
+export function defaultLine(d) {
+  const parts = [];
+  const model = d?.model?.display_name || d?.model?.id;
+  if (model) parts.push(model);
+  const dir = d?.workspace?.current_dir || d?.cwd;
+  if (dir) parts.push(basename(dir));
+  const w = windowsOf(d?.rate_limits);
+  if (w.five_hour) parts.push(`5h ${Math.round(w.five_hour.used)}%`);
+  if (w.seven_day) parts.push(`7d ${Math.round(w.seven_day.used)}%`);
+  return parts.join(' · ');
+}
+
+function main() {
+  let raw = '';
+  try { raw = readFileSync(0, 'utf8'); } catch { /* no input */ }
+  let d = {};
+  try { d = JSON.parse(raw || '{}'); } catch { /* not JSON */ }
+  try { record(d.rate_limits); } catch { /* the record never costs the status line */ }
+  let conf = {};
+  try { conf = JSON.parse(readFileSync(CONF, 'utf8')); } catch { /* none saved */ }
+  if (typeof conf.chain === 'string' && conf.chain.trim()) {
+    const r = spawnSync('/bin/sh', ['-c', conf.chain], { input: raw, encoding: 'utf8', timeout: 5000 });
+    process.stdout.write(r.stdout || '');
+    return;
+  }
+  process.stdout.write(`${defaultLine(d)}\n`);
+}
+
+// Real paths on both sides: the module URL is resolved through symlinks (macOS
+// /var → /private/var, a symlinked home), the command line is not.
+const real = (p) => { try { return realpathSync(p); } catch { return resolve(p); } };
+if (process.argv[1] && real(fileURLToPath(import.meta.url)) === real(process.argv[1])) main();

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.57.0",
+  "version": "3.58.1",
   "author": {
     "name": "Alexander Velikiy",
     "url": "https://hashnode.com/@Greatcto"

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

@@ -13,7 +13,7 @@ import { sseClients, notifHistory } from './state.mjs';
 import { autoRegisterProject, listProjects, resolveProjectCwd, resolveProjectInfo, getChangeTier, readProjectsRegistry, getRegistryDegradation } from './projects.mjs';
 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 { usageIndexSnapshot, summarizeUsage, readCodexTitles, readClaudeLimits, claudeRecorder } 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';
@@ -1507,7 +1507,7 @@ async function dispatch(req, res, url, cwd) {
     if (snap.state !== 'ready') {
       body = { state: snap.state, why: snap.why };
     } else {
-      const sum = summarizeUsage(snap.index, { days, codexTitles: readCodexTitles() });
+      const sum = summarizeUsage(snap.index, { days, codexTitles: readCodexTitles(), claudeReadings: readClaudeLimits(), claudeRecorderState: claudeRecorder() });
       const ours = new Set(boardAgentNames());
       for (const host of Object.keys(sum.lists)) {
         sum.lists[host].agents = sum.lists[host].agents.map((a) => ({ ...a, ours: ours.has(a.name) }));

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

@@ -2443,6 +2443,7 @@ h1, h2, h3, h4 { font-weight: 600; font-family: var(--sans); }
 .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-card code, .usage-note code, .usage-sub code { font-family: var(--mono); font-size: var(--fs-caption); color: var(--text); background: var(--bg-muted); padding: 1px 4px; }
 .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; }
@@ -6077,8 +6078,21 @@ function usageHostCard(d, host) {
       : `<div class="usage-limit"><div class="usage-limit-head"><span>Plan limit</span>${absent('unloaded', 'no Codex session has reported its rate-limit window yet')}</div></div>`;
   } else {
     const hits = h.limitHits || { plan: 0, server: 0 };
-    limit = `<div class="usage-limit"><div class="usage-limit-head"><span>Plan limit</span>${absent('uncomputable', 'Claude Code does not write how much of the plan is used — only when a request is refused')}</div>
-      <div class="usage-sub">${hits.plan} refused at the plan limit · ${hits.server} server-side throttles (not your limit) in ${d.window.days} days</div></div>`;
+    const P = d.limits && d.limits.claude && d.limits.claude.plan;
+    const meter = (lane) => {
+      const c = lane && lane.current;
+      if (!c || !c.open) return '';
+      const used = Math.max(0, Math.min(100, Number(c.used) || 0));
+      const cls = used >= 90 ? 'full' : used >= 70 ? 'warn' : '';
+      return `<div class="usage-limit-head"><span>${usageLimitWindow(lane.minutes)}</span><b>${used}% used</b></div>
+        <div class="usage-meter ${cls}" role="meter" aria-valuemin="0" aria-valuemax="100" aria-valuenow="${used}" aria-label="${esc(usageLimitWindow(lane.minutes))}"><span style="width:${used}%"></span></div>
+        <div class="usage-sub">resets ${esc(fmtWhen(c.resets))}</div>`;
+    };
+    const meters = P ? meter(P.fiveHour) + meter(P.weekly) : '';
+    limit = meters
+      ? `<div class="usage-limit">${meters}<div class="usage-sub">as Claude Code reported it to the status line, ${esc(relTime(new Date(Math.max(...Object.values(P).map((l) => (l.current && l.current.readAt) || 0))).toISOString()))} ago · ${hits.plan} refused at a limit in ${d.window.days} days</div></div>`
+      : `<div class="usage-limit"><div class="usage-limit-head"><span>Plan limit</span>${absent('unloaded', usageRecorderHint(d).short)}</div>
+      <div class="usage-sub">${hits.plan} refused at the plan limit · ${hits.server} server-side throttles (not your limit) in ${d.window.days} days · plan percentage: ${d.limits && d.limits.claude && d.limits.claude.recorder === 'on' ? 'from <code>claude</code> in a terminal' : '<code>great-cto statusline install</code>'}</div></div>`;
   }
   return `<section class="usage-card" data-host="${host}">
     <h3><span>${name}</span><span class="muted">${esc(d.window.from)} → ${esc(d.window.to)}</span></h3>
@@ -6191,8 +6205,21 @@ function usageLineSvg({ from, to, points, max, marks = [], ceiling = null, label
     <line class="grid" x1="0" x2="${W}" y1="${H}" y2="${H}"></line>${ceil}${ticks}<path class="ln" d="${path}"></path></svg>`;
 }
 
+// Plan percentage reaches only a status line Claude Code draws: the terminal
+// `claude` draws one, the desktop app's Code tab does not. So "recorder on, no
+// reading yet" gets its own words — sending the operator to install what they
+// already installed is the hint that misled on the first day.
+function usageRecorderHint(d) {
+  const on = d.limits && d.limits.claude && d.limits.claude.recorder === 'on';
+  return on
+    ? { short: 'recorder on, no reading yet — readings come from claude in a terminal', long: 'The recorder is on and has no reading yet. Claude Code passes its plan percentage only to a status line it draws: the terminal <code>claude</code> does, the desktop app\'s Code tab does not. One terminal session fills this in.' }
+    : { short: 'Claude Code reports plan use only to the status line — turn on the recorder: great-cto statusline install', long: 'Claude Code hands its plan percentage to the status line and to nothing else. <code>great-cto statusline install</code> records it here and keeps your own status line; readings come from <code>claude</code> in a terminal.' };
+}
+
 function usageClaudeLimits(d) {
-  const head = `<h3><span>Claude Code limits</span><span class="muted">from refusals — no plan percentage is recorded</span></h3>`;
+  const L0 = d.limits && d.limits.claude;
+  const plan = L0 && L0.plan;
+  const head = `<h3><span>Claude Code limits</span><span class="muted">${plan ? 'as Claude Code reported them to the status line' : L0 && L0.recorder === 'on' ? 'from refusals — plan percentages arrive from claude in a terminal' : 'from refusals — turn on the status line recorder for plan percentages'}</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>`;
@@ -6211,7 +6238,12 @@ function usageClaudeLimits(d) {
   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>` : '';
+  const CLAUDE_LANE = { fiveHour: '5-hour limit', weekly: 'Weekly limit', seven_day_opus: 'Weekly limit · Opus', seven_day_sonnet: 'Weekly limit · Sonnet', seven_day_oauth_apps: 'Weekly limit · apps' };
+  const lanes = plan
+    ? ['fiveHour', 'weekly', ...Object.keys(plan).filter((k) => k !== 'fiveHour' && k !== 'weekly')].filter((k) => plan[k]).map((k) => usageCodexLane(k, plan[k], d, CLAUDE_LANE[k] || k)).join('')
+    : `<p class="usage-note">${usageRecorderHint(d).long}</p>`;
   return `<section class="usage-card" data-limits="claude">${head}
+    ${lanes}
     <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>` : ''}
@@ -6221,8 +6253,8 @@ function usageClaudeLimits(d) {
   </section>`;
 }
 
-function usageCodexLane(name, lane, d) {
-  const title = usageLimitWindow(lane.minutes);
+function usageCodexLane(name, lane, d, label = null) {
+  const title = label || 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>`;

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

@@ -695,28 +695,98 @@ export function laneName(minutes) {
  * 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) {
+  const samples = [];
+  for (const p of points) {
     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);
+      if (p[iu] == null || !p[im] || !p[ir]) continue;
+      samples.push({ t: p[0], lane: laneName(p[im]), minutes: p[im], used: p[iu], resets: p[ir] });
+    }
+  }
+  return laneDetail(samples, { fromMs, now });
+}
+
+/** Window lengths of the plan windows Claude Code reports, by the name it gives them. */
+const CLAUDE_WINDOWS = { five_hour: 300 };
+export function claudeWindowMinutes(name) {
+  return CLAUDE_WINDOWS[name] ?? (/^seven_day/.test(name) ? 10080 : null);
+}
+
+/**
+ * Claude's plan windows, from the readings the great_cto status line recorded
+ * (~/.great_cto/claude-limits.jsonl — Claude Code hands plan use to the status
+ * line and to nothing else). Same shape as Codex's.
+ */
+export function claudePlanDetail(readings, { fromMs, now }) {
+  const samples = [];
+  for (const r of readings) {
+    const t = Date.parse(r?.ts);
+    if (!Number.isFinite(t)) continue;
+    for (const [name, w] of Object.entries(r.windows || {})) {
+      const minutes = claudeWindowMinutes(name);
+      if (!minutes || !Number.isFinite(w?.used) || !w?.resets) continue;
+      samples.push({ t, lane: name === 'five_hour' ? 'fiveHour' : name === 'seven_day' ? 'weekly' : name, minutes, used: w.used, resets: w.resets });
+    }
+  }
+  return laneDetail(samples, { fromMs, now });
+}
+
+/** The readings file, oldest first; [] when the status line was never installed. */
+export function readClaudeLimits(file = path.join(home(), '.great_cto', 'claude-limits.jsonl')) {
+  const out = [];
+  for (const f of [`${file}.1`, file]) {
+    let text = '';
+    try { text = fs.readFileSync(f, 'utf8'); } catch { continue; }
+    for (const line of text.split('\n')) {
+      if (!line.trim()) continue;
+      try { out.push(JSON.parse(line)); } catch { /* partial line */ }
+    }
+  }
+  return out;
+}
+
+/**
+ * Is the plan-use recorder on? `great-cto statusline install` points Claude Code's
+ * statusLine at ~/.great_cto/statusline.mjs. On with no reading yet is not the
+ * same as never installed: only a status line Claude Code DRAWS gets the plan
+ * percentage — the terminal `claude` draws one, the desktop app's Code tab does
+ * not — so the board must say which of the two the operator is in.
+ */
+export function claudeRecorder(homeDir = home()) {
+  try {
+    const s = JSON.parse(fs.readFileSync(path.join(homeDir, '.claude', 'settings.json'), 'utf8'));
+    const cmd = s && s.statusLine && s.statusLine.command;
+    return typeof cmd === 'string' && /\.great_cto[\\/]statusline\.mjs/.test(cmd) ? 'on' : 'off';
+  } catch { return 'off'; }
+}
+
+/**
+ * Plan windows from readings [{t, lane, minutes, used, resets}]: 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.
+ *
+ * `resets` drifts by seconds between readings of one window, so it is grouped to
+ * ten minutes — unrounded, one week read as forty windows.
+ */
+function laneDetail(samples, { fromMs, now }) {
+  if (!samples.length) return null;
+  const sorted = [...samples].sort((a, b) => a.t - b.t);
+  const lanes = {};
+  for (const s of sorted) {
+    const { t, minutes, used, resets } = s;
+    const resetMs = resets * 1000;
+    if (resetMs < fromMs) continue;
+    const lane = lanes[s.lane] || (lanes[s.lane] = { minutes, windows: new Map(), series: [] });
+    if (t >= fromMs) {
+      const prev = lane.series[lane.series.length - 1];
+      if (!prev || prev[1] !== used) lane.series.push([t, 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 = t;
+    if (!w.last || t >= w.last[0]) w.last = [t, used];
+    lane.windows.set(key, w);
   }
   const out = {};
   for (const [name, lane] of Object.entries(lanes)) {
@@ -742,6 +812,7 @@ function codexLimitDetail(points, { fromMs, now }) {
       filled: list.filter((w) => w.fullAt).length,
       series: lane.series,
       projection,
+      current: latest ? { used: latest.last[1], readAt: latest.last[0], resets: latest.resets, open: latest.resets > now } : null,
     };
   }
   return Object.keys(out).length ? out : null;
@@ -752,7 +823,7 @@ function codexLimitDetail(points, { fromMs, now }) {
  * @param {object} index  from scanUsage
  * @param {{days?:number, now?:number, codexTitles?:Record<string,string>, prices?:object, top?:number}} opts
  */
-export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles = {}, prices = effectivePrices(), top = 10 } = {}) {
+export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles = {}, prices = effectivePrices(), top = 10, claudeReadings = [], claudeRecorderState = 'off' } = {}) {
   const span = Math.max(1, Math.min(365, Math.floor(days) || 30));
   const dates = [];
   for (let i = span - 1; i >= 0; i--) dates.push(dayOf(now - i * 86400000));
@@ -887,7 +958,7 @@ export function summarizeUsage(index, { days = 30, now = Date.now(), codexTitles
     }])),
     limits: {
       codex: codexLimits ? { ...codexLimits, plan: codexLimits.plan || codexPlan?.plan || null, detail: codexLimitDetail(codexPoints, { fromMs, now }) } : null,
-      claude: claudeLimits(hourly.claude, { fromMs, now, lastHit }),
+      claude: { ...claudeLimits(hourly.claude, { fromMs, now, lastHit }), plan: claudePlanDetail(claudeReadings, { fromMs, now }), recorder: claudeRecorderState },
     },
     unpricedModels: [...unpriced].sort(),
     // Claude Code only: Codex does not write hook outcomes to its session logs.

package/dist/main.js

@@ -139,6 +139,11 @@ function parseArgs(argv) {
             args.command = "upgrade";
         else if (a === "uninstall")
             args.command = "uninstall";
+        else if (a === "statusline") {
+            args.command = "statusline";
+            args.taskArgs = argv.slice(i + 1);
+            break;
+        }
         else if (a === "--purge-data")
             args.purgeData = true;
         else if (a === "--projects")
@@ -767,6 +772,8 @@ ${bold("Usage:")}
   npx great-cto serve [--port 3142]
   npx great-cto upgrade [superpowers|beads]  Re-clone companions to latest tag + re-apply overlays
   npx great-cto upgrade --self                Upgrade the great-cto CLI itself, in place
+  npx great-cto statusline install            Record Claude's plan use (5h / weekly %) for the board; keeps your status line
+  npx great-cto statusline uninstall          Put your previous status line back
   npx great-cto uninstall [--yes]             Show what great_cto installed; --yes removes it (your data stays)
   npx great-cto help
   npx great-cto version
@@ -1718,6 +1725,10 @@ async function main() {
             await finish(2);
         }
     }
+    if (args.command === "statusline") {
+        const { runStatuslineCommand } = await import("./statusline.js");
+        await finish(runStatuslineCommand(args.taskArgs ?? []));
+    }
     if (args.command === "upgrade") {
         try {
             const code = await runUpgrade(rawArgv, args);

package/dist/statusline.js

@@ -0,0 +1,145 @@
+// `great-cto statusline install | uninstall | status`
+//
+// Claude Code gives the status line command its plan usage (`rate_limits`: the
+// 5-hour window, the week, per-model weeks) and gives it to nothing else. This
+// installs a small status line (assets/statusline.mjs → ~/.great_cto/statusline.mjs)
+// that records those numbers for the board and then prints the status line the
+// user already had. Opt-in, reversible: the previous setting is kept and put back.
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getSettingsPath } from "./settings.js";
+import { dim, success, warn } from "./ui.js";
+export function statuslinePaths(home = homedir()) {
+    const gctoDir = process.env["GREAT_CTO_HOME"] || join(home, ".great_cto");
+    return {
+        settings: process.env["GREAT_CTO_HOME"] ? join(home, ".claude", "settings.json") : getSettingsPath(),
+        gctoDir,
+        script: join(gctoDir, "statusline.mjs"),
+        conf: join(gctoDir, "statusline.json"),
+        log: join(gctoDir, "claude-limits.jsonl"),
+        asset: resolve(dirname(fileURLToPath(import.meta.url)), "..", "assets", "statusline.mjs"),
+    };
+}
+function readJson(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, "utf-8");
+        return raw.trim() ? JSON.parse(raw) : {};
+    }
+    catch {
+        return "invalid";
+    }
+}
+function writeJsonAtomic(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${Date.now()}`;
+    writeFileSync(tmp, JSON.stringify(value, null, 2) + "\n", "utf-8");
+    renameSync(tmp, path);
+}
+export function ourCommand(p) {
+    return `node "${p.script}"`;
+}
+function isOurs(statusLine, p) {
+    const cmd = statusLine?.command;
+    return typeof cmd === "string" && cmd.includes(p.script);
+}
+export function installStatusline(p = statuslinePaths()) {
+    const settings = readJson(p.settings);
+    if (settings === "invalid")
+        return { ok: false, message: `${p.settings} is not valid JSON — left alone` };
+    const s = settings ?? {};
+    if (!existsSync(p.asset))
+        return { ok: false, message: `the status line script is missing from this install (${p.asset})` };
+    mkdirSync(p.gctoDir, { recursive: true });
+    copyFileSync(p.asset, p.script);
+    const current = s["statusLine"];
+    if (!isOurs(current, p)) {
+        // What the user had is kept twice: run by ours on every refresh (chain), and
+        // stored whole so uninstall can put it back exactly.
+        const chain = typeof current?.command === "string"
+            ? String(current.command) : null;
+        writeJsonAtomic(p.conf, { chain, previous: current ?? null, installedAt: new Date().toISOString() });
+    }
+    let backup = null;
+    if (existsSync(p.settings)) {
+        backup = `${p.settings}.bak-${Date.now()}`;
+        copyFileSync(p.settings, backup);
+    }
+    const prevPadding = current?.padding;
+    s["statusLine"] = { type: "command", command: ourCommand(p), ...(typeof prevPadding === "number" ? { padding: prevPadding } : {}) };
+    writeJsonAtomic(p.settings, s);
+    return { ok: true, message: isOurs(current, p) ? "status line script refreshed" : "status line installed", backup };
+}
+export function uninstallStatusline(p = statuslinePaths()) {
+    const settings = readJson(p.settings);
+    if (settings === "invalid")
+        return { ok: false, message: `${p.settings} is not valid JSON — left alone` };
+    const s = settings ?? {};
+    if (!isOurs(s["statusLine"], p))
+        return { ok: true, message: "the great_cto status line is not installed — nothing changed" };
+    const conf = readJson(p.conf);
+    const previous = conf && conf !== "invalid" ? conf["previous"] : null;
+    let backup = null;
+    if (existsSync(p.settings)) {
+        backup = `${p.settings}.bak-${Date.now()}`;
+        copyFileSync(p.settings, backup);
+    }
+    if (previous && typeof previous === "object")
+        s["statusLine"] = previous;
+    else
+        delete s["statusLine"];
+    writeJsonAtomic(p.settings, s);
+    return { ok: true, message: previous ? "your previous status line is back" : "status line removed", backup };
+}
+export function statuslineStatus(p = statuslinePaths()) {
+    const settings = readJson(p.settings);
+    const installed = !!settings && settings !== "invalid" && isOurs(settings["statusLine"], p);
+    const conf = readJson(p.conf);
+    const chain = conf && conf !== "invalid" && typeof conf["chain"] === "string" ? String(conf["chain"]) : null;
+    let lastReading = null;
+    try {
+        const lines = readFileSync(p.log, "utf-8").trim().split("\n");
+        lastReading = JSON.parse(lines[lines.length - 1] || "null");
+    }
+    catch { /* nothing recorded yet */ }
+    return { installed, chain, lastReading };
+}
+export function runStatuslineCommand(argv) {
+    const sub = argv[0] || "status";
+    if (sub === "install") {
+        const r = installStatusline();
+        if (!r.ok) {
+            warn(r.message);
+            return 1;
+        }
+        success(`${r.message} ${dim(r.backup ? `(settings backup: ${r.backup})` : "")}`);
+        console.log("  Claude's plan use is recorded on the next status line refresh; the board shows it under Usage → Limits.");
+        console.log("  Readings come from `claude` in a terminal: the desktop app's Code tab does not draw a status line.");
+        console.log(`  Undo: ${dim("great-cto statusline uninstall")}`);
+        return 0;
+    }
+    if (sub === "uninstall") {
+        const r = uninstallStatusline();
+        if (!r.ok) {
+            warn(r.message);
+            return 1;
+        }
+        success(`${r.message} ${dim(r.backup ? `(settings backup: ${r.backup})` : "")}`);
+        return 0;
+    }
+    if (sub === "status") {
+        const st = statuslineStatus();
+        console.log(`installed: ${st.installed ? "yes" : "no"}`);
+        if (st.chain)
+            console.log(`your status line (shown through it): ${st.chain}`);
+        console.log(`last reading: ${st.lastReading ? JSON.stringify(st.lastReading) : "none yet"}`);
+        if (st.installed && !st.lastReading)
+            console.log("  (readings come from `claude` in a terminal; the desktop app's Code tab does not draw a status line)");
+        return 0;
+    }
+    warn(`unknown: great-cto statusline ${sub} — use install, uninstall or status`);
+    return 1;
+}

package/package.json

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