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

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

@@ -155,7 +155,18 @@ function getCostHistory(cwd = process.cwd(), days = 30) {
   for (let i = 0; i <= days; i++) {
     const d = new Date(now - i * 86400000);
     const key = d.toISOString().slice(0, 10);
-    buckets.set(key, { date: key, llm: 0, human: 0, plans: 0, runs: 0 });
+    // `runs` was one field incremented in two places for two different things:
+  // once per verdict that carried a cost, and once per closed task on a day that
+  // happened to have no cost data. Its meaning therefore changed from day to day
+  // depending on whether anything had been measured, and the two sums were
+  // indistinguishable once added.
+  //
+  // Measured against the verdict logs on disk, it was wrong in BOTH directions —
+  // +18 on one project over 90 days (closed tasks counted as agent runs) and −3
+  // on two others (verdicts with no cost contributing nothing). Split into the
+  // two facts, with `runs` kept as their sum so every existing reader keeps
+  // working and no chart silently changes shape.
+  buckets.set(key, { date: key, llm: 0, human: 0, plans: 0, runs: 0, agent_runs: 0, task_estimates: 0 });
   }
 
   // Plans: file mtime as date
@@ -165,6 +176,20 @@ function getCostHistory(cwd = process.cwd(), days = 30) {
   // "LLM" and another near "Human", and FIRE the sanity check below to
   // reject pathological pairs (the 7,638× regression — total_human present
   // but total_llm fell to zero because the LLM regex was too strict).
+  // Whether a plan carried a cost at all, kept apart from what that cost was.
+  //
+  // The pair of regexes below reads a format nothing writes: measured across
+  // this repository's 41 plans, ZERO carry an LLM figure at the start of a line
+  // and one carries a Human figure — which the guard then subtracts back out. So
+  // `total_human` was $0 on every window, beside a plan count in the dozens, and
+  // read as "these plans cost nothing" rather than "no plan states a cost".
+  //
+  // There is no plan template to blame the plans for: the only template shipped
+  // is GAP-WAVE-PLAN-template.yaml, so no cost line was ever specified. Counted
+  // rather than parsed harder — the dollar figures that DO appear in plans are
+  // prose ("10 × ~$0.15", "assert total < $5") and reading them as this plan's
+  // cost would be inventing a number.
+  let planCostParsed = 0, planCostAbsent = 0, planHumanSuppressed = 0;
   const plansDir = path.join(cwd, 'docs/plans');
   if (fs.existsSync(plansDir)) {
     const planFiles = fs.readdirSync(plansDir).filter(x => x.endsWith('.md')).map(x => path.join(plansDir, x));
@@ -199,8 +224,10 @@ function getCostHistory(cwd = process.cwd(), days = 30) {
       if (humanMatch && !llmMatch && b.human > 0) {
         // Reverse the suppression — drop the bogus single-sided Human entry.
         b.human -= parseFloat(humanMatch[1].replace(/,/g, ''));
+        planHumanSuppressed += 1;
       }
       b.plans++;
+      if (llmMatch || humanMatch) planCostParsed += 1; else planCostAbsent += 1;
     }
   }
 
@@ -217,18 +244,28 @@ function getCostHistory(cwd = process.cwd(), days = 30) {
   // feature=X aggregation — answers "how much did stripe-webhook cost?"
   const featureMap = new Map(); // feature → { llm, runs }
   for (const v of verdicts) {
-    if (v.cost_usd == null) continue;
     const dayKey = (v.ts || '').slice(0, 10);
     if (!buckets.has(dayKey)) continue;
     const b = buckets.get(dayKey);
-    b.llm += v.cost_usd;
+    // A run that was never priced is still a run.
+    //
+    // This began `if (v.cost_usd == null) continue`, so a verdict carrying no
+    // cost contributed nothing at all — not even its own existence. Measured
+    // against the logs: one project had four verdicts and reported ZERO agent
+    // runs, because none of the four had been priced. "We do not know what it
+    // cost" was being rendered as "it did not happen", which is the confusion
+    // this codebase keeps having to unpick.
+    //
+    // Cost is added only when there is one; the run is counted either way.
+    if (v.cost_usd != null) b.llm += v.cost_usd;
+    b.agent_runs++;
     b.runs++;
     // Extract feature= tag from raw verdict line
     const featMatch = v.raw && v.raw.match(/\bfeature=([^\s|]+)/);
     if (featMatch) {
       const feat = featMatch[1];
       const f = featureMap.get(feat) || { llm: 0, runs: 0 };
-      f.llm += v.cost_usd;
+      if (v.cost_usd != null) f.llm += v.cost_usd;
       f.runs++;
       featureMap.set(feat, f);
     }
@@ -258,6 +295,10 @@ function getCostHistory(cwd = process.cwd(), days = 30) {
       if (b.llm === 0) {
         const mins = t.estimated_minutes || DEFAULT_TASK_MIN;
         b.llm += mins / 60 * LLM_RATE_PER_HR;
+        // A closed task is not an agent run. It is counted, and counted
+        // separately, so a caller asking "how many times did agents run" is not
+        // handed a number that is partly something else.
+        b.task_estimates++;
         b.runs++;
       }
     }
@@ -267,6 +308,11 @@ function getCostHistory(cwd = process.cwd(), days = 30) {
   let totalLlm = series.reduce((a, b) => a + b.llm, 0);
   let totalHuman = series.reduce((a, b) => a + b.human, 0);
   const totalPlans = series.reduce((a, b) => a + b.plans, 0);
+  // Reported alongside the sum rather than instead of it: `total_runs` keeps its
+  // meaning for every existing caller, and the two facts it was made of are now
+  // separately answerable.
+  const totalAgentRuns = series.reduce((a, b) => a + b.agent_runs, 0);
+  const totalTaskEstimates = series.reduce((a, b) => a + b.task_estimates, 0);
 
   // SANITY GUARD — anti-7,638× regression. If ratio > 1000×, one of the
   // numbers is wrong. Almost always: total_llm collapsed to ~0 because plan
@@ -291,6 +337,14 @@ function getCostHistory(cwd = process.cwd(), days = 30) {
     total_llm: Math.round(totalLlm * 100) / 100,
     total_human: Math.round(totalHuman),
     total_plans: totalPlans,
+    total_agent_runs: totalAgentRuns,
+    total_task_estimates: totalTaskEstimates,
+    // Three states, not a number and a silence: a plan that states a cost, a
+    // plan that states none, and a plan whose Human figure was suppressed
+    // because its LLM counterpart could not be read.
+    plans_with_cost: planCostParsed,
+    plans_without_cost: planCostAbsent,
+    plans_human_suppressed: planHumanSuppressed,
     daily_avg: Math.round(dayRate * 100) / 100,
     projected_monthly: projectedMonthly,
     monthly_budget: budget,

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

@@ -92,6 +92,28 @@ function readVerdicts(cwd = null, health = null) {
       continue;
     }
     for (const file of files) {
+    // Only per-agent verdict logs. `<agent>-YYYY-MM-DD-HHMMSS.log` is a different
+    // artefact that lives in the same directory: a free-text report of one run,
+    // written as prose. Reading it as a verdict log made its first words into
+    // records — `ts: "DONE:"`, `ts: "artifact:"`, `ts: "next:"`, with the agent
+    // name taken from the filename including its timestamp. Six of the ten
+    // "verdicts" one project appeared to have were paragraph openings.
+    //
+    // Skipped rather than parsed leniently: a run report has no verdict token, no
+    // cost and no meta, so anything recovered from it would be invented. Counted,
+    // though — a directory whose contents this reader ignores is worth saying out
+    // loud, because from outside it looks identical to a project that never ran.
+    if (!file.endsWith('.log')) continue;
+    // Rejected by the shape that IDENTIFIES a run report, not by trying to
+    // describe what a valid agent name looks like. The first attempt did the
+    // latter — `/^[A-Za-z0-9_:.-]+\.log$/` — and matched
+    // `architect-2026-08-26-134109.log` perfectly well, because digits and
+    // hyphens are exactly what an agent name may contain. An allowlist that
+    // cannot exclude the thing it was written to exclude is not a filter.
+    if (RUN_REPORT_FILE.test(file)) {
+      health?.notes?.push(`${file} is a run report, not a verdict log — not read`);
+      continue;
+    }
     const agent = file.replace('.log', '');
     let lines;
     try {
@@ -192,6 +214,9 @@ function readVerdicts(cwd = null, health = null) {
   return results.sort((a, b) => a.ts.localeCompare(b.ts));
 }
 
+/** `<agent>-YYYY-MM-DD-HHMMSS.log` — a prose report of one run, not a verdict. */
+const RUN_REPORT_FILE = /-\d{4}-\d{2}-\d{2}-\d{6}\.log$/;
+
 function readPlanCosts(cwd = process.cwd(), sinceMsAgo = null) {
   const plansDir = path.join(cwd, 'docs/plans');
   let totalLlmMin = 0, totalLlmUsd = 0, totalHumanUsd = 0, count = 0;

package/board/scripts/lib/verdict-record.mjs

@@ -164,10 +164,29 @@ export function parseVerdictLine(line) {
     agent = fields.length >= 2 ? fields[0] : '';
     verdict = fields.length >= 2 ? fields[1] : fields[0];
   } else {
+    // The space form comes in two shapes, and this used to assume only one:
+    //
+    //   <ts> <verdict> <rest>            what the comment here claimed
+    //   <ts> <agent> <verdict> <rest>    also written, e.g. by log-verdict.sh
+    //
+    // Assuming the first turned `2026-08-26T16:59:22Z great_cto:code-reviewer
+    // APPROVED …` into a record whose VERDICT was `GREAT_CTO:CODE-REVIEWER`. It
+    // parsed, it validated, and the board showed an agent name in the verdict
+    // column — a wrong value that looks like a value.
+    //
+    // Discriminated by the one fact the file already carries: whether the token
+    // is a verdict this system knows. Neither position matching leaves the
+    // original reading in place rather than guessing a different wrong one.
     const parts = raw.split(/\s+/);
     ts = parts[0] || '';
-    verdict = parts[1] || '';
-    agent = '';           // the space form never carried one; the filename did
+    const known = (t) => KNOWN_VERDICTS.includes(String(t || '').toUpperCase());
+    if (!known(parts[1]) && known(parts[2])) {
+      agent = parts[1] || '';
+      verdict = parts[2] || '';
+    } else {
+      verdict = parts[1] || '';
+      agent = '';         // this shape does not carry one; the filename does
+    }
   }
 
   const rec = { v: VERDICT_FORMAT_VERSION, ts, agent, verdict: String(verdict || '').toUpperCase() };

package/package.json

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