great-cto 3.69.0 → 3.70.1

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

@@ -4139,6 +4139,9 @@ let metrics = {};
 let shareState = { enabled: false, url: null };
 let currentTab = 'work';
 window.GctoWork.bind({
+  canvas: true,
+  navigate: canonical => window.GctoAdmin?.navigateWork(canonical),
+  onViewChange: view => window.GctoAdmin?.setWorkView(view),
   project: () => new URLSearchParams(location.search).get('project') || '',
   visible: () => currentTab === 'work' || currentTab === 'history',
   read: url => api(url),
@@ -7815,6 +7818,7 @@ async function switchProject(slug) {
   resetProjectUsage();
   if (currentTab === 'usage') loadUsage();
   if (currentTab === 'skills') loadSkillsInventory();
+  if (window.GctoWork.parseRoute((location.hash || '').replace(/^#\/?/, ''))?.selectedKey) history.replaceState(history.state, '', '#/work');
   window.GctoWork.reset();
   // Optimistic UI clear
   allTasks = [];
@@ -7882,6 +7886,7 @@ function filterTasks(q) {
 function onSearch(q) {
   window.GctoWork.search(q);
   searchQuery = q;
+  if (currentTab === 'work' || currentTab === 'history') return;
   renderKanban(filterTasks(q));
   document.getElementById('topbar-task-count').textContent =
     `${filterTasks(q).length} ${q ? 'MATCH' : 'ISSUES'}`;
@@ -8025,11 +8030,21 @@ async function init() {
     || fromTaskId
     || 'project';
   serverDefaultProject = !urlProject && !(allProjects || []).some(p => p.slug === proj);
+  // Registered default projects get an explicit scope before history entries
+  // are created. Keep the unregistered server-default fallback unqualified.
+  if (!urlProject && !serverDefaultProject) {
+    const scopedURL = new URL(location.href); scopedURL.searchParams.set('project', proj);
+    history.replaceState(history.state, '', scopedURL.toString());
+    const workRoute = (location.hash || '#/work').replace(/^#\/?/, '');
+    if (window.GctoWork.parseRoute(workRoute)) window.GctoWork.navigateRoute(workRoute);
+  }
   currentProject = proj;
   resetProjectUsage();
   if (currentTab === 'usage') loadUsage();
   if (currentTab === 'skills') loadSkillsInventory();
-  window.GctoWork.reset();
+  // Work already reads the URL's project during bind(). Late bootstrap data
+  // must refresh that same scope, not erase an Execution/Evidence selection.
+  window.GctoWork.refresh();
   document.getElementById('project-name').textContent = proj;
   document.getElementById('crumb-project').textContent = proj;
   document.title = `${proj} · great_cto`;
@@ -9430,7 +9445,36 @@ function routeFromHash() {
   }
   return ROUTES[h] ? h : (LEGACY_ROUTES[h] || null);
 }
-addEventListener('hashchange', () => { const r = routeFromHash(); if (r) switchTab(r); });
+let routeReplay = 0, lastRouteReplay = '';
+async function replayBoardRoute() {
+  if (location.href === lastRouteReplay) return;
+  lastRouteReplay = location.href;
+  const ticket = ++routeReplay;
+  let project = new URLSearchParams(location.search).get('project') || '';
+  const expectedHash = location.hash, expectedURL = location.href;
+  if (!project && typeof currentProject !== 'undefined' && currentProject) {
+    // A legacy unqualified history entry means the server default, not the
+    // project whose records happen to be in memory. Clear it before resolving.
+    window.GctoWork.navigateRoute('work');
+    const defaults = await api('/api/work');
+    if (ticket !== routeReplay || location.href !== expectedURL) return;
+    project = defaults?.projectName || '';
+    if (!project || !(allProjects || []).some(item => item.slug === project)) { location.reload(); return; }
+    const scopedURL = new URL(location.href); scopedURL.searchParams.set('project', project);
+    history.replaceState(history.state, '', scopedURL.toString());
+  }
+  if (project && typeof currentProject !== 'undefined' && currentProject && project !== currentProject) {
+    const loading = switchProject(project);
+    history.replaceState(history.state, '', expectedHash || '#/work');
+    await loading;
+    if (ticket !== routeReplay || project !== new URLSearchParams(location.search).get('project')) return;
+    history.replaceState(history.state, '', expectedHash || '#/work');
+  }
+  if (ticket !== routeReplay) return;
+  const r = routeFromHash(); if (r) switchTab(r);
+}
+addEventListener('hashchange', replayBoardRoute);
+addEventListener('popstate', replayBoardRoute);
 addEventListener('DOMContentLoaded', () => { const r = routeFromHash(); if (r && r !== 'work') switchTab(r); });
 
 async function refreshLogs() {

package/board/scripts/codex-pipeline.mjs

@@ -8,6 +8,7 @@ import { codexRunStore, listCodexRuns, codexHostDoctor } from './lib/codex-host-
 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 { projectExecutionTrace } from './lib/execution-trace.mjs';
 import { readBenchmarkRegistration, bindBenchmarkTrial } from './lib/adaptive-benchmark-collector.mjs';
 import { readDomainPolicy } from './lib/domain-admission.mjs';
 
@@ -49,7 +50,11 @@ try {
     console.log(JSON.stringify(result, null, 2)); process.exit(result.state === 'ready' ? 0 : 2);
   }
   if (command === 'list') {
-    console.log(JSON.stringify(listCodexRuns({ root: value('--dir') ? realpathSync(resolve(value('--dir'))) : null, store }), null, 2));
+    const output = JSON.stringify(listCodexRuns({ root: value('--dir') ? realpathSync(resolve(value('--dir'))) : null, store }), null, 2) + '\n';
+    // Piped stdout is asynchronous: exiting before the callback can truncate JSON.
+    await new Promise((resolve, reject) => {
+      process.stdout.write(output, error => error ? reject(error) : resolve());
+    });
     process.exit(0);
   }
   let state;
@@ -163,6 +168,7 @@ try {
   }
   console.log(JSON.stringify({ id: state.id, status: state.status, reason: state.reason,
     controllerDispatch: dispatchEvidenceSummary(state),
+    executionGraph: projectExecutionTrace(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,

package/board/scripts/lib/codex-host-state.mjs

@@ -6,6 +6,7 @@ import { spawnSync } from 'node:child_process';
 import { detectCodex } from './codex-exec.mjs';
 import { detectClaude } from './claude-exec.mjs';
 import { dispatchEvidenceSummary } from './controller-dispatch-evidence.mjs';
+import { projectExecutionTrace } from './execution-trace.mjs';
 
 export const codexRunStore = ({ home = homedir(), env = process.env } = {}) =>
   env.GREAT_CTO_CODEX_RUNS_DIR || join(home, '.great_cto', 'codex-runs');
@@ -21,6 +22,7 @@ export function projectCodexState(state) {
     queue: state.queue || [],
     hostRoutes: state.hostRoutes || {},
     controllerDispatch: dispatchEvidenceSummary(state),
+    executionGraph: projectExecutionTrace(state),
     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 || {}),
     attempts: (state.attempts || []).map(({ id, role, host, number, phase, status, startedAt, finishedAt, invocationId }) =>

package/board/scripts/lib/codex-pipeline.mjs

@@ -20,6 +20,7 @@ import { scopedReviewInput, scopedReviewCandidate, attestScopedReview, completeS
 import { observeControllerCall } from './controller-dispatch-evidence.mjs';
 import { invocationIdentity } from './invocation-identity.mjs';
 import { bindDomainPolicy, domainInvocation } from './domain-admission.mjs';
+import { initializeTrace, recordTrace, traceAttempt, traceKey, traceIncoming, traceSchedule, traceParents, traceGate, traceApproval } from './execution-trace.mjs';
 
 export const PLUGIN_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
 const hash = text => createHash('sha256').update(text).digest('hex');
@@ -279,6 +280,7 @@ export function newRun({ root, prompt, allowed, entry = 'product-owner', pluginR
   if (specialistPolicy) { state.specialistGraph = structuredClone(graph); validateSpecialistPolicy(state, specialistPolicy); }
   state.hostRoutes = validateRoutes(hostRoutes, state.graph);
   if (domainPolicy) state.domainAdmission = bindDomainPolicy(root, domainPolicy);
+  initializeTrace(state);
   return state;
 }
 
@@ -303,6 +305,9 @@ function descendants(state, role) {
 
 function rewind(state, target, feedback) {
   if (!state.graph[target] || target.includes('.') || externalRoles.has(target)) throw Error('invalid repair target');
+  const cause = recordTrace(state, 'rework', { role: target, status: 'rework',
+    parents: [traceKey(state, `result:${feedback?.attemptId}`), traceKey(state, `attempt:${feedback?.attemptId}`),
+      ...traceParents(state, [feedback?.role])], relation: 'retry' });
   const used = (state.attempts || []).filter(a => a.role === target).length;
   if (used >= (state.maxAttempts ?? 1)) {
     state.status = 'blocked'; state.reason = `repair attempt limit reached for ${target}`; return;
@@ -316,13 +321,19 @@ function rewind(state, target, feedback) {
     state.invalidations.at(-1).release = state.release;
     state.release = null;
   }
-  for (const role of affected) delete state.results[role];
+  for (const role of affected) {
+    delete state.results[role];
+    // Retain historical nodes, not invalidated scheduling authority. A queued
+    // partner may never have dispatched and therefore still have old inputs.
+    traceSchedule(state, role, []);
+  }
   state.approvals = state.approvals.filter(a => !affected.has(a.role));
   state.released = state.released.filter(role => !affected.has(role));
   // Replace all affected work, including a not-yet-run join partner. It will be
   // scheduled again by the repaired predecessor, never mixed with old evidence.
   state.queue = [target, ...state.queue.filter(role => !affected.has(role))];
   state.pending = null; state.active = null; state.rework = feedback;
+  traceSchedule(state, target, [cause]);
   state.status = 'ready'; delete state.reason;
   if (state.specialistPolicy && target === 'senior-dev') {
     state.graph = structuredClone(state.specialistImplementationGraph || state.specialistGraph); delete state.specialistReview;
@@ -382,6 +393,10 @@ export function recover(state) {
     state.waveHistory ??= [];
     state.waveHistory.push({ id: wave.id, roles: [...roles], hosts: { ...wave.hosts },
       status: 'blocked', reason: state.reason, receipt: wave.receipt, recoveredAt: new Date().toISOString() });
+    const recovery = recordTrace(state, 'recovery', { status: 'recovered',
+      parents: [traceKey(state, `wave:${wave.id}`), ...roles.map(role => traceKey(state, `dispatch:${wave.attemptIds?.[role]}`))],
+      relation: 'recovery', input: current });
+    for (const role of roles) traceSchedule(state, role, [recovery]);
     state.wave = null; state.status = 'ready'; delete state.reason;
     return;
   }
@@ -396,11 +411,19 @@ export function recover(state) {
   if (!completeReceipt(currentReceipt) || JSON.stringify(currentReceipt) !== JSON.stringify(expected)) throw Error('recovery refused: working tree changed or receipt unavailable');
   if (state.attempts.filter(a => a.role === state.active).length >= (state.maxAttempts ?? 1)) throw Error('recovery attempt limit reached');
   attempt.status = 'recovered'; attempt.recoveredAt = new Date().toISOString();
+  const recovery = recordTrace(state, 'recovery', { role: attempt.role, attemptId: attempt.id, status: 'recovered',
+    parents: [traceKey(state, `failure:${attempt.id}`) || traceKey(state, `result:${attempt.id}`) || traceKey(state, `attempt:${attempt.id}`)], relation: 'recovery', input: currentReceipt });
+  traceSchedule(state, attempt.role, [recovery]);
   state.active = null; state.status = 'ready'; delete state.reason;
 }
 
 export function cancel(state) {
   if (state.status === 'done') throw Error('completed run cannot be cancelled');
+  recordTrace(state, 'cancel', { status: 'cancelled', parents: [
+    state.pending ? traceGate(state) : null,
+    ...(state.attempts || []).filter(a => a.status === 'running').map(a => traceKey(state, `attempt:${a.id}`)),
+    state.wave ? traceKey(state, `wave:${state.wave.id}`) : null,
+  ], relation: 'cancel' });
   state.cancelledAt = new Date().toISOString(); state.status = 'cancelled';
   state.pending = null;
   if (state.release && state.release.status !== 'verified') { state.release.status = 'cancelled'; delete state.release.token; }
@@ -466,9 +489,12 @@ export function advance(state) {
         state.status = 'blocked'; state.reason = 'graph cannot enforce high-risk gate floor'; return;
       }
     }
-    for (const g of declared.filter(g => !applicable.includes(g))) {
+    const skipped = declared.filter(g => !applicable.includes(g));
+    for (const g of skipped) {
       if (state.gatePolicy && !state.gatePolicy.skipped.includes(g)) state.gatePolicy.skipped.push(g);
     }
+    const skippedNode = skipped.length ? recordTrace(state, 'gate', { key: `skipped:${role}:${result.digest}`, role, status: 'skipped',
+      gates: skipped, parents: traceParents(state, [role, ...joined]), relation: 'gate', resultDigest: result.digest }) : null;
     const gates = applicable.filter(gate => !state.approvals.some(a => a.role === role && a.gate === gate && a.result === result.digest));
     if (gates.length) {
       const receipt = treeReceipt(state.root);
@@ -485,14 +511,18 @@ export function advance(state) {
       // Found by walking shared/pipeline.toml end to end; the two-role fixture
       // has no join and could not see it.
       state.pending = { token: randomUUID(), role, gates, result: result.digest, receipt };
+      traceGate(state);
       state.status = 'awaiting-gate'; return;
     }
     state.released.push(role);
+    const transition = recordTrace(state, 'transition', { key: `transition:${role}:${result.digest}`, role, verdict: result.verdict,
+      resultDigest: result.digest, parents: [...traceParents(state, [role, ...joined]), skippedNode], relation: joined.length ? 'join' : 'transition' });
     for (const next of list(rule.next)) {
       if (state.results[next] && state.graph[`${role}.${result.verdict}`]) {
         rewind(state, next, { role, verdict: result.verdict, summary: result.summary }); return;
       }
       if (!state.results[next] && !state.queue.includes(next)) state.queue.push(next);
+      if (!state.results[next]) traceSchedule(state, next, [transition], true);
     }
   }
   try { schedulePreparation(state); }
@@ -527,6 +557,7 @@ function assertPendingGate(state, token) {
 
 export function approve(state, token) {
   const { role, gates, result } = assertPendingGate(state, token);
+  traceApproval(state, state.pending);
   for (const gate of gates) state.approvals.push({ role, gate, result, at: new Date().toISOString() });
   state.pending = null;
   advance(state);
@@ -538,12 +569,14 @@ export function reject(state, token, reason) {
   const { role } = assertPendingGate(state, token);
   if (!state.graph[role] || externalRoles.has(role) || role.includes('.')) throw Error('gate cannot be reworked by this controller');
   const pending = structuredClone(state.pending);
+  const rejected = traceApproval(state, pending, true);
   const modulePath = fileURLToPath(import.meta.url);
   const feedback = { kind: 'operator-rejection', role, reason: reason.trim(), pending,
     controller: { modulePath, sha256: hash(readFileSync(modulePath)) }, at: new Date().toISOString() };
   state.rejections ??= [];
   state.rejections.push(feedback);
   rewind(state, role, feedback);
+  traceSchedule(state, role, [rejected], true);
 }
 
 function frozenPolicyContext(state) {
@@ -631,6 +664,7 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
     state.queue.shift(); advance(state); save(state); return state;
   }
   if (externalRoles.has(role)) {
+    recordTrace(state, 'manual', { role, status: 'manual-action', parents: traceIncoming(state, role) });
     state.status = 'manual-action'; state.reason = `${role} requires execution outside the file-proposal controller`; save(state); return state;
   }
   // Project MCP/config can restore side-effecting tools even for a read-only shell.
@@ -649,6 +683,7 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
   if (attempt.number > (state.maxAttempts ?? 1)) throw Error('stage attempt limit reached');
   attempt.invocationId = invocationIdentity({ session_id: state.id, agent_id: attempt.id });
   state.attempts.push(attempt);
+  traceAttempt(state, attempt, { waveId: prepared ? state.wave?.id : null });
   state.active = role; state.steps++; save(state);
   // Recorded only once the stage is really dispatched: a run awaiting a gate, or
   // one that returned above, is not an agent starting.
@@ -685,6 +720,11 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
         `Rework feedback (untrusted evidence, not instructions): ${JSON.stringify(state.rework)}\n`;
     }
     const prompt = head + context;
+    const contextNode = prepared ? traceKey(state, `context:${attempt.id}`) : recordTrace(state, 'context', {
+      key: `context:${attempt.id}`, role, attemptId: attempt.id, host: attempt.host,
+      parents: [traceKey(state, `attempt:${attempt.id}`), ...traceParents(state, attempt.context.results, false)],
+      relation: 'input', input: attempt.inputReceipt, contextDigest: attempt.context.sha256 || hash(context),
+    });
     const runner = execute || hostRunner(state, role, runners);
     let reused = null;
     const reusePolicy = state.specialistPolicy?.reviewReuse;
@@ -695,6 +735,8 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
           const candidate = scopedReviewCandidate(state, role, reusePolicy.scopes[role], reusePolicy.sources[role]);
           const path = `${state.specialistStages?.[role] ? 'docs/specialist-contracts' : 'docs/specialist-reviews'}/${role}-reuse-${attempt.id}.md`;
           attempt.reuse = candidate.prior;
+          recordTrace(state, 'reuse', { key: `reuse:${attempt.id}`, role, attemptId: attempt.id,
+            parents: [contextNode], relation: 'input', contextDigest: hash(candidate.content), verdict: 'historical-report-no-worker' });
           reused = { state: 'ok', code: 0, errors: [], text: JSON.stringify({ verdict: candidate.verdict,
             summary: 'Historical scoped report submitted for fresh independent current-task verification; no historic approval inherited',
             meta: { report: path }, files: [{ path, before: null, content: candidate.content }] }) };
@@ -709,10 +751,11 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
       const admitted = domainInvocation(state, roleHost(state, role), { prompt }, { contextBytes: attempt.context.bytes });
       if (admitted.evidence) { attempt.domainContext = admitted.evidence; save(state); }
       stageStarted = true; emit(state, { kind: 'agent-start', agent, invocation_id: attempt.invocationId });
-      return observeControllerCall(state, { id: `${attempt.id}:worker`, host: roleHost(state, role), role, kind: 'worker' }, () => runner({ prompt: admitted.options.prompt, cwd: state.root, sandbox: 'read-only', ephemeral: true,
+      return observeControllerCall(state, { id: `${attempt.id}:worker`, attemptId: attempt.id, host: roleHost(state, role), role, kind: 'worker' }, () => runner({ prompt: admitted.options.prompt, cwd: state.root, sandbox: 'read-only', ephemeral: true,
       bin: roleHost(state, role) === 'codex' ? process.env.GREAT_CTO_CODEX_BIN || 'codex' : process.env.GREAT_CTO_CLAUDE_BIN || 'claude',
       invocationId: attempt.invocationId, timeoutMs: 300000, extraArgs: roleHost(state, role) === 'codex' ? workerArgs : [], onEvent: toolListener(state, agent, attempt.invocationId) }), save);
     });
+    const proposalSource = traceKey(state, `dispatch:${attempt.id}`) || traceKey(state, `reuse:${attempt.id}`) || contextNode;
     // Codex can recover its session-index lookup without degrading the worker.
     // Keep the diagnostic in the receipt; every other warning/error blocks.
     const proposal = cleanResponse(response);
@@ -724,6 +767,8 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
     const rule = state.graph[`${role}.${proposal.verdict}`] || state.graph[role];
     if (['FAIL', 'REJECTED'].includes(proposal.verdict) && repairTarget(state, role) !== role) {
       Object.assign(attempt, { status: 'rework', verdict: proposal.verdict, summary: proposal.summary, finishedAt: new Date().toISOString() });
+      recordTrace(state, 'result', { key: `result:${attempt.id}`, role, attemptId: attempt.id, host: attempt.host,
+        status: 'rework', parents: [proposalSource], relation: 'outcome', verdict: proposal.verdict });
       // A negative reviewer verdict cannot write or approve anything. It can
       // only request bounded repair through the controller-owned route.
       rewind(state, repairTarget(state, role), { role, attemptId: attempt.id, verdict: proposal.verdict, summary: proposal.summary });
@@ -780,15 +825,23 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
       attempt.phase = 'checking'; save(state);
       attempt.checks = await checks(state, { safePath });
       if (!['passed', 'failed', 'unverifiable'].includes(attempt.checks?.state)) throw Error('invalid checks evidence');
+      recordTrace(state, 'checks', { key: `checks:${attempt.id}`, role, attemptId: attempt.id, status: attempt.checks.state,
+        parents: [proposalSource], relation: 'checks', input: receipt });
       save(state);
     }
     attempt.phase = 'verifying'; save(state);
     const beforeVerifier = stageReceipt(state, treeReceipt(state.root), 'verifier input');
     if (JSON.stringify(beforeVerifier) !== JSON.stringify(receipt)) throw Error('working tree changed before verification');
+    if (!attempt.checks || attempt.checks.state === 'passed') {
+      recordTrace(state, 'verifier', { key: `verifier:${attempt.id}`, role, attemptId: attempt.id, host: 'codex', status: 'intent',
+        parents: [traceKey(state, `checks:${attempt.id}`) || proposalSource,
+          ...traceParents(state, Object.keys(state.results), false)], relation: 'verification', input: receipt });
+      save(state);
+    }
     let verification = attempt.checks && attempt.checks.state !== 'passed'
       ? { state: attempt.checks.state === 'failed' ? 'rework' : 'unverifiable', findings: [`Required checks ${attempt.checks.state}: ${JSON.stringify(checkSummary(attempt.checks))}`], checks: ['controller executed mandatory checks'] }
       : await withAgentBudget(state, { callId: `${attempt.id}:verifier`, host: 'codex', role: 'codex-verifier' }, () =>
-        observeControllerCall(state, { id: `${attempt.id}:verifier`, host: 'codex', role: 'codex-verifier', kind: 'verifier' },
+        observeControllerCall(state, { id: `${attempt.id}:verifier`, attemptId: attempt.id, host: 'codex', role: 'codex-verifier', kind: 'verifier' },
           () => verify(state, role, proposal, execute || runCodexExec), save));
     if (!['verified', 'rework', 'unverifiable'].includes(verification?.state) || !Array.isArray(verification.findings) ||
         !Array.isArray(verification.checks) || !verification.checks.length) throw Error('invalid or empty verifier evidence');
@@ -799,6 +852,9 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
     }
     state.verification = verification;
     Object.assign(attempt, { verification, receipt, proposalDigest: hash(JSON.stringify(proposal)), finishedAt: new Date().toISOString() });
+    recordTrace(state, 'result', { key: `result:${attempt.id}`, role, attemptId: attempt.id, host: attempt.host, status: verification.state,
+      parents: [traceKey(state, `verifier-call:${attempt.id}`) || traceKey(state, `checks:${attempt.id}`)],
+      relation: 'outcome', input: attempt.inputReceipt, output: receipt, resultDigest: hash(JSON.stringify({ attemptId: attempt.id, proposal })), verdict: proposal.verdict });
     if (verification.state === 'rework') {
       attempt.status = 'rework';
       const feedback = { role, attemptId: attempt.id, findings: verification.findings, checks: verification.checks };
@@ -808,6 +864,8 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
       if (target !== role) {
         rewind(state, target, feedback);
       } else if (attempt.number < (state.maxAttempts ?? 1)) {
+        traceSchedule(state, role, [recordTrace(state, 'rework', { role, attemptId: attempt.id, status: 'rework',
+          parents: [traceKey(state, `result:${attempt.id}`)], relation: 'retry' })]);
         state.status = 'ready'; delete state.reason;
       } else {
         state.status = 'blocked'; state.reason = `verifier rework limit reached for ${role}: ${JSON.stringify(verification.findings)}`;
@@ -838,6 +896,8 @@ export async function runStage(state, { execute = null, runners = { codex: runCo
   } catch (error) {
     Object.assign(attempt, { status: 'blocked', reason: error.message, finishedAt: new Date().toISOString() });
     state.status = 'blocked'; state.reason = error.message;
+    recordTrace(state, 'result', { key: `failure:${attempt.id}`, role, attemptId: attempt.id, host: attempt.host, status: 'blocked',
+      parents: [traceKey(state, `result:${attempt.id}`) || traceKey(state, `verifier-call:${attempt.id}`) || traceKey(state, `verifier:${attempt.id}`) || traceKey(state, `checks:${attempt.id}`) || traceKey(state, `dispatch:${attempt.id}`) || traceKey(state, `reuse:${attempt.id}`) || traceKey(state, `context:${attempt.id}`) || traceKey(state, `attempt:${attempt.id}`)], relation: 'outcome' });
     // Keep active set: a partial write or interrupted process must not be replayed.
     save(state);
   } finally {
@@ -915,6 +975,14 @@ export async function runParallelWave(state, { runners = { codex: runCodexExec,
       hosts: Object.fromEntries(roles.map(role => [role, roleHost(state, role)])), startedAt: new Date().toISOString() };
     const context = inlineContext(state);
     state.wave.context = context;
+    const waveNode = recordTrace(state, 'wave', { key: `wave:${waveId}`, waveId, status: 'intent', input: receipt,
+      parents: roles.flatMap(role => traceIncoming(state, role)), relation: 'wave' });
+    for (const role of roles) {
+      const id = state.wave.attemptIds[role];
+      const attemptNode = traceAttempt(state, { id, role, host: roleHost(state, role), inputReceipt: receipt }, { parents: [waveNode], waveId });
+      recordTrace(state, 'context', { key: `context:${id}`, role, attemptId: id, host: roleHost(state, role), waveId,
+        parents: [attemptNode, ...traceParents(state, context.record.results, false)], relation: 'input', input: receipt, contextDigest: context.record.sha256 });
+    }
     try { save(state); } catch (error) { for (const lease of leases) releaseAgent(state.executionBudget, lease); throw error; }
     const calls = roles.map(async (role, index) => {
       const agent = hostAgent(state, role), started = Date.now();
@@ -927,7 +995,7 @@ export async function runParallelWave(state, { runners = { codex: runCodexExec,
         const admitted = domainInvocation(state, roleHost(state, role), { prompt: workerHead(state, role) + context.text }, { contextBytes: context.record.bytes });
         if (admitted.evidence) { state.wave.domainContexts ??= {}; state.wave.domainContexts[role] = admitted.evidence; save(state); }
         emit(state, { kind: 'agent-start', agent, invocation_id: invocationId }); startedHost = true;
-        const result = await observeControllerCall(state, { id: `${waveId}:${role}`, host: roleHost(state, role), role, kind: 'worker' }, () => runner({ prompt: admitted.options.prompt, cwd: state.root,
+        const result = await observeControllerCall(state, { id: `${waveId}:${role}`, attemptId: state.wave.attemptIds[role], host: roleHost(state, role), role, kind: 'worker' }, () => runner({ prompt: admitted.options.prompt, cwd: state.root,
           sandbox: 'read-only', ephemeral: true, timeoutMs: 300000,
           bin: roleHost(state, role) === 'codex' ? process.env.GREAT_CTO_CODEX_BIN || 'codex' : process.env.GREAT_CTO_CLAUDE_BIN || 'claude',
           invocationId, extraArgs: roleHost(state, role) === 'codex' ? workerArgs : [], onEvent: toolListener(state, agent, invocationId) }), save);

package/board/scripts/lib/codex-release.mjs

@@ -6,6 +6,7 @@ import { validateArtifacts, bundleDigest, digest, artifactPath } from './codex-a
 import { validateCheckPolicy, runChecks } from './codex-checks.mjs';
 import { treeReceipt } from './receipt.mjs';
 import { publishGitHubRelease } from './codex-github-release.mjs';
+import { recordTrace, traceKey, traceIncoming, traceSchedule } from './execution-trace.mjs';
 const ROOT_MARKER = '.great-cto-release-root';
 const ROOT_MARKER_CONTENT = 'great-cto-release-root:v1\n';
 const backendFields = policy => policy.backend === 'local'
@@ -83,11 +84,16 @@ export function prepareRelease(state) {
   const r = state.release;
   r.bindingDigest = digest(JSON.stringify({ id: r.id, target: r.target, policyDigest: r.policyDigest, artifactDigest: r.artifactDigest, receipt: r.receipt }));
   state.status = 'awaiting-release';
+  recordTrace(state, 'gate', { key: `release:${r.id}:gate`, role: 'devops', status: 'pending',
+    parents: traceIncoming(state, 'devops'), relation: 'gate', input: receipt, resultDigest: r.artifactDigest, gates: ['gate:release'] });
 }
 
 export function approveRelease(state, token) {
   const r = assertRelease(state);
   if (state.status !== 'awaiting-release' || r.status !== 'awaiting-approval' || token !== r.token) throw Error('release approval token does not match');
+  const approved = recordTrace(state, 'approval', { key: `release:${r.id}:approval`, role: 'devops', status: 'approved',
+    parents: [traceKey(state, `release:${r.id}:gate`)], relation: 'approval', input: r.receipt, resultDigest: r.artifactDigest, gates: ['gate:release'] });
+  traceSchedule(state, 'devops', [approved]);
   r.approvedAt = new Date().toISOString(); r.status = 'approved'; delete r.token;
   state.status = 'ready';
 }
@@ -113,6 +119,9 @@ function verifyDirectory(path, artifacts) {
 export function recoverRelease(state) {
   const r = assertRelease(state);
   if (!r.approvedAt || !['publishing', 'failed'].includes(r.status)) throw Error('release is not recoverable');
+  const recovery = recordTrace(state, 'recovery', { role: 'devops', status: 'recovered',
+    parents: traceIncoming(state, 'devops'), relation: 'recovery', input: r.receipt, resultDigest: r.artifactDigest });
+  traceSchedule(state, 'devops', [recovery]);
   // Reuse operation ID and candidate; never rebuild or approve a replacement.
   state.status = 'ready'; delete state.reason;
 }
@@ -120,6 +129,7 @@ export function recoverRelease(state) {
 export async function executeRelease(state, { safePath, checks = runChecks, gh, save = () => {} } = {}) {
   const r = assertRelease(state);
   if (!r.approvedAt || !['approved', 'publishing', 'failed', 'verified'].includes(r.status)) throw Error('release was not approved');
+  const publication = recordTrace(state, 'release', { role: 'devops', status: 'intent', parents: traceIncoming(state, 'devops'), relation: 'release', input: r.receipt, resultDigest: r.artifactDigest });
   r.status = 'publishing'; save(state);
   if (r.adapter === 'github-release') {
     try {
@@ -131,8 +141,11 @@ export async function executeRelease(state, { safePath, checks = runChecks, gh,
       }, { safePath }) });
       Object.assign(r, { url: published.url, remoteAssets: published.remoteAssets, smoke: published.smoke,
         publishedAt: r.publishedAt ?? new Date().toISOString(), status: 'verified', verifiedAt: new Date().toISOString() });
-      assertRelease(state); save(state); return r;
+      assertRelease(state);
+      recordTrace(state, 'release', { key: `release:${r.id}:published`, role: 'devops', status: 'published', parents: [publication], relation: 'release', resultDigest: r.artifactDigest });
+      save(state); return r;
     } catch (error) {
+      traceSchedule(state, 'devops', [recordTrace(state, 'release', { role: 'devops', status: 'failed', parents: [publication], relation: 'release', resultDigest: r.artifactDigest })]);
       r.status = 'failed'; state.status = 'blocked'; state.reason = error.message; save(state); throw error;
     }
   }
@@ -160,8 +173,10 @@ export async function executeRelease(state, { safePath, checks = runChecks, gh,
     if (r.smoke?.state !== 'passed' || r.smoke.code !== 0) throw Error('post-release smoke did not pass');
     assertRelease(state);
     r.status = 'verified'; r.verifiedAt = new Date().toISOString();
+    recordTrace(state, 'release', { key: `release:${r.id}:published`, role: 'devops', status: 'published', parents: [publication], relation: 'release', resultDigest: r.artifactDigest });
     save(state); return r;
   } catch (error) {
+    traceSchedule(state, 'devops', [recordTrace(state, 'release', { role: 'devops', status: 'failed', parents: [publication], relation: 'release', resultDigest: r.artifactDigest })]);
     r.status = 'failed'; state.status = 'blocked'; state.reason = error.message; save(state); throw error;
   } finally {
     // Only this invocation's private staging directory is discarded. A published

package/board/scripts/lib/controlled-specialists.mjs

@@ -8,6 +8,7 @@ import { RULES } from '../hooks/auto-attach-reviewers.mjs';
 import { codexRoleProfile } from './codex-role-profiles.mjs';
 import { validateReviewReusePolicy } from './scoped-review-reuse.mjs';
 import { assertReviewGraphFloor, assertPreparationGraphFloor } from './review-graph-floor.mjs';
+import { recordTrace, traceIncoming, traceParents, traceSchedule } from './execution-trace.mjs';
 
 const mandatory = ['code-reviewer', 'qa-engineer', 'security-officer'];
 const contracts = new Set(['auth-engineer', 'subscription-billing-engineer', 'integrations-engineer', 'connector-builder',
@@ -82,7 +83,12 @@ export function schedulePreparation(state) {
   state.specialistPreparation = { roles, selected, fingerprint: plan.fingerprint, plan, hardGates: gates,
     reports: [], status: roles.length ? 'scheduled' : 'complete', reusablePass: false };
   state.specialistImplementationGraph = structuredClone(state.graph);
-  if (roles.length) state.queue.splice(state.queue.indexOf('senior-dev'), 1, ...roles);
+  if (roles.length) {
+    state.queue.splice(state.queue.indexOf('senior-dev'), 1, ...roles);
+    const admission = recordTrace(state, 'transition', { role: 'senior-dev',
+      parents: [...traceIncoming(state, 'senior-dev'), ...traceParents(state, Object.keys(state.results))] });
+    for (const role of roles) traceSchedule(state, role, [admission]);
+  }
 }
 
 export function specialistRole(state, role) { return state.specialistStages?.[role]?.role || role; }

package/board/scripts/lib/controller-dispatch-evidence.mjs

@@ -1,4 +1,5 @@
 /** Controller invocation evidence, not provider API usage or quality scores. */
+import { recordTrace, traceKey } from './execution-trace.mjs';
 const hosts = new Set(['codex', 'claude-code']);
 const kinds = new Set(['worker', 'verifier']);
 
@@ -23,6 +24,11 @@ export async function observeControllerCall(state, identity, run, save = () => {
     throw error;
   } finally {
     record.finishedAt = new Date().toISOString();
+    if (identity.attemptId) recordTrace(state, 'result', {
+      key: `${identity.kind === 'worker' ? 'dispatch' : 'verifier-call'}:${identity.attemptId}`,
+      role: identity.role, attemptId: identity.attemptId, host: identity.host, status: record.outcome,
+      parents: [traceKey(state, `${identity.kind === 'worker' ? 'context' : 'verifier'}:${identity.attemptId}`)], relation: 'outcome',
+    });
     save(state);
   }
 }