agentxchain 2.89.0 → 2.91.0

package/bin/agentxchain.js

@@ -199,7 +199,7 @@ program
 
 program
   .command('stop')
-  .description('Stop watch daemon and Claude Code sessions; close Cursor/VS Code chats manually')
+  .description('Stop dashboard/watch daemons and Claude Code sessions; close Cursor/VS Code chats manually')
   .action(stopCommand);
 
 program
@@ -477,6 +477,7 @@ program
   .command('dashboard')
   .description('Open the read-only governance dashboard in your browser')
   .option('--port <port>', 'Server port', '3847')
+  .option('--daemon', 'Run the dashboard in background mode')
   .option('--no-open', 'Do not auto-open the browser')
   .action(dashboardCommand);
 

package/dashboard/components/initiative.js

@@ -207,6 +207,23 @@ export function render({
       if (Array.isArray(barrier.satisfied_repos) && barrier.satisfied_repos.length > 0) {
         html += `<div class="turn-detail"><span class="detail-label">Satisfied Repos:</span> ${esc(barrier.satisfied_repos.join(', '))}</div>`;
       }
+      const decisionIds = barrier.required_decision_ids_by_repo || barrier.alignment_decision_ids || null;
+      if (decisionIds && typeof decisionIds === 'object' && !Array.isArray(decisionIds)) {
+        const satisfiedSet = new Set(Array.isArray(barrier.satisfied_repos) ? barrier.satisfied_repos : []);
+        html += `<div class="turn-detail"><span class="detail-label">Decision Requirements:</span></div>`;
+        html += `<div class="decision-req-list" style="margin-left:1.2em;margin-top:0.3em">`;
+        for (const [repo, ids] of Object.entries(decisionIds)) {
+          if (!Array.isArray(ids) || ids.length === 0) continue;
+          const repoSatisfied = satisfiedSet.has(repo);
+          const idBadges = ids.map((id) =>
+            repoSatisfied
+              ? badge(`${id} ✓`, 'var(--green)')
+              : badge(id, 'var(--text-dim)')
+          ).join(' ');
+          html += `<div style="margin-bottom:0.2em"><span class="mono" style="margin-right:0.5em">${esc(repo)}:</span>${idBadges}</div>`;
+        }
+        html += `</div>`;
+      }
       html += `</div>`;
     }
     html += `</div>`;

package/package.json

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

package/src/commands/dashboard.js

@@ -5,13 +5,17 @@
  * The dashboard remains mostly observational, but can approve pending gates.
  */
 
-import { existsSync } from 'fs';
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { spawn } from 'child_process';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { createBridgeServer } from '../lib/dashboard/bridge-server.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_PORT = 3847;
+const DASHBOARD_PID_FILE = '.agentxchain-dashboard.pid';
+const DASHBOARD_SESSION_FILE = '.agentxchain-dashboard.json';
+const DASHBOARD_DAEMON_CHILD_ENV = 'AGENTXCHAIN_DASHBOARD_DAEMON_CHILD';
 
 export async function dashboardCommand(options) {
   const cwd = process.cwd();
@@ -29,12 +33,25 @@ export async function dashboardCommand(options) {
     process.exit(1);
   }
 
-  const port = parseInt(options.port, 10) || DEFAULT_PORT;
+  if (options.daemon && process.env[DASHBOARD_DAEMON_CHILD_ENV] !== '1') {
+    await startDashboardDaemon({ cwd, port: parseDashboardPort(options.port) });
+    return;
+  }
+
+  cleanupDashboardFiles(cwd);
+
+  const port = parseDashboardPort(options.port);
   const bridge = createBridgeServer({ agentxchainDir, dashboardDir, port });
 
   try {
     const { port: actualPort } = await bridge.start();
     const url = `http://localhost:${actualPort}`;
+    writeDashboardSession(cwd, {
+      pid: process.pid,
+      port: actualPort,
+      url,
+      started_at: new Date().toISOString(),
+    });
 
     console.log(`Dashboard running at ${url}`);
     console.log('Press Ctrl+C to stop.\n');
@@ -51,16 +68,19 @@ export async function dashboardCommand(options) {
       }
     }
 
-    // Keep running until interrupted
+    let shuttingDown = false;
     const shutdown = async () => {
+      if (shuttingDown) return;
+      shuttingDown = true;
       console.log('\nShutting down dashboard...');
+      cleanupDashboardFiles(cwd);
       await bridge.stop();
       process.exit(0);
     };
     process.on('SIGINT', shutdown);
     process.on('SIGTERM', shutdown);
-
   } catch (err) {
+    cleanupDashboardFiles(cwd);
     if (err.code === 'EADDRINUSE') {
       console.error(`Error: Port ${port} is already in use. Try --port <number>.`);
       process.exit(1);
@@ -68,3 +88,111 @@ export async function dashboardCommand(options) {
     throw err;
   }
 }
+
+export function getDashboardPid(root) {
+  const pidPath = join(root, DASHBOARD_PID_FILE);
+  if (!existsSync(pidPath)) return null;
+  try {
+    const pid = parseInt(readFileSync(pidPath, 'utf8').trim(), 10);
+    if (!Number.isFinite(pid)) return null;
+    process.kill(pid, 0);
+    return pid;
+  } catch (err) {
+    if (err?.code === 'ESRCH') {
+      cleanupDashboardFiles(root);
+      return null;
+    }
+    return null;
+  }
+}
+
+export function getDashboardSession(root) {
+  const sessionPath = join(root, DASHBOARD_SESSION_FILE);
+  if (!existsSync(sessionPath)) return null;
+  try {
+    return JSON.parse(readFileSync(sessionPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function cleanupDashboardFiles(root) {
+  const paths = [
+    join(root, DASHBOARD_PID_FILE),
+    join(root, DASHBOARD_SESSION_FILE),
+  ];
+  for (const path of paths) {
+    if (!existsSync(path)) continue;
+    try { unlinkSync(path); } catch {}
+  }
+}
+
+function parseDashboardPort(value) {
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_PORT;
+}
+
+function writeDashboardSession(root, session) {
+  writeFileSync(join(root, DASHBOARD_PID_FILE), `${session.pid}\n`);
+  writeFileSync(join(root, DASHBOARD_SESSION_FILE), `${JSON.stringify(session, null, 2)}\n`);
+}
+
+async function startDashboardDaemon({ cwd, port }) {
+  const existingPid = getDashboardPid(cwd);
+  if (existingPid) {
+    const existingSession = getDashboardSession(cwd);
+    const existingUrl = existingSession?.url || `http://localhost:${existingSession?.port || port}`;
+    console.error(`Error: Dashboard already running at ${existingUrl} (PID: ${existingPid}). Stop it first with "agentxchain stop".`);
+    process.exit(1);
+  }
+
+  cleanupDashboardFiles(cwd);
+
+  const cliBin = join(__dirname, '..', '..', 'bin', 'agentxchain.js');
+  const child = spawn(process.execPath, [cliBin, 'dashboard', '--port', String(port), '--no-open'], {
+    cwd,
+    env: {
+      ...process.env,
+      [DASHBOARD_DAEMON_CHILD_ENV]: '1',
+    },
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+
+  try {
+    const session = await waitForDashboardSession(cwd, child.pid);
+    console.log(`Dashboard started in daemon mode at ${session.url}`);
+    console.log(`PID: ${session.pid}`);
+  } catch (err) {
+    try { process.kill(child.pid, 'SIGTERM'); } catch {}
+    cleanupDashboardFiles(cwd);
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function waitForDashboardSession(root, expectedPid, timeoutMs = 8000) {
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+
+    const poll = () => {
+      const pid = getDashboardPid(root);
+      const session = getDashboardSession(root);
+
+      if (pid === expectedPid && session?.pid === expectedPid && typeof session?.url === 'string') {
+        resolve(session);
+        return;
+      }
+
+      if (Date.now() - startedAt >= timeoutMs) {
+        reject(new Error('Dashboard daemon did not report a live session within 8s.'));
+        return;
+      }
+
+      setTimeout(poll, 100);
+    };
+
+    poll();
+  });
+}

package/src/commands/stop.js

@@ -3,9 +3,12 @@ import { join } from 'path';
 import chalk from 'chalk';
 import { loadConfig } from '../lib/config.js';
 import { getWatchPid } from './watch.js';
+import { cleanupDashboardFiles, getDashboardPid, getDashboardSession } from './dashboard.js';
 
 const SESSION_FILE = '.agentxchain-session.json';
 const WATCH_PID_FILE = '.agentxchain-watch.pid';
+const DASHBOARD_PID_FILE = '.agentxchain-dashboard.pid';
+const DASHBOARD_SESSION_FILE = '.agentxchain-dashboard.json';
 
 export async function stopCommand() {
   const result = loadConfig();
@@ -14,7 +17,12 @@ export async function stopCommand() {
   const { root } = result;
   const sessionPath = join(root, SESSION_FILE);
   const watchPidPath = join(root, WATCH_PID_FILE);
+  const dashboardPidPath = join(root, DASHBOARD_PID_FILE);
+  const dashboardSessionPath = join(root, DASHBOARD_SESSION_FILE);
   const watchPid = getWatchPid(root);
+  const hadDashboardArtifacts = existsSync(dashboardPidPath) || existsSync(dashboardSessionPath);
+  const dashboardPid = getDashboardPid(root);
+  const dashboardSession = getDashboardSession(root);
   let didStopAnything = false;
 
   if (watchPid) {
@@ -41,6 +49,26 @@ export async function stopCommand() {
     } catch {}
   }
 
+  if (dashboardPid) {
+    try {
+      process.kill(dashboardPid, 'SIGTERM');
+      cleanupDashboardFiles(root);
+      didStopAnything = true;
+      console.log('');
+      console.log(chalk.green(`  ✓ Stopped dashboard process (PID: ${dashboardPid})${dashboardSession?.url ? ` at ${dashboardSession.url}` : ''}`));
+      console.log('');
+    } catch (err) {
+      if (err.code === 'ESRCH') {
+        cleanupDashboardFiles(root);
+      } else {
+        console.log(chalk.red(`  ✗ Could not stop dashboard process (PID: ${dashboardPid}): ${err.message}`));
+      }
+    }
+  } else if (hadDashboardArtifacts) {
+    cleanupDashboardFiles(root);
+    console.log(chalk.dim('  Removed stale dashboard session files.'));
+  }
+
   if (existsSync(sessionPath)) {
     let session;
     try {

package/src/lib/coordinator-acceptance.js

@@ -267,7 +267,7 @@ function evaluateBarrierEffects(workspacePath, state, config, repoId, workstream
         snapshotChanged = true;
       }
     }
-    if (barrier.type === 'interface_alignment') {
+    if (barrier.type === 'interface_alignment' || barrier.type === 'named_decisions') {
       const satisfiedRepos = getAlignedReposForBarrier(barrier, history);
       if (JSON.stringify(barrier.satisfied_repos || []) !== JSON.stringify(satisfiedRepos)) {
         barrier.satisfied_repos = satisfiedRepos;

package/src/lib/coordinator-barriers.js

@@ -41,7 +41,7 @@ export function getAcceptedReposForWorkstream(history, workstreamId, requiredRep
 
 export function getAlignedReposForBarrier(barrier, history) {
   const requiredRepos = Array.isArray(barrier.required_repos) ? barrier.required_repos : [];
-  const alignmentDecisionIds = barrier.alignment_decision_ids || {};
+  const alignmentDecisionIds = barrier.required_decision_ids_by_repo || barrier.alignment_decision_ids || {};
   const { repoDecisionIds } = collectAcceptedDecisionIds(history, barrier.workstream_id, requiredRepos);
   const alignedRepos = [];
 
@@ -105,6 +105,7 @@ export function computeBarrierStatus(barrier, history, config) {
       return computeOrderedRepoSequenceStatus(barrier, history, config);
 
     case 'interface_alignment':
+    case 'named_decisions':
       return computeInterfaceAlignmentStatus(barrier, history);
 
     case 'shared_human_gate':

package/src/lib/coordinator-config.js

@@ -11,6 +11,7 @@ const VALID_PHASE_NAME = /^[a-z][a-z0-9_-]*$/;
 const VALID_BARRIER_TYPES = new Set([
   'all_repos_accepted',
   'interface_alignment',
+  'named_decisions',
   'ordered_repo_sequence',
   'shared_human_gate',
 ]);
@@ -151,34 +152,30 @@ function validateWorkstreams(raw, repoIds, errors) {
       );
     }
 
-    validateInterfaceAlignment(workstreamId, workstream, errors);
+    validateDecisionRequirementBarrier(workstreamId, workstream, errors);
   }
 
   detectWorkstreamCycles(raw.workstreams, errors);
   return workstreamIds;
 }
 
-function validateInterfaceAlignment(workstreamId, workstream, errors) {
-  if (workstream.completion_barrier !== 'interface_alignment') {
-    return;
-  }
-
-  const alignment = workstream.interface_alignment;
-  if (!alignment || typeof alignment !== 'object' || Array.isArray(alignment)) {
+function validateDecisionIdsByRepo(workstreamId, workstream, errors, sectionName, errorPrefix) {
+  const section = workstream[sectionName];
+  if (!section || typeof section !== 'object' || Array.isArray(section)) {
     pushError(
       errors,
-      'workstream_interface_alignment_invalid',
-      `workstream "${workstreamId}" with completion_barrier "interface_alignment" must declare interface_alignment.decision_ids_by_repo`,
+      `${errorPrefix}_invalid`,
+      `workstream "${workstreamId}" with completion_barrier "${workstream.completion_barrier}" must declare ${sectionName}.decision_ids_by_repo`,
     );
     return;
   }
 
-  const byRepo = alignment.decision_ids_by_repo;
+  const byRepo = section.decision_ids_by_repo;
   if (!byRepo || typeof byRepo !== 'object' || Array.isArray(byRepo)) {
     pushError(
       errors,
-      'workstream_interface_alignment_decisions_invalid',
-      `workstream "${workstreamId}" interface_alignment.decision_ids_by_repo must be an object`,
+      `${errorPrefix}_decisions_invalid`,
+      `workstream "${workstreamId}" ${sectionName}.decision_ids_by_repo must be an object`,
     );
     return;
   }
@@ -190,8 +187,8 @@ function validateInterfaceAlignment(workstreamId, workstream, errors) {
     if (!(repoId in byRepo)) {
       pushError(
         errors,
-        'workstream_interface_alignment_repo_missing',
-        `workstream "${workstreamId}" must declare interface_alignment.decision_ids_by_repo["${repoId}"]`,
+        `${errorPrefix}_repo_missing`,
+        `workstream "${workstreamId}" must declare ${sectionName}.decision_ids_by_repo["${repoId}"]`,
       );
       continue;
     }
@@ -200,8 +197,8 @@ function validateInterfaceAlignment(workstreamId, workstream, errors) {
     if (!Array.isArray(decisionIds) || decisionIds.length === 0) {
       pushError(
         errors,
-        'workstream_interface_alignment_repo_invalid',
-        `workstream "${workstreamId}" interface_alignment.decision_ids_by_repo["${repoId}"] must be a non-empty array`,
+        `${errorPrefix}_repo_invalid`,
+        `workstream "${workstreamId}" ${sectionName}.decision_ids_by_repo["${repoId}"] must be a non-empty array`,
       );
       continue;
     }
@@ -211,16 +208,16 @@ function validateInterfaceAlignment(workstreamId, workstream, errors) {
       if (typeof decisionId !== 'string' || !/^DEC-\d+$/.test(decisionId)) {
         pushError(
           errors,
-          'workstream_interface_alignment_decision_invalid',
-          `workstream "${workstreamId}" interface_alignment decision "${decisionId}" for repo "${repoId}" must match DEC-NNN`,
+          `${errorPrefix}_decision_invalid`,
+          `workstream "${workstreamId}" ${sectionName} decision "${decisionId}" for repo "${repoId}" must match DEC-NNN`,
         );
         continue;
       }
       if (seen.has(decisionId)) {
         pushError(
           errors,
-          'workstream_interface_alignment_decision_duplicate',
-          `workstream "${workstreamId}" interface_alignment decision "${decisionId}" is duplicated for repo "${repoId}"`,
+          `${errorPrefix}_decision_duplicate`,
+          `workstream "${workstreamId}" ${sectionName} decision "${decisionId}" is duplicated for repo "${repoId}"`,
         );
         continue;
       }
@@ -232,13 +229,49 @@ function validateInterfaceAlignment(workstreamId, workstream, errors) {
     if (!repoIdSet.has(repoId)) {
       pushError(
         errors,
-        'workstream_interface_alignment_repo_unknown',
-        `workstream "${workstreamId}" interface_alignment references undeclared repo "${repoId}"`,
+        `${errorPrefix}_repo_unknown`,
+        `workstream "${workstreamId}" ${sectionName} references undeclared repo "${repoId}"`,
       );
     }
   }
 }
 
+function validateDecisionRequirementBarrier(workstreamId, workstream, errors) {
+  if (workstream.completion_barrier === 'interface_alignment') {
+    validateDecisionIdsByRepo(
+      workstreamId,
+      workstream,
+      errors,
+      'interface_alignment',
+      'workstream_interface_alignment',
+    );
+    return;
+  }
+
+  if (workstream.completion_barrier === 'named_decisions') {
+    validateDecisionIdsByRepo(
+      workstreamId,
+      workstream,
+      errors,
+      'named_decisions',
+      'workstream_named_decisions',
+    );
+  }
+}
+
+function normalizeDecisionIdsByRepo(section) {
+  return section?.decision_ids_by_repo
+    ? {
+        decision_ids_by_repo: Object.fromEntries(
+          Object.entries(section.decision_ids_by_repo).map(([repoId, decisionIds]) => [
+            repoId,
+            Array.isArray(decisionIds) ? [...new Set(decisionIds)] : [],
+          ]),
+        ),
+      }
+    : null;
+}
+
 function detectWorkstreamCycles(workstreams, errors) {
   const visiting = new Set();
   const visited = new Set();
@@ -451,16 +484,8 @@ export function normalizeCoordinatorConfig(raw) {
           entry_repo: workstream.entry_repo,
           depends_on: Array.isArray(workstream.depends_on) ? [...new Set(workstream.depends_on)] : [],
           completion_barrier: workstream.completion_barrier,
-          interface_alignment: workstream.interface_alignment?.decision_ids_by_repo
-            ? {
-                decision_ids_by_repo: Object.fromEntries(
-                  Object.entries(workstream.interface_alignment.decision_ids_by_repo).map(([repoId, decisionIds]) => [
-                    repoId,
-                    Array.isArray(decisionIds) ? [...new Set(decisionIds)] : [],
-                  ]),
-                ),
-              }
-            : null,
+          interface_alignment: normalizeDecisionIdsByRepo(workstream.interface_alignment),
+          named_decisions: normalizeDecisionIdsByRepo(workstream.named_decisions),
         },
       ]),
     ),

package/src/lib/coordinator-recovery.js

@@ -366,7 +366,7 @@ export function resyncFromRepoAuthority(workspacePath, state, config) {
         barriersChanged = true;
       }
     }
-    if (barrier.type === 'interface_alignment') {
+    if (barrier.type === 'interface_alignment' || barrier.type === 'named_decisions') {
       const satisfiedRepos = getAlignedReposForBarrier(barrier, fullHistory);
       if (JSON.stringify(barrier.satisfied_repos || []) !== JSON.stringify(satisfiedRepos)) {
         barrier.satisfied_repos = satisfiedRepos;

package/src/lib/coordinator-state.js

@@ -112,6 +112,9 @@ function bootstrapBarriers(config) {
       status: 'pending',
       required_repos: [...workstream.repos],
       satisfied_repos: [],
+      required_decision_ids_by_repo: workstream.named_decisions?.decision_ids_by_repo
+        || workstream.interface_alignment?.decision_ids_by_repo
+        || null,
       alignment_decision_ids: workstream.interface_alignment?.decision_ids_by_repo || null,
       created_at: new Date().toISOString(),
     };

package/src/lib/cross-repo-context.js

@@ -61,6 +61,7 @@ function collectActiveBarriers(barriers, workstreamIds, targetRepoId) {
       type: barrier.type || 'unknown',
       status: barrier.status,
       notes: barrier.notes || null,
+      required_decision_ids_by_repo: barrier.required_decision_ids_by_repo || barrier.alignment_decision_ids || null,
       alignment_decision_ids: barrier.alignment_decision_ids || null,
     }));
 }
@@ -78,13 +79,13 @@ function buildRequiredFollowups(workstreamId, dependencyIds, upstreamAcceptances
 
   for (const barrier of activeBarriers) {
     if (
-      barrier.type === 'interface_alignment'
-      && barrier.alignment_decision_ids
-      && Array.isArray(barrier.alignment_decision_ids[targetRepoId])
-      && barrier.alignment_decision_ids[targetRepoId].length > 0
+      (barrier.type === 'interface_alignment' || barrier.type === 'named_decisions')
+      && barrier.required_decision_ids_by_repo
+      && Array.isArray(barrier.required_decision_ids_by_repo[targetRepoId])
+      && barrier.required_decision_ids_by_repo[targetRepoId].length > 0
     ) {
       followups.push(
-        `Accept declared interface-alignment decisions for ${targetRepoId}: ${barrier.alignment_decision_ids[targetRepoId].join(', ')}.`,
+        `Accept declared decision requirements for ${targetRepoId}: ${barrier.required_decision_ids_by_repo[targetRepoId].join(', ')}.`,
       );
     }
 
@@ -146,12 +147,12 @@ function renderContextMarkdown(snapshot) {
     for (const barrier of snapshot.active_barriers) {
       let suffix = '';
       if (
-        barrier.type === 'interface_alignment'
-        && barrier.alignment_decision_ids
-        && Array.isArray(barrier.alignment_decision_ids[snapshot.target_repo_id])
-        && barrier.alignment_decision_ids[snapshot.target_repo_id].length > 0
+        (barrier.type === 'interface_alignment' || barrier.type === 'named_decisions')
+        && barrier.required_decision_ids_by_repo
+        && Array.isArray(barrier.required_decision_ids_by_repo[snapshot.target_repo_id])
+        && barrier.required_decision_ids_by_repo[snapshot.target_repo_id].length > 0
       ) {
-        suffix = ` Required decision IDs for ${snapshot.target_repo_id}: ${barrier.alignment_decision_ids[snapshot.target_repo_id].join(', ')}.`;
+        suffix = ` Required decision IDs for ${snapshot.target_repo_id}: ${barrier.required_decision_ids_by_repo[snapshot.target_repo_id].join(', ')}.`;
       }
       lines.push(`- ${barrier.barrier_id}: ${barrier.type} (${barrier.status})${suffix}`);
     }

package/src/lib/report.js

@@ -767,14 +767,28 @@ function extractBarrierSummary(artifact) {
   return Object.entries(data)
     .filter(([, b]) => b && typeof b === 'object' && !Array.isArray(b))
     .sort(([a], [b]) => a.localeCompare(b, 'en'))
-    .map(([barrierId, b]) => ({
-      barrier_id: barrierId,
-      workstream_id: b.workstream_id || null,
-      type: b.type || 'unknown',
-      status: b.status || 'unknown',
-      required_repos: Array.isArray(b.required_repos) ? b.required_repos : [],
-      satisfied_repos: Array.isArray(b.satisfied_repos) ? b.satisfied_repos : [],
-    }));
+    .map(([barrierId, b]) => {
+      const entry = {
+        barrier_id: barrierId,
+        workstream_id: b.workstream_id || null,
+        type: b.type || 'unknown',
+        status: b.status || 'unknown',
+        required_repos: Array.isArray(b.required_repos) ? b.required_repos : [],
+        satisfied_repos: Array.isArray(b.satisfied_repos) ? b.satisfied_repos : [],
+      };
+      const decisionIds =
+        b.required_decision_ids_by_repo || b.alignment_decision_ids || null;
+      if (decisionIds && typeof decisionIds === 'object' && !Array.isArray(decisionIds)) {
+        entry.required_decision_ids_by_repo = decisionIds;
+        const satisfiedSet = new Set(entry.satisfied_repos);
+        const satisfiedByRepo = {};
+        for (const [repo, ids] of Object.entries(decisionIds)) {
+          satisfiedByRepo[repo] = satisfiedSet.has(repo) ? [...ids] : [];
+        }
+        entry.satisfied_decision_ids_by_repo = satisfiedByRepo;
+      }
+      return entry;
+    });
 }
 
 function summarizeBarrierTransition(entry) {
@@ -1442,6 +1456,17 @@ export function formatGovernanceReportText(report) {
       const satisfied = b.satisfied_repos.length;
       const required = b.required_repos.length;
       lines.push(`  - ${b.barrier_id}: ${b.status} (${b.type}, ${satisfied}/${required} repos satisfied, workstream ${b.workstream_id || 'unknown'})`);
+      if (b.required_decision_ids_by_repo) {
+        lines.push('    Decision requirements:');
+        for (const [repo, ids] of Object.entries(b.required_decision_ids_by_repo)) {
+          if (!Array.isArray(ids) || ids.length === 0) continue;
+          const satisfiedIds = new Set(
+            Array.isArray(b.satisfied_decision_ids_by_repo?.[repo]) ? b.satisfied_decision_ids_by_repo[repo] : []
+          );
+          const labels = ids.map((id) => `${id} (${satisfiedIds.has(id) ? 'satisfied' : 'pending'})`);
+          lines.push(`      ${repo}: ${labels.join(', ')}`);
+        }
+      }
     }
   }
 
@@ -1917,6 +1942,20 @@ export function formatGovernanceReportMarkdown(report) {
     for (const b of barrier_summary) {
       mdLines.push(`| \`${b.barrier_id}\` | \`${b.workstream_id || 'unknown'}\` | \`${b.type}\` | \`${b.status}\` | ${b.satisfied_repos.length}/${b.required_repos.length} repos |`);
     }
+    const barriersWithDecisions = barrier_summary.filter((b) => b.required_decision_ids_by_repo);
+    if (barriersWithDecisions.length > 0) {
+      mdLines.push('', '### Decision Requirements');
+      for (const b of barriersWithDecisions) {
+        mdLines.push('', `**\`${b.barrier_id}\`** decision requirements:`, '', '| Repo | Required | Satisfied |', '|------|----------|-----------|');
+        for (const [repo, ids] of Object.entries(b.required_decision_ids_by_repo)) {
+          if (!Array.isArray(ids) || ids.length === 0) continue;
+          const satisfiedIds = Array.isArray(b.satisfied_decision_ids_by_repo?.[repo]) ? b.satisfied_decision_ids_by_repo[repo] : [];
+          const reqStr = ids.map((id) => `\`${id}\``).join(', ');
+          const satStr = satisfiedIds.length > 0 ? satisfiedIds.map((id) => `\`${id}\``).join(', ') : '—';
+          mdLines.push(`| \`${repo}\` | ${reqStr} | ${satStr} |`);
+        }
+      }
+    }
   }
 
   if (barrier_ledger_timeline && barrier_ledger_timeline.length > 0) {