agentxchain 2.90.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.90.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/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) {