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

package/board/packages/board/lib/beads.mjs

@@ -132,7 +132,14 @@ function tasksMdStatus(rawStatus, id, title) {
   else if (s === 'in_progress' || s === 'in-progress' || s === 'wip' || s === 'doing') status = 'in_progress';
   else if (s === 'blocked') status = 'blocked';
   else status = isGate ? 'gate' : 'backlog';
-  return { status, raw_status: status === 'done' ? 'closed' : 'open', isGate };
+  // raw_status is what the inbox filters on, because mapStatus() rewrites any
+  // gate-labelled task to 'gate' and filtering on the mapped value would leave
+  // closed gates in the inbox forever. That fix covered `done`; it did not cover
+  // `blocked`, so a gate marked blocked in tasks.md reported raw_status 'open'
+  // and never left the inbox — for exactly the bd-less projects this parser
+  // exists to serve.
+  const raw = status === 'done' ? 'closed' : status === 'blocked' ? 'blocked' : 'open';
+  return { status, raw_status: raw, isGate };
 }
 
 // Build the full task record both parsers emit — one shape so getTasks can

package/board/packages/board/lib/fleet.mjs

@@ -23,7 +23,12 @@ function deriveDomain(slug) {
   const s = slug.toLowerCase();
   if (/architect|adr|design|prompt/.test(s)) return 'arch';
   if (/security|sec-|threat|pci|gdpr|hipaa/.test(s)) return 'security';
-  if (/qa|test|eval|review/.test(s)) return 'qa';
+  // `review` used to be in this alternation, and it matched every `*-reviewer`
+  // slug — so 37 of the 40 agents in `qa` were domain reviewers, the `domain`
+  // bucket below was permanently empty, and the panel grouped 58% of the fleet
+  // under one heading. The rule that was supposed to separate them sat two lines
+  // later and could never be reached.
+  if (/\bqa\b|test|eval|^code-reviewer$/.test(s)) return 'qa';
   if (/devops|deploy|infra|l3|support|oncall/.test(s)) return 'ops';
   if (/reviewer$/.test(s)) return 'domain';
   if (/pm|plan|product/.test(s)) return 'pm';

package/dist/main.js

@@ -1196,6 +1196,23 @@ async function runSelfUpgrade() {
         return result.exitCode;
     }
     success(result.message);
+    // The CLI is upgraded; the plugin Claude Code actually loads may not be.
+    // `npm i -g` never touches the plugin cache, so without this the user is told
+    // the upgrade succeeded and keeps running the previous release's hooks and
+    // agent prompts with nothing anywhere saying so.
+    try {
+        const { pluginCacheLagWarning } = await import("./self-upgrade.js");
+        const { readdirSync } = await import("node:fs");
+        const { join } = await import("node:path");
+        const cacheRoot = join(homedir(), ".claude", "plugins", "cache", "local", "great_cto");
+        const dirs = readdirSync(cacheRoot);
+        const warning = pluginCacheLagWarning(result.newVersion ?? "", dirs);
+        if (warning) {
+            log("");
+            log(dim(warning));
+        }
+    }
+    catch { /* no plugin cache is not a lag — the plugin is simply not installed */ }
     return 0;
 }
 async function runUpgrade(rawArgv, args) {
@@ -1242,6 +1259,10 @@ async function main() {
     // is the single exit funnel: it fires one fire-and-forget event (command + node + os
     // + exit_code + duration, no PII) only when the user has opted in, then exits.
     const __tStart = Date.now();
+    // Promise<never>, not Promise<void>: this always exits, and typing it as such
+    // is what lets `await finish(2)` narrow a nullable the way `process.exit(2)`
+    // did. Without it, routing an exit through the update check would silently
+    // widen types at every call site.
     const finish = async (code) => {
         try {
             await sendUsagePing({
@@ -1270,7 +1291,7 @@ async function main() {
     if (args.command === "telemetry") {
         const { exitCode, output } = telemetrySubcommand(args.positional[0]);
         process.stdout.write(output);
-        process.exit(exitCode);
+        await finish(exitCode);
     }
     if (args.command === "help") {
         printHelp();
@@ -1281,7 +1302,7 @@ async function main() {
         error(`great-cto: unknown command or flag '${tok}'`);
         log("");
         log(`Run ${cyan("great-cto --help")} for usage.`);
-        process.exit(2);
+        await finish(2);
     }
     if (args.command === "board") {
         try {
@@ -1304,7 +1325,7 @@ async function main() {
         }
         catch (e) {
             error(e.message);
-            process.exit(1);
+            await finish(1);
         }
     }
     if (args.command === "console") {
@@ -1314,7 +1335,7 @@ async function main() {
         }
         catch (e) {
             error(e.message);
-            process.exit(1);
+            await finish(1);
         }
     }
     if (args.command === "register") {
@@ -1324,7 +1345,7 @@ async function main() {
         }
         catch (e) {
             error(e.message);
-            process.exit(1);
+            await finish(1);
         }
     }
     if (args.command === "ci") {
@@ -1335,7 +1356,7 @@ async function main() {
         }
         catch (e) {
             error(e.message);
-            process.exit(2);
+            await finish(2);
         }
     }
     if (args.command === "mcp") {
@@ -1349,7 +1370,7 @@ async function main() {
         }
         catch (e) {
             error(e.message);
-            process.exit(2);
+            await finish(2);
         }
     }
     if (args.command === "adapt") {
@@ -1364,16 +1385,16 @@ async function main() {
         }
         catch (e) {
             error(e.message);
-            process.exit(2);
+            await finish(2);
         }
     }
     if (args.command === "task") {
         const { runTask } = await import("./worker.js");
-        process.exit(await runTask(args.taskArgs ?? []));
+        await finish(await runTask(args.taskArgs ?? []));
     }
     if (args.command === "worker") {
         const { runWorker } = await import("./worker.js");
-        process.exit(await runWorker(args.taskArgs ?? []));
+        await finish(await runWorker(args.taskArgs ?? []));
     }
     if (args.command === "serve") {
         try {
@@ -1390,7 +1411,7 @@ async function main() {
         }
         catch (e) {
             error(e.message);
-            process.exit(2);
+            await finish(2);
         }
     }
     if (args.command === "webhook") {
@@ -1399,14 +1420,14 @@ async function main() {
             const parsed = parseWebhookArgs(rawArgv);
             if (!parsed) {
                 error("usage: great-cto webhook list | add-incoming <name> --secret <s> | add-outgoing <name> --url <u> --format <f> --triggers <t1,t2> | remove <name> | test <name>");
-                process.exit(2);
+                return finish(2);
             }
             const code = await runWebhookCli(parsed);
             await finish(code);
         }
         catch (e) {
             error(e.message);
-            process.exit(2);
+            await finish(2);
         }
     }
     if (args.command === "upgrade") {
@@ -1416,7 +1437,7 @@ async function main() {
         }
         catch (e) {
             error(e.message);
-            process.exit(2);
+            await finish(2);
         }
     }
     if (args.command === "chat-only-hint") {
@@ -1433,21 +1454,21 @@ async function main() {
         log(`  ${cyan("serve")} · ${cyan("webhook")} · ${cyan("report")} · ${cyan("board")} · ${cyan("register")} · ${cyan("upgrade")}`);
         log("");
         log(`Run ${cyan("npx great-cto --help")} for the full CLI reference.`);
-        process.exit(2);
+        await finish(2);
     }
     if (args.command === "report") {
         try {
             const { runReport, parseReportArgs } = await import("./report.js");
             const parsed = parseReportArgs(rawArgv, args.dir);
             if (!parsed) {
-                process.exit(2);
+                return finish(2);
             }
             const code = await runReport(parsed);
             await finish(code);
         }
         catch (e) {
             error(e.message);
-            process.exit(2);
+            await finish(2);
         }
     }
     if (args.command === "version") {
@@ -1464,7 +1485,7 @@ async function main() {
                     const pkg = JSON.parse(readFileSync(p, "utf-8"));
                     if (pkg.name === "great-cto" && pkg.version) {
                         log(pkg.version);
-                        process.exit(0);
+                        await finish(0);
                     }
                 }
                 catch { /* keep searching */ }
@@ -1474,7 +1495,7 @@ async function main() {
         catch {
             log("0.0.0");
         }
-        process.exit(0);
+        await finish(0);
     }
     try {
         const code = await runInit(args);

package/dist/self-upgrade.js

@@ -154,3 +154,57 @@ export function performSelfUpgrade(opts) {
 }
 // Re-export for callers that only need the prefix-derivation logic directly.
 export { derivePrefixFromBinPath as _derivePrefixFromBinPath };
+/**
+ * Newest version present in the Claude Code plugin cache, or null.
+ *
+ * Takes the directory names so the rule is testable without a filesystem.
+ */
+export function newestCachedPlugin(dirNames) {
+    const versions = dirNames.filter((d) => /^\d+\.\d+\.\d+$/.test(d));
+    if (!versions.length)
+        return null;
+    const key = (v) => v.split(".").map(Number);
+    return versions.sort((a, b) => {
+        const [A, B] = [key(a), key(b)];
+        for (let i = 0; i < 3; i++)
+            if (A[i] !== B[i])
+                return A[i] - B[i];
+        return 0;
+    })[versions.length - 1];
+}
+/**
+ * Warn when the npm package has moved ahead of the plugin Claude Code loads.
+ *
+ * `npm i -g` replaces the CLI. It does not touch
+ * ~/.claude/plugins/cache/local/great_cto/<version>/, which is where the hooks
+ * and agent prompts are actually read from — so a user can take the update
+ * prompt, be told the upgrade succeeded, and keep running the previous release's
+ * agents with nothing anywhere saying so. That is the same defect this codebase
+ * keeps finding: a step reported as done while the thing it was meant to change
+ * stayed as it was.
+ *
+ * Returns null when they match, when nothing is cached (the plugin is simply not
+ * installed), or when the cache is somehow ahead — none of those are the failure
+ * this exists to catch.
+ */
+export function pluginCacheLagWarning(npmVersion, cachedDirs) {
+    const cached = newestCachedPlugin(cachedDirs);
+    if (!cached || !npmVersion)
+        return null;
+    if (cached === npmVersion)
+        return null;
+    const key = (v) => v.split(".").map(Number);
+    const [c, n] = [key(cached), key(npmVersion)];
+    for (let i = 0; i < 3; i++) {
+        if (c[i] > n[i])
+            return null; // cache ahead — not the case we guard
+        if (c[i] < n[i])
+            break;
+    }
+    return [
+        `note: the npm package is ${npmVersion}, but the plugin Claude Code loads is ${cached}.`,
+        "      Hooks and agent prompts come from the plugin cache, not from npm — until it is",
+        "      refreshed, this session keeps running the previous release's agents.",
+        "      Refresh it with:  bash scripts/install-local.sh --prune",
+    ].join("\n");
+}

package/dist/update-check.js

@@ -58,6 +58,29 @@ export function cachePath() {
 }
 /** Pure function: is a suppression condition active? Fail-open to "suppressed" on any ambiguity. */
 export function isSuppressed(opts = {}) {
+    if (isRefreshSuppressed(opts))
+        return true;
+    // Nothing may be printed when stderr is not a terminal — the output is being
+    // read by something. This is about PRINTING only; see isRefreshSuppressed.
+    if (opts.stderrIsTTY === false)
+        return true;
+    return false;
+}
+/**
+ * Should the background cache refresh be suppressed too?
+ *
+ * Deliberately narrower than isSuppressed. Not printing and not learning are
+ * different things, and conflating them had a consequence: the refresh sits
+ * behind the same non-TTY check as the hint, so a user whose runs are mostly
+ * non-interactive never warmed the cache — and their occasional interactive run
+ * therefore had no cache to read and showed nothing, every time. The cache file
+ * was simply absent on this machine, which is how this was found.
+ *
+ * A detached refresh with stdio ignored pollutes no output. What genuinely must
+ * not spawn: the protocol commands, whose children would outlive a parsed
+ * stream, and anyone who asked us not to check at all.
+ */
+export function isRefreshSuppressed(opts = {}) {
     const env = opts.env ?? process.env;
     if (env.CI != null && env.CI !== "" && env.CI !== "0" && env.CI !== "false")
         return true;
@@ -65,8 +88,6 @@ export function isSuppressed(opts = {}) {
         return true;
     if (opts.command && PROTOCOL_SENSITIVE_COMMANDS.has(opts.command))
         return true;
-    if (opts.stderrIsTTY === false)
-        return true;
     return false;
 }
 /**
@@ -213,10 +234,15 @@ export async function checkForUpdate(opts) {
         const env = opts.env ?? process.env;
         const stderrIsTTY = opts.stderrIsTTY ?? Boolean(process.stderr.isTTY);
         const stdinIsTTY = opts.stdinIsTTY ?? Boolean(process.stdin.isTTY);
-        if (isSuppressed({ env, command: opts.command, stderrIsTTY }))
+        // Warm the cache even when nothing may be printed. A run that cannot show a
+        // hint can still learn the version for the run that can.
+        if (isRefreshSuppressed({ env, command: opts.command }))
             return;
+        const quiet = isSuppressed({ env, command: opts.command, stderrIsTTY });
         const cache = readCache();
         if (isCacheFresh(cache, opts.now)) {
+            if (quiet)
+                return; // fresh cache, but this run may not speak
             if (!cache || !isNewerVersion(opts.currentVersion, cache.latest))
                 return;
             if (shouldPrompt({ currentVersion: opts.currentVersion, cache, env, command: opts.command, stderrIsTTY, stdinIsTTY })) {

package/package.json

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