great-cto 3.61.0 → 3.62.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 72 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.61.0",
+  "version": "3.62.0",
   "author": {
     "name": "Alexander Velikiy",
     "url": "https://hashnode.com/@Greatcto"
@@ -141,6 +141,17 @@
       }
     ],
     "PreToolUse": [
+      {
+        "matcher": "Agent|Task",
+        "hooks": [
+          {
+            "type": "command",
+            "timeout": 5,
+            "command": "_gd=\"$PWD\"; while [ -n \"$_gd\" ] && { [ \"$_gd\" = \"$HOME\" ] || [ ! -f \"$_gd/.great_cto/PROJECT.md\" ]; }; do _gd=\"${_gd%/*}\"; done; [ -n \"$_gd\" ] && cd \"$_gd\"; [ -n \"$GREAT_CTO_AGENT_BUDGET_FILE\" ] || exit 0; node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/agent-execution-budget.mjs\" pre; _budget_exit=$?; if [ $_budget_exit -ne 0 ]; then exit 2; fi",
+            "statusMessage": "Checking shared agent execution budget..."
+          }
+        ]
+      },
       {
         "matcher": "Bash",
         "hooks": [
@@ -195,6 +206,17 @@
       }
     ],
     "PostToolUse": [
+      {
+        "matcher": "Agent|Task",
+        "hooks": [
+          {
+            "type": "command",
+            "timeout": 5,
+            "command": "_gd=\"$PWD\"; while [ -n \"$_gd\" ] && { [ \"$_gd\" = \"$HOME\" ] || [ ! -f \"$_gd/.great_cto/PROJECT.md\" ]; }; do _gd=\"${_gd%/*}\"; done; [ -n \"$_gd\" ] && cd \"$_gd\"; [ -n \"$GREAT_CTO_AGENT_BUDGET_FILE\" ] || exit 0; node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/agent-execution-budget.mjs\" post; _budget_exit=$?; if [ $_budget_exit -ne 0 ]; then exit 2; fi",
+            "statusMessage": "Releasing completed foreground agent budget lease..."
+          }
+        ]
+      },
       {
         "matcher": "Write|Edit|MultiEdit",
         "hooks": [

package/board/packages/board/lib/config.mjs

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import os from 'os';
+import { stateHome } from '../../cli/src/state-home.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // `--port N` (or `--port=N`) first — server.mjs's usage line documents it, and
@@ -28,17 +28,24 @@ const HOST = (() => {
   const i = process.argv.indexOf('--host');
   return String(i > -1 ? process.argv[i + 1] : process.env.GREAT_CTO_HOST || '127.0.0.1');
 })();
-const GREAT_CTO_DIR = path.join(os.homedir(), '.great_cto');
+// Shared dedicated namespace with the CLI; unset/empty keeps the operator default.
+const GREAT_CTO_DIR = stateHome();
 const SHARE_STATE_FILE = path.join(GREAT_CTO_DIR, 'board-share.json');
 // Test seam: honor an explicit override so tests can point the registry at a
 // tmp fixture without touching the real ~/.great_cto/projects.json (same
 // convention as GREAT_CTO_BD_BIN in lib/beads.mjs). Unset in production —
 // zero behavior change at runtime.
-const PROJECTS_FILE = process.env.GREAT_CTO_PROJECTS_FILE || path.join(GREAT_CTO_DIR, 'projects.json');
+function stateFileOverride(name, fallback) {
+  const value = process.env[name];
+  if (!value) return path.join(GREAT_CTO_DIR, fallback);
+  if (!path.isAbsolute(value) || value.includes('\0')) throw new Error(`${name} must be absolute and contain no NUL`);
+  return path.resolve(value);
+}
+const PROJECTS_FILE = stateFileOverride('GREAT_CTO_PROJECTS_FILE', 'projects.json');
 const SHARE_ENDPOINT = 'https://greatcto.systems/r/';
 const VAPID_KEYS_FILE = path.join(GREAT_CTO_DIR, 'vapid-keys.json');
 const PUSH_SUBS_FILE = path.join(GREAT_CTO_DIR, 'push-subscriptions.json');
-const NOTIF_HISTORY_FILE = process.env.GREAT_CTO_NOTIF_HISTORY_FILE || path.join(GREAT_CTO_DIR, 'notif-history.json');
+const NOTIF_HISTORY_FILE = stateFileOverride('GREAT_CTO_NOTIF_HISTORY_FILE', 'notif-history.json');
 const VAPID_SUBJECT = 'mailto:hi@updates.greatcto.systems';
 
 export {

package/board/packages/board/lib/data-readers.mjs

@@ -1,7 +1,6 @@
 import { reversibilityOf } from '../../../scripts/lib/gate-reversibility.mjs';
 import fs from 'fs';
 import path from 'path';
-import os from 'os';
 import { GREAT_CTO_DIR } from './config.mjs';
 import { readFileSafe } from './util.mjs';
 import { getTasks } from './beads.mjs';
@@ -21,7 +20,6 @@ function gateNameOf(task) {
 }
 
 function getMemory(cwd = process.cwd()) {
-  const home = os.homedir();
   const layers = [
     // Project-local (.great_cto/) — L1 archetype + L2 codebase + L3 retros
     { id: 'project',     scope: 'project', layer: 'L1', name: 'PROJECT.md',    desc: 'Archetype, size, compliance, owners',           path: path.join(cwd, '.great_cto', 'PROJECT.md') },
@@ -33,9 +31,9 @@ function getMemory(cwd = process.cwd()) {
     { id: 'handoff',     scope: 'project', layer: 'L3', name: 'HANDOFF.md',    desc: 'Auto-written on context compaction',            path: path.join(cwd, '.great_cto', 'HANDOFF.md') },
     { id: 'local',       scope: 'project', layer: 'L3', name: 'local.md',      desc: 'Project-local notes (gitignored)',              path: path.join(cwd, '.great_cto', 'local.md') },
     // Cross-project (~/.great_cto/) — L4 global memory shared across all projects
-    { id: 'g-decisions', scope: 'global',  layer: 'L4', name: 'decisions.md',  desc: 'Append-only ADR log — every gate approval',     path: path.join(home, '.great_cto', 'decisions.md') },
-    { id: 'g-prefs',     scope: 'global',  layer: 'L4', name: 'preferences.md',desc: 'User-level CTO preferences (style, defaults)',  path: path.join(home, '.great_cto', 'preferences.md') },
-    { id: 'g-lessons',   scope: 'global',  layer: 'L4', name: 'lessons.md',    desc: 'Cross-project lessons promoted from L3',        path: path.join(home, '.great_cto', 'lessons.md') },
+    { id: 'g-decisions', scope: 'global',  layer: 'L4', name: 'decisions.md',  desc: 'Append-only ADR log — every gate approval',     path: path.join(GREAT_CTO_DIR, 'decisions.md') },
+    { id: 'g-prefs',     scope: 'global',  layer: 'L4', name: 'preferences.md',desc: 'User-level CTO preferences (style, defaults)',  path: path.join(GREAT_CTO_DIR, 'preferences.md') },
+    { id: 'g-lessons',   scope: 'global',  layer: 'L4', name: 'lessons.md',    desc: 'Cross-project lessons promoted from L3',        path: path.join(GREAT_CTO_DIR, 'lessons.md') },
   ];
   const result = layers.map(l => ({
     ...l,
@@ -45,7 +43,7 @@ function getMemory(cwd = process.cwd()) {
     // is photographed. The layer already knows its scope, so the display form is
     // derived rather than guessed.
     displayPath: l.scope === 'global'
-      ? path.join('~', path.relative(home, l.path)).split(path.sep).join('/')
+      ? path.join(process.env.GREAT_CTO_HOME ? '$GREAT_CTO_HOME' : path.join('~', '.great_cto'), path.relative(GREAT_CTO_DIR, l.path)).split(path.sep).join('/')
       : path.relative(cwd, l.path).split(path.sep).join('/'),
     content: readFileSafe(l.path),
     exists: fs.existsSync(l.path),

package/board/packages/board/lib/projects.mjs

@@ -204,7 +204,15 @@ function getChangeTier(dir) {
     return { tier: 'T2', error: e.message };  // fail-safe: unknown → full gates
   }
 }
+function isGlobalStateProject(dir) {
+  const canonical = value => { try { return fs.realpathSync(value); } catch { return path.resolve(value); } };
+  const resolved = canonical(dir);
+  const state = canonical(GREAT_CTO_DIR);
+  return isInsideDir(state, resolved) || canonical(path.join(resolved, '.great_cto')) === state;
+}
+
 function autoRegisterProject(dir) {
+  if (isGlobalStateProject(dir)) return null;
   // The home directory is never a project.
   //
   // `~/.great_cto/` is the GLOBAL store — cross-project verdicts, decisions,
@@ -228,18 +236,29 @@ function autoRegisterProject(dir) {
   // the board there added it as a separate project reading great_cto's beads —
   // 228 tasks counted twice, under two names, in a fleet of seventeen.
   try {
+    // Automatic discovery/cwd must not bypass the raw-path registration
+    // boundary. An explicit isolated discovery scope replaces HOME, never
+    // falls back to it, and is canonicalized before containment checks.
+    const scope = getDiscoveryScope();
+    const boundary = fs.realpathSync(scope.includeClaudeProjects ? os.homedir() : scope.roots[0]);
+    const canonical = fs.realpathSync(dir);
+    if (!isInsideDir(boundary, canonical)) return null;
     const resolved = path.resolve(dir);
     if (resolved === path.resolve(os.homedir())) return null;
     if (isInsideDir(path.join(os.homedir(), '.claude', 'plugins'), resolved)) return null;
     const enclosing = readProjectsRegistry().projects
       .find((e) => e.path && path.resolve(e.path) !== resolved && isInsideDir(path.resolve(e.path), resolved));
     if (enclosing) return null;
-  } catch { /* if we cannot resolve it, fall through to the normal checks */ }
+  } catch { return null; } // Unknown scope is not permission to register it.
 
   const meta = readProjectMd(dir);
   if (!meta) return null;
   const reg = readProjectsRegistry();
-  const existingByPath = reg.projects.find(p => p.path === meta.path);
+  const existingByPath = reg.projects.find(p => {
+    if (p.path === meta.path) return true;
+    try { return fs.realpathSync(p.path) === fs.realpathSync(meta.path); }
+    catch { return false; }
+  });
   if (existingByPath) return meta; // already registered at this path, nothing to do
   // Only an entry whose path is GONE is this repo having moved. An entry whose
   // path still exists is a different project that happens to share a name, and
@@ -264,20 +283,40 @@ function autoRegisterProject(dir) {
 // project that ran /audit or /start (which writes .great_cto/PROJECT.md) gets
 // auto-registered without the user having to do anything.
 // Fully async — never blocks the event loop.
+function getDiscoveryScope() {
+  const scoped = process.env.GREAT_CTO_DISCOVERY_ROOT;
+  if (scoped) {
+    if (!path.isAbsolute(scoped)) throw new Error('GREAT_CTO_DISCOVERY_ROOT must be absolute');
+    const root = fs.realpathSync(scoped);
+    if (!fs.statSync(root).isDirectory()) throw new Error('GREAT_CTO_DISCOVERY_ROOT must be a directory');
+    return { roots: [root], includeClaudeProjects: false };
+  }
+  const home = os.homedir();
+  return { roots: [
+    path.join(home, 'work'), path.join(home, 'dev'),
+    path.join(home, 'development'), path.join(home, 'code'),
+    path.join(home, 'projects'), path.join(home, 'src'),
+    path.join(home, 'Documents', 'projects'), home,
+  ], includeClaudeProjects: true };
+}
+
 async function discoverProjects() {
   const fsAsync = fs.promises;
   const HOME = os.homedir();
   const seen = new Set();
   const found = [];
+  // Resolve before scanning. A broken explicit scope must never fall back to
+  // scanning the operator's home or Claude project cache.
+  const scope = getDiscoveryScope();
 
   async function scanDir(dir, depth) {
-    if (depth < 0 || seen.has(dir)) return;
+    if (depth < 0 || seen.has(dir) || isInsideDir(GREAT_CTO_DIR, dir)) return;
     seen.add(dir);
     try {
       // Check the dir itself first — but NEVER treat HOME's own .great_cto as a
       // project: ~/.great_cto is the global config dir, not a project. Without
       // this guard, $HOME gets registered as a bogus project (great_cto-…).
-      if (dir !== HOME) {
+      if (dir !== HOME && !isGlobalStateProject(dir)) {
         try {
           await fsAsync.access(path.join(dir, '.great_cto', 'PROJECT.md'));
           found.push(dir);
@@ -298,22 +337,13 @@ async function discoverProjects() {
   }
 
   // 1) Common dev folders — top-level scan, 1-level deep
-  const roots = [
-    path.join(HOME, 'work'),
-    path.join(HOME, 'dev'),
-    path.join(HOME, 'development'),
-    path.join(HOME, 'code'),
-    path.join(HOME, 'projects'),
-    path.join(HOME, 'src'),
-    path.join(HOME, 'Documents', 'projects'),
-    HOME,
-  ];
+  const roots = scope.roots;
   for (const root of roots) {
     try { await fsAsync.access(root); await scanDir(root, 1); } catch {}
   }
 
   // 2) Claude Code's known project list (~/.claude/projects/<encoded-path>/)
-  try {
+  if (scope.includeClaudeProjects) try {
     const ccProj = path.join(HOME, '.claude', 'projects');
     await fsAsync.access(ccProj);
     const entries = await fsAsync.readdir(ccProj);
@@ -322,7 +352,7 @@ async function discoverProjects() {
       const decoded = '/' + dir.replace(/^-+/, '').replace(/-/g, '/');
       try {
         await fsAsync.access(path.join(decoded, '.great_cto', 'PROJECT.md'));
-        found.push(decoded);
+        if (!isGlobalStateProject(decoded)) found.push(decoded);
       } catch {}
     }
   } catch {}
@@ -342,7 +372,7 @@ function listProjects() {
   // .great_cto has no project marker or task source left (no PROJECT.md,
   // no tasks.md, no .beads → nothing to show, just clutters the switcher).
   reg.projects = reg.projects.filter(p =>
-    p.path !== HOME &&
+    p.path !== HOME && !isGlobalStateProject(p.path) &&
     fs.existsSync(p.path) &&
     (fs.existsSync(path.join(p.path, '.great_cto', 'PROJECT.md')) ||
      fs.existsSync(path.join(p.path, '.great_cto', 'tasks.md')) ||
@@ -457,6 +487,7 @@ export {
   getChangeTier,
   autoRegisterProject,
   getRegistryDegradation,
+  getDiscoveryScope,
   discoverProjects,
   listProjects,
   resolveProjectCwd,

package/board/packages/board/lib/routes.mjs

@@ -598,7 +598,8 @@ async function dispatch(req, res, url, cwd) {
       let transitions = null;
       try {
         const { pipelineMapFor } = await import('../../../scripts/lib/pipeline-health.mjs');
-        const { parsePipelineToml } = await import('../../../scripts/hooks/pipeline-dispatcher.mjs');
+        // Use the pure parser, not the native hook that merely reexports it.
+        const { parsePipelineToml } = await import('../../../scripts/lib/pipeline-toml.mjs');
         const map = pipelineMapFor(cwd);
         if (map.path) transitions = parsePipelineToml(fs.readFileSync(map.path, 'utf8'));
       } catch { transitions = null; }

package/board/packages/board/push-adapter.mjs

@@ -12,6 +12,7 @@ import http from 'node:http';
 import fs from 'node:fs';
 import path from 'node:path';
 import { URL } from 'node:url';
+import { readPrivateState, writePrivateState } from '../cli/src/private-state.mjs';
 
 // ── Helpers: base64url ────────────────────────────────────────────────────
 
@@ -74,7 +75,7 @@ export function getVapidKeys(keyPath) {
   // Load existing keys from disk
   if (fs.existsSync(keyPath)) {
     try {
-      const stored = JSON.parse(fs.readFileSync(keyPath, 'utf8'));
+      const stored = JSON.parse(readPrivateState(keyPath));
       if (stored.publicKey && stored.privateKey) return stored;
     } catch { /* regenerate if corrupt */ }
   }
@@ -93,8 +94,7 @@ export function getVapidKeys(keyPath) {
   const keys = { publicKey, privateKey: jwk };
 
   // Persist — best effort
-  try { fs.mkdirSync(path.dirname(keyPath), { recursive: true }); } catch { /* ignore */ }
-  try { fs.writeFileSync(keyPath, JSON.stringify(keys, null, 2)); } catch { /* best-effort */ }
+  writePrivateState(keyPath, JSON.stringify(keys, null, 2));
 
   return keys;
 }

package/board/packages/cli/src/private-state.mjs

@@ -0,0 +1,43 @@
+import fs from 'node:fs';
+import { dirname } from 'node:path';
+
+/** @param {string} file */
+function regularOrAbsent(file) {
+  try {
+    const stat = fs.lstatSync(file);
+    if (stat.isSymbolicLink() || !stat.isFile()) throw new Error('private state must be a regular file, not a symlink');
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+}
+
+/** Tighten existing secrets as well as new files; never follow file symlinks.
+ * @param {string} file
+ * @returns {string}
+ */
+export function readPrivateState(file) {
+  regularOrAbsent(file);
+  const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+  try {
+    if (!fs.fstatSync(fd).isFile()) throw new Error('private state is not a regular file');
+    const stat = fs.fstatSync(fd);
+    if ((stat.mode & 0o777) !== 0o600) fs.fchmodSync(fd, 0o600);
+    return fs.readFileSync(fd, 'utf8');
+  } finally { fs.closeSync(fd); }
+}
+
+/** @param {string} file @param {string} text @param {boolean} [append] */
+export function writePrivateState(file, text, append = false) {
+  regularOrAbsent(file);
+  fs.mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+  const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_NOFOLLOW
+    | fs.constants.O_NONBLOCK | (append ? fs.constants.O_APPEND : 0);
+  const fd = fs.openSync(file, flags, 0o600);
+  try {
+    if (!fs.fstatSync(fd).isFile()) throw new Error('private state is not a regular file');
+    fs.fchmodSync(fd, 0o600);
+    // Refuse permission failures before modifying existing bytes.
+    if (!append) fs.ftruncateSync(fd, 0);
+    fs.writeFileSync(fd, text);
+  } finally { fs.closeSync(fd); }
+}

package/board/packages/cli/src/state-home.mjs

@@ -0,0 +1,15 @@
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+
+/** One resolver for CLI and board, independent of their working directories.
+ * @param {Record<string, string | undefined>} [env]
+ * @param {string} [home]
+ */
+export function stateHome(env = process.env, home = homedir()) {
+  const configured = env.GREAT_CTO_HOME;
+  if (configured === undefined || configured === '') return join(home, '.great_cto');
+  if (typeof configured !== 'string' || !isAbsolute(configured) || configured.includes('\0')) {
+    throw new Error('GREAT_CTO_HOME must be an absolute dedicated state directory');
+  }
+  return resolve(configured);
+}

package/board/scripts/codex-pipeline.mjs

@@ -2,11 +2,13 @@
 import { mkdirSync, readFileSync, writeFileSync, renameSync, rmdirSync, realpathSync } from 'node:fs';
 import { join, resolve, relative, sep, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { newRun, runStage, runParallelWave, parallelPair, approve, recover, cancel } from './lib/codex-pipeline.mjs';
+import { newRun, runStage, runParallelWave, parallelPair, approve, reject, recover, cancel } from './lib/codex-pipeline.mjs';
 import { approveRelease } from './lib/codex-release.mjs';
 import { codexRunStore, listCodexRuns, codexHostDoctor } from './lib/codex-host-state.mjs';
 import { beginWork, finishWork, acquireProjectLease, readWorkTask, linkWork, observeWorkRun, controlledDecisions } from './lib/work-tasks.mjs';
 import { detectClaude } from './lib/claude-exec.mjs';
+import { dispatchEvidenceSummary } from './lib/controller-dispatch-evidence.mjs';
+import { readBenchmarkRegistration, bindBenchmarkTrial } from './lib/adaptive-benchmark-collector.mjs';
 
 // State is outside the worker workspace. A per-run exclusive lock covers the entire subprocess lifetime.
 const args = process.argv.slice(2);
@@ -81,11 +83,31 @@ try {
       if (rel !== '..' && !rel.startsWith(`..${sep}`)) throw Error('release policy must be operator-owned outside the target workspace');
       releasePolicy = JSON.parse(readFileSync(policyPath, 'utf8'));
     }
-    state = newRun({ root, prompt: value('--prompt'), checkPolicy, releasePolicy,
+    let gatePolicy = null;
+    if (args.includes('--gate-policy')) {
+      if (!value('--gate-policy')) throw Error('--gate-policy requires an operator-owned policy file');
+      const policyPath = realpathSync(value('--gate-policy'));
+      const rel = relative(root, policyPath);
+      if (rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`))) throw Error('gate policy must be operator-owned outside the target workspace');
+      gatePolicy = JSON.parse(readFileSync(policyPath, 'utf8'));
+    }
+    let specialistPolicy = null;
+    if (args.includes('--specialist-policy')) {
+      if (!value('--specialist-policy')) throw Error('--specialist-policy requires an operator-owned policy file');
+      const policyPath = realpathSync(value('--specialist-policy'));
+      const rel = relative(root, policyPath);
+      if (rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`))) throw Error('specialist policy must be operator-owned outside the target workspace');
+      specialistPolicy = JSON.parse(readFileSync(policyPath, 'utf8'));
+    }
+    state = newRun({ root, prompt: value('--prompt'), checkPolicy, releasePolicy, specialistPolicy,
       allowed, intent, entry: intent === 'research' ? 'project-auditor' : value('--entry') || 'product-owner',
-      maxAttempts, hostRoutes });
+      maxAttempts, hostRoutes, gatePolicy });
     state.taskId = taskId || work.task.taskId;
     state.acceptance = acceptance;
+    if (args.includes('--benchmark-trial')) {
+      if (!value('--benchmark-trial')) throw Error('--benchmark-trial requires an operator-owned trial registration');
+      bindBenchmarkTrial(state, readBenchmarkRegistration(root, value('--benchmark-trial')));
+    }
     linkWork(state.taskId, 'runs', state.id, { root, host: 'codex' });
     save(state);
   } else {
@@ -100,7 +122,7 @@ try {
       } else projectLease = acquireProjectLease(state.root, { reuseToken: inheritedLease });
     }
   }
-  if (!['start', 'resume', 'status', 'approve', 'approve-release', 'recover', 'cancel', 'approve-task'].includes(command)) throw Error('expected start, resume, status, approve, approve-release, recover, cancel, list or doctor');
+  if (!['start', 'resume', 'status', 'approve', 'reject', 'approve-release', 'recover', 'cancel', 'approve-task'].includes(command)) throw Error('expected start, resume, status, approve, reject, approve-release, recover, cancel, list or doctor');
   if (command !== 'status') {
     const lock = join(store, `${state.id}.lock`);
     mkdirSync(lock); locked = lock;
@@ -115,6 +137,7 @@ try {
       if (decision.kind === 'release') approveRelease(state, state.release.token); else approve(state, state.pending.token);
       save(state);
     } else if (command === 'approve') { approve(state, value('--token')); save(state); }
+    else if (command === 'reject') { reject(state, value('--token'), value('--reason')); save(state); }
     else if (command === 'approve-release') { approveRelease(state, value('--token')); save(state); }
     else if (command === 'recover') { recover(state); save(state); }
     else if (command === 'cancel') { cancel(state); save(state); }
@@ -126,10 +149,16 @@ try {
     }
   }
   console.log(JSON.stringify({ id: state.id, status: state.status, reason: state.reason,
+    controllerDispatch: dispatchEvidenceSummary(state),
     release: state.release ? { status: state.release.status, token: state.release.token, adapter: state.release.adapter,
       artifactDigest: state.release.artifactDigest, target: state.release.target, path: state.release.path, url: state.release.url,
       activation: state.release.activation, rollback: state.release.rollback } : null,
-    pending: state.pending, queue: state.queue, hostRoutes: state.hostRoutes || {}, wave: state.wave ? {
+    pending: state.pending, queue: state.queue, specialistPreparation: state.specialistPreparation ? {
+      roles: state.specialistPreparation.roles, status: state.specialistPreparation.status,
+      fingerprint: state.specialistPreparation.fingerprint, reusablePass: false } : null,
+    specialistReview: state.specialistReview ? {
+      roles: state.specialistReview.roles, fingerprint: state.specialistReview.fingerprint, reusablePass: false } : null,
+    hostRoutes: state.hostRoutes || {}, wave: state.wave ? {
       id: state.wave.id, roles: state.wave.roles, hosts: state.wave.hosts, status: state.wave.status } : null,
     rolesCompleted: Object.keys(state.results), stateFile: join(store, `${state.id}.json`) }, null, 2));
   process.exitCode = ['blocked', 'manual-action', 'join-wait'].includes(state.status) ? 2 : 0;