great-cto 3.32.0 → 3.33.0

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

package/board/packages/board/mcp-server.mjs

@@ -10,6 +10,7 @@
  *   cost_summary     — LLM spend, budget burn, top features
  *   pipeline_stages  — detailed stage list with verdicts
  *   recent_verdicts  — last N agent verdicts (default 10)
+ *   wait_for_board_change — block until a verdict lands or a session is blocked
  *
  * Usage:
  *   # Start as MCP server (board must be running on --port)
@@ -31,6 +32,7 @@
  */
 
 import { createInterface } from 'node:readline';
+import { waitForChange } from '../../scripts/lib/board-watch.mjs';
 
 const PORT = parseInt(process.env.GREAT_CTO_PORT || '3141', 10);
 const BASE_URL = `http://127.0.0.1:${PORT}`;
@@ -115,6 +117,23 @@ const TOOLS = [
       },
     },
   },
+  {
+    name: 'wait_for_board_change',
+    description:
+      'Blocks until something in this project needs you — an agent wrote a verdict ' +
+      '(BLOCKED/FAIL first), or a session stopped on a permission prompt — then returns ' +
+      'only those changes. Use it instead of polling status in a loop while parallel ' +
+      'work runs: one call, not a sleep-and-list per turn. Call first with no `since` ' +
+      'to get a cursor; pass the returned `cursor` back each time so nothing between ' +
+      'calls is missed. Reads the project files directly; the board need not be running.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        since: { type: 'string', description: 'Cursor from the previous call. Omit on the first call.' },
+        timeout_s: { type: 'number', description: 'Longest wait in seconds (1–600). Default: 300.' },
+      },
+    },
+  },
 ];
 
 // ── HTTP helpers ───────────────────────────────────────────────────────────
@@ -245,6 +264,12 @@ async function callTool(name, args = {}) {
     return lines.join('\n');
   }
 
+  if (name === 'wait_for_board_change') {
+    // The MCP server runs in the project directory (codex-host starts it there).
+    const r = await waitForChange({ cwd: process.cwd(), since: args.since || null, timeoutS: args.timeout_s || 300 });
+    return JSON.stringify(r);
+  }
+
   throw new Error(`Unknown tool: ${name}`);
 }
 

package/board/scripts/lib/board-watch.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * board-watch — wait until something in this project needs the caller, then say
+ * what. One blocking call instead of a polling loop.
+ *
+ * Why this exists
+ * ---------------
+ * An orchestrator waiting on parallel work (coordinator, codex-host) has no way to
+ * wait: it sleeps, lists, sleeps, lists, and every round trip is a turn. On the
+ * projects measured on 2026-09-21, 69 agent runs ended at their turn cap.
+ * fynnfluegge/agtx (Apache-2.0) counted the same cost in one 14-task run — 73
+ * sleeps and 96 listings — and replaced it with `wait_for_board_change`: block,
+ * and return only the changes that need the caller. Written here, from files the
+ * project already has, so it needs no board process:
+ *
+ *   verdict   an agent wrote a new verdict (its value and kind: negative first)
+ *   blocked   a session stopped on a permission prompt or an unanswered wait
+ *
+ * The cursor is the snapshot the caller last saw, so a change that happens between
+ * two calls is never missed: pass back the `cursor` from the previous answer.
+ *
+ * Usage:
+ *   node scripts/lib/board-watch.mjs [--since <cursor>] [--timeout 300] [--cwd DIR]
+ *   → one JSON line: { cursor, changes: [...], timedOut }
+ *   With no --since it answers at once with the current cursor and nothing else.
+ */
+import { fileURLToPath } from 'node:url';
+import { latestVerdicts } from './ship-evidence.mjs';
+import { readSessionStatus } from './session-status.mjs';
+
+export const MAX_TIMEOUT_S = 600;
+
+/** What the caller could need to react to, reduced to comparable keys. */
+export function snapshot(cwd, { now = Date.now() } = {}) {
+  const verdicts = {};
+  for (const [agent, v] of latestVerdicts(cwd)) verdicts[agent] = { verdict: v.verdict, ts: v.ts, kind: v.kind };
+  const blocked = {};
+  for (const s of readSessionStatus(cwd, { now })) {
+    if (s.state === 'blocked') blocked[s.session] = { since: s.since, reason: s.reason || '' };
+  }
+  return { verdicts, blocked };
+}
+
+/** Changes from `prev` to `next` that need the caller, most urgent first. */
+export function diffSnapshots(prev, next) {
+  const out = [];
+  for (const [agent, v] of Object.entries(next.verdicts || {})) {
+    const p = prev.verdicts?.[agent];
+    if (!p || p.ts !== v.ts || p.verdict !== v.verdict) out.push({ type: 'verdict', agent, verdict: v.verdict, kind: v.kind, ts: v.ts });
+  }
+  for (const [session, b] of Object.entries(next.blocked || {})) {
+    const p = prev.blocked?.[session];
+    if (!p || p.since !== b.since) out.push({ type: 'blocked', session, reason: b.reason, since: b.since });
+  }
+  const rank = (c) => (c.type === 'blocked' ? 0 : c.kind === 'negative' ? 1 : 2);
+  return out.sort((a, b) => rank(a) - rank(b));
+}
+
+export const encodeCursor = (snap) => Buffer.from(JSON.stringify(snap)).toString('base64url');
+export function decodeCursor(c) {
+  try { return JSON.parse(Buffer.from(String(c), 'base64url').toString('utf8')); } catch { return null; }
+}
+
+/**
+ * Block until a change needs the caller, or the timeout passes.
+ * @returns {Promise<{cursor:string, changes:object[], timedOut:boolean, note?:string}>}
+ */
+export async function waitForChange({ cwd = process.cwd(), since = null, timeoutS = 300, pollMs = 2000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
+  const first = snapshot(cwd);
+  const prev = since ? decodeCursor(since) : null;
+  if (!prev) {
+    return { cursor: encodeCursor(first), changes: [], timedOut: false, note: since ? 'unreadable cursor — here is a fresh one' : 'first call — pass this cursor back to wait' };
+  }
+  const deadline = Date.now() + Math.min(MAX_TIMEOUT_S, Math.max(1, timeoutS)) * 1000;
+  let snap = first;
+  for (;;) {
+    const changes = diffSnapshots(prev, snap);
+    if (changes.length) return { cursor: encodeCursor(snap), changes, timedOut: false };
+    if (Date.now() >= deadline) return { cursor: encodeCursor(snap), changes: [], timedOut: true };
+    await sleep(Math.min(pollMs, Math.max(0, deadline - Date.now())));
+    snap = snapshot(cwd);
+  }
+}
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isMain) {
+  const a = process.argv.slice(2);
+  const opt = (k, d) => { const i = a.indexOf(k); return i >= 0 ? a[i + 1] : d; };
+  const r = await waitForChange({ cwd: opt('--cwd', process.cwd()), since: opt('--since', null), timeoutS: Number(opt('--timeout', 300)) });
+  process.stdout.write(`${JSON.stringify(r)}\n`);
+}

package/board/scripts/lib/ship-evidence.mjs

@@ -0,0 +1,115 @@
+/**
+ * ship-evidence — what the verdict logs say about whether gate:ship may pass.
+ *
+ * Read across the 16 projects with verdicts on the measuring machine (2026-09-21):
+ *
+ *  - a healthcare-reviewer BLOCKED was never followed by a later verdict of its
+ *    own, and the task it blocked was closed an hour later;
+ *  - 11 of the 16 had no qa-engineer verdict at all;
+ *  - great_cto's own last QA verdict was three weeks older than its last ship.
+ *
+ * gate-check read Beads task states and required domain reviewers; it read no
+ * verdict's VALUE. This does, three rules:
+ *
+ *  1. An agent whose LATEST verdict is negative (BLOCKED, FAIL, REJECTED, REWORK)
+ *     has an open finding. A later positive verdict from the same agent closes it.
+ *  2. qa-engineer and security-officer must each have a positive latest verdict.
+ *  3. Both must be newer than the last commit that changed code — a verdict from
+ *     before the change it is supposed to cover is not evidence about it.
+ *
+ * Agent names are read from the log's file name and normalised: the same agent
+ * was found logged as `code-reviewer`, `great-cto:code-reviewer`,
+ * `great_cto:code-reviewer`, and QA as both `qa` and `qa-engineer`.
+ */
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { parseVerdictLog } from './verdict-record.mjs';
+
+export const MANDATORY_FOR_SHIP = ['qa-engineer', 'security-officer'];
+
+const ALIASES = { qa: 'qa-engineer', security: 'security-officer', sec: 'security-officer' };
+
+/** `great-cto:qa`, `great_cto:qa-engineer`, `qa` → `qa-engineer`. */
+export function canonicalAgent(name) {
+  const bare = String(name || '').trim().toLowerCase().replace(/^.*:/, '').replace(/\.log$/, '');
+  return ALIASES[bare] || bare;
+}
+
+/** negative | positive | neutral, from a verdict value in any dialect written so far. */
+export function verdictKind(v) {
+  const s = String(v || '').toUpperCase();
+  if (/^(BLOCKED|FAIL|FAILED|REJECTED|REWORK)\b/.test(s)) return 'negative';
+  // `APPROVED_WITH_DEFERRED_CRITICALS` and friends are approvals that name open
+  // criticals; they are not a clean pass and are read as negative.
+  if (/^APPROVED.*(DEFERRED|CRITICAL)/.test(s)) return 'negative';
+  if (/^(APPROVED|PASS|PASSED|DONE|OK)\b/.test(s)) return 'positive';
+  return 'neutral';
+}
+
+const tsOf = (ts) => { const t = Date.parse(ts); return Number.isFinite(t) ? t : null; };
+
+/**
+ * The latest verdict per agent in `<dir>/.great_cto/verdicts/`.
+ * `gate:*.log` files record gate decisions, not an agent's verdict, and are skipped.
+ * @returns {Map<string, {verdict:string, ts:string, kind:string}>}
+ */
+export function latestVerdicts(projectDir) {
+  const dir = join(projectDir, '.great_cto', 'verdicts');
+  const out = new Map();
+  let files = [];
+  try { files = readdirSync(dir).filter((f) => f.endsWith('.log') && !f.startsWith('gate')); } catch { return out; }
+  for (const f of files) {
+    const agent = canonicalAgent(f);
+    let text = '';
+    try { text = readFileSync(join(dir, f), 'utf8'); } catch { continue; }
+    for (const rec of parseVerdictLog(text, { agent }).records) {
+      const t = tsOf(rec.ts);
+      if (t === null) continue;
+      const prev = out.get(agent);
+      if (!prev || t >= tsOf(prev.ts)) out.set(agent, { verdict: rec.verdict, ts: rec.ts, kind: verdictKind(rec.verdict) });
+    }
+  }
+  return out;
+}
+
+/** ISO time of the last commit that changed something other than docs and pipeline records. */
+export function lastCodeChange(projectDir) {
+  const r = spawnSync('git', ['log', '-1', '--format=%cI', '--', '.',
+    ':(exclude).great_cto', ':(exclude)docs', ':(exclude)*.md', ':(exclude).beads'],
+  { cwd: projectDir, encoding: 'utf8', timeout: 10_000 });
+  return r.status === 0 && r.stdout.trim() ? r.stdout.trim() : null;
+}
+
+/**
+ * @param {Map} latest            from latestVerdicts()
+ * @param {string|null} lastChange from lastCodeChange()
+ * @param {{as?: string}} opts    `as`: the agent running this check about its own
+ *                                verdict — its own latest is not held against it.
+ * @returns {{agent:string, why:string}[]} what blocks gate:ship, each with its reason
+ */
+export function shipBlockers(latest, lastChange, { as } = {}) {
+  const self = as ? canonicalAgent(as) : null;
+  const out = [];
+  for (const [agent, v] of latest) {
+    if (agent === self || v.kind !== 'negative') continue;
+    out.push({ agent, why: `latest verdict ${v.verdict} (${v.ts}) — no later verdict from ${agent} closes it` });
+  }
+  for (const agent of MANDATORY_FOR_SHIP) {
+    if (agent === self) continue;
+    const v = latest.get(agent);
+    if (!v) { out.push({ agent, why: 'no verdict in this project' }); continue; }
+    if (v.kind === 'neutral') out.push({ agent, why: `latest verdict ${v.verdict} is not a pass` });
+  }
+  // A verdict counts for the code it saw. Both post-implementation checks must be
+  // newer than the last code change; agtx (fynnfluegge/agtx) applies the same rule
+  // to a phase artifact — only one written after the phase began counts.
+  for (const agent of MANDATORY_FOR_SHIP) {
+    if (agent === self) continue;
+    const v = latest.get(agent);
+    if (v && v.kind === 'positive' && lastChange && tsOf(v.ts) !== null && tsOf(v.ts) < tsOf(lastChange)) {
+      out.push({ agent, why: `verdict ${v.ts} predates the last code change ${lastChange} — re-run ${agent} on what ships` });
+    }
+  }
+  return out;
+}

package/package.json

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