agentxchain 2.155.72 → 2.156.0

package/dashboard/components/org-runs.js

@@ -0,0 +1,168 @@
+/**
+ * Org Runs component — renders cross-project run list as a filterable data table.
+ *
+ * Pure render function: takes data, returns HTML string.
+ * Follows the same pattern as ledger.js filter bar and run-history.js table.
+ */
+
+function esc(str) {
+  if (str == null) return '';
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function badge(label, color = 'var(--text-dim)') {
+  return `<span class="badge" style="color:${color};border-color:${color}">${esc(label)}</span>`;
+}
+
+function statusBadge(status) {
+  switch (status) {
+    case 'active': return badge('active', 'var(--green)');
+    case 'blocked': return badge('blocked', 'var(--yellow)');
+    case 'completed': return badge('completed', 'var(--green)');
+    case 'failed': return badge('failed', 'var(--red)');
+    default: return badge(status || 'unknown', 'var(--text-dim)');
+  }
+}
+
+function phaseBadge(phase) {
+  switch (phase) {
+    case 'planning': return badge('planning', 'var(--accent)');
+    case 'implementation': return badge('implementation', '#38bdf8');
+    case 'qa': return badge('qa', 'var(--yellow)');
+    default: return badge(phase || 'unknown', 'var(--text-dim)');
+  }
+}
+
+function formatUsd(amount) {
+  return '$' + (amount || 0).toFixed(2);
+}
+
+function relativeTime(isoString) {
+  if (!isoString) return '—';
+  try {
+    const dt = new Date(isoString);
+    const now = Date.now();
+    const diffMs = now - dt.getTime();
+    if (diffMs < 0) return esc(isoString);
+    const seconds = Math.floor(diffMs / 1000);
+    if (seconds < 60) return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24) return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+  } catch {
+    return esc(isoString);
+  }
+}
+
+function truncateRunId(runId) {
+  if (!runId) return '—';
+  return runId.length > 20 ? runId.slice(0, 20) + '...' : runId;
+}
+
+function renderFilterBar(runs, filter) {
+  const projectSet = new Set(runs.map(r => r.project_name));
+  const projectOptions = ['all', ...Array.from(projectSet).sort()];
+  const phaseOptions = ['all', 'planning', 'implementation', 'qa'];
+  const statusOptions = ['all', 'active', 'blocked', 'completed', 'failed'];
+
+  function options(list, selected) {
+    return list.map(v =>
+      `<option value="${esc(v)}"${v === selected ? ' selected' : ''}>${esc(v)}</option>`
+    ).join('');
+  }
+
+  return `<div class="filter-bar">
+    <label class="filter-control">
+      Project
+      <select data-view-control="org-runs-project">
+        ${options(projectOptions, filter?.project || 'all')}
+      </select>
+    </label>
+    <label class="filter-control">
+      Phase
+      <select data-view-control="org-runs-phase">
+        ${options(phaseOptions, filter?.phase || 'all')}
+      </select>
+    </label>
+    <label class="filter-control">
+      Status
+      <select data-view-control="org-runs-status">
+        ${options(statusOptions, filter?.status || 'all')}
+      </select>
+    </label>
+  </div>`;
+}
+
+function applyFilter(runs, filter) {
+  let filtered = runs;
+  if (filter?.project && filter.project !== 'all') {
+    filtered = filtered.filter(r => r.project_name === filter.project);
+  }
+  if (filter?.phase && filter.phase !== 'all') {
+    filtered = filtered.filter(r => r.phase === filter.phase);
+  }
+  if (filter?.status && filter.status !== 'all') {
+    filtered = filtered.filter(r => r.status === filter.status);
+  }
+  return filtered;
+}
+
+/**
+ * @param {{ orgRuns: object, liveMeta: object, filter?: object }} data
+ * @returns {string} HTML string
+ */
+export function render(data) {
+  const runsData = data?.orgRuns?.data || data?.orgRuns || null;
+  const runs = Array.isArray(runsData) ? runsData : (runsData?.data || []);
+  const filter = data?.filter || {};
+
+  if (!runs.length && !filter.project && !filter.phase && !filter.status) {
+    return `<div class="placeholder">
+      <h2>Org Runs</h2>
+      <p>No cross-project runs available. Register projects and start governed runs.</p>
+    </div>`;
+  }
+
+  const filtered = applyFilter(runs, filter);
+
+  const tableRows = filtered.map(r => `<tr>
+    <td>${esc(r.project_name)}</td>
+    <td class="mono">${esc(truncateRunId(r.run_id))}</td>
+    <td>${phaseBadge(r.phase)}</td>
+    <td>${statusBadge(r.status)}</td>
+    <td>${r.turns_completed || 0}</td>
+    <td>${formatUsd(r.cost_usd)}</td>
+    <td>${relativeTime(r.started_at)}</td>
+    <td>${relativeTime(r.updated_at)}</td>
+  </tr>`).join('');
+
+  return `<div class="section">
+  <h3>Org Runs (${filtered.length})</h3>
+  ${renderFilterBar(runs, filter)}
+  <table class="data-table">
+    <thead>
+      <tr>
+        <th>Project</th>
+        <th>Run ID</th>
+        <th>Phase</th>
+        <th>Status</th>
+        <th>Turns</th>
+        <th>Cost</th>
+        <th>Started</th>
+        <th>Updated</th>
+      </tr>
+    </thead>
+    <tbody>
+      ${tableRows || '<tr><td colspan="8" style="text-align:center;color:var(--text-dim)">No runs match filters</td></tr>'}
+    </tbody>
+  </table>
+</div>`;
+}

package/dashboard/index.html

@@ -395,6 +395,10 @@
   </header>
   <div class="action-banner" id="action-banner"></div>
   <nav>
+    <a href="#org-overview">Org Overview</a>
+    <a href="#org-runs">Org Runs</a>
+    <a href="#org-history">Org History</a>
+    <a href="#org-audit-trail">Audit Trail</a>
     <a href="#initiative">Initiative</a>
     <a href="#cross-repo">Cross-Repo</a>
     <a href="#timeline" class="active">Timeline</a>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.155.72",
+  "version": "2.156.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {
@@ -26,10 +26,8 @@
   ],
   "scripts": {
     "dev": "node bin/agentxchain.js",
-    "test": "npm run test:vitest && npm run test:node",
-    "test:vitest": "vitest run --reporter=verbose",
-    "test:beta": "node --test test/beta-tester-scenarios/*.test.js",
-    "test:node": "node --test --test-timeout=60000 --test-concurrency=4 test/*.test.js test/beta-tester-scenarios/*.test.js",
+    "test": "vitest run --reporter=verbose",
+    "test:watch": "vitest --reporter=verbose",
     "preflight:release": "bash scripts/release-preflight.sh",
     "preflight:release:strict": "bash scripts/release-preflight.sh --strict",
     "check:release-alignment": "node scripts/check-release-alignment.mjs",
@@ -77,6 +75,7 @@
     "node": ">=18.17.0 || >=20.5.0"
   },
   "devDependencies": {
+    "js-yaml": "^4.1.1",
     "vitest": "^4.1.2"
   }
 }

package/scripts/migrate-node-test-to-vitest.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = fileURLToPath(new URL('.', import.meta.url));
+const CLI_ROOT = join(SCRIPT_DIR, '..');
+const TEST_ROOT = process.argv[2] ? resolve(process.argv[2]) : join(CLI_ROOT, 'test');
+
+function walk(dir) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const absolute = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walk(absolute));
+    } else if (entry.isFile() && entry.name.endsWith('.test.js')) {
+      files.push(absolute);
+    }
+  }
+  return files;
+}
+
+function parseNamedSpecifiers(specifiers) {
+  return specifiers
+    .split(',')
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+function migrateNamedSpecifiers(specifiers) {
+  let importsBefore = false;
+  let importsAfter = false;
+  const migrated = parseNamedSpecifiers(specifiers).map((specifier) => {
+    if (specifier === 'before') {
+      importsBefore = true;
+      return 'beforeAll';
+    }
+    if (specifier === 'after') {
+      importsAfter = true;
+      return 'afterAll';
+    }
+    return specifier;
+  });
+  return {
+    importsBefore,
+    importsAfter,
+    importLine: `import { ${migrated.join(', ')} } from 'vitest';`,
+  };
+}
+
+function migrateSource(source) {
+  let importsBefore = false;
+  let importsAfter = false;
+  let changed = false;
+
+  let next = source.replace(
+    /^import\s+test\s+from\s+['"]node:test['"];$/gm,
+    () => {
+      changed = true;
+      return "import { test } from 'vitest';";
+    },
+  );
+
+  next = next.replace(
+    /^import\s+\{([^}]+)\}\s+from\s+['"]node:test['"];$/gm,
+    (_match, specifiers) => {
+      const migrated = migrateNamedSpecifiers(specifiers);
+      importsBefore ||= migrated.importsBefore;
+      importsAfter ||= migrated.importsAfter;
+      changed = true;
+      return migrated.importLine;
+    },
+  );
+
+  if (importsBefore) {
+    next = next.replace(/\bbefore(?=\s*\()/g, 'beforeAll');
+  }
+  if (importsAfter) {
+    next = next.replace(/\bafter(?=\s*\()/g, 'afterAll');
+  }
+
+  return { changed, source: next };
+}
+
+const changedFiles = [];
+for (const file of walk(TEST_ROOT)) {
+  const source = readFileSync(file, 'utf8');
+  const migrated = migrateSource(source);
+  if (!migrated.changed || migrated.source === source) continue;
+  writeFileSync(file, migrated.source);
+  changedFiles.push(relative(CLI_ROOT, file));
+}
+
+console.log(`Migrated ${changedFiles.length} test files from node:test to vitest.`);
+for (const file of changedFiles) {
+  console.log(file);
+}

package/scripts/release-postflight.sh

@@ -78,7 +78,7 @@ FAIL=0
 TARBALL_URL=""
 REGISTRY_CHECKSUM=""
 PACKAGE_NAME="$(node -e "console.log(JSON.parse(require('fs').readFileSync('package.json', 'utf8')).name)")"
-PACKAGE_BIN_NAME="$(node -e "const pkg = JSON.parse(require('fs').readFileSync('package.json', 'utf8')); if (typeof pkg.bin === 'string') { console.log(pkg.name); process.exit(0); } const names = Object.keys(pkg.bin || {}); if (names.length !== 1) { console.error('package.json bin must declare exactly one entry'); process.exit(1); } console.log(names[0]);")"
+PACKAGE_BIN_NAME="$(node -e "const pkg = JSON.parse(require('fs').readFileSync('package.json', 'utf8')); if (typeof pkg.bin === 'string') { console.log(pkg.name); process.exit(0); } const bins = pkg.bin || {}; if (bins[pkg.name]) { console.log(pkg.name); process.exit(0); } const names = Object.keys(bins); if (names.length === 1) { console.log(names[0]); process.exit(0); } console.error('package.json bin must declare the primary package bin'); process.exit(1);")"
 RUNNER_INTERFACE_VERSION_EXPECTED="$(node --input-type=module -e "import('./src/lib/runner-interface.js').then((mod) => { console.log(mod.RUNNER_INTERFACE_VERSION); }).catch((error) => { console.error(error.message); process.exit(1); });")"
 ADAPTER_INTERFACE_VERSION_EXPECTED="$(node --input-type=module -e "import('./src/lib/adapter-interface.js').then((mod) => { console.log(mod.ADAPTER_INTERFACE_VERSION); }).catch((error) => { console.error(error.message); process.exit(1); });")"
 

package/scripts/release-preflight.sh

@@ -179,15 +179,15 @@ if [[ "$PUBLISH_GATE" -eq 1 ]]; then
       fail "No beta-tester scenario tests found for release-gate verification"
       TEST_OUTPUT=""
       TEST_STATUS=1
-    elif run_and_capture TEST_OUTPUT env AGENTXCHAIN_RELEASE_TARGET_VERSION="${TARGET_VERSION}" AGENTXCHAIN_RELEASE_PREFLIGHT=1 node --test "${GATE_TEST_ARGS[@]}"; then
+    elif run_and_capture TEST_OUTPUT env AGENTXCHAIN_RELEASE_TARGET_VERSION="${TARGET_VERSION}" AGENTXCHAIN_RELEASE_PREFLIGHT=1 npm test -- "${GATE_TEST_ARGS[@]}"; then
       TEST_STATUS=0
     else
       TEST_STATUS=$?
     fi
-    NODE_PASS="$(printf '%s\n' "$TEST_OUTPUT" | awk '/^ℹ tests / { print $3; exit }')"
-    NODE_FAIL="$(printf '%s\n' "$TEST_OUTPUT" | awk '/^ℹ fail / { print $3; exit }')"
-    if [ "$TEST_STATUS" -eq 0 ] && [ "${NODE_FAIL:-0}" = "0" ]; then
-      pass "${NODE_PASS:-?} release-gate tests passed, 0 failures"
+    VITEST_PASS="$(printf '%s\n' "$TEST_OUTPUT" | awk '/^[[:space:]]*Tests[[:space:]]+[0-9]+[[:space:]]+passed/ { for (i = 1; i <= NF; i++) if ($i ~ /^[0-9]+$/) { print $i; exit } }')"
+    VITEST_FAIL="$(printf '%s\n' "$TEST_OUTPUT" | awk '/^[[:space:]]*Tests[[:space:]]+[0-9]+[[:space:]]+failed/ { for (i = 1; i <= NF; i++) if ($i ~ /^[0-9]+$/) { print $i; exit } }')"
+    if [ "$TEST_STATUS" -eq 0 ] && [ "${VITEST_FAIL:-0}" = "0" ]; then
+      pass "${VITEST_PASS:-?} release-gate tests passed, 0 failures"
     else
       fail "Release-gate tests failed"
       printf '%s\n' "$TEST_OUTPUT" | tail -20

package/scripts/verify-post-publish.sh

@@ -21,7 +21,7 @@ TARGET_VERSION=""
 
 FORMULA_PATH="${CLI_DIR}/homebrew/agentxchain.rb"
 PACKAGE_NAME="$(node -e "console.log(JSON.parse(require('fs').readFileSync('package.json','utf8')).name)")"
-PACKAGE_BIN_NAME="$(node -e "const pkg = JSON.parse(require('fs').readFileSync('package.json','utf8')); if (typeof pkg.bin === 'string') { console.log(pkg.name); process.exit(0); } const names = Object.keys(pkg.bin || {}); if (names.length !== 1) { console.error('package.json bin must declare exactly one entry'); process.exit(1); } console.log(names[0]);")"
+PACKAGE_BIN_NAME="$(node -e "const pkg = JSON.parse(require('fs').readFileSync('package.json','utf8')); if (typeof pkg.bin === 'string') { console.log(pkg.name); process.exit(0); } const bins = pkg.bin || {}; if (bins[pkg.name]) { console.log(pkg.name); process.exit(0); } const names = Object.keys(bins); if (names.length === 1) { console.log(names[0]); process.exit(0); } console.error('package.json bin must declare the primary package bin'); process.exit(1);")"
 
 formula_url() {
   local formula_path="$1"

package/src/commands/ci-report.js

@@ -0,0 +1,80 @@
+import { buildRunExport } from '../lib/export.js';
+import { loadExportArtifact } from '../lib/export-verifier.js';
+import { buildGovernanceReport } from '../lib/report.js';
+import {
+  deriveCIExitCode,
+  detectCIEnvironment,
+  formatGitHubAnnotations,
+  formatJUnitXml,
+  writeGitHubOutputVars,
+} from '../lib/ci-reporter.js';
+
+export async function ciReportCommand(options) {
+  const cwd = process.cwd();
+  const format = options.format || 'auto';
+
+  // Step 1: Build or load the governance report
+  let report;
+  if (options.input && options.input !== '-') {
+    const loaded = loadExportArtifact(options.input, cwd);
+    if (!loaded.ok) {
+      console.error(loaded.error);
+      process.exitCode = 1;
+      return;
+    }
+    const result = buildGovernanceReport(loaded.artifact, { input: loaded.input });
+    report = result.report;
+  } else {
+    // Build from current project
+    const exportResult = buildRunExport(cwd);
+    if (!exportResult.ok) {
+      console.error(exportResult.error);
+      process.exitCode = 1;
+      return;
+    }
+    const result = buildGovernanceReport(exportResult.export, { input: 'current-project' });
+    report = result.report;
+  }
+
+  // Step 2: Detect CI environment and resolve format
+  const ci = detectCIEnvironment();
+  let resolvedFormat = format;
+  if (resolvedFormat === 'auto') {
+    if (ci?.provider === 'github_actions') {
+      resolvedFormat = 'github-actions';
+    } else {
+      resolvedFormat = 'json';
+    }
+  }
+
+  // Step 3: Emit formatted output
+  switch (resolvedFormat) {
+    case 'github-actions': {
+      const annotations = formatGitHubAnnotations(report);
+      console.log(annotations);
+
+      // Write output variables if $GITHUB_OUTPUT is set
+      const ghOutput = process.env.GITHUB_OUTPUT;
+      if (ghOutput) {
+        writeGitHubOutputVars(report, ghOutput);
+      }
+      break;
+    }
+    case 'junit-xml': {
+      const xml = formatJUnitXml(report);
+      console.log(xml);
+      break;
+    }
+    case 'json': {
+      console.log(JSON.stringify(report, null, 2));
+      break;
+    }
+    default:
+      console.error(`Unsupported ci-report format "${resolvedFormat}". Use "github-actions", "junit-xml", "json", or "auto".`);
+      process.exitCode = 1;
+      return;
+  }
+
+  // Step 4: Exit with CI-appropriate code
+  process.exitCode = deriveCIExitCode(report);
+}

package/src/commands/doctor.js

@@ -21,7 +21,7 @@ import { detectActiveTurnBindingDrift, detectStateBundleDesync } from '../lib/go
 import { findPendingApprovedIntents } from '../lib/intake.js';
 import { checkCleanBaseline } from '../lib/repo-observer.js';
 import { probeRuntimeSpawnContext } from '../lib/runtime-spawn-context.js';
-import { getClaudeSubprocessAuthIssue } from '../lib/claude-local-auth.js';
+import { getClaudeSubprocessAuthIssue, isCursorLocalCliRuntime, isWindsurfLocalCliRuntime, isOpenCodeLocalCliRuntime } from '../lib/claude-local-auth.js';
 
 export async function doctorCommand(opts = {}) {
   const root = findProjectRoot(process.cwd());
@@ -502,6 +502,27 @@ async function checkRuntimeReachable(root, rtId, rt, boundRoleEntries = []) {
     case 'local_cli': {
       const probe = probeRuntimeSpawnContext(root, rt, { runtimeId: rtId });
       if (probe.ok) {
+        if (isCursorLocalCliRuntime(rt)) {
+          return attachRuntimeContract({
+            ...base,
+            level: 'pass',
+            detail: `${probe.detail} (Cursor IDE local_cli connector)`,
+          }, rtId, rt, boundRoleEntries);
+        }
+        if (isWindsurfLocalCliRuntime(rt)) {
+          return attachRuntimeContract({
+            ...base,
+            level: 'pass',
+            detail: `${probe.detail} (Windsurf IDE local_cli connector)`,
+          }, rtId, rt, boundRoleEntries);
+        }
+        if (isOpenCodeLocalCliRuntime(rt)) {
+          return attachRuntimeContract({
+            ...base,
+            level: 'pass',
+            detail: `${probe.detail} (OpenCode local_cli connector)`,
+          }, rtId, rt, boundRoleEntries);
+        }
         const claudeAuthIssue = await getClaudeSubprocessAuthIssue(rt);
         if (claudeAuthIssue) {
           return attachRuntimeContract({

package/src/commands/intake-approve.js

@@ -18,6 +18,7 @@ export async function intakeApproveCommand(opts) {
   const result = approveIntent(root, opts.intent, {
     approver: opts.approver || undefined,
     reason: opts.reason || undefined,
+    forceScope: opts.forceScope || false,
   });
 
   if (opts.json) {

package/src/commands/replay.js

@@ -54,6 +54,7 @@ export async function replayTurnCommand(turnId, opts = {}) {
       root,
       verification: entry.verification,
       timeoutMs,
+      allowCommandExecution: Boolean(opts.execute),
     }),
   };
 

package/src/commands/run.js

@@ -18,6 +18,7 @@ import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { loadProjectContext, loadProjectState } from '../lib/config.js';
 import { runLoop } from '../lib/run-loop.js';
+import { isCredentialedExitGate } from '../lib/approval-policy.js';
 import { transitionActiveTurnLifecycle } from '../lib/runner-interface.js';
 import { buildRunExport } from '../lib/export.js';
 import { buildGovernanceReport, formatGovernanceReportMarkdown } from '../lib/report.js';
@@ -362,6 +363,15 @@ export async function executeGovernedRun(context, opts = {}) {
         turnId: turn.turn_id,
         onSpawnAttached: ({ pid, at }) => ensureStartingState(pid, at),
         onFirstOutput: ({ at, stream }) => ensureRunningState(stream, at),
+        onStartupHeartbeat: ({ elapsed_since_spawn_ms }) => {
+          tracker.heartbeat(`Adapter keepalive (${Math.round((elapsed_since_spawn_ms || 0) / 1000)}s since spawn)`);
+        },
+        onLivenessHeartbeat: ({ elapsed_since_spawn_ms }) => {
+          // RB-6: refresh last_activity_at while the subprocess is alive but
+          // output-silent, so the stale-turn watchdog does not misfire during
+          // long quiet operations (e.g. running a test suite inside the turn).
+          tracker.heartbeat(`Subprocess alive (${Math.round((elapsed_since_spawn_ms || 0) / 1000)}s since spawn)`);
+        },
       };
 
       const recordOutputActivity = (stream, text) => {
@@ -435,6 +445,37 @@ export async function executeGovernedRun(context, opts = {}) {
           const transport = runtime ? resolvePromptTransport(runtime) : 'dispatch_bundle_only';
           log(chalk.dim(`  Dispatching to local CLI: ${runtime?.command || '(default)'}  transport: ${transport}`));
           adapterResult = await dispatchLocalCli(projectRoot, state, cfg, adapterOpts);
+
+          // Rate-limit backoff: if adapter classified as rate_limited + retryable,
+          // apply exponential backoff and re-dispatch. Does NOT consume max_turn_retries.
+          const RATE_LIMIT_MAX_RETRIES = 5;
+          const RATE_LIMIT_BASE_DELAY_MS = 2000;
+          const RATE_LIMIT_MAX_DELAY_MS = 120_000;
+          const RATE_LIMIT_BACKOFF_MULTIPLIER = 2;
+
+          let rateLimitAttempt = 0;
+          while (
+            adapterResult?.classified?.error_class === 'rate_limited' &&
+            adapterResult?.classified?.retryable === true &&
+            rateLimitAttempt < RATE_LIMIT_MAX_RETRIES
+          ) {
+            rateLimitAttempt++;
+            const resetMs = adapterResult.classified.reset_ms;
+            const exponentialDelay = Math.min(
+              RATE_LIMIT_MAX_DELAY_MS,
+              RATE_LIMIT_BASE_DELAY_MS * RATE_LIMIT_BACKOFF_MULTIPLIER ** (rateLimitAttempt - 1),
+            );
+            const delayMs = resetMs != null ? Math.max(resetMs, RATE_LIMIT_BASE_DELAY_MS) : exponentialDelay;
+            // Add jitter: 0-25% of delay
+            const jitter = Math.floor(Math.random() * delayMs * 0.25);
+            const totalDelay = delayMs + jitter;
+
+            log(chalk.yellow(`  Rate-limited by provider (attempt ${rateLimitAttempt}/${RATE_LIMIT_MAX_RETRIES}). Retrying in ${Math.ceil(totalDelay / 1000)}s...`));
+            await new Promise((resolve) => setTimeout(resolve, totalDelay));
+
+            log(chalk.dim(`  Re-dispatching after rate-limit backoff...`));
+            adapterResult = await dispatchLocalCli(projectRoot, state, cfg, adapterOpts);
+          }
         } else if (runtimeType === 'remote_agent') {
           ensureStartingState(null);
           ensureRunningState('request');
@@ -575,6 +616,15 @@ export async function executeGovernedRun(context, opts = {}) {
 
     async approveGate(gateType, state) {
       if (autoApprove) {
+        // Lights-out without blind trust: a credentialed gate (protecting an
+        // irreversible, external, or operator-owned action) is NEVER auto-approved,
+        // even under --auto-approve / continuous mode. It falls through to gate_held,
+        // so a human must approve it (agentxchain approve-transition / approve-completion).
+        if (isCredentialedExitGate(config, state?.phase)) {
+          const gateId = config?.routing?.[state?.phase]?.exit_gate;
+          log(chalk.red(`  Gate "${gateId}" is credentialed — auto-approval refused. A human must approve (lights-out without blind trust).`));
+          return false;
+        }
         log(chalk.yellow(`  Auto-approved ${gateType} gate`));
         return true;
       }

package/src/commands/serve.js

@@ -0,0 +1,64 @@
+/**
+ * agentxchain serve — start the hosted runner HTTP server.
+ *
+ * Exposes control plane API routes for remote run management and dispatches
+ * governed turns to cloud agent APIs via the execution worker.
+ *
+ * Usage:
+ *   agentxchain serve [--port 4100] [--host 127.0.0.1] [--project <path>]
+ */
+
+import { resolve } from 'node:path';
+import { findProjectRoot, loadProjectContext } from '../lib/config.js';
+import { createHostedRunner } from '../lib/api/hosted-runner.js';
+
+export async function serveCommand(opts) {
+  const rootHint = opts.project || process.cwd();
+  const root = findProjectRoot(resolve(rootHint));
+
+  if (!root) {
+    process.stderr.write(
+      `[agentxchain serve] Error: no agentxchain.json found at or above ${rootHint}\n`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const ctx = loadProjectContext(root);
+  if (!ctx || !ctx.config) {
+    process.stderr.write(
+      `[agentxchain serve] Error: failed to load project configuration from ${root}\n`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const port = parseInt(opts.port || '4100', 10);
+  const host = opts.host || '127.0.0.1';
+
+  const additionalProjects = (opts.projects || '')
+    .split(',')
+    .map(p => p.trim())
+    .filter(Boolean)
+    .map(p => resolve(p));
+
+  const runner = createHostedRunner({
+    root,
+    config: ctx.config,
+    port,
+    host,
+    projects: additionalProjects,
+  });
+
+  await runner.start();
+  process.stderr.write(`[agentxchain serve] Hosted runner listening on http://${host}:${port}\n`);
+
+  const shutdown = async () => {
+    process.stderr.write('[agentxchain serve] Shutting down...\n');
+    await runner.stop();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}