great-cto 2.96.0 → 2.98.0

package/board/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "great_cto",
   "id": "great_cto",
   "description": "Engineering process for solo founders and teams up to 50 engineers. Agents do architecture, code review, QA, and security. You make two decisions per feature.",
-  "version": "2.96.0",
+  "version": "2.98.0",
   "author": {
     "name": "Great CTO",
     "url": "https://github.com/avelikiy/great_cto"
@@ -195,6 +195,10 @@
             "command": "PLUGIN_DIR=$(ls -d ~/.claude/plugins/cache/local/great_cto/*/ 2>/dev/null | sort -V | tail -1 | sed 's|/$||'); node \"${PLUGIN_DIR}/scripts/hooks/reviewer-nudge.mjs\" 2>/dev/null || true",
             "timeout": 5,
             "statusMessage": "Checking reviewer rules for this file..."
+          },
+          {
+            "type": "command",
+            "command": "PLUGIN_DIR=$(ls -d ~/.claude/plugins/cache/local/great_cto/*/ 2>/dev/null | sort -V | tail -1 | sed 's|/$||'); node \"${PLUGIN_DIR}/scripts/hooks/lesson-rules-check.mjs\" 2>/dev/null; true"
           }
         ]
       },

package/board/packages/board/lib/data-readers.mjs

@@ -322,17 +322,62 @@ function getInbox(cwd = process.cwd()) {
     return ageH > 48;
   });
   const sec = readSecStats(cwd);
+
+  // One object, one section.
+  //
+  // These four filters overlap — a P0 that is also blocked matched two of them,
+  // so it rendered as two rows and the nav badge (gates + p0 + blocked) counted
+  // it twice. "Two things need you" when one thing does is a small lie that
+  // costs real attention, and it is the same defect as any other count that
+  // measures the query rather than the world.
+  //
+  // Each task lands in its strongest section only, strongest first: a gate is
+  // waiting on a signature, a P0 is an emergency, blocked is a state, stale is
+  // an observation. The other states it is in are kept on the row as `also`, so
+  // deduplicating loses nothing — the row can still say "and it is blocked".
+  const ORDER = [
+    ['gate', pendingGates],
+    ['p0', p0],
+    ['blocked', blocked],
+    ['stale', stale],
+  ];
+  const homeOf = new Map();      // task id → the section that owns it
+  const alsoOf = new Map();      // task id → the other sections it matched
+  for (const [name, list] of ORDER) {
+    for (const t of list) {
+      const id = t?.id ?? t?.title;
+      if (id === undefined) continue;
+      if (homeOf.has(id)) { alsoOf.set(id, [...(alsoOf.get(id) || []), name]); continue; }
+      homeOf.set(id, name);
+    }
+  }
+  const own = (name, list, limit) => list
+    .filter((t) => homeOf.get(t?.id ?? t?.title) === name)
+    .map((t) => ({ ...t, also: alsoOf.get(t?.id ?? t?.title) || [] }))
+    .slice(0, limit);
+
+  const ownedGates = own('gate', pendingGates, 20);
+  const ownedP0 = own('p0', p0, 10);
+  const ownedBlocked = own('blocked', blocked, 10);
+  const ownedStale = own('stale', stale, 10);
+
   return {
-    pending_gates: pendingGates.slice(0, 20),
-    blocked: blocked.slice(0, 10),
-    p0_open: p0.slice(0, 10),
-    stale_in_progress: stale.slice(0, 10),
+    pending_gates: ownedGates,
+    blocked: ownedBlocked,
+    p0_open: ownedP0,
+    stale_in_progress: ownedStale,
     security: { blocked: sec.blocked, approved: sec.approved },
     summary: {
-      gates: pendingGates.length,
-      blocked: blocked.length,
-      p0: p0.length,
-      stale: stale.length,
+      // Counts of distinct objects, so gates + p0 + blocked is a real total
+      // rather than a sum over overlapping sets.
+      gates: [...homeOf.values()].filter((s) => s === 'gate').length,
+      blocked: [...homeOf.values()].filter((s) => s === 'blocked').length,
+      p0: [...homeOf.values()].filter((s) => s === 'p0').length,
+      stale: [...homeOf.values()].filter((s) => s === 'stale').length,
+      // How many distinct things want attention at all — the number the nav
+      // badge means, stated once here rather than re-derived by every caller
+      // that might re-derive it wrongly.
+      needs_you: [...homeOf.values()].filter((s) => s !== 'stale').length,
     },
   };
 }

package/board/packages/board/lib/docs.mjs

@@ -13,6 +13,7 @@
 // Zero dependencies, like the rest of the board.
 
 import fs from 'node:fs';
+import { judgeFreshness } from '../../../scripts/lib/freshness.mjs';
 import path from 'node:path';
 
 /**
@@ -100,6 +101,38 @@ export function groupFor(rel) {
  * differently — the same reason the pipeline view labels a stale verdict rather
  * than hiding it.
  */
+/**
+ * One document's freshness, as three states rather than a date.
+ *
+ * `unknown` covers two different absences and says which: a file we could not
+ * read at all, and a file that simply declares no date. Neither may render as
+ * fresh — the whole reason `stale_after` exists is that a document nobody can
+ * judge must not look like one that passed.
+ */
+function freshnessOf(abs, nowMs = Date.now(), staleDays = 180) {
+  let text;
+  try { text = fs.readFileSync(abs, 'utf8'); }
+  catch (e) {
+    return { freshness: 'unknown', freshnessBasis: 'unreadable', staleAfter: null,
+      freshnessWhy: `could not read this file: ${String(e?.message || e)}` };
+  }
+  try {
+    const j = judgeFreshness({ text, dateType: 'any', nowMs, staleDays });
+    return {
+      freshness: j.verdict,
+      freshnessBasis: j.basis,
+      staleAfter: j.staleAfter,
+      freshnessWhy: j.basis === 'declared'
+        ? `the author declared it good until ${j.staleAfter}`
+        : (j.date ? `judged by its own date ${j.date} (${j.ageDays}d, threshold ${staleDays}d)`
+                  : 'no stale_after and no date — nothing to judge it by'),
+    };
+  } catch (e) {
+    return { freshness: 'unknown', freshnessBasis: 'unreadable', staleAfter: null,
+      freshnessWhy: String(e?.message || e) };
+  }
+}
+
 export function listDocs(root, { max = MAX_DOCS } = {}) {
   const found = [];
   for (const g of DOC_GROUPS) {
@@ -125,6 +158,12 @@ export function listDocs(root, { max = MAX_DOCS } = {}) {
       group: groupFor(d.rel),
       size: d.size,
       modified: d.modified,
+      // A modification time answers "when was this file last touched", which is
+      // a different question from "is this still true". A typo fix rejuvenates a
+      // document that stopped being true months earlier, and the list showed
+      // only the former. `judgeFreshness` gives three verdicts and names which
+      // rule produced each — see scripts/lib/freshness.mjs.
+      ...freshnessOf(d.abs),
     });
   }
 

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

@@ -551,6 +551,113 @@ async function dispatch(req, res, url, cwd) {
     return true;
   }
 
+  // Receipt — does the approval still apply to what is in the tree?
+  //
+  // The reviewing agents already record a hash-bound receipt of the bytes they
+  // read, and those verdicts are in the log this board reads. Nothing surfaced
+  // them, so the top rung of the evidence ladder — the reviewed bytes are the
+  // shipped bytes — was being written and never looked at. An approval that no
+  // longer describes the tree is the one thing a gate button cannot tell you.
+  if (pathname === '/api/receipt') {
+    const c = url.searchParams.get('project') ? resolveProjectCwd(url.searchParams.get('project')) : cwd;
+    let out;
+    try {
+      const { latestApproval, treeReceipt, compareReceipts, mergeBase } = await import('../../../scripts/lib/receipt.mjs');
+      const approval = latestApproval(c);
+      if (!approval?.receipt) {
+        out = { state: 'no-receipt', why: 'no approving verdict carries a receipt yet', agent: approval?.agent || null, ts: approval?.ts || null };
+      } else {
+        const current = treeReceipt(c, { base: approval.receipt.base || mergeBase(c) });
+        const cmp = compareReceipts(approval.receipt, current, { cwd: c });
+        out = { ...cmp, agent: approval.agent, ts: approval.ts };
+      }
+    } catch (e) {
+      // Never "matches" on an error. Not knowing whether the approval still
+      // holds is its own state, and calling it a match would put the strongest
+      // reassurance exactly where the least is known.
+      out = { state: 'unreadable', why: String(e?.message || e), agent: null, ts: null };
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(out));
+    return true;
+  }
+
+  // Gate tiers — will this gate wait for you, or announce and proceed?
+  //
+  // A gate card offered Approve/Reject regardless, which is the right control
+  // for a `gated` gate and the wrong one for a tiered gate that already went
+  // ahead. Two states rendered where the machinery has three.
+  //
+  // `enabled` is returned alongside, because a tier is only in force when the
+  // project opted in with `gate-tiering: evidence`. Showing "notify" on a
+  // project that never opted in would describe a stand-down that will not
+  // happen — the mirror image of the defect this whole feature guards.
+  if (pathname === '/api/gate-tiers') {
+    const c = url.searchParams.get('project') ? resolveProjectCwd(url.searchParams.get('project')) : cwd;
+    try {
+      const { tierAll, tieringEnabled } = await import('../../../scripts/lib/gate-tier.mjs');
+      const { fileURLToPath: f2u } = await import('node:url');
+      const libDir = path.dirname(f2u(import.meta.url));
+      const histPath = path.join(libDir, '..', '..', '..', 'tests', 'eval', 'results-history.jsonl');
+
+      let enabled = false;
+      try { enabled = tieringEnabled(fs.readFileSync(path.join(c, '.great_cto', 'PROJECT.md'), 'utf8')); }
+      catch { /* no PROJECT.md — tiering is off, which is the safe reading */ }
+
+      const rows = [];
+      let historyRead = false;
+      try {
+        for (const line of fs.readFileSync(histPath, 'utf8').split('\n')) {
+          if (!line.trim()) continue;
+          try { rows.push(JSON.parse(line)); } catch { /* a bad row is not evidence */ }
+        }
+        historyRead = true;
+      } catch { /* reported as unmeasured below, never as gated-because-fine */ }
+
+      const byAgent = {};
+      for (const t of tierAll(rows)) byAgent[t.agent] = { tier: t.tier, why: t.why, evals: t.evals };
+      res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+      res.end(JSON.stringify({ enabled, measured: historyRead, agents: byAgent }));
+    } catch (e) {
+      // The real error. An agent missing from `agents` reads as unmeasured on the
+      // client, which keeps its gate — the correct direction to be wrong in.
+      res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+      res.end(JSON.stringify({ enabled: false, measured: false, agents: {}, why: String(e?.message || e) }));
+    }
+    return true;
+  }
+
+  // Stand-downs — gates that proceeded WITHOUT being asked, and on what evidence.
+  //
+  // ADR-009: a gate is not the only valid answer, but silence is never one. An
+  // evidence-tiered gate announces instead of waiting, and until now that
+  // announcement had nowhere on this board to land — the record was being
+  // written and nothing read it.
+  if (pathname === '/api/stand-downs') {
+    const c = url.searchParams.get('project') ? resolveProjectCwd(url.searchParams.get('project')) : cwd;
+    let rows = null;
+    let why = '';
+    try {
+      const { readStandDowns } = await import('../../../scripts/lib/stand-down.mjs');
+      rows = readStandDowns(c, { limit: 50 });
+    } catch (e) {
+      // The real error. A handler that names a cause it did not observe sends
+      // the reader looking in the wrong place — this file has done that once.
+      why = String(e?.message || e);
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+    // Three states, because two cannot carry them: `readStandDowns` returns null
+    // when the ledger exists and could not be read, [] when nothing has stood
+    // down, and rows when something has. "I could not look" must never render as
+    // "nothing happened".
+    res.end(JSON.stringify(
+      rows === null
+        ? { state: 'unreadable', why: why || 'the stand-down ledger exists but could not be read', rows: [] }
+        : { state: rows.length ? 'some' : 'none', why: '', rows },
+    ));
+    return true;
+  }
+
   // Resume — pick up where you left off (last verdicts + WIP + recent decisions)
   if (pathname === '/api/resume') {
     res.writeHead(200, verdictHeaders(cwd, { 'Content-Type': 'application/json' }));