great-cto 3.70.1 → 3.72.0

package/board/scripts/lib/host-graph-journal.mjs

@@ -0,0 +1,210 @@
+/** Private observations only. This journal cannot dispatch, approve or verify work. */
+import { createHash } from 'node:crypto';
+import { constants, closeSync, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, writeSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+
+export const HOST_GRAPH_LIMITS = Object.freeze({ events: 4096, bytes: 4 * 1024 * 1024, eventBytes: 4096, page: 200 });
+export const hostGraphStore = () => process.env.GREAT_CTO_HOST_GRAPHS_DIR || join(homedir(), '.great_cto', 'host-graphs');
+const hash = value => createHash('sha256').update(value).digest('hex');
+const digest = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const identity = value => typeof value === 'string' && /^[a-zA-Z0-9_.:-]{1,160}$/.test(value);
+const hosts = new Set(['codex', 'claude-code']), modes = new Set(['controlled', 'native']);
+const kinds = new Set(['session', 'turn', 'tool', 'child', 'error']);
+const phases = new Set(['started', 'completed', 'failed', 'stopped', 'unknown']);
+const outcomes = new Set(['unknown', 'succeeded', 'failed', 'cancelled']);
+const tools = new Set(['shell', 'read', 'write', 'search', 'mcp', 'agent', 'other']);
+export const HOST_GRAPH_DIAGNOSTICS = Object.freeze(['unsupported-host-or-mode', 'invalid-trusted-binding', 'invalid-event', 'unsupported-event-shape', 'invalid-trusted-parents', 'missing-explicit-parent', 'missing-source-event-identity', 'source-version-unverified', 'observer-listener-failure', 'observer-transport-failure']);
+const diagnosticCodes = new Set(HOST_GRAPH_DIAGNOSTICS);
+const date = value => typeof value === 'string' && value.length <= 40 && Number.isFinite(Date.parse(value));
+const safeVersion = value => value === null || value === undefined || (typeof value === 'string' && /^\d{1,5}(?:\.\d{1,5}){0,3}(?:[-+][0-9A-Za-z.-]{1,32})?$/.test(value) && value.length <= 80);
+
+function bindingIdentity(binding) {
+  if (!binding || typeof binding.root !== 'string' || !identity(binding.runId) || !identity(binding.sessionId)
+    || (binding.attemptId != null && !identity(binding.attemptId)) || (binding.host != null && !hosts.has(binding.host))) throw Error('invalid journal binding');
+  const root = realpathSync(binding.root), projectId = 'project:' + hash(root);
+  if (binding.projectId !== projectId) throw Error('journal project binding does not match root');
+  // A journal spans retries in one session, while attempts remain event-specific.
+  return { root, projectId, runId: binding.runId, sessionId: binding.sessionId, host: binding.host ?? null,
+    key: hash(JSON.stringify([projectId, binding.runId, binding.sessionId, ...(binding.host ? [binding.host] : [])])) };
+}
+function secureAncestors(path) {
+  const parents = [];
+  for (let cursor = resolve(path); ; cursor = dirname(cursor)) {
+    parents.push(cursor); if (dirname(cursor) === cursor) break;
+  }
+  for (const parent of parents.reverse()) {
+    try { if (lstatSync(parent).isSymbolicLink()) throw Error('journal path cannot contain symlinks'); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+}
+function context(binding, store, create = false) {
+  const bound = bindingIdentity(binding), location = resolve(store);
+  secureAncestors(location);
+  const rel = relative(bound.root, location);
+  if (!rel || (rel !== '..' && !rel.startsWith('..' + sep) && !isAbsolute(rel))) throw Error('journal must be outside the worker project');
+  if (create) mkdirSync(location, { recursive: true, mode: 0o700 });
+  if (existsSync(location)) {
+    const info = lstatSync(location);
+    if (!info.isDirectory() || (info.mode & 0o077) || (typeof process.getuid === 'function' && info.uid !== process.getuid())) throw Error('journal store must be owner-only 0700');
+  }
+  return { ...bound, store: location, file: join(location, bound.key + '.jsonl') };
+}
+function normalize(event, binding, expected) {
+  if (!event || event.schemaVersion !== 1 || !digest(event.id) || (event.sourceEventId != null && !digest(event.sourceEventId))
+    || !hosts.has(event.host) || (expected.host != null && event.host !== expected.host) || !modes.has(event.mode) || !kinds.has(event.kind) || !phases.has(event.phase)
+    || !outcomes.has(event.outcome) || (event.callId != null && !digest(event.callId)) || event.sessionId !== expected.sessionId
+    || (event.projectId != null && event.projectId !== expected.projectId) || (event.runId != null && event.runId !== expected.runId)
+    || (event.attemptId != null && !identity(event.attemptId)) || (binding.attemptId != null && event.attemptId !== binding.attemptId)
+    || (event.sequence != null && (!Number.isSafeInteger(event.sequence) || event.sequence < 0))
+    || !Array.isArray(event.parentIds) || event.parentIds.length > 16 || event.parentIds.some(id => !digest(id) || id === event.id)
+    || (event.diagnosticCodes != null && (event.kind !== 'error' || !Array.isArray(event.diagnosticCodes) || event.diagnosticCodes.length > 16 || event.diagnosticCodes.some(code => !diagnosticCodes.has(code))))
+    || !date(event.observedAt) || (event.occurredAt != null && !date(event.occurredAt))
+    || (event.toolClass != null && !tools.has(event.toolClass)) || !safeVersion(event.sourceVersion)) throw Error('invalid normalized journal event');
+  const value = { schemaVersion: 1, id: event.id, projectId: expected.projectId, runId: expected.runId,
+    sourceEventId: event.sourceEventId ?? null, sequence: event.sequence ?? null, host: event.host, mode: event.mode,
+    kind: event.kind, phase: event.phase, outcome: event.outcome, callId: event.callId ?? null, sessionId: expected.sessionId,
+    attemptId: event.attemptId ?? null, parentIds: [...new Set(event.parentIds)],
+    occurredAt: event.occurredAt ?? null, observedAt: event.observedAt, toolClass: event.toolClass ?? null,
+    sourceVersion: event.sourceVersion ?? null, ...(event.diagnosticCodes ? { diagnosticCodes: [...new Set(event.diagnosticCodes)] } : {}) };
+  if (Buffer.byteLength(JSON.stringify(value)) > HOST_GRAPH_LIMITS.eventBytes) throw Error('journal event exceeds size limit');
+  return value;
+}
+const comparable = event => { const { observedAt, ...rest } = event; return JSON.stringify(rest); };
+function descriptor(file, flags) {
+  const fd = openSync(file, flags | (constants.O_NOFOLLOW || 0) | (constants.O_NONBLOCK || 0), 0o600);
+  try {
+    const info = fstatSync(fd);
+    if (!info.isFile() || info.nlink !== 1 || (info.mode & 0o077) || (typeof process.getuid === 'function' && info.uid !== process.getuid())) throw Error('journal file must be owner-only 0600 with one link');
+    return { fd, info };
+  } catch (error) { closeSync(fd); throw error; }
+}
+function scan(ctx, binding) {
+  let opened;
+  try { opened = descriptor(ctx.file, constants.O_RDONLY); }
+  catch (error) { if (error.code === 'ENOENT') return { events: [], diagnostics: [], bytes: 0, tail: false, absent: true }; throw error; }
+  try {
+    if (opened.info.size > HOST_GRAPH_LIMITS.bytes) throw Error('journal exceeds byte quota');
+    const raw = readFileSync(opened.fd, 'utf8');
+    const lines = raw.split('\n'), tail = !!lines.at(-1), diagnostics = [], events = [], ids = new Map();
+    if (tail) diagnostics.push('truncated-tail');
+    for (const line of lines) {
+      if (!line) continue;
+      if (Buffer.byteLength(line) > HOST_GRAPH_LIMITS.eventBytes) { diagnostics.push('oversized-record'); continue; }
+      try {
+        const event = normalize(JSON.parse(line), { ...binding, attemptId: null }, ctx);
+        if (ids.has(event.id)) {
+          if (comparable(ids.get(event.id)) !== comparable(event)) diagnostics.push('conflicting-event-id');
+          continue;
+        }
+        if (events.length >= HOST_GRAPH_LIMITS.events) { diagnostics.push('event-quota'); break; }
+        ids.set(event.id, event); events.push(event); diagnostics.push(...(event.diagnosticCodes || []));
+      } catch { diagnostics.push('malformed-record'); }
+    }
+    if (events.length >= HOST_GRAPH_LIMITS.events) diagnostics.push('event-quota');
+    return { events, diagnostics: [...new Set(diagnostics)], bytes: Buffer.byteLength(raw), tail, absent: false };
+  } finally { closeSync(opened.fd); }
+}
+const reasonFor = error => typeof error?.code === 'string' && /^E[A-Z0-9_]+$/.test(error.code)
+  ? `journal I/O unavailable (${error.code})` : String(error?.message || 'journal unavailable').slice(0, 180);
+
+const LOSS_CODES = new Set(['writer-contention', 'event-conflict', 'event-quota', 'byte-quota', 'append-failure', 'writer-cleanup-failure']);
+function lossDiagnostics(ctx) {
+  let opened;
+  try {
+    opened = descriptor(ctx.file + '.incomplete', constants.O_RDONLY);
+    if (opened.info.size > 512) return ['invalid-loss-marker'];
+    const marker = JSON.parse(readFileSync(opened.fd, 'utf8'));
+    return marker?.schemaVersion === 1 && marker.binding === ctx.key && LOSS_CODES.has(marker.code)
+      ? [marker.code] : ['invalid-loss-marker'];
+  } catch (error) { return error.code === 'ENOENT' ? [] : ['invalid-loss-marker']; }
+  finally { if (opened) closeSync(opened.fd); }
+}
+function markIncomplete(ctx, code) {
+  if (!ctx || !LOSS_CODES.has(code)) return false;
+  let fd;
+  try {
+    // One immutable marker is enough to establish loss, even when the journal lock is held.
+    ({ fd } = descriptor(ctx.file + '.incomplete', constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL));
+    const bytes = Buffer.from(JSON.stringify({ schemaVersion: 1, binding: ctx.key, code }) + '\n');
+    let offset = 0;
+    while (offset < bytes.length) offset += writeSync(fd, bytes, offset, bytes.length - offset);
+    fsyncSync(fd);
+    const dir = openSync(ctx.store, constants.O_RDONLY); try { fsyncSync(dir); } finally { closeSync(dir); }
+    return true;
+  } catch (error) { return error.code === 'EEXIST' && lossDiagnostics(ctx).some(c => LOSS_CODES.has(c)); }
+  finally { if (fd !== undefined) closeSync(fd); }
+}
+function lost(ctx, code, reason) {
+  return { state: 'degraded', reason, lossMarker: markIncomplete(ctx, code) ? 'recorded' : 'unavailable' };
+}
+
+/** A lock failure never steals a writer lease or changes execution state. */
+export function appendHostGraphEvent(binding, event, { store = hostGraphStore() } = {}) {
+  let ctx, locked = false;
+  try {
+    ctx = context(binding, store, true);
+    const value = normalize(event, binding, ctx), lock = ctx.file + '.lock';
+    try { mkdirSync(lock, { mode: 0o700 }); locked = true; }
+    catch (error) { if (error.code === 'EEXIST') return lost(ctx, 'writer-contention', 'journal writer is busy; delivery is incomplete'); throw error; }
+    const current = scan(ctx, binding), previous = current.events.find(e => e.id === value.id);
+    if (previous) return comparable(previous) === comparable(value) ? { state: 'duplicate', reason: null }
+      : lost(ctx, 'event-conflict', 'conflicting event identity; history is unchanged');
+    if (current.events.length >= HOST_GRAPH_LIMITS.events) return lost(ctx, 'event-quota', 'journal event quota reached; history is incomplete');
+    const line = (current.tail ? '\n' : '') + JSON.stringify(value) + '\n';
+    if (current.bytes + Buffer.byteLength(line) > HOST_GRAPH_LIMITS.bytes) return lost(ctx, 'byte-quota', 'journal byte quota reached; history is incomplete');
+    const { fd } = descriptor(ctx.file, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT);
+    try {
+      const bytes = Buffer.from(line); let offset = 0;
+      while (offset < bytes.length) offset += writeSync(fd, bytes, offset, bytes.length - offset);
+      fsyncSync(fd);
+    } finally { closeSync(fd); }
+    if (current.absent) { const dir = openSync(ctx.store, constants.O_RDONLY); try { fsyncSync(dir); } finally { closeSync(dir); } }
+    return { state: 'recorded', reason: current.diagnostics.length ? 'earlier journal damage remains visible' : null };
+  } catch (error) { return lost(ctx, 'append-failure', reasonFor(error)); }
+  finally { if (locked) { try { rmSync(ctx.file + '.lock', { recursive: true, force: true }); } catch { markIncomplete(ctx, 'writer-cleanup-failure'); } } }
+}
+function coverage(events, diagnostics, capabilities) {
+  const support = value => value === true || value === 'supported' ? true : value === false || value === 'unsupported' ? false : null;
+  const item = (value, reason) => { const supported = support(value); return { supported, state: supported === false || !events.length ? 'unavailable' : 'partial', reason }; };
+  // Even a terminal event cannot attest that the host delivered every event.
+  return {
+    lifecycle: item(capabilities?.lifecycle ?? null, diagnostics.length ? 'Observation gaps or damage are recorded.' : 'Host delivery completeness is not attested.'),
+    parentChild: item(capabilities?.parentChild ?? null, 'Only explicit parent identities establish relationships.'),
+    tools: item(capabilities?.tools ?? null, 'Tool observations do not establish complete host coverage.'),
+    verification: item(false, 'Verifier authority comes from controller receipts, never host observations.'),
+    gates: item(false, 'Gate authority comes from validated controller decisions, never host observations.'),
+    artifacts: item(false, 'Publication and deployment require separately bound evidence.'),
+  };
+}
+export function readHostGraph(binding, { store = hostGraphStore(), cursor = null, limit = HOST_GRAPH_LIMITS.page, capabilities = null } = {}) {
+  let events = [], diagnostics = [];
+  try {
+    const ctx = context(binding, store), result = scan(ctx, binding); events = result.events; diagnostics = [...result.diagnostics, ...lossDiagnostics(ctx)];
+    let offset = 0;
+    if (cursor != null) {
+      if (typeof cursor !== 'string' || !/^[a-f0-9]{64}:[0-9]{1,5}$/.test(cursor) || cursor.split(':')[0] !== ctx.key) throw Error('invalid journal cursor');
+      offset = Number(cursor.split(':')[1]); if (offset > events.length) throw Error('journal cursor is outside history');
+    }
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > HOST_GRAPH_LIMITS.page) throw Error('invalid journal page limit');
+    const ids = new Set(events.map(e => e.id));
+    if (events.some(e => e.parentIds.some(id => !ids.has(id)))) diagnostics.push('missing-parent');
+    const sequences = new Map();
+    for (const e of events.filter(e => e.sequence != null)) {
+      const source = `${e.host}:${e.attemptId || ''}`, seen = sequences.get(source) || new Set(); seen.add(e.sequence); sequences.set(source, seen);
+    }
+    for (const seen of sequences.values()) {
+      const sorted = [...seen].sort((a, b) => a - b);
+      if (sorted.some((n, i) => i > 0 && n !== sorted[i - 1] + 1)) diagnostics.push('source-sequence-gap');
+    }
+    diagnostics = [...new Set(diagnostics)];
+    const page = events.slice(offset, offset + limit), next = offset + page.length;
+    return { state: events.length ? 'recorded' : 'unavailable', events: page, total: events.length,
+      cursor: next < events.length ? `${ctx.key}:${next}` : null, health: diagnostics.length ? 'degraded' : result.absent ? 'absent' : 'ok',
+      reason: diagnostics.length ? 'Journal observations are incomplete.' : result.absent ? 'No host observation journal is recorded.' : null,
+      diagnostics, coverage: coverage(events, diagnostics, capabilities) };
+  } catch (error) {
+    return { state: 'unavailable', events: [], total: 0, cursor: null, health: 'degraded', reason: reasonFor(error),
+      diagnostics: ['unreadable-journal'], coverage: coverage([], ['unreadable-journal'], capabilities) };
+  }
+}

package/board/scripts/lib/host-graph-observer.mjs

@@ -0,0 +1,61 @@
+/** Local observation only. Never owns execution, gate decisions or native sessions. */
+import { createHash } from 'node:crypto';
+import { normalizeHostEvents } from './host-graph-events.mjs';
+import { appendHostGraphEvent, readHostGraph } from './host-graph-journal.mjs';
+import { projectIdentity } from './work-tasks.mjs';
+
+export function graphBinding({ root, runId, sessionId, attemptId = null, host = null }) {
+  return { root, projectId: projectIdentity(root), runId, sessionId, attemptId, ...(host ? { host } : {}) };
+}
+export function recordHostGraphGap(binding, host, mode, diagnosticCodes, { store } = {}) {
+  const codes = [...new Set(diagnosticCodes)].sort();
+  const id = createHash('sha256').update(JSON.stringify([binding.projectId, binding.runId, binding.sessionId, binding.attemptId, codes])).digest('hex');
+  return appendHostGraphEvent(binding, { schemaVersion: 1, id, host, mode, kind: 'error', phase: 'unknown', outcome: 'unknown',
+    sessionId: binding.sessionId, attemptId: binding.attemptId || null, parentIds: [], observedAt: new Date().toISOString(), diagnosticCodes: codes }, { store });
+}
+export function observeHostGraph({ binding, host, mode, sourceVersion, event, store }) {
+  try {
+    const normalized = normalizeHostEvents({ host, mode, sourceVersion, event, binding });
+    const results = normalized.events.map(e => appendHostGraphEvent(binding, e, { store }));
+    if (normalized.diagnostics.length) {
+      results.push(recordHostGraphGap(binding, host, mode, normalized.diagnostics, { store }));
+    }
+    const degraded = normalized.diagnostics.length || results.some(r => r.state === 'degraded');
+    return { state: degraded ? 'degraded' : results.length ? 'recorded' : 'ignored',
+      recorded: results.filter(r => r.state === 'recorded').length,
+      // Do not forward parser exceptions or source payloads into public state.
+      reason: degraded ? 'Host observations have gaps or unavailable storage.' : null };
+  } catch { return { state: 'degraded', recorded: 0, reason: 'Host observation could not be recorded.' }; }
+}
+
+/** Explicit call identity links start/end; ordering alone never creates an edge. */
+export function projectHostObservations(binding, options = {}) {
+  try {
+    const read = readHostGraph(binding, options), events = read.events || [];
+    const nodes = events.map(e => ({ id: e.id, kind: e.kind, role: e.toolClass || e.kind,
+      host: e.host, sourceVersion: e.sourceVersion || null, phase: e.phase, outcome: e.outcome,
+      status: e.outcome === 'unknown' ? e.phase : e.outcome,
+      at: e.occurredAt || e.observedAt, attemptId: e.attemptId, source: 'host-observation' }));
+    const ids = new Set(nodes.map(n => n.id)), edges = [], starts = new Map(), ends = new Map();
+    const callKey = e => JSON.stringify([e.host, e.sessionId, e.attemptId, e.callId]);
+    for (const e of events) {
+      for (const parent of e.parentIds || []) if (ids.has(parent) && parent !== e.id) edges.push({ from: parent, to: e.id, kind: 'observed-parent' });
+      if (e.callId) { const map = e.phase === 'started' ? starts : ends; const key = callKey(e);
+        map.set(key, map.has(key) ? null : e.id); }
+    }
+    for (const e of events) if (e.callId && e.phase !== 'started' && starts.get(callKey(e)) && ends.get(callKey(e)) === e.id) {
+      const from = starts.get(callKey(e)); if (from !== e.id) edges.push({ from, to: e.id, kind: 'same-call' });
+    }
+    const times = events.map(e => Date.parse(e.observedAt)).filter(Number.isFinite);
+    return { binding: { runId: binding.runId, sessionId: binding.sessionId, host: binding.host || events[0]?.host || null }, state: nodes.length ? 'recorded' : 'unavailable', source: 'host-observation', complete: false,
+      truncated: !!read.cursor, nodes, edges, snapshots: [], diagnostics: (read.diagnostics || []).slice(0, 16),
+      observedInterval: times.length ? { from: new Date(Math.min(...times)).toISOString(), to: new Date(Math.max(...times)).toISOString() } : null, coverage: read.coverage, health: read.health,
+      cursor: read.cursor, total: read.total, reason: read.reason || 'Host observations do not establish controller transitions, delivery completeness or gate approval.' };
+  } catch (error) { return { state: 'unavailable', source: 'host-observation', complete: false, truncated: false,
+    nodes: [], edges: [], snapshots: [], health: 'degraded', reason: typeof error?.code === 'string' && /^E[A-Z0-9_]+$/.test(error.code)
+      ? `Host observation source is unreadable (${error.code}).` : 'Host observation source is unreadable.' }; }
+}
+
+export const bindingDigest = binding => createHash('sha256').update(JSON.stringify([
+  binding.projectId, binding.runId, binding.sessionId,
+])).digest('hex');

package/board/scripts/lib/host-graph-runtime.mjs

@@ -0,0 +1,38 @@
+/** Provider-free CLI surface audit. Help text is not execution or hook-delivery proof. */
+import { spawnSync } from 'node:child_process';
+
+const hosts = new Set(['codex', 'claude-code']);
+const commandOptions = Object.freeze({ encoding: 'utf8', timeout: 10000, maxBuffer: 1024 * 1024, windowsHide: true });
+const hasFlag = (text, flag) => new RegExp(`(?:^|[\\s,\\[|])${flag}(?=[\\s,=\\]|]|$)`).test(text);
+const sourceVersion = result => {
+  const text = String(result?.stdout || result?.stderr || '');
+  return text.match(/\b(\d{1,5}\.\d{1,5}\.\d{1,5}(?:[-+][a-zA-Z0-9.-]{1,32})?)\b/)?.[1] || null;
+};
+function command(run, bin, args) {
+  try { return run(bin, args, { ...commandOptions }); }
+  catch { return { status: null, error: { code: 'AUDIT_COMMAND_FAILED' } }; }
+}
+
+export function auditHostGraphRuntime({ host, bin = host === 'claude-code' ? 'claude' : 'codex', run = spawnSync } = {}) {
+  if (!hosts.has(host)) throw Error('unsupported graph host');
+  const result = { host, sourceVersion: null, state: 'unreadable', controlled: { streamEvents: null },
+    native: { hookEvents: null }, liveAcceptance: 'not-checked' };
+  const version = command(run, bin, ['--version']);
+  if (version?.error || version?.status !== 0) {
+    result.state = version?.error?.code === 'ENOENT' ? 'absent' : 'unreadable';
+    return result;
+  }
+  result.sourceVersion = sourceVersion(version);
+  const help = command(run, bin, host === 'codex' ? ['exec', '--help'] : ['--help']);
+  if (help?.error || help?.status !== 0) return result;
+  const text = String(help.stdout || '');
+  const stream = host === 'codex' ? hasFlag(text, '--json')
+    : hasFlag(text, '--output-format') && /\bstream-json\b/.test(text);
+  result.controlled.streamEvents = stream;
+  result.state = !result.sourceVersion ? 'unreadable' : stream ? 'available' : 'unsupported';
+  return result;
+}
+
+export function auditHostGraphRuntimes({ run = spawnSync, binaries = {} } = {}) {
+  return ['codex', 'claude-code'].map(host => auditHostGraphRuntime({ host, run, bin: binaries[host] || (host === 'codex' ? 'codex' : 'claude') }));
+}

package/board/scripts/work-task.mjs

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 /** Advanced operator contract behind `great-cto task work`; no new daily flow. */
+import { auditHostGraphRuntimes } from './lib/host-graph-runtime.mjs';
 import { resolve } from 'node:path';
+import { readSync } from 'node:fs';
+import { bindNativeGraph, unbindNativeGraph, nativeGraphObservations, observeNativeGraphHook, readNativeGraphPage, enableNativeGraph, disableNativeGraph } from './lib/host-graph-bindings.mjs';
 import { listWorkTasks, readWorkTask } from './lib/work-tasks.mjs';
 import { approveWorkDecision, decisionCapabilities } from './lib/work-decisions.mjs';
 import { applyOutcome, readOutcomeEvidence } from './lib/work-outcomes.mjs';
@@ -8,14 +11,24 @@ import { measureWork, compareWork } from './lib/work-metrics.mjs';
 import { previewPublication, publishPublication } from './lib/work-publication.mjs';
 const args = process.argv.slice(2), action = args.shift();
 try {
-  const supported = new Set(['--dir','--task','--decision','--revision','--operation','--evidence','--baseline','--base','--allow','--approval','--confirm']);
+  const supported = new Set(['--dir','--task','--decision','--revision','--operation','--evidence','--baseline','--base','--allow','--approval','--confirm','--host','--session','--source-version','--cursor','--limit']);
   const opts = {};
   for (let i = 0; i < args.length; i += 2) { if (!supported.has(args[i]) || !args[i+1] || args[i+1].startsWith('--') || opts[args[i]] !== undefined) throw Error('invalid or duplicate operator option'); opts[args[i]] = args[i+1]; }
-  const perAction = { preview: ['--dir','--task','--base','--allow'], publish: ['--dir','--task','--base','--allow','--revision','--approval','--confirm'], metrics: ['--dir','--baseline'], decisions: ['--dir','--task'], approve: ['--dir','--task','--decision','--revision','--operation'], verify: ['--dir','--task','--revision','--operation','--evidence'], complete: ['--dir','--task','--revision','--operation'] };
+  const perAction = { 'graph-audit': [], 'graph-enable': ['--dir','--host','--source-version'], 'graph-disable': ['--dir','--host'], 'graph-bind': ['--dir','--host','--session','--source-version'], 'graph-unbind': ['--dir','--host','--session'], 'graph-read': ['--dir','--host','--session','--cursor','--limit'], 'graph-ingest': ['--dir','--host'], preview: ['--dir','--task','--base','--allow'], publish: ['--dir','--task','--base','--allow','--revision','--approval','--confirm','--host','--session','--source-version'], metrics: ['--dir','--baseline'], decisions: ['--dir','--task'], approve: ['--dir','--task','--decision','--revision','--operation'], verify: ['--dir','--task','--revision','--operation','--evidence'], complete: ['--dir','--task','--revision','--operation'] };
   if (perAction[action] && Object.keys(opts).some(k => !perAction[action].includes(k))) throw Error('option is not supported for this operation');
   const root = resolve(opts['--dir'] || '.'), taskId = opts['--task'];
   let result;
-  if (['preview','publish'].includes(action)) {
+  if (action === 'graph-audit') result = auditHostGraphRuntimes();
+  else if (action === 'graph-enable' || action === 'graph-disable') result = (action === 'graph-enable' ? enableNativeGraph : disableNativeGraph)({ root, host: opts['--host'], sourceVersion: opts['--source-version'] || null });
+  else if (action === 'graph-bind' || action === 'graph-unbind') {
+    result = (action === 'graph-bind' ? bindNativeGraph : unbindNativeGraph)({ root, host: opts['--host'], sessionId: opts['--session'], sourceVersion: opts['--source-version'] || null });
+  } else if (action === 'graph-read') result = opts['--session'] ? readNativeGraphPage({ root, host: opts['--host'], sessionId: opts['--session'], cursor: opts['--cursor'] || null, limit: opts['--limit'] ? Number(opts['--limit']) : 200 }) : nativeGraphObservations(root);
+  else if (action === 'graph-ingest') {
+    const pieces = []; let size = 0, count; const buffer = Buffer.alloc(65536);
+    while ((count = readSync(0, buffer, 0, buffer.length, null)) > 0) { size += count; if (size > 1024 * 1024) throw Error('event input limit'); pieces.push(Buffer.from(buffer.subarray(0, count))); }
+    const raw = Buffer.concat(pieces).toString('utf8');
+    result = observeNativeGraphHook({ root, host: opts['--host'], event: JSON.parse(raw) });
+  } else if (['preview','publish'].includes(action)) {
     const request = { root, taskId, base: opts['--base'] || 'main', allow: opts['--allow'] ? opts['--allow'].split(',') : null };
     result = action === 'preview' ? previewPublication(request) : publishPublication({ ...request,
       expectedRevision: Number(opts['--revision']), approval: opts['--approval'], confirm: opts['--confirm'] });
@@ -26,6 +39,6 @@ try {
   } else if (action === 'decisions') result = decisionCapabilities(readWorkTask(taskId, { root }));
   else if (action === 'approve') result = approveWorkDecision({ root, taskId, decisionId: opts['--decision'], expectedRevision: Number(opts['--revision']), operationId: opts['--operation'] });
   else if (['verify','complete'].includes(action)) result = applyOutcome({ root, taskId, kind: action, expectedRevision: Number(opts['--revision']), operationId: opts['--operation'], evidenceFile: opts['--evidence'] });
-  else throw Error('usage: great-cto task work decisions|approve|verify|complete|metrics|preview|publish --dir PATH [--task UUID --revision N --operation UUID --decision ID --evidence EXTERNAL_FILE --baseline EXTERNAL_FILE --base BRANCH --allow PATHS --approval DIGEST --confirm publish-draft-pr]');
+  else throw Error('usage: great-cto task work decisions|approve|verify|complete|metrics|preview|publish|graph-audit|graph-enable|graph-disable|graph-bind|graph-unbind|graph-ingest|graph-read --dir PATH [--task UUID --revision N --operation UUID --decision ID --evidence EXTERNAL_FILE --baseline EXTERNAL_FILE --base BRANCH --allow PATHS --approval DIGEST --confirm publish-draft-pr]');
   console.log(JSON.stringify(result, null, 2));
 } catch (e) { console.error('work-task: ' + e.message); process.exitCode = 2; }

package/board/shared/pipeline.toml

@@ -303,7 +303,13 @@ next = ["qa-engineer"]
 on = ["DONE", "APPROVED"]
 # DESIGN-{slug}.md — the design + a11y contract
 produces = ["design"]
-next = ["senior-dev"]
+# Into pm, not senior-dev. Both used to lead to senior-dev with no join, and the
+# routing table ran design-advisor alongside pm, so each success opened the edge
+# and senior-dev could start twice. A join cannot fix it: design-advisor runs only
+# for UI features, and pm would wait for a stage that never starts. One path into
+# senior-dev does; pm also plans the UI tasks against the finished contract — the
+# order the Codex controller already runs (design-advisor-prebuild).
+next = ["pm"]
 
 # Audits the Solidity/EVM contracts once they exist (web3, or /review --contracts).
 # PASS hands the audit to security-officer, which reads it before gate:ship; FAIL

package/dist/adapt.js

@@ -325,7 +325,7 @@ dirty-commits: false
 // a path nothing reads is the exact defect this repository exists to delete: it
 // looked more finished than an absent one.
 /**
- * The config.toml fragment for Codex — only the part that runs.
+ * A comment-only Codex notice until verified no-fetch activation is supported.
  *
  * What this used to emit, and why each line is gone:
  *
@@ -340,10 +340,8 @@ dirty-commits: false
  *                              "full 57-agent routing" — we ship seventy, and
  *                              Codex routes none of them
  *
- * An MCP server is the one thing here Codex actually starts, so it is the one
- * thing left. The rest of the fragment is now a statement of what does NOT come
- * with it, taken from `codexInstallPlan` so the two cannot drift apart again —
- * which is precisely how they drifted the first time.
+ * ADR-045 also removes the mutable registry MCP recipe. Keep unsupported
+ * capability notes from codexInstallPlan, without enabling an executable route.
  */
 function getCodexConfigFragment(meta) {
     const plan = codexInstallPlan({ repoDir: "<path-to-great_cto>", codexOnPath: true });
@@ -351,11 +349,11 @@ function getCodexConfigFragment(meta) {
     return `# great_cto ⇄ Codex — generated by great-cto adapt
 # Generated: ${new Date().toISOString().slice(0, 10)}
 #
-# This file contains ONE section, because one section is what Codex runs from a
-# config fragment. Merge it into ~/.codex/config.toml.
+# UNSUPPORTED: native MCP activation has no admitted no-fetch runtime route.
+# This is a comment-only notice. Do not merge an executable MCP recipe or
+# refresh a marketplace from this generated file (ADR-045).
 #
-# For skills, install the plugin instead of copying anything by hand:
-#   ${plan.commands.join("\n#   ")}
+# Existing operator-managed sessions remain separate from verified activation.
 #
 # What does NOT come with either, on codex-cli as it stands today:
 ${notes}
@@ -363,12 +361,6 @@ ${notes}
 # Details, measured rather than inferred:
 # docs/analysis/2026-09-05-codex-phase0-findings.md
 
-[mcp_servers.great_cto]
-command = "npx"
-args = ["great-cto@latest", "mcp"]
-# Generous: npx downloads on first run.
-startup_timeout_sec = 60
-
 # Archetype: ${meta.archetype}
 # Compliance: ${meta.compliance.join(", ") || "none"}
 # Re-run great-cto adapt to refresh.
@@ -459,7 +451,7 @@ conventions. Generated by \`great-cto adapt\`.
                 break;
             }
             case "codex": {
-                // One file, and only the MCP section in it. The previous version also
+                // One comment-only notice. The previous version also
                 // wrote `.codex/hooks.json` and then said "restart Codex to activate
                 // hooks and MCP server" — half of which was true. A user who followed
                 // that line came away believing the gate chain and secret-scan were
@@ -471,11 +463,8 @@ conventions. Generated by \`great-cto adapt\`.
                 // than delete it: it is in the user's project, and it may be theirs now.
                 const stale = join(cwd, ".codex", "hooks.json");
                 if (!dryRun) {
-                    console.log("  ⚠  Codex: merge .codex/great_cto.toml into ~/.codex/config.toml, then restart Codex.");
-                    console.log("     That gives you the MCP server. For the skills, install the plugin:");
-                    for (const c of codexInstallPlan({ repoDir: "<path-to-great_cto>", codexOnPath: true }).commands) {
-                        console.log(`       ${c}`);
-                    }
+                    console.log("  ⚠  Codex: UNSUPPORTED native activation pending an admitted no-fetch runtime route (ADR-045).");
+                    console.log("     .codex/great_cto.toml is comment-only; no active MCP command or registry fallback was generated.");
                     console.log("     Hooks, slash commands and the role agents do NOT carry over to Codex today —");
                     console.log("     see docs/analysis/2026-09-05-codex-phase0-findings.md.");
                     if (existsSync(stale)) {

package/dist/codex.js

@@ -72,7 +72,6 @@ export function codexInstallPlan({ repoDir, codexOnPath }) {
 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(":")) {
@@ -134,18 +133,8 @@ export function upgradeCodexPlugin(opts = {}) {
         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 };
+    return {
+        status: "failed", fromVersion: from, toVersion: from,
+        reason: "verified native Codex activation is unsupported until no-fetch runtime and preactivation/recovery admission are proven; marketplace refresh was not invoked",
+    };
 }

package/dist/companion.js

@@ -1,25 +1,4 @@
-/**
- * Companion plugin installer — superpowers + beads.
- *
- * great_cto requires these two plugins to be present. This module installs
- * them automatically during `great-cto init/install` so users get a working
- * setup in one command without reading the "Requires:" line in the README.
- *
- * Install strategy:
- *   - Clone (depth=1) the latest semver tag from GitHub into
- *     ~/.claude/plugins/cache/local/<name>/<version>/
- *   - Enable <name>@local in ~/.claude/settings.json
- *   - Idempotent — skips if any version is already present in the cache dir
- *   - Best-effort — never fails the parent install; logs a human-friendly
- *     hint if git is unavailable or clone fails
- */
-import { spawnSync, execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { dim, success, log, warn } from "./ui.js";
-import { enablePlugin } from "./settings.js";
-import { semverDescending } from "./semver.js";
+/** Companion metadata is discoverable; installation requires separate artifact admission. */
 export const COMPANION_PLUGINS = [
     {
         name: "superpowers",
@@ -32,107 +11,12 @@ export const COMPANION_PLUGINS = [
         repoUrl: "https://github.com/steveyegge/beads.git",
     },
 ];
-function getPluginCacheDir(name) {
-    return join(homedir(), ".claude", "plugins", "cache", "local", name);
-}
-/** Returns true if any version folder already exists in the cache dir. */
-function isAlreadyInstalled(name) {
-    const base = getPluginCacheDir(name);
-    if (!existsSync(base))
-        return null;
-    try {
-        const versions = readdirSync(base).filter((v) => /\S/.test(v));
-        if (versions.length === 0)
-            return null;
-        // Return the highest version, not filesystem order — matches
-        // upgrade.ts/installer.ts which both sort before picking.
-        return versions.sort(semverDescending)[0];
-    }
-    catch {
-        return null;
-    }
-}
-/** Detect the latest semver tag from a remote repo without cloning. */
-export function detectLatestTag(repoUrl) {
-    try {
-        const out = execFileSync("git", ["ls-remote", "--tags", repoUrl], {
-            encoding: "utf-8",
-            timeout: 15_000,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const tags = out
-            .split("\n")
-            .map((line) => line.match(/refs\/tags\/v?([0-9]+\.[0-9]+\.[0-9]+)(?!\^)/)?.[1])
-            .filter((t) => !!t)
-            .sort(semverDescending);
-        return tags[0] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Install a single companion plugin.
- * Silent no-op if already present. Best-effort on failure.
- */
+/** Third-party snapshots have no publisher admission or managed recovery contract. */
+export const COMPANION_ADMISSION_REQUIRED = "UNSUPPORTED: companion artifact admission and managed activation are not established; no files changed";
+/** Refuse before network, cache inspection, settings enablement or overlay writes. */
 export function installCompanionPlugin(plugin) {
-    const { name, pluginKey, repoUrl } = plugin;
-    // ── already installed? ─────────────────────────────────────────────────
-    const existing = isAlreadyInstalled(name);
-    if (existing) {
-        // Make sure it's enabled in settings even if it was manually placed
-        enablePlugin(pluginKey);
-        return { name, status: "already_present", version: existing };
-    }
-    // ── git available? ─────────────────────────────────────────────────────
-    try {
-        execFileSync("git", ["--version"], { stdio: "ignore", timeout: 5_000 });
-    }
-    catch {
-        const msg = `git not found — install git, then run: npx great-cto install`;
-        warn(`${name}: ${msg}`);
-        return { name, status: "skipped", version: "—", reason: msg };
-    }
-    // ── resolve version ────────────────────────────────────────────────────
-    const tag = detectLatestTag(repoUrl);
-    const version = tag ?? "main";
-    const ref = tag ? `v${tag}` : "main";
-    const destDir = join(getPluginCacheDir(name), version);
-    mkdirSync(getPluginCacheDir(name), { recursive: true });
-    log(dim(`  installing ${name} ${version}…`));
-    // ── clone ──────────────────────────────────────────────────────────────
-    const cloneArgs = tag
-        ? ["clone", "--depth=1", "--branch", ref, repoUrl, destDir]
-        : ["clone", "--depth=1", repoUrl, destDir];
-    const result = spawnSync("git", cloneArgs, {
-        stdio: ["ignore", "pipe", "pipe"],
-        timeout: 60_000,
-    });
-    if (result.status !== 0) {
-        const stderr = (result.stderr?.toString() ?? "").slice(0, 200);
-        const msg = `clone failed: ${stderr}`;
-        warn(`${name}: ${msg}`);
-        warn(`  install manually: claude plugin install github.com/${repoUrl.replace("https://github.com/", "").replace(".git", "")}`);
-        return { name, status: "skipped", version: "—", reason: msg };
-    }
-    // ── enable in settings ─────────────────────────────────────────────────
-    enablePlugin(pluginKey);
-    success(`${name} ${version} installed`);
-    return { name, status: "installed", version };
+    return { name: plugin.name, status: "skipped", version: "—", reason: COMPANION_ADMISSION_REQUIRED };
 }
-/**
- * Install all companion plugins declared in COMPANION_PLUGINS.
- * Returns a summary array. Never throws — best-effort for all.
- */
 export function installAllCompanions() {
-    return COMPANION_PLUGINS.map((plugin) => {
-        try {
-            return installCompanionPlugin(plugin);
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            warn(`${plugin.name}: unexpected error — ${msg}`);
-            return { name: plugin.name, status: "skipped", version: "—", reason: msg };
-        }
-    });
+    return COMPANION_PLUGINS.map(installCompanionPlugin);
 }