great-cto 3.28.7 → 3.28.9

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

package/board/packages/board/lib/metrics.mjs

@@ -13,15 +13,33 @@ import { readVerdicts, readPlanCosts, readQAStats, readSecStats } from './verdic
 // accepted change yet" is the honest reading (same discipline as the null-score
 // oracle). Only two of the five metrics the literature lists are built here on
 // purpose — a solo project's denominator is tiny and the other three would be noise.
+//
+// A halting verdict is split three ways by the `need` its author declared:
+// `implementer` is a pass the implementer can make (rework), `decision` is a
+// question for a human, and anything else is undeclared. Counting every halt as
+// rework called a waiver request "rework"; and REWORK itself, the token the
+// dispatcher sends work back with, matched none of the old patterns and was never
+// counted. Undeclared is its own count because it is not known to be either.
 function acceptanceMetrics(verdicts = [], windowCostUsd = null) {
-  const isAccepted = (v) => /^APPROVED$/i.test(v.verdict || '');
-  const isRework = (v) => /^(CHANGES(_REQUESTED)?|REJECT(ED)?|FAIL(ED)?|BLOCKED)$/i.test(v.verdict || '');
+  const token = (v) => String(v?.verdict || '');
+  const isAccepted = (v) => /^APPROVED$/i.test(token(v));
+  const isSentBack = (v) => /^(REWORK|CHANGES(_REQUESTED)?)$/i.test(token(v));
+  const isHalt = (v) => /^(REJECT(ED)?|FAIL(ED)?|BLOCKED)$/i.test(token(v));
+  const needOf = (v) => v?.meta?.need;
+  let rework_rounds = 0, decisions = 0, undeclared_blocks = 0;
+  for (const v of verdicts) {
+    if (isSentBack(v)) rework_rounds++;
+    else if (isHalt(v)) {
+      if (needOf(v) === 'implementer') rework_rounds++;
+      else if (needOf(v) === 'decision') decisions++;
+      else undeclared_blocks++;
+    }
+  }
   const accepted = verdicts.filter(isAccepted).length;
-  const rework_rounds = verdicts.filter(isRework).length;
   const cost_per_accepted = (accepted > 0 && windowCostUsd != null)
     ? Math.round((windowCostUsd / accepted) * 100) / 100
     : null;
-  return { accepted, cost_per_accepted, rework_rounds };
+  return { accepted, cost_per_accepted, rework_rounds, decisions, undeclared_blocks };
 }
 
 // ── Metrics ────────────────────────────────────────────────────────────────────

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

@@ -140,6 +140,9 @@ function readVerdicts(cwd = null, health = null) {
         agent,
         verdict,
         cost_usd: parsed.rec.cost_usd ?? null,
+        // Kept so a metric can read what the author declared (`need`, `task`).
+        // Dropping it made every halt look undeclared.
+        meta: parsed.rec.meta ?? null,
         raw: line.replace(/\s*\bcost=\$?\d+\.?\d*\b/i, ''),
       });
     }

package/board/scripts/lib/receipt.mjs

@@ -52,7 +52,7 @@ export const MAX_FILES = 200;
  * Returns `null` outside a git repository rather than a fabricated receipt: a
  * receipt that cannot be built must not look like one that matched.
  */
-export function treeReceipt(cwd = process.cwd(), { base = null, maxFiles = MAX_FILES } = {}) {
+export function treeReceipt(cwd = process.cwd(), { base = null, maxFiles = MAX_FILES, verdictsDir = null } = {}) {
   const head = git(['rev-parse', 'HEAD'], cwd)?.trim();
   if (!head) return null;
 
@@ -73,7 +73,35 @@ export function treeReceipt(cwd = process.cwd(), { base = null, maxFiles = MAX_F
   // Which files the change touches. `--diff-filter=d` drops deletions: a file
   // that is gone cannot have a blob sha, and its absence is already visible in
   // the map as a missing key.
-  const ref = base || mergeBase(cwd) || 'HEAD';
+  // What the change is measured against. The merge-base with the default branch
+  // is right on a feature branch, and wrong on the branch itself: once the work is
+  // on main, or there is no upstream at all, the merge-base IS HEAD, and a stage
+  // that committed before recording its verdict gets a change set holding only
+  // uncommitted leftovers. A live run on 2026-09-14 did exactly that — senior-dev
+  // committed its fix, the receipt named two logs and a report, and the
+  // independent judge, shown no code, correctly said nothing was implemented.
+  //
+  // So when the caller hands in the project's verdicts, the change starts where
+  // the previous stage stood (taskBase), unless the merge-base is closer.
+  // `base_from` records which, so a reader can tell what the judge was shown.
+  let ref, baseFrom;
+  if (base) {
+    ref = base; baseFrom = 'explicit';
+  } else {
+    const tb = verdictsDir ? taskBase(cwd, { verdictsDir, head }) : null;
+    const mb = mergeBase(cwd);
+    const mbBelow = mb && mb !== head ? mb : null;
+    if (tb && mbBelow) {
+      ref = isAncestor(cwd, mbBelow, tb) ? tb : mbBelow;
+      baseFrom = ref === tb ? 'task' : 'merge-base';
+    } else if (tb) {
+      ref = tb; baseFrom = 'task';
+    } else if (mbBelow) {
+      ref = mbBelow; baseFrom = 'merge-base';
+    } else {
+      ref = mb || 'HEAD'; baseFrom = 'head';
+    }
+  }
   const names = [
     ...(git(['diff', '--name-only', '--diff-filter=d', ref], cwd) ?? '')
       .split('\n').map((s) => s.trim()).filter(Boolean),
@@ -90,7 +118,7 @@ export function treeReceipt(cwd = process.cwd(), { base = null, maxFiles = MAX_F
     if (blob) files[p] = blob;
   }
 
-  return { head, dirty, base: ref, files, ...(truncated ? { truncated: true } : {}) };
+  return { head, dirty, base: ref, base_from: baseFrom, files, ...(truncated ? { truncated: true } : {}) };
 }
 
 /**
@@ -105,6 +133,50 @@ export function fileDigest(cwd, path) {
   return out ? out.trim() : null;
 }
 
+/** Is `ancestor` in the history of `descendant`? */
+function isAncestor(cwd, ancestor, descendant) {
+  return git(['merge-base', '--is-ancestor', ancestor, descendant], cwd) !== null;
+}
+
+/**
+ * Where the current stage's work began: the commit the previous stage stood on.
+ *
+ * The newest verdict in `verdictsDir` that carries a receipt names that commit as
+ * `receipt.head`. It is a base only if it is still in this history and is not
+ * HEAD itself — a previous stage recorded at HEAD means nothing has been
+ * committed since, and an earlier verdict would attribute another stage's work
+ * to this one. A recorded head that is not an ancestor (rebased away, or from a
+ * different clone) is skipped for the next newest.
+ *
+ * Null when there is no such commit; the caller falls back to the merge-base.
+ */
+export function taskBase(cwd, { verdictsDir, head = null, read = readFileSync, list = null } = {}) {
+  if (!verdictsDir) return null;
+  const now = head || git(['rev-parse', 'HEAD'], cwd)?.trim();
+  if (!now) return null;
+  let names;
+  try { names = (list || fsModule.readdirSync)(verdictsDir).filter((f) => f.endsWith('.log')); }
+  catch { return null; }
+  const recorded = [];
+  for (const f of names) {
+    let text;
+    try { text = read(join(verdictsDir, f), 'utf8'); } catch { continue; }
+    for (const line of String(text).split('\n')) {
+      if (!line.trim()) continue;
+      let rec;
+      try { rec = JSON.parse(line); } catch { continue; }
+      const h = rec?.receipt?.head;
+      if (typeof h === 'string' && /^[0-9a-f]{7,40}$/.test(h)) recorded.push({ ts: String(rec.ts || ''), head: h });
+    }
+  }
+  recorded.sort((a, b) => b.ts.localeCompare(a.ts));
+  for (const { head: h } of recorded) {
+    if (h === now) return null;
+    if (isAncestor(cwd, h, now)) return h;
+  }
+  return null;
+}
+
 /** The fork point from the default branch, or null when there isn't one. */
 export function mergeBase(cwd) {
   for (const branch of ['origin/main', 'main', 'origin/master', 'master']) {
@@ -301,7 +373,10 @@ function requireFs() {
 if (import.meta.url === `file://${process.argv[1]}`) {
   const argv = process.argv.slice(2);
   if (argv.includes('--emit')) {
-    const r = treeReceipt(process.cwd());
+    // `--verdicts <dir>`: measure the change from where the previous stage stood.
+    const vi = argv.indexOf('--verdicts');
+    const verdictsDir = vi >= 0 && argv[vi + 1] ? argv[vi + 1] : null;
+    const r = treeReceipt(process.cwd(), { verdictsDir });
     process.stdout.write(r ? JSON.stringify(r) : '');
     process.exit(r ? 0 : 1);
   }

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

@@ -55,6 +55,24 @@ export const KNOWN_VERDICTS = Object.freeze([
  * @property {object} [meta]    free-form key/value from the caller
  */
 
+/**
+ * Who a halting verdict is for, as `meta.need`.
+ *
+ *   implementer — the agent that did the work can fix this; no human choice
+ *   decision    — a waiver, a scope change or a trade-off; a human decides
+ *
+ * Anything else, including absence, reads as `undeclared`, and undeclared is never
+ * routed anywhere: it halts exactly as a BLOCKED always has. qa and security wrote
+ * this distinction in prose for months and no verdict line carried it.
+ */
+export const NEED_VALUES = Object.freeze(['implementer', 'decision']);
+
+/** 'implementer' | 'decision' | 'undeclared'. Never throws. */
+export function needOf(rec) {
+  const n = rec?.meta?.need;
+  return NEED_VALUES.includes(n) ? n : 'undeclared';
+}
+
 const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
 
 /**
@@ -97,9 +115,15 @@ export function makeVerdict({ ts, agent, verdict, project, cost_usd, meta, recei
   if (receipt && typeof receipt === 'object' && receipt.head) rec.receipt = receipt;
 
   const { valid, errors } = validateVerdict(rec);
+  // An unknown `need` is refused HERE, at write time, and not in validateVerdict:
+  // that also runs on read, where refusing would discard the verdict itself. On
+  // read the value survives and needOf() calls it undeclared.
+  if (rec.meta && 'need' in rec.meta && !NEED_VALUES.includes(rec.meta.need)) {
+    errors.push(`meta.need must be one of ${NEED_VALUES.join(', ')}, got ${JSON.stringify(rec.meta.need)}`);
+  }
   // Refusing here is the point: a malformed record that reaches the log is read
   // by something later, and by then nobody knows which agent wrote it.
-  if (!valid) throw new Error(`invalid verdict record: ${errors.join('; ')}`);
+  if (errors.length) throw new Error(`invalid verdict record: ${errors.join('; ')}`);
   return rec;
 }
 

package/package.json

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