great-cto 3.70.0 → 3.71.1

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

@@ -0,0 +1,157 @@
+/** Host observations are metadata, never controller approval or execution authority. */
+import { createHash } from 'node:crypto';
+
+const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const safeId = value => typeof value === 'string' && /^[a-zA-Z0-9_.:-]{1,160}$/.test(value) ? value : null;
+const uuid = value => typeof value === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+const version = value => typeof value === 'string' && /^\d{1,5}(?:\.\d{1,5}){0,3}(?:[-+][a-zA-Z0-9.-]{1,32})?$/.test(value) ? value : null;
+const hosts = new Set(['codex', 'claude-code']);
+const modes = new Set(['controlled', 'native']);
+const timestamp = value => typeof value === 'string' && value.length <= 40 && Number.isFinite(Date.parse(value)) ? new Date(value).toISOString() : null;
+
+/** Supported event families do not attest that a particular run was fully observed. */
+export function hostGraphCapabilities({ host, mode, sourceVersion } = {}) {
+  const known = false; // Version compatibility is established by the collector's capability audit, never semver syntax alone.
+  return { lifecycle: known ? 'supported' : 'unknown', tools: known ? 'supported' : 'unknown',
+    parentChild: known ? 'supported' : 'unknown', verification: 'unsupported', gates: 'unsupported', artifacts: 'unsupported' };
+}
+
+function toolClass(name) {
+  if (typeof name !== 'string') return 'other';
+  if (/^(?:mcp__|mcp:)/.test(name)) return 'mcp';
+  const classes = { Bash: 'shell', shell: 'shell', command_execution: 'shell', Read: 'read', read_file: 'read',
+    Edit: 'write', Write: 'write', MultiEdit: 'write', apply_patch: 'write', file_change: 'write',
+    Glob: 'search', Grep: 'search', WebSearch: 'search', web_search: 'search',
+    Agent: 'agent', Task: 'agent', collab_tool_call: 'agent', mcp_tool_call: 'mcp' };
+  return Object.hasOwn(classes, name) ? classes[name] : 'other';
+}
+const opaque = value => typeof value === 'string' && value.length > 0 && value.length <= 512 ? hash(value) : null;
+const record = value => value && typeof value === 'object' && !Array.isArray(value);
+export function codexNativeTurnIdentity(raw) {
+  if (!['UserPromptSubmit', 'Stop'].includes(raw?.hook_event_name)) return null;
+  return safeId(raw.event_id) || safeId(raw.turn_id);
+}
+const codexTrackedItems = new Set(['command_execution', 'file_change', 'mcp_tool_call', 'web_search', 'collab_tool_call']);
+function ignoredClaudeBlock(block) {
+  if (!record(block)) return false;
+  return (block.type === 'text' && typeof block.text === 'string')
+    || (block.type === 'thinking' && typeof block.thinking === 'string')
+    || (block.type === 'redacted_thinking' && typeof block.data === 'string');
+}
+function ignoredPayload(host, mode, raw, sourceVersion) {
+  if (host === 'codex' && !(mode === 'native' && raw.hook_event_name)) {
+    if (!['item.started', 'item.updated', 'item.completed'].includes(raw.type) || !record(raw.item) || !opaque(raw.item.id)) return false;
+    const item = raw.item;
+    if (raw.type === 'item.updated' && codexTrackedItems.has(item.type)) return true;
+    if (['agent_message', 'reasoning'].includes(item.type)) return typeof item.text === 'string';
+    return item.type === 'todo_list' && Array.isArray(item.items)
+      && item.items.every(value => record(value) && typeof value.text === 'string' && typeof value.completed === 'boolean');
+  }
+  if (host !== 'claude-code') return false;
+  // Audited 2.1.292 schema: this push invalidates rendered UI trees only.
+  // Keep future versions, instance variants and extra structural fields visible
+  // as gaps until independently classified; subtype alone is not evidence.
+  if (mode === 'controlled' && sourceVersion === '2.1.292' && raw.type === 'system' && raw.subtype === 'ui_invalidate'
+    && raw.event === 'ui.render' && uuid(raw.uuid) && uuid(raw.session_id)
+    && Object.keys(raw).length === 5
+    && Object.keys(raw).every(key => ['type', 'subtype', 'event', 'uuid', 'session_id'].includes(key))) return true;
+  if (['assistant', 'user'].includes(raw.type)) {
+    const content = raw.message?.content;
+    return Array.isArray(content) && content.length > 0 && content.every(ignoredClaudeBlock);
+  }
+  // These advisory frames carry no graph lifecycle or causal relationship.
+  if (raw.type === 'system' && raw.subtype === 'status') return raw.status === null || raw.status === 'compacting';
+  if (raw.type === 'system' && raw.subtype === 'compact_boundary') return record(raw.compact_metadata)
+    && ['manual', 'auto'].includes(raw.compact_metadata.trigger) && Number.isSafeInteger(raw.compact_metadata.pre_tokens) && raw.compact_metadata.pre_tokens >= 0;
+  return raw.type === 'rate_limit_event' && record(raw.rate_limit_info)
+    && ['allowed', 'allowed_warning', 'rejected'].includes(raw.rate_limit_info.status);
+}
+function codexEvent(raw) {
+  if (raw.type === 'thread.started') return { kind: 'session', phase: 'started', source: raw.thread_id };
+  if (raw.type === 'turn.started') return { kind: 'turn', phase: 'started' };
+  if (raw.type === 'turn.completed') return { kind: 'turn', phase: 'completed', outcome: 'succeeded' };
+  if (raw.type === 'turn.failed') return { kind: 'turn', phase: 'failed', outcome: 'failed' };
+  if (raw.type === 'error') return { kind: 'error', phase: 'failed', outcome: 'failed' };
+  if (!['item.started', 'item.completed'].includes(raw.type) || !raw.item || typeof raw.item !== 'object') return null;
+  const item = raw.item;
+  if (!codexTrackedItems.has(item.type)) return null;
+  const status = String(item.status || '').toLowerCase();
+  const started = raw.type === 'item.started';
+  const outcome = started ? 'unknown' : ['failed', 'errored'].includes(status) || (Number.isInteger(item.exit_code) && item.exit_code !== 0) ? 'failed'
+    : ['declined', 'cancelled', 'canceled', 'interrupted'].includes(status) ? 'cancelled' : status === 'completed' ? 'succeeded' : 'unknown';
+  return { kind: item.type === 'collab_tool_call' ? 'child' : 'tool', phase: started ? 'started' : outcome === 'failed' ? 'failed' : 'completed',
+    outcome, source: item.id, toolClass: toolClass(item.type) };
+}
+function claudeEvent(raw) {
+  const hook = raw.hook_event_name;
+  const hooks = {
+    SessionStart: { kind: 'session', phase: 'started' }, SessionEnd: { kind: 'session', phase: 'stopped' },
+    UserPromptSubmit: { kind: 'turn', phase: 'started' }, Stop: { kind: 'turn', phase: 'stopped' },
+    PreToolUse: { kind: 'tool', phase: 'started' }, PostToolUse: { kind: 'tool', phase: 'completed', outcome: 'succeeded' },
+    PostToolUseFailure: { kind: 'tool', phase: 'failed', outcome: 'failed' },
+    SubagentStart: { kind: 'child', phase: 'started' }, SubagentStop: { kind: 'child', phase: 'stopped' },
+  };
+  if (Object.hasOwn(hooks, hook || '')) return { ...hooks[hook], source: raw.tool_use_id || raw.agent_id || raw.event_id,
+    toolClass: hooks[hook].kind === 'tool' ? toolClass(raw.tool_name) : hooks[hook].kind === 'child' ? 'agent' : null };
+  if (raw.type === 'system' && raw.subtype === 'init') return { kind: 'session', phase: 'started', source: raw.session_id };
+  if (raw.type === 'result') return { kind: 'turn', phase: raw.is_error === true ? 'failed' : 'completed',
+    outcome: raw.is_error === true ? 'failed' : raw.is_error === false || raw.subtype === 'success' ? 'succeeded' : 'unknown', source: raw.uuid };
+  if (!['assistant', 'user'].includes(raw.type)) return null;
+  const content = raw.message?.content;
+  if (!Array.isArray(content) || content.length !== 1 || !record(content[0])) return null;
+  const b = content[0];
+  if (b.type === 'tool_use' ? !opaque(b.id) || typeof b.name !== 'string' || !b.name.length
+    : b.type === 'tool_result' ? !opaque(b.tool_use_id) || (b.is_error !== undefined && typeof b.is_error !== 'boolean') : true) return null;
+  return b.type === 'tool_use' ? { kind: 'tool', phase: 'started', source: b.id, toolClass: toolClass(b.name) }
+    : { kind: 'tool', phase: b.is_error === true ? 'failed' : 'completed', outcome: b.is_error === true ? 'failed' : b.is_error === false ? 'succeeded' : 'unknown', source: b.tool_use_id, toolClass: 'other' };
+}
+
+/** Bindings come from the operator-owned collector, not fields inside the host payload. */
+export function normalizeHostEvent({ host, mode, sourceVersion, event: raw, binding } = {}) {
+  const capabilities = hostGraphCapabilities({ host, mode, sourceVersion });
+  const rejected = reason => ({ event: null, diagnostics: [reason], capabilities });
+  if (!hosts.has(host) || !modes.has(mode)) return rejected('unsupported-host-or-mode');
+  if (!binding || !safeId(binding.projectId) || !safeId(binding.runId) || !safeId(binding.sessionId)
+    || (binding.attemptId != null && !safeId(binding.attemptId))) return rejected('invalid-trusted-binding');
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return rejected('invalid-event');
+  if (ignoredPayload(host, mode, raw, sourceVersion)) return { event: null, diagnostics: [], capabilities };
+  const hookShape = mode === 'native' && typeof raw.hook_event_name === 'string';
+  const parsed = host === 'codex' && !hookShape ? codexEvent(raw) : claudeEvent(raw);
+  if (!parsed) return rejected('unsupported-event-shape');
+  if (host === 'codex' && hookShape) {
+    // Codex PostToolUse also fires for failed calls; output content is not a status.
+    if (raw.hook_event_name === 'PostToolUse') parsed.outcome = 'unknown';
+    if (['UserPromptSubmit', 'Stop'].includes(raw.hook_event_name)) parsed.source = codexNativeTurnIdentity(raw);
+  }
+  const parents = binding.parentIds ?? [];
+  if (!Array.isArray(parents) || parents.length > 16 || parents.some(p => !safeId(p))) return rejected('invalid-trusted-parents');
+  const diagnostics = [];
+  if (parsed.kind === 'child' && !parents.length) diagnostics.push('missing-explicit-parent');
+  const sequence = Number.isSafeInteger(binding.sequence) && binding.sequence >= 0 ? binding.sequence : null;
+  const rawSourceId = binding.sourceEventId ?? parsed.source ?? binding.turnId ?? null;
+  const sourceEventId = opaque(rawSourceId);
+  if (rawSourceId != null && !sourceEventId) diagnostics.push('missing-source-event-identity');
+  if (!sourceEventId && sequence === null && (['tool', 'child'].includes(parsed.kind) || (parsed.kind === 'turn' && binding.attemptId == null))) diagnostics.push('missing-source-event-identity');
+  if (!version(sourceVersion)) diagnostics.push('source-version-unverified');
+  const event = { schemaVersion: 1, projectId: binding.projectId, runId: binding.runId, sessionId: binding.sessionId,
+    attemptId: binding.attemptId ?? null, host, mode, sourceVersion: version(sourceVersion), sourceEventId, sequence,
+    kind: parsed.kind, phase: parsed.phase, outcome: parsed.outcome || 'unknown', parentIds: [...new Set(parents)],
+    occurredAt: timestamp(raw.timestamp ?? raw.at), toolClass: parsed.toolClass ?? null,
+    callId: ['tool', 'child'].includes(parsed.kind) ? opaque(parsed.source ?? binding.sourceEventId ?? null) : null };
+  // Collector wall clock is excluded: replaying an identical source event is idempotent.
+  return { event: { ...event, id: hash(event), observedAt: new Date().toISOString() }, diagnostics: [...new Set(diagnostics)], capabilities };
+}
+
+/** A streamed Claude message may carry several independent tool blocks. */
+export function normalizeHostEvents(input = {}) {
+  const content = input.event?.message?.content;
+  if (input.host !== 'claude-code' || !['assistant', 'user'].includes(input.event?.type) || !Array.isArray(content)) {
+    const result = normalizeHostEvent(input);
+    return { events: result.event ? [result.event] : [], diagnostics: result.diagnostics, capabilities: result.capabilities };
+  }
+  if (!content.length) return { events: [], diagnostics: ['unsupported-event-shape'], capabilities: hostGraphCapabilities(input) };
+  const results = content.map(block => normalizeHostEvent({ ...input,
+    event: { ...input.event, message: { content: [block] } } }));
+  return { events: results.flatMap(r => r.event ? [r.event] : []),
+    diagnostics: [...new Set(results.flatMap(r => r.diagnostics))], capabilities: hostGraphCapabilities(input) };
+}

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/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)) {