agentxchain 2.91.0 → 2.93.0

package/bin/agentxchain.js

@@ -113,6 +113,7 @@ import { intakeResolveCommand } from '../src/commands/intake-resolve.js';
 import { intakeStatusCommand } from '../src/commands/intake-status.js';
 import { demoCommand } from '../src/commands/demo.js';
 import { historyCommand } from '../src/commands/history.js';
+import { decisionsCommand } from '../src/commands/decisions.js';
 import { diffCommand } from '../src/commands/diff.js';
 import { eventsCommand } from '../src/commands/events.js';
 import { connectorCheckCommand } from '../src/commands/connector.js';
@@ -157,7 +158,7 @@ program
 program
   .command('audit')
   .description('Render a governance audit directly from the current governed project or coordinator workspace')
-  .option('--format <format>', 'Output format: text, json, or markdown', 'text')
+  .option('--format <format>', 'Output format: text, json, markdown, or html', 'text')
   .action(auditCommand);
 
 program
@@ -176,7 +177,7 @@ program
   .command('report')
   .description('Render a human-readable governance summary from an export artifact')
   .option('--input <path>', 'Export artifact path, or "-" for stdin', '-')
-  .option('--format <format>', 'Output format: text, json, or markdown', 'text')
+  .option('--format <format>', 'Output format: text, json, markdown, or html', 'text')
   .action(reportCommand);
 
 program
@@ -333,6 +334,15 @@ program
   .option('-d, --dir <path>', 'Project directory')
   .action(historyCommand);
 
+program
+  .command('decisions')
+  .description('Show repo-level decisions that persist across governed runs')
+  .option('-j, --json', 'Output as JSON')
+  .option('-a, --all', 'Include overridden decisions')
+  .option('-s, --show <id>', 'Show details for a specific decision (e.g. DEC-042)')
+  .option('-d, --dir <path>', 'Project directory')
+  .action(decisionsCommand);
+
 program
   .command('diff <left_run_id> <right_run_id>')
   .description('Compare two recorded governed runs from run-history')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.91.0",
+  "version": "2.93.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/audit.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { buildCoordinatorExport, buildRunExport } from '../lib/export.js';
 import {
   buildGovernanceReport,
+  formatGovernanceReportHtml,
   formatGovernanceReportMarkdown,
   formatGovernanceReportText,
 } from '../lib/report.js';
@@ -43,6 +44,11 @@ function printAndExit(report, format, exitCode) {
     process.exit(exitCode);
   }
 
+  if (format === 'html') {
+    console.log(formatGovernanceReportHtml(report));
+    process.exit(exitCode);
+  }
+
   if (format === 'text') {
     if (report.overall === 'error' || report.overall === 'fail') {
       console.log(chalk.red(formatGovernanceReportText(report)));
@@ -52,7 +58,7 @@ function printAndExit(report, format, exitCode) {
     process.exit(exitCode);
   }
 
-  console.error(`Unsupported audit format "${format}". Use "text", "json", or "markdown".`);
+  console.error(`Unsupported audit format "${format}". Use "text", "json", "markdown", or "html".`);
   process.exit(2);
 }
 

package/src/commands/decisions.js

@@ -0,0 +1,94 @@
+/**
+ * agentxchain decisions — cross-run decision carryover surface.
+ *
+ * Shows repo-level decisions that persist across governed runs.
+ */
+
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+import chalk from 'chalk';
+import { readRepoDecisions, getActiveRepoDecisions, getRepoDecisionById } from '../lib/repo-decisions.js';
+
+/**
+ * @param {object} opts - { json?: boolean, all?: boolean, show?: string, dir?: string }
+ */
+export async function decisionsCommand(opts) {
+  const root = findProjectRoot(opts.dir || process.cwd());
+  if (!root) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+
+  // ── Show single decision ───────────────────────────────────────────────
+  if (opts.show) {
+    const dec = getRepoDecisionById(root, opts.show);
+    if (!dec) {
+      console.error(chalk.red(`Decision ${opts.show} not found in repo decisions.`));
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(dec, null, 2));
+      return;
+    }
+    console.log(chalk.bold(`Decision ${dec.id}`));
+    console.log(`  Category:    ${dec.category}`);
+    console.log(`  Statement:   ${dec.statement}`);
+    console.log(`  Rationale:   ${dec.rationale}`);
+    console.log(`  Status:      ${formatStatus(dec.status)}`);
+    console.log(`  Role:        ${dec.role || '—'}`);
+    console.log(`  Phase:       ${dec.phase || '—'}`);
+    console.log(`  Run:         ${(dec.run_id || '—').slice(0, 16)}`);
+    console.log(`  Turn:        ${(dec.turn_id || '—').slice(0, 16)}`);
+    console.log(`  Created:     ${dec.created_at || '—'}`);
+    if (dec.overridden_by) {
+      console.log(`  Overridden:  ${chalk.yellow(dec.overridden_by)}`);
+    }
+    return;
+  }
+
+  // ── List decisions ─────────────────────────────────────────────────────
+  const decisions = opts.all ? readRepoDecisions(root) : getActiveRepoDecisions(root);
+
+  if (opts.json) {
+    console.log(JSON.stringify(decisions, null, 2));
+    return;
+  }
+
+  if (decisions.length === 0) {
+    console.log(chalk.dim('No repo-level decisions found.'));
+    if (!opts.all) {
+      console.log(chalk.dim('Use --all to include overridden decisions.'));
+    }
+    return;
+  }
+
+  const label = opts.all ? 'Repo Decisions (all)' : 'Active Repo Decisions';
+  console.log(chalk.bold(`${label}: ${decisions.length}`));
+  console.log('');
+
+  for (const dec of decisions) {
+    const status = formatStatus(dec.status);
+    const runShort = (dec.run_id || '').slice(0, 12);
+    const override = dec.overridden_by ? chalk.dim(` → ${dec.overridden_by}`) : '';
+    console.log(`  ${chalk.cyan(dec.id)}  ${status}  ${chalk.dim(dec.category)}  ${dec.statement}${override}`);
+    console.log(`    ${chalk.dim(`by ${dec.role || '?'} in ${runShort || '?'}`)}`);
+  }
+}
+
+function formatStatus(status) {
+  if (status === 'active') return chalk.green('active');
+  if (status === 'overridden') return chalk.yellow('overridden');
+  return chalk.dim(status || '—');
+}
+
+function findProjectRoot(dir) {
+  let current = resolve(dir);
+  while (current !== '/') {
+    if (existsSync(resolve(current, 'agentxchain.json'))) return current;
+    if (existsSync(resolve(current, '.agentxchain'))) return current;
+    const parent = resolve(current, '..');
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}

package/src/commands/doctor.js

@@ -5,6 +5,7 @@ import chalk from 'chalk';
 import { loadConfig, loadLock, findProjectRoot } from '../lib/config.js';
 import { validateProject } from '../lib/validation.js';
 import { getWatchPid } from './watch.js';
+import { getDashboardPid, getDashboardSession } from './dashboard.js';
 import { loadNormalizedConfig, detectConfigVersion } from '../lib/normalized-config.js';
 import { readDaemonState, evaluateDaemonStatus } from '../lib/run-schedule.js';
 import { getGovernedVersionSurface, formatGovernedVersionLabel } from '../lib/protocol-version.js';
@@ -219,6 +220,21 @@ function governedDoctor(root, rawConfig, opts) {
     }
   }
 
+  // 9. Dashboard session health (unconditional — dashboard is a general operator surface)
+  {
+    const dashPid = getDashboardPid(root);
+    const dashSession = getDashboardSession(root);
+    if (dashPid && dashSession) {
+      checks.push({ id: 'dashboard_session', name: 'Dashboard session', level: 'pass', detail: `Dashboard running at ${dashSession.url} (PID: ${dashPid})` });
+    } else if (dashPid && !dashSession) {
+      checks.push({ id: 'dashboard_session', name: 'Dashboard session', level: 'warn', detail: `Dashboard PID ${dashPid} alive but session file missing` });
+    } else if (!dashPid && dashSession) {
+      checks.push({ id: 'dashboard_session', name: 'Dashboard session', level: 'warn', detail: `Stale dashboard session files (PID ${dashSession.pid || '?'} not running)` });
+    } else {
+      checks.push({ id: 'dashboard_session', name: 'Dashboard session', level: 'info', detail: 'No dashboard session' });
+    }
+  }
+
   // Compute summary
   const failCount = checks.filter(c => c.level === 'fail').length;
   const warnCount = checks.filter(c => c.level === 'warn').length;
@@ -253,7 +269,9 @@ function governedDoctor(root, rawConfig, opts) {
         ? chalk.green('PASS')
         : c.level === 'warn'
           ? chalk.yellow('WARN')
-          : chalk.red('FAIL');
+          : c.level === 'info'
+            ? chalk.dim('INFO')
+            : chalk.red('FAIL');
       console.log(`  ${badge}  ${c.name.padEnd(24)} ${chalk.dim(c.detail)}`);
     }
 

package/src/commands/report.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { loadExportArtifact } from '../lib/export-verifier.js';
 import {
   buildGovernanceReport,
+  formatGovernanceReportHtml,
   formatGovernanceReportMarkdown,
   formatGovernanceReportText,
 } from '../lib/report.js';
@@ -18,6 +19,11 @@ function printAndExit(report, format, exitCode) {
     process.exit(exitCode);
   }
 
+  if (format === 'html') {
+    console.log(formatGovernanceReportHtml(report));
+    process.exit(exitCode);
+  }
+
   if (format === 'text') {
     if (report.overall === 'error') {
       console.log(chalk.red(formatGovernanceReportText(report)));
@@ -29,7 +35,7 @@ function printAndExit(report, format, exitCode) {
     process.exit(exitCode);
   }
 
-  console.error(`Unsupported report format "${format}". Use "text", "json", or "markdown".`);
+  console.error(`Unsupported report format "${format}". Use "text", "json", "markdown", or "html".`);
   process.exit(1);
 }
 

package/src/commands/status.js

@@ -9,6 +9,7 @@ import { getConnectorHealth } from '../lib/connector-health.js';
 import { deriveWorkflowKitArtifacts } from '../lib/workflow-kit-artifacts.js';
 import { evaluateTimeouts } from '../lib/timeout-evaluator.js';
 import { summarizeRunProvenance } from '../lib/run-provenance.js';
+import { getDashboardPid, getDashboardSession } from './dashboard.js';
 
 export async function statusCommand(opts) {
   const context = loadProjectContext();
@@ -87,6 +88,14 @@ function renderGovernedStatus(context, opts) {
   const workflowKitArtifacts = deriveWorkflowKitArtifacts(root, config, state);
 
   if (opts.json) {
+    const dashPid = getDashboardPid(root);
+    const dashSession = getDashboardSession(root);
+    const dashboardSessionObj = dashPid
+      ? { status: 'running', pid: dashPid, url: dashSession?.url || null, started_at: dashSession?.started_at || null }
+      : dashSession
+        ? { status: 'stale', pid: dashSession.pid || null, url: dashSession.url || null, started_at: dashSession.started_at || null }
+        : { status: 'not_running', pid: null, url: null, started_at: null };
+
     console.log(JSON.stringify({
       version,
       protocol_mode: config.protocol_mode,
@@ -96,9 +105,11 @@ function renderGovernedStatus(context, opts) {
       state,
       provenance: state?.provenance || null,
       inherited_context: state?.inherited_context || null,
+      repo_decisions: state?.repo_decisions || null,
       continuity,
       connector_health: connectorHealth,
       workflow_kit_artifacts: workflowKitArtifacts,
+      dashboard_session: dashboardSessionObj,
     }, null, 2));
     return;
   }
@@ -123,6 +134,9 @@ function renderGovernedStatus(context, opts) {
   if (state?.inherited_context?.parent_run_id) {
     console.log(`  ${chalk.dim('Inherits:')} ${chalk.magenta(`parent ${state.inherited_context.parent_run_id} (${state.inherited_context.parent_status || 'unknown'})`)}`);
   }
+  if (state?.repo_decisions?.length > 0) {
+    console.log(`  ${chalk.dim('Repo decisions:')} ${chalk.yellow(`${state.repo_decisions.length} active`)}`);
+  }
   if (state?.accepted_integration_ref) {
     console.log(`  ${chalk.dim('Accepted:')} ${state.accepted_integration_ref}`);
   }

package/src/lib/adapters/local-cli-adapter.js

@@ -115,7 +115,7 @@ export async function dispatchLocalCli(root, state, config, options = {}) {
       child = spawn(command, args, {
         cwd: runtime.cwd ? join(root, runtime.cwd) : root,
         stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env },
+        env: { ...process.env, AGENTXCHAIN_TURN_ID: turn.turn_id },
       });
     } catch (err) {
       resolve({ ok: false, error: `Failed to spawn "${command}": ${err.message}`, logs });

package/src/lib/dispatch-bundle.js

@@ -18,6 +18,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, readdirSync
 import { join } from 'path';
 import { getActiveTurn, getActiveTurns } from './governed-state.js';
 import { renderInheritedContextMarkdown } from './run-context-inheritance.js';
+import { renderRepoDecisionsMarkdown } from './repo-decisions.js';
 import {
   DISPATCH_INDEX_PATH,
   getDispatchAssignmentPath,
@@ -605,6 +606,14 @@ function renderContext(state, config, root, turn, role) {
     lines.push('');
   }
 
+  // Repo-level decisions that persist across runs
+  if (state.repo_decisions && state.repo_decisions.length > 0) {
+    const repoDecMd = renderRepoDecisionsMarkdown(state.repo_decisions);
+    if (repoDecMd) {
+      lines.push(repoDecMd);
+    }
+  }
+
   // Inherited context from parent run (when --inherit-context was used)
   if (state.inherited_context) {
     // First turn gets the full rendering; subsequent turns get compact

package/src/lib/export.js

@@ -7,6 +7,8 @@ import { loadProjectContext, loadProjectState } from './config.js';
 import { loadCoordinatorConfig, COORDINATOR_CONFIG_FILE } from './coordinator-config.js';
 import { loadCoordinatorState } from './coordinator-state.js';
 import { normalizeRunProvenance } from './run-provenance.js';
+import { getDashboardPid, getDashboardSession } from '../commands/dashboard.js';
+import { readRepoDecisions } from './repo-decisions.js';
 
 const EXPORT_SCHEMA_VERSION = '0.3';
 
@@ -23,10 +25,13 @@ const COORDINATOR_INCLUDED_ROOTS = [
 export const RUN_EXPORT_INCLUDED_ROOTS = [
   'agentxchain.json',
   'TALK.md',
+  '.agentxchain-dashboard.pid',
+  '.agentxchain-dashboard.json',
   '.agentxchain/state.json',
   '.agentxchain/session.json',
   '.agentxchain/history.jsonl',
   '.agentxchain/decision-ledger.jsonl',
+  '.agentxchain/repo-decisions.jsonl',
   '.agentxchain/hook-audit.jsonl',
   '.agentxchain/hook-annotations.jsonl',
   '.agentxchain/notification-audit.jsonl',
@@ -166,6 +171,59 @@ function countDirectoryFiles(files, prefix) {
   return Object.keys(files).filter((path) => path.startsWith(`${prefix}/`)).length;
 }
 
+function buildDashboardSessionSummary(root) {
+  const dashPid = getDashboardPid(root);
+  const dashSession = getDashboardSession(root);
+
+  if (dashPid && dashSession) {
+    return {
+      status: 'running',
+      pid: dashPid,
+      url: dashSession.url || null,
+      started_at: dashSession.started_at || null,
+    };
+  }
+
+  if (dashPid && !dashSession) {
+    return {
+      status: 'pid_only',
+      pid: dashPid,
+      url: null,
+      started_at: null,
+    };
+  }
+
+  if (!dashPid && dashSession) {
+    return {
+      status: 'stale',
+      pid: dashSession.pid || null,
+      url: dashSession.url || null,
+      started_at: dashSession.started_at || null,
+    };
+  }
+
+  return {
+    status: 'not_running',
+    pid: null,
+    url: null,
+    started_at: null,
+  };
+}
+
+export function buildRepoDecisionsSummary(root) {
+  const all = readRepoDecisions(root);
+  if (!all || all.length === 0) return null;
+  const active = all.filter(d => d.status === 'active');
+  const overridden = all.filter(d => d.status === 'overridden');
+  return {
+    total: all.length,
+    active_count: active.length,
+    overridden_count: overridden.length,
+    active: active.map(d => ({ id: d.id, category: d.category, statement: d.statement, role: d.role, run_id: d.run_id })),
+    overridden: overridden.map(d => ({ id: d.id, overridden_by: d.overridden_by, statement: d.statement })),
+  };
+}
+
 export function buildDelegationSummary(files) {
   const historyData = files['.agentxchain/history.jsonl']?.data;
   if (!Array.isArray(historyData)) {
@@ -404,7 +462,9 @@ export function buildRunExport(startDir = process.cwd()) {
         staging_artifact_files: countDirectoryFiles(files, '.agentxchain/staging'),
         intake_present: Object.keys(files).some((path) => path.startsWith('.agentxchain/intake/')),
         coordinator_present: Object.keys(files).some((path) => path.startsWith('.agentxchain/multirepo/')),
+        dashboard_session: buildDashboardSessionSummary(root),
         delegation_summary: buildDelegationSummary(files),
+        repo_decisions: buildRepoDecisionsSummary(root),
       },
       workspace: buildRunWorkspaceMetadata(root),
       files,

package/src/lib/governed-state.js

@@ -44,6 +44,12 @@ import { emitRunEvent } from './run-events.js';
 import { writeSessionCheckpoint } from './session-checkpoint.js';
 import { recordRunHistory } from './run-history.js';
 import { buildDefaultRunProvenance } from './run-provenance.js';
+import {
+  getActiveRepoDecisions,
+  appendRepoDecision,
+  overrideRepoDecision,
+  validateOverride,
+} from './repo-decisions.js';
 import {
   replayVerificationMachineEvidence,
   summarizeVerificationReplay,
@@ -799,6 +805,61 @@ function readJsonlEntries(root, relPath) {
     .filter(Boolean);
 }
 
+function collectPendingConcurrentSiblingDeclarations(root, state, currentTurn, historyEntries = []) {
+  const concurrentIds = new Set(
+    Array.isArray(currentTurn?.concurrent_with)
+      ? currentTurn.concurrent_with.filter((id) => typeof id === 'string' && id.length > 0)
+      : [],
+  );
+  const activeTurns = getActiveTurns(state);
+  for (const turn of Object.values(activeTurns)) {
+    if (
+      turn?.turn_id !== currentTurn?.turn_id
+      && Array.isArray(turn?.concurrent_with)
+      && turn.concurrent_with.includes(currentTurn?.turn_id)
+    ) {
+      concurrentIds.add(turn.turn_id);
+    }
+  }
+  if (concurrentIds.size === 0) {
+    return [];
+  }
+
+  const acceptedIds = new Set(
+    (Array.isArray(historyEntries) ? historyEntries : [])
+      .map((entry) => entry?.turn_id)
+      .filter((turnId) => typeof turnId === 'string' && turnId.length > 0),
+  );
+  const declarations = [];
+
+  for (const siblingTurnId of concurrentIds) {
+    if (siblingTurnId === currentTurn?.turn_id || acceptedIds.has(siblingTurnId) || !activeTurns[siblingTurnId]) {
+      continue;
+    }
+
+    const stagedSibling = loadHookStagedTurn(root, getTurnStagingResultPath(siblingTurnId));
+    const siblingResult = stagedSibling.turnResult;
+    if (!siblingResult || siblingResult.turn_id !== siblingTurnId) {
+      continue;
+    }
+
+    const siblingFiles = [...new Set(
+      (Array.isArray(siblingResult.files_changed) ? siblingResult.files_changed : [])
+        .filter((filePath) => typeof filePath === 'string' && filePath.length > 0),
+    )];
+    if (siblingFiles.length === 0) {
+      continue;
+    }
+
+    declarations.push({
+      turn_id: siblingTurnId,
+      files_changed: siblingFiles,
+    });
+  }
+
+  return declarations;
+}
+
 function getObservedFiles(entry) {
   if (Array.isArray(entry?.observed_artifact?.files_changed)) {
     return entry.observed_artifact.files_changed;
@@ -1853,6 +1914,7 @@ export function initializeGovernedRun(root, config, options = {}) {
   const runId = generateId('run');
   const now = new Date().toISOString();
   const provenance = buildDefaultRunProvenance(options.provenance);
+  const repoDecisions = getActiveRepoDecisions(root);
   const updatedState = {
     ...state,
     run_id: runId,
@@ -1867,6 +1929,7 @@ export function initializeGovernedRun(root, config, options = {}) {
     },
     provenance,
     inherited_context: options.inherited_context || null,
+    repo_decisions: repoDecisions.length > 0 ? repoDecisions : null,
   };
 
   writeState(root, updatedState);
@@ -2368,12 +2431,39 @@ function _acceptGovernedTurnLocked(root, config, opts) {
   }
 
   const turnResult = validation.turnResult;
+
+  // Validate cross-run decision overrides against repo-decisions.jsonl
+  if (turnResult.decisions && turnResult.decisions.length > 0) {
+    for (const dec of turnResult.decisions) {
+      if (dec.overrides) {
+        const overrideCheck = validateOverride(root, dec);
+        if (!overrideCheck.ok) {
+          return {
+            ok: false,
+            error: `Override validation failed: ${overrideCheck.error}`,
+            error_code: 'override_validation_failed',
+          };
+        }
+      }
+    }
+  }
+
   const stagingFile = join(root, resolvedStagingPath);
   const now = new Date().toISOString();
   const baseline = currentTurn.baseline || null;
   const rawObservation = observeChanges(root, baseline);
   const historyEntries = readJsonlEntries(root, HISTORY_PATH);
-  const observation = attributeObservedChangesToTurn(rawObservation, currentTurn, historyEntries);
+  const pendingConcurrentSiblingDeclarations = collectPendingConcurrentSiblingDeclarations(
+    root,
+    state,
+    currentTurn,
+    historyEntries,
+  );
+  const observation = attributeObservedChangesToTurn(rawObservation, currentTurn, historyEntries, {
+    currentDeclaredFiles: turnResult.files_changed || [],
+    concurrentSiblingIds: pendingConcurrentSiblingDeclarations.map((entry) => entry.turn_id),
+    pendingConcurrentSiblingDeclarations,
+  });
   const role = config.roles?.[turnResult.role];
   const runtimeId = turnResult.runtime_id;
   const runtime = config.runtimes?.[runtimeId];
@@ -2381,11 +2471,28 @@ function _acceptGovernedTurnLocked(root, config, opts) {
   materializeDerivedReviewArtifact(root, turnResult, state, runtimeType, baseline);
   materializeDerivedProposalArtifact(root, turnResult, state, runtimeType);
   const writeAuthority = role?.write_authority || 'review_only';
+
+  // When concurrent siblings exist but have not yet been accepted, the
+  // observation includes their file changes too.  The attribution system
+  // (attributeObservedChangesToTurn) only removes sibling files for
+  // *later*-accepted turns.  For the *first*-accepted concurrent turn,
+  // undeclared files are expected noise from concurrency — downgrade to
+  // warnings so the governance contract is not broken by turn-acceptance
+  // ordering.
+  const concurrentIds = new Set(
+    Array.isArray(currentTurn.concurrent_with) ? currentTurn.concurrent_with : [],
+  );
+  const acceptedTurnIds = new Set(historyEntries.map(h => h.turn_id));
+  const hasUnacceptedConcurrentSiblings = [...concurrentIds].some(id => !acceptedTurnIds.has(id));
+
   const diffComparison = compareDeclaredVsObserved(
     turnResult.files_changed || [],
     observation.files_changed,
     writeAuthority,
-    { observation_available: observation.observation_available },
+    {
+      observation_available: observation.observation_available,
+      has_unaccepted_concurrent_siblings: hasUnacceptedConcurrentSiblings,
+    },
   );
   if (diffComparison.errors.length > 0) {
     return {
@@ -3214,11 +3321,36 @@ function _acceptGovernedTurnLocked(root, config, opts) {
   };
   writeAcceptanceJournal(root, journal);
 
-  // ── Commit order: history → ledger → talk → state → cleanup → journal ─
+  // ── Commit order: history → ledger → repo-decisions → talk → state → cleanup → journal ─
   appendJsonl(root, HISTORY_PATH, historyEntry);
   for (const entry of ledgerEntries) {
     appendJsonl(root, LEDGER_PATH, entry);
   }
+  // Persist repo-durable decisions and process overrides
+  if (turnResult.decisions && turnResult.decisions.length > 0) {
+    for (const dec of turnResult.decisions) {
+      // Process override first (marks target as overridden in repo-decisions.jsonl)
+      if (dec.overrides) {
+        overrideRepoDecision(root, dec.overrides, dec.id);
+      }
+      // Write to repo-decisions.jsonl if repo-durable or overriding a repo decision
+      if ((dec.durability || 'run') === 'repo' || dec.overrides) {
+        appendRepoDecision(root, {
+          id: dec.id,
+          run_id: state.run_id,
+          turn_id: turnResult.turn_id,
+          role: turnResult.role,
+          phase: state.phase,
+          category: dec.category,
+          statement: dec.statement,
+          rationale: dec.rationale,
+          status: 'active',
+          overridden_by: null,
+          created_at: now,
+        });
+      }
+    }
+  }
   appendTalk(root, talkSection);
   writeState(root, updatedState);