great-cto 3.28.6 → 3.28.8

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.6",
+  "version": "3.28.8",
   "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/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.6",
+  "version": "3.28.8",
   "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",