great-cto 3.5.0 → 3.7.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": "3.5.0",
+  "version": "3.7.0",
   "author": {
     "name": "Great CTO",
     "url": "https://github.com/avelikiy/great_cto"

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

@@ -5,6 +5,7 @@ import { GREAT_CTO_DIR } from './config.mjs';
 import { readFileSafe } from './util.mjs';
 import { getTasks } from './beads.mjs';
 import { readVerdicts, readSecStats } from './verdicts.mjs';
+import { datePlans } from './plan-date.mjs';
 
 // ── Memory: 4-layer file contents ─────────────────────────────────────────────
 function getMemory(cwd = process.cwd()) {
@@ -166,11 +167,15 @@ function getCostHistory(cwd = process.cwd(), days = 30) {
   // but total_llm fell to zero because the LLM regex was too strict).
   const plansDir = path.join(cwd, 'docs/plans');
   if (fs.existsSync(plansDir)) {
-    for (const f of fs.readdirSync(plansDir).filter(x => x.endsWith('.md'))) {
-      const fp = path.join(plansDir, f);
-      const stat = fs.statSync(fp);
-      const dayKey = stat.mtime.toISOString().slice(0, 10);
-      if (!buckets.has(dayKey)) continue;
+    const planFiles = fs.readdirSync(plansDir).filter(x => x.endsWith('.md')).map(x => path.join(plansDir, x));
+    // The day a plan lands on is read from the plan, not from its mtime. The
+    // twin of the same defect in readPlanCosts: on a fresh clone every file
+    // carries the clone time, so the whole history stacked onto one bar of this
+    // chart — today's — and every earlier day read as zero spend.
+    const dated = datePlans(planFiles, { root: cwd, dir: 'docs/plans' });
+    for (const fp of planFiles) {
+      const dayKey = dated.dates.get(fp)?.date;
+      if (!dayKey || !buckets.has(dayKey)) continue;
       const content = fs.readFileSync(fp, 'utf8');
       // Anchor LLM/Human at START of line (with optional markdown emphasis)
       // so we never mis-match cases like:

package/board/packages/board/lib/plan-date.mjs

@@ -0,0 +1,136 @@
+/**
+ * plan-date — when a plan was written, as opposed to when its file was touched.
+ *
+ * The defect
+ * ----------
+ * Both cost readers dated a plan by `statSync(fp).mtime`. mtime is not a fact
+ * about the plan; it is a fact about the filesystem, and everything ordinary
+ * changes it — a reformat, a checkout, a copy, a `sed -i` over the directory.
+ *
+ * `git clone` is the case that turns it from imprecise into wrong. Clone writes
+ * every file at clone time, so on a fresh checkout of this repository all 41
+ * plans carry today's date: THIRTEEN distinct dates collapse into ONE. The
+ * 30-day cost window then selects every plan ever written, and reports the
+ * project's entire history as the last month. Measured, both ways:
+ *
+ *     fresh clone     30-day window → 41 plans, $150 human   ← identical to
+ *                     all time      → 41 plans, $150 human      all-time
+ *     this checkout   30-day window → 13 plans
+ *                     all time      → 41 plans
+ *
+ * Nobody would read "$150 in the last 30 days" as suspicious. That is the shape
+ * of the whole defect class: a number that is wrong in a way that looks normal.
+ *
+ * Where the date actually lives
+ * -----------------------------
+ * Measured over this repository's 41 plans rather than assumed:
+ *
+ *     21  the filename — `PLAN-2026-08-17-gate-fail-closed.md`
+ *     20  nowhere in the file at all
+ *      0  front-matter (supported anyway; it is the one an author can correct)
+ *
+ * So git is not a nicety, it is the only honest source for half of them: the
+ * first commit that added the file is when the plan appeared. One batched
+ * `git log` covers the whole directory in 0.27s, against 1.47s for one call per
+ * file, so the cheap way is also the correct way.
+ *
+ * Three states, and the third is the point
+ * ----------------------------------------
+ * When no source but mtime exists the date is still returned — dropping the plan
+ * would silently shrink the window, which is a different wrong answer. It is
+ * returned with `reliable: false`, and callers report how many of those went
+ * into a figure. A total assembled partly from filesystem timestamps should say
+ * so rather than present itself as measured.
+ */
+
+import { statSync, readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+
+const ISO_DAY = /(\d{4}-\d{2}-\d{2})/;
+
+/** `date:` in YAML front-matter, if the file opens with a front-matter block. */
+export function frontMatterDate(text) {
+  const m = String(text || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  const d = m[1].match(/^date:\s*(\d{4}-\d{2}-\d{2})/m);
+  return d ? d[1] : null;
+}
+
+/** `YYYY-MM-DD` anywhere in the basename. */
+export function fileNameDate(file) {
+  const m = path.basename(file).match(ISO_DAY);
+  return m ? m[1] : null;
+}
+
+/**
+ * One `git log` for a whole directory: relative path → date the file was ADDED.
+ *
+ * Returns an empty Map when git is absent, the directory is untracked, or the
+ * project is not a repository at all. That is not an error — it is a project
+ * without this source, and the caller falls through to the next one.
+ */
+export function gitAddedIndex(root, dir) {
+  const out = new Map();
+  let res;
+  try {
+    res = spawnSync('git', ['log', '--diff-filter=A', '--name-only',
+                            '--format=%x00%ad', '--date=short', '--', dir],
+                    { cwd: root, encoding: 'utf8', timeout: 15_000 });
+  } catch { return out; }
+  if (!res || res.status !== 0 || !res.stdout) return out;
+
+  let current = null;
+  for (const line of res.stdout.split('\n')) {
+    if (line.startsWith('\0')) { current = line.slice(1).trim(); continue; }
+    const rel = line.trim();
+    // git log walks newest-first, so the LAST assignment for a path is its
+    // oldest add — a file added, deleted and re-added should date from the
+    // first time it appeared, not the most recent.
+    if (rel && current) out.set(rel, current);
+  }
+  return out;
+}
+
+/**
+ * @returns {{date: string|null, source: 'front-matter'|'filename'|'git'|'mtime'|'none', reliable: boolean}}
+ */
+export function planDate(absPath, { root = process.cwd(), gitIndex = null, readText = null } = {}) {
+  let text = '';
+  try { text = readText ? readText(absPath) : readFileSync(absPath, 'utf8').slice(0, 2000); } catch { /* unreadable */ }
+
+  const fm = frontMatterDate(text);
+  if (fm) return { date: fm, source: 'front-matter', reliable: true };
+
+  const fn = fileNameDate(absPath);
+  if (fn) return { date: fn, source: 'filename', reliable: true };
+
+  if (gitIndex && gitIndex.size) {
+    const rel = path.relative(root, absPath);
+    const g = gitIndex.get(rel);
+    if (g) return { date: g, source: 'git', reliable: true };
+  }
+
+  try {
+    return { date: statSync(absPath).mtime.toISOString().slice(0, 10), source: 'mtime', reliable: false };
+  } catch {
+    return { date: null, source: 'none', reliable: false };
+  }
+}
+
+/**
+ * Date every `.md` in a directory in one pass, with one git call for all of them.
+ *
+ * @returns {{dates: Map<string,{date,source,reliable}>, unreliable: number, total: number}}
+ */
+export function datePlans(files, { root = process.cwd(), dir = 'docs/plans' } = {}) {
+  const gitIndex = gitAddedIndex(root, dir);
+  const dates = new Map();
+  let unreliable = 0;
+  for (const f of files) {
+    const d = planDate(f, { root, gitIndex });
+    dates.set(f, d);
+    if (!d.reliable) unreliable += 1;
+  }
+  return { dates, unreliable, total: files.length };
+}

package/board/packages/board/lib/verdicts.mjs

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { GREAT_CTO_DIR } from './config.mjs';
+import { datePlans } from './plan-date.mjs';
 import { parseVerdictLine } from '../../../scripts/lib/verdict-record.mjs';
 
 
@@ -140,16 +141,42 @@ function readVerdicts(cwd = null, health = null) {
       if (!fs.existsSync(histPath)) continue;
       const lines = fs.readFileSync(histPath, 'utf8').split('\n').filter(Boolean);
       for (const line of lines) {
-        const m = line.match(/^(\S+)\s+(\S+)\s+(\d+\.?\d*)/);
+        // Anchored on a real ISO timestamp rather than "the first run of
+        // non-space characters". The writer used to emit an entire compact-JSON
+        // verdict in that position, and `\S+` accepted it — producing keys like
+        // `{"v":1,"ts":"202|qa-engineer` that could never match a verdict.
+        // Lines from that era are skipped here instead of being half-parsed.
+        const m = line.match(/^(\d{4}-\d{2}-\d{2}T\S+)\s+(\S+)\s+(\d+\.?\d*)(?:\s|$)/);
         if (!m) continue;
+        const usd = parseFloat(m[3]);
+        // A recorded zero is `log-verdict.sh` writing through whatever the agent
+        // reported, which is nothing. Enriching a zero verdict with a zero from
+        // this file changes no number and would label it `measured` — a claim
+        // that something was measured when the file says only that a line exists.
+        if (!(usd > 0)) continue;
         const key = `${m[1].slice(0, 16)}|${m[2]}`;  // minute + agent
-        if (!costByKey.has(key)) costByKey.set(key, parseFloat(m[3])); // project wins
+        if (!costByKey.has(key)) costByKey.set(key, usd); // project wins
       }
     }
     for (const v of results) {
-      if (v.cost_usd != null) continue;
+      // A self-reported ZERO is not a measurement — it is the absence of one,
+      // and it must not shadow a figure that was actually measured.
+      //
+      // This read `if (v.cost_usd != null) continue`, and every verdict carries
+      // `cost_usd: 0` because agents do not measure their own spend. Zero is not
+      // null, so enrichment was skipped for all 26 verdicts in the window while
+      // the measured costs sat in cost-history.log unused — and the budgets
+      // screen reported `unmeasured`, which was true of what it read and false
+      // of what existed.
+      //
+      // A measured value overrides a zero; nothing overrides a non-zero figure
+      // an agent actually reported.
+      if (v.cost_usd != null && v.cost_usd > 0) continue;
       const key = `${(v.ts || '').slice(0, 16)}|${v.agent}`;
-      if (costByKey.has(key)) v.cost_usd = costByKey.get(key);
+      if (costByKey.has(key)) {
+        v.cost_usd = costByKey.get(key);
+        v.cost_source = 'measured';   // read from a transcript, not self-reported
+      }
     }
   }
 
@@ -161,12 +188,23 @@ function readPlanCosts(cwd = process.cwd(), sinceMsAgo = null) {
   let totalLlmMin = 0, totalLlmUsd = 0, totalHumanUsd = 0, count = 0;
   if (!fs.existsSync(plansDir)) return { llm_usd: 0, human_usd: 0, savings_x: 0, count: 0 };
   const cutoff = sinceMsAgo != null ? Date.now() - sinceMsAgo : null;
-  for (const file of fs.readdirSync(plansDir).filter(f => f.endsWith('.md'))) {
-    const fp = path.join(plansDir, file);
-    // Skip plans outside the requested time window (use file mtime, same as
-    // getCostHistory — fixes BH-26 where readPlanCosts had no date filter and
-    // included all-time plans while getCostHistory only looked at the window).
-    if (cutoff != null && fs.statSync(fp).mtimeMs < cutoff) continue;
+  const planFiles = fs.readdirSync(plansDir).filter(f => f.endsWith('.md')).map(f => path.join(plansDir, f));
+  // Dated from the plan itself — front-matter, then the filename, then the
+  // commit that added it — rather than from mtime. mtime is a fact about the
+  // filesystem: `git clone` stamps every plan with the clone time, which
+  // collapsed thirteen dates into one and made this 30-day window return the
+  // project's entire history. See plan-date.mjs for the measurement.
+  const dated = datePlans(planFiles, { root: cwd, dir: 'docs/plans' });
+  let fromMtime = 0;
+  for (const fp of planFiles) {
+    const d = dated.dates.get(fp);
+    if (cutoff != null) {
+      if (!d?.date) continue;                                   // undatable: not in any window
+      if (Date.parse(`${d.date}T23:59:59Z`) < cutoff) continue;  // outside it
+    }
+    // Counted after the window test, so the figure describes the plans that
+    // actually went into these totals rather than everything in the directory.
+    if (d && !d.reliable) fromMtime += 1;
     const content = fs.readFileSync(fp, 'utf8');
     // Parse cost lines from PLAN-*.md.
     // Use the SAME anchored regex as getCostHistory() so both endpoints agree
@@ -188,6 +226,10 @@ function readPlanCosts(cwd = process.cwd(), sinceMsAgo = null) {
     human_usd: Math.round(totalHumanUsd),
     savings_x: totalLlmUsd > 0 ? Math.round(totalHumanUsd / totalLlmUsd) : 0,
     count,
+    // How many of these plans could only be dated by their file timestamp. A
+    // figure assembled partly from filesystem metadata says so rather than
+    // presenting itself as measured.
+    dated_by_mtime: fromMtime,
   };
 }
 

package/package.json

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