great-cto 3.44.0 → 3.46.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 71 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.44.0",
+  "version": "3.46.0",
   "author": {
     "name": "Alexander Velikiy",
     "url": "https://hashnode.com/@Greatcto"

package/board/packages/board/public/index.html

@@ -5815,6 +5815,7 @@ function renderAgentActivity(snap) {
       return `${esc(e.tool || 'tool')}${p}`;
     }
     if (e.kind === 'pipeline') return `pipeline: ${esc(e.outcome || '')}${e.verdict ? ' · ' + esc(e.verdict) : ''}`;
+    if (e.kind === 'hint') return `hint: ${esc(e.hook || '')}${Array.isArray(e.paths) && e.paths.length ? ' ' + esc(e.paths[0]) : ''}${e.host === 'codex' ? ' · codex' : ''}`;
     return esc(e.kind || '');
   };
   const attention = (Array.isArray(snap.attention) ? snap.attention : []).map((e) =>

package/board/scripts/lib/agent-events.mjs

@@ -28,8 +28,10 @@ import { appendFileSync, closeSync, fstatSync, mkdirSync, openSync, readFileSync
 import { join } from 'node:path';
 
 export const EVENTS_FILE = 'events.jsonl';
-export const EVENT_KINDS = Object.freeze(['agent-start', 'agent-stop', 'tool', 'denied', 'stop', 'pipeline']);
-export const EVENT_FIELDS = Object.freeze(['v', 'ts', 'kind', 'session', 'agent', 'tool', 'paths', 'ok', 'duration_ms', 'outcome', 'verdict']);
+// `hint`: a context hook (edit-impact, lesson-tripwire) put text in front of the model.
+// Recorded so its noise can be measured — how often, on what, how long — not what it said.
+export const EVENT_KINDS = Object.freeze(['agent-start', 'agent-stop', 'tool', 'denied', 'stop', 'pipeline', 'hint']);
+export const EVENT_FIELDS = Object.freeze(['v', 'ts', 'kind', 'session', 'agent', 'tool', 'paths', 'ok', 'duration_ms', 'outcome', 'verdict', 'hook', 'chars', 'host']);
 export const MAX_BYTES = 5 * 1024 * 1024;
 
 const MAX_PATHS = 10;
@@ -55,6 +57,9 @@ export function makeEvent(input, { now = Date.now() } = {}) {
   if (Number.isFinite(input.duration_ms) && input.duration_ms >= 0) e.duration_ms = Math.round(input.duration_ms);
   if (typeof input.outcome === 'string' && /^[a-z][a-z-]{0,39}$/.test(input.outcome)) e.outcome = input.outcome;
   if (typeof input.verdict === 'string' && /^[A-Z][A-Z_-]{0,39}$/.test(input.verdict)) e.verdict = input.verdict;
+  if (typeof input.hook === 'string' && /^[a-z][a-z-]{0,39}$/.test(input.hook)) e.hook = input.hook;
+  if (Number.isInteger(input.chars) && input.chars >= 0) e.chars = input.chars;
+  if (input.host === 'claude' || input.host === 'codex') e.host = input.host;
   return e;
 }
 

package/dist/codex.js

@@ -48,7 +48,7 @@ export function codexInstallPlan({ repoDir, codexOnPath }) {
             "skills — all of them, the same tree Claude Code reads",
             "the MCP server (great_cto), resolved from npm",
             "the controlled role pipeline — run `npx --yes great-cto codex-host doctor` then `npx --yes great-cto codex-host start`",
-            "six safety guards as Codex plugin hooks (destructive commands, gate bypasses, a neighbour session's work, secrets in files, frozen gates, weakened checks) and two hints that never block (edit-impact, lesson-tripwire) — Codex asks you to review them once on the next interactive `codex` start; they do not run until you do",
+            "six safety guards as Codex plugin hooks (destructive commands, gate bypasses, a neighbour session's work, secrets in files, frozen gates, weakened checks) and two hints that never block (edit-impact, lesson-tripwire) — Codex asks you to review them once on the next interactive `codex` start; they do not run until you do. Codex does not update great_cto by itself — `great-cto upgrade` (or `great-cto upgrade codex`) does",
         ],
         // Codex runs plugin hooks (verified 2026-09-28, codex-cli 0.153.4) but has no
         // plugin surface for commands or role agents. Saying "installed" without saying
@@ -60,3 +60,92 @@ export function codexInstallPlan({ repoDir, codexOnPath }) {
         ],
     };
 }
+// ── Keeping the Codex install current ────────────────────────────────────────
+//
+// Codex installs great_cto from a Git marketplace snapshot and never refreshes it on
+// its own. `release.sh` and `install-local` update the Claude Code plugin only, so on
+// the maintainer's machine Codex sat at 3.37.0 while 3.45.0 shipped — every Codex
+// guard released in between (3.42–3.45) had never reached it. Measured 2026-09-30:
+// `codex plugin marketplace upgrade great-cto` refreshes the snapshot AND the installed
+// plugin cache in one step. `great-cto upgrade` now runs it when Codex has the
+// great-cto marketplace configured.
+import { existsSync as fsExists, readdirSync, readFileSync as fsRead } from "node:fs";
+import { homedir as home } from "node:os";
+import { join as pjoin } from "node:path";
+import { execFileSync } from "node:child_process";
+/** A usable `codex` binary: PATH first, then nvm installs, then the desktop app. Null when none. */
+export function findCodexBinary(env = process.env, h = home()) {
+    for (const dir of String(env.PATH || "").split(":")) {
+        if (dir && fsExists(pjoin(dir, "codex")))
+            return pjoin(dir, "codex");
+    }
+    // A shell that did not load nvm (a conda base, a login shell without .nvmrc) cannot
+    // see an npm-installed codex; look where nvm puts it.
+    const nvm = pjoin(h, ".nvm", "versions", "node");
+    let versions = [];
+    try {
+        versions = readdirSync(nvm).sort().reverse();
+    }
+    catch { /* no nvm */ }
+    for (const v of versions) {
+        const p = pjoin(nvm, v, "bin", "codex");
+        if (fsExists(p))
+            return p;
+    }
+    const app = "/Applications/Codex.app/Contents/Resources/codex";
+    return fsExists(app) ? app : null;
+}
+/** Does Codex have great_cto's marketplace configured? Read from its config.toml. */
+export function codexHasGreatCtoMarketplace(codexHome = pjoin(home(), ".codex")) {
+    try {
+        return /^\s*\[marketplaces\.(?:"great-cto"|great-cto)\]\s*$/m.test(fsRead(pjoin(codexHome, "config.toml"), "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+/** The newest great_cto version in Codex's plugin cache, or null. */
+export function installedCodexVersion(codexHome = pjoin(home(), ".codex")) {
+    const cache = pjoin(codexHome, "plugins", "cache");
+    let markets = [];
+    try {
+        markets = readdirSync(cache);
+    }
+    catch {
+        return null;
+    }
+    const versions = [];
+    for (const m of markets) {
+        try {
+            versions.push(...readdirSync(pjoin(cache, m, "great-cto")).filter((v) => /^\d+\.\d+\.\d+/.test(v)));
+        }
+        catch { /* not this market */ }
+    }
+    const key = (v) => v.split(".").map((n) => parseInt(n, 10) || 0);
+    versions.sort((a, b) => { const x = key(a), y = key(b); for (let i = 0; i < 3; i++)
+        if (x[i] !== y[i])
+            return x[i] - y[i]; return 0; });
+    return versions.at(-1) ?? null;
+}
+/** Refresh great_cto in Codex. Skips, with the reason, when Codex or the marketplace is absent. */
+export function upgradeCodexPlugin(opts = {}) {
+    const codexHome = opts.codexHome ?? pjoin(home(), ".codex");
+    if (!codexHasGreatCtoMarketplace(codexHome)) {
+        return { status: "skipped", fromVersion: null, toVersion: null, reason: "great_cto is not installed for Codex" };
+    }
+    const from = installedCodexVersion(codexHome);
+    const bin = opts.bin === undefined ? findCodexBinary() : opts.bin;
+    if (!bin) {
+        return { status: "skipped", fromVersion: from, toVersion: from, reason: "codex not found on PATH or under ~/.nvm — run: codex plugin marketplace upgrade great-cto" };
+    }
+    try {
+        execFileSync(bin, ["plugin", "marketplace", "upgrade", "great-cto"], {
+            stdio: ["ignore", "pipe", "pipe"], timeout: 180_000, env: { ...process.env, CODEX_HOME: codexHome },
+        });
+    }
+    catch (e) {
+        return { status: "failed", fromVersion: from, toVersion: from, reason: String(e.message).split("\n")[0] };
+    }
+    const to = installedCodexVersion(codexHome);
+    return { status: to && to !== from ? "upgraded" : "already_latest", fromVersion: from, toVersion: to };
+}

package/dist/main.js

@@ -772,6 +772,7 @@ ${bold("Upgrade:")}
   great-cto upgrade superpowers  Upgrade superpowers only
   great-cto upgrade beads        Upgrade beads only
   great-cto upgrade --self       Upgrade the great-cto CLI itself (also: upgrade self)
+  great-cto upgrade codex        Refresh great_cto in Codex (also part of plain upgrade)
   great-cto uninstall            Plan: what would be removed, what is kept (changes nothing)
   great-cto uninstall --yes      Remove plugin, agents, commands, board service, caches
       --purge-data               Also move ~/.great_cto aside (reversible, never deleted)
@@ -1435,6 +1436,9 @@ async function runUpgrade(rawArgv, args) {
     // Optional positional: great-cto upgrade [plugin-name]
     const pluginArg = firstArgAfterUpgrade;
     const targetPlugin = pluginArg && !pluginArg.startsWith("--") ? pluginArg : undefined;
+    // `great-cto upgrade codex` refreshes only the Codex install.
+    if (targetPlugin === "codex")
+        return reportCodexUpgrade();
     let results;
     if (targetPlugin) {
         const plugin = COMPANION_PLUGINS.find((p) => p.name === targetPlugin);
@@ -1458,6 +1462,28 @@ async function runUpgrade(rawArgv, args) {
             warn(`${r.name} skipped — ${r.reason ?? "unknown reason"}`);
         }
     }
+    // Codex keeps its own snapshot of great_cto and never refreshes it; without this
+    // step every Codex guard shipped after the first install stays out of reach.
+    if (!targetPlugin)
+        await reportCodexUpgrade();
+    return 0;
+}
+async function reportCodexUpgrade() {
+    const { upgradeCodexPlugin } = await import("./codex.js");
+    const r = upgradeCodexPlugin();
+    if (r.status === "upgraded") {
+        success(`codex: great_cto ${r.fromVersion ?? "—"} → ${r.toVersion} — new or changed hooks need one review at the next \`codex\` start`);
+    }
+    else if (r.status === "already_latest") {
+        log(`  ${dim(`codex: great_cto ${r.toVersion} already at latest`)}`);
+    }
+    else if (r.status === "failed") {
+        warn(`codex: upgrade failed — ${r.reason}`);
+        return 1;
+    }
+    else if (r.reason && r.reason !== "great_cto is not installed for Codex") {
+        warn(`codex: ${r.reason}`);
+    }
     return 0;
 }
 async function main() {

package/package.json

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