agentxchain 2.115.0 → 2.117.0

package/README.md

@@ -202,7 +202,7 @@ Partial coordinator artifacts are first-class here too: `audit` and `report` kee
 | `multi init\|status\|step\|resume\|approve-gate\|resync` | Run the multi-repo coordinator lifecycle, including blocked-state recovery via `multi resume` |
 | `intake record\|triage\|approve\|plan\|start\|scan\|resolve` | Continuous-delivery intake: turn delivery signals into governed work items |
 | `intake handoff` | Bridge a planned intake intent to a coordinator workstream for multi-repo execution |
-| `schedule list\|run-due\|daemon\|status` | Run repo-local lights-out scheduling: inspect schedules, execute due runs, poll in a local daemon loop, or check daemon heartbeat |
+| `schedule list\|run-due\|daemon\|status` | Run repo-local lights-out scheduling: inspect schedules, execute due runs, poll in a local daemon loop, continue explicitly unblocked schedule-owned runs, or check daemon heartbeat |
 | `plugin install\|list\|remove` | Install, inspect, or remove governed hook plugins under `.agentxchain/plugins/` |
 | `plugin list-available` | List bundled built-in plugins installable by short name |
 | `export [--output <path>]` | Export the portable raw governed/coordinator artifact for continuity or offline review |

package/bin/agentxchain.js

@@ -67,6 +67,8 @@ import { rebindCommand } from '../src/commands/rebind.js';
 import { branchCommand } from '../src/commands/branch.js';
 import { migrateCommand } from '../src/commands/migrate.js';
 import { resumeCommand } from '../src/commands/resume.js';
+import { unblockCommand } from '../src/commands/unblock.js';
+import { injectCommand } from '../src/commands/inject.js';
 import { escalateCommand } from '../src/commands/escalate.js';
 import { acceptTurnCommand } from '../src/commands/accept-turn.js';
 import { rejectTurnCommand } from '../src/commands/reject-turn.js';
@@ -122,7 +124,7 @@ import { eventsCommand } from '../src/commands/events.js';
 import { connectorCheckCommand } from '../src/commands/connector.js';
 import { scheduleDaemonCommand, scheduleListCommand, scheduleRunDueCommand, scheduleStatusCommand } from '../src/commands/schedule.js';
 import { chainLatestCommand, chainListCommand, chainShowCommand } from '../src/commands/chain.js';
-import { missionAttachChainCommand, missionListCommand, missionPlanApproveCommand, missionPlanCommand, missionPlanLaunchCommand, missionPlanListCommand, missionPlanShowCommand, missionShowCommand, missionStartCommand } from '../src/commands/mission.js';
+import { missionAttachChainCommand, missionListCommand, missionPlanApproveCommand, missionPlanAutopilotCommand, missionPlanCommand, missionPlanLaunchCommand, missionPlanListCommand, missionPlanShowCommand, missionShowCommand, missionStartCommand } from '../src/commands/mission.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
@@ -498,6 +500,18 @@ missionPlanCmd
   .option('-d, --dir <path>', 'Project directory')
   .action(missionPlanLaunchCommand);
 
+missionPlanCmd
+  .command('autopilot [plan_id]')
+  .description('Run unattended wave execution of an approved plan (default: latest plan)')
+  .option('-m, --mission <mission_id>', 'Explicit mission ID')
+  .option('--max-waves <n>', 'Maximum number of dependency waves (default: 10)')
+  .option('--continue-on-failure', 'Skip failed workstreams and keep launching ready ones')
+  .option('--cooldown <seconds>', 'Pause between waves in seconds (default: 5)')
+  .option('--auto-approve', 'Auto-approve run gates during execution')
+  .option('-j, --json', 'Output as JSON')
+  .option('-d, --dir <path>', 'Project directory')
+  .action(missionPlanAutopilotCommand);
+
 missionPlanCmd
   .command('list')
   .description('List all plans for a mission')
@@ -588,6 +602,23 @@ program
   .option('--turn <id>', 'Target a specific retained turn when multiple exist')
   .action(resumeCommand);
 
+program
+  .command('unblock <escalation-id>')
+  .description('Resolve the current human escalation record and continue the governed run')
+  .action(unblockCommand);
+
+program
+  .command('inject <description>')
+  .description('Inject a priority work item into the intake queue (composed record + triage + approve)')
+  .option('--priority <level>', 'Priority level (p0, p1, p2, p3)', 'p0')
+  .option('--template <id>', 'Governed template (generic, api-service, cli-tool, library, web-app, enterprise-app)', 'generic')
+  .option('--charter <text>', 'Delivery charter (defaults to description)')
+  .option('--acceptance <text>', 'Comma-separated acceptance criteria')
+  .option('--approver <name>', 'Approver identity', 'human')
+  .option('--no-approve', 'Stop at triaged state instead of auto-approving')
+  .option('-j, --json', 'Output as JSON')
+  .action(injectCommand);
+
 program
   .command('escalate')
   .description('Raise an operator escalation and block the governed run intentionally')
@@ -640,6 +671,11 @@ program
   .option('--chain-on <statuses>', 'Comma-separated terminal statuses that trigger chaining (default: completed)')
   .option('--chain-cooldown <seconds>', 'Seconds to wait between chained runs (default: 5)', parseInt)
   .option('--mission <mission_id>', 'Bind chained runs to a mission (use "latest" for most recent mission)')
+  .option('--continuous', 'Enable continuous vision-driven loop: derive work from VISION.md and run until satisfied')
+  .option('--vision <path>', 'Path to VISION.md (project-relative or absolute, default: .planning/VISION.md)')
+  .option('--max-runs <n>', 'Maximum consecutive governed runs in continuous mode (default: 100)', parseInt)
+  .option('--poll-seconds <n>', 'Seconds between idle-detection cycles in continuous mode (default: 30)', parseInt)
+  .option('--max-idle-cycles <n>', 'Stop after N consecutive idle cycles with no derivable work (default: 3)', parseInt)
   .action(runCommand);
 
 program

package/package.json

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

package/src/commands/events.js

@@ -73,7 +73,12 @@ function printEvent(evt) {
   const gateFailedDetail = evt.event_type === 'gate_failed' && evt.payload?.from_phase
     ? ` ${evt.payload.from_phase} → ${evt.payload.to_phase || '?'}${evt.payload.reasons?.length ? ` — ${evt.payload.reasons[0]}` : ''}${evt.payload.gate_id ? ` (${evt.payload.gate_id})` : ''}`
     : '';
-  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${conflictDetail}${rejectionDetail}${phaseTransitionDetail}${gateFailedDetail}`);
+  const humanEscalationDetail = evt.event_type === 'human_escalation_raised' && evt.payload?.escalation_id
+    ? ` ${evt.payload.escalation_id} [${evt.payload.type || '?'}]${evt.payload.service ? ` (${evt.payload.service})` : ''}`
+    : evt.event_type === 'human_escalation_resolved' && evt.payload?.escalation_id
+      ? ` ${evt.payload.escalation_id} via ${evt.payload.resolved_via || '?'}`
+      : '';
+  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${conflictDetail}${rejectionDetail}${phaseTransitionDetail}${gateFailedDetail}${humanEscalationDetail}`);
 }
 
 function formatConflictDetail(evt) {
@@ -115,6 +120,8 @@ function colorEventType(type) {
     phase_entered: chalk.magenta,
     escalation_raised: chalk.red.bold,
     escalation_resolved: chalk.green,
+    human_escalation_raised: chalk.red.bold,
+    human_escalation_resolved: chalk.green,
     gate_pending: chalk.yellow,
     gate_approved: chalk.green,
     gate_failed: chalk.red,

package/src/commands/inject.js

@@ -0,0 +1,81 @@
+import chalk from 'chalk';
+import { loadProjectContext } from '../lib/config.js';
+import { injectIntent } from '../lib/intake.js';
+
+export async function injectCommand(description, opts) {
+  const context = loadProjectContext();
+  if (!context) {
+    console.log(chalk.red('No agentxchain.json found. Run `agentxchain init` first.'));
+    process.exit(1);
+  }
+
+  const { root, config } = context;
+
+  if (config.protocol_mode !== 'governed') {
+    console.log(chalk.red('The inject command is only available for governed projects.'));
+    process.exit(1);
+  }
+
+  if (!description || !String(description).trim()) {
+    console.log(chalk.red('A description is required. Example: agentxchain inject "Fix the sidebar ordering"'));
+    process.exit(1);
+  }
+
+  const result = injectIntent(root, String(description).trim(), {
+    priority: opts.priority,
+    template: opts.template,
+    charter: opts.charter,
+    acceptance: opts.acceptance,
+    approver: opts.approver,
+    noApprove: opts.approve === false,
+  });
+
+  if (!result.ok) {
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: false, error: result.error }, null, 2));
+    } else {
+      console.log(chalk.red(result.error));
+    }
+    process.exit(result.exitCode || 1);
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify({
+      ok: true,
+      intent_id: result.intent.intent_id,
+      event_id: result.event.event_id,
+      status: result.intent.status,
+      priority: result.intent.priority,
+      deduplicated: result.deduplicated,
+      preemption_marker: result.preemption_marker,
+    }, null, 2));
+    return;
+  }
+
+  console.log('');
+  if (result.deduplicated) {
+    console.log(chalk.yellow('  ⚠ Duplicate injection — existing intent returned'));
+    console.log(chalk.dim(`  Intent: ${result.intent?.intent_id || 'unknown'}`));
+    console.log(chalk.dim(`  Status: ${result.intent?.status || 'unknown'}`));
+    console.log('');
+    return;
+  }
+
+  const priority = result.intent.priority || 'p0';
+  const priorityColor = priority === 'p0' ? chalk.red.bold : priority === 'p1' ? chalk.yellow.bold : chalk.dim;
+
+  console.log(chalk.green.bold('  Injected'));
+  console.log(chalk.dim(`  Intent:   ${result.intent.intent_id}`));
+  console.log(`  Priority: ${priorityColor(priority)}`);
+  console.log(chalk.dim(`  Status:   ${result.intent.status}`));
+  console.log(chalk.dim(`  Charter:  ${result.intent.charter || description}`));
+
+  if (result.preemption_marker) {
+    console.log('');
+    console.log(chalk.red.bold('  ⚡ Preemption marker written'));
+    console.log(chalk.dim('  The current run will yield after the active turn completes.'));
+    console.log(chalk.dim('  The scheduler/continuous loop will pick up this intent next.'));
+  }
+
+  console.log('');
+}

package/src/commands/mission.js

@@ -740,6 +740,333 @@ async function missionPlanLaunchAllReady(planTarget, opts, context) {
   }
 }
 
+// ── Autopilot (unattended wave execution) ───────────────────────────────────
+
+export async function missionPlanAutopilotCommand(planTarget, opts) {
+  const context = loadProjectContext(opts.dir || process.cwd());
+  if (!context) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+  const { root } = context;
+
+  const mission = opts.mission
+    ? loadMissionArtifact(root, opts.mission)
+    : loadLatestMissionArtifact(root);
+
+  if (!mission) {
+    console.error(chalk.red('No mission found.'));
+    console.error(chalk.dim('  Use --mission <id> or create a mission first.'));
+    process.exit(1);
+  }
+
+  const plan = planTarget && planTarget !== 'latest'
+    ? loadPlan(root, mission.mission_id, planTarget)
+    : loadLatestPlan(root, mission.mission_id);
+
+  if (!plan) {
+    if (planTarget && planTarget !== 'latest') {
+      console.error(chalk.red(`Plan not found: ${planTarget}`));
+    } else {
+      console.error(chalk.red(`No plans found for mission ${mission.mission_id}.`));
+      console.error(chalk.dim('  Run `agentxchain mission plan latest` to generate one.'));
+    }
+    process.exit(1);
+  }
+
+  const continueOnFailure = !!opts.continueOnFailure;
+
+  if (plan.status === 'completed') {
+    if (opts.json) {
+      console.log(JSON.stringify({
+        plan_id: plan.plan_id,
+        mission_id: mission.mission_id,
+        waves: [],
+        summary: { total_waves: 0, total_launched: 0, completed: 0, failed: 0, terminal_reason: 'plan_completed' },
+      }, null, 2));
+    } else {
+      console.log(chalk.green(`Plan ${plan.plan_id} is already completed. Nothing to do.`));
+    }
+    return;
+  }
+
+  if (plan.status !== 'approved' && !(plan.status === 'needs_attention' && continueOnFailure)) {
+    console.error(chalk.red(`Plan ${plan.plan_id} status is "${plan.status}". Autopilot requires an approved plan${continueOnFailure ? ' (or needs_attention with --continue-on-failure)' : ''}.`));
+    process.exit(1);
+  }
+
+  const maxWaves = Math.max(1, parseInt(opts.maxWaves, 10) || 10);
+  const cooldownSeconds = Math.max(0, parseInt(opts.cooldown, 10) || 5);
+  const executor = opts._executeGovernedRun || executeGovernedRun;
+  const logger = opts._log || console.log;
+  const sleep = opts._sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+
+  const waves = [];
+  let totalLaunched = 0;
+  let totalCompleted = 0;
+  let totalFailed = 0;
+  let terminalReason = null;
+  let interrupted = false;
+
+  // SIGINT handler
+  const onSigint = () => { interrupted = true; };
+  process.on('SIGINT', onSigint);
+
+  try {
+    for (let waveNum = 1; waveNum <= maxWaves; waveNum++) {
+      if (interrupted) {
+        terminalReason = 'interrupted';
+        break;
+      }
+
+      // Reload plan from disk to pick up outcomes from previous waves
+      const currentPlan = loadPlan(root, mission.mission_id, plan.plan_id);
+      if (!currentPlan) {
+        terminalReason = 'plan_read_error';
+        break;
+      }
+
+      if (currentPlan.status === 'completed') {
+        terminalReason = 'plan_completed';
+        break;
+      }
+
+      const readyWorkstreams = getReadyWorkstreams(currentPlan);
+      if (readyWorkstreams.length === 0) {
+        terminalReason = deriveAutopilotIdleOutcome(currentPlan, continueOnFailure);
+        break;
+      }
+
+      if (!opts.json) {
+        console.log(chalk.bold(`\n━━━ Wave ${waveNum} — launching ${readyWorkstreams.length} workstream(s) ━━━\n`));
+      }
+
+      const waveResults = [];
+      let waveHadFailure = false;
+
+      for (let i = 0; i < readyWorkstreams.length; i++) {
+        if (interrupted) break;
+
+        const ws = readyWorkstreams[i];
+        const prefix = `[${i + 1}/${readyWorkstreams.length}]`;
+
+        // Skip remaining in wave if failure and not continue-on-failure
+        if (waveHadFailure && !continueOnFailure) {
+          waveResults.push({ workstream_id: ws.workstream_id, status: 'skipped', skip_reason: 'prior workstream failed' });
+          if (!opts.json) {
+            console.log(`${prefix} ${chalk.dim(ws.workstream_id)} — ${chalk.dim('skipped (prior workstream failed)')}`);
+          }
+          continue;
+        }
+
+        const launch = launchWorkstream(root, mission.mission_id, plan.plan_id, ws.workstream_id, {
+          allowNeedsAttention: continueOnFailure,
+        });
+        if (!launch.ok) {
+          waveHadFailure = true;
+          totalFailed++;
+          waveResults.push({ workstream_id: ws.workstream_id, status: 'launch_error', error: launch.error });
+          if (!opts.json) {
+            console.log(`${prefix} ${chalk.red(ws.workstream_id)} — launch error: ${launch.error}`);
+          }
+          continue;
+        }
+
+        totalLaunched++;
+        if (!opts.json) {
+          process.stdout.write(`${prefix} ${chalk.cyan(ws.workstream_id)} → ${launch.chainId} ... `);
+        }
+
+        const chainOpts = {
+          enabled: true,
+          maxChains: 0,
+          chainOn: ['completed'],
+          cooldownSeconds: 0,
+          mission: mission.mission_id,
+          chainId: launch.chainId,
+        };
+        const runOpts = {
+          autoApprove: !!opts.autoApprove,
+          provenance: {
+            trigger: 'autopilot',
+            created_by: 'operator',
+            trigger_reason: `mission:${mission.mission_id} workstream:${ws.workstream_id} autopilot:wave-${waveNum}`,
+          },
+        };
+
+        let execution;
+        try {
+          execution = await executeChainedRun(context, runOpts, chainOpts, executor, logger);
+        } catch (error) {
+          markWorkstreamOutcome(root, mission.mission_id, plan.plan_id, ws.workstream_id, {
+            terminalReason: 'execution_error',
+            completedAt: new Date().toISOString(),
+          });
+          waveHadFailure = true;
+          totalFailed++;
+          waveResults.push({ workstream_id: ws.workstream_id, chain_id: launch.chainId, status: 'needs_attention', error: error.message });
+          if (!opts.json) {
+            console.log(chalk.red(`needs_attention ✗ (${error.message})`));
+          }
+          continue;
+        }
+
+        const lastRun = execution?.chainReport?.runs?.[execution.chainReport.runs.length - 1] || null;
+        const wsTerminalReason = lastRun?.status === 'completed'
+          ? 'completed'
+          : (lastRun?.status || execution?.chainReport?.terminal_reason || 'execution_error');
+
+        markWorkstreamOutcome(root, mission.mission_id, plan.plan_id, ws.workstream_id, {
+          terminalReason: wsTerminalReason,
+          completedAt: execution?.chainReport?.completed_at || new Date().toISOString(),
+        });
+
+        const wsStatus = wsTerminalReason === 'completed' ? 'completed' : 'needs_attention';
+        if (wsStatus === 'completed') {
+          totalCompleted++;
+        } else {
+          totalFailed++;
+          waveHadFailure = true;
+        }
+
+        waveResults.push({ workstream_id: ws.workstream_id, chain_id: launch.chainId, status: wsStatus });
+
+        if (!opts.json) {
+          if (wsStatus === 'completed') {
+            console.log(chalk.green('completed ✓'));
+          } else {
+            console.log(chalk.red('needs_attention ✗'));
+          }
+        }
+      }
+
+      waves.push({ wave: waveNum, launched: waveResults.filter((r) => r.chain_id).map((r) => r.workstream_id), results: waveResults });
+
+      if (interrupted) {
+        terminalReason = 'interrupted';
+        break;
+      }
+
+      // Check if plan is now complete after this wave
+      const afterWavePlan = loadPlan(root, mission.mission_id, plan.plan_id);
+      if (afterWavePlan?.status === 'completed') {
+        terminalReason = 'plan_completed';
+        break;
+      }
+
+      const remainingReadyWorkstreams = getReadyWorkstreams(afterWavePlan);
+      if (remainingReadyWorkstreams.length === 0) {
+        terminalReason = deriveAutopilotIdleOutcome(afterWavePlan, continueOnFailure);
+        break;
+      }
+
+      if (waveHadFailure && !continueOnFailure) {
+        terminalReason = 'failure_stopped';
+        break;
+      }
+
+      if (waveNum === maxWaves) {
+        terminalReason = 'wave_limit_reached';
+        break;
+      }
+
+      // Cooldown between waves
+      if (cooldownSeconds > 0 && !interrupted) {
+        if (!opts.json) {
+          console.log(chalk.dim(`\nCooldown: ${cooldownSeconds}s before next wave...\n`));
+        }
+        await sleep(cooldownSeconds * 1000);
+      }
+    }
+  } finally {
+    process.removeListener('SIGINT', onSigint);
+  }
+
+  if (!terminalReason) {
+    terminalReason = totalFailed > 0
+      ? (continueOnFailure ? 'plan_incomplete' : 'failure_stopped')
+      : 'plan_completed';
+  }
+
+  const jsonOutput = {
+    plan_id: plan.plan_id,
+    mission_id: mission.mission_id,
+    waves,
+    summary: {
+      total_waves: waves.length,
+      total_launched: totalLaunched,
+      completed: totalCompleted,
+      failed: totalFailed,
+      terminal_reason: terminalReason,
+    },
+  };
+
+  if (opts.json) {
+    console.log(JSON.stringify(jsonOutput, null, 2));
+  } else {
+    console.log('');
+    console.log(chalk.bold('━━━ Autopilot Summary ━━━'));
+    console.log(`  Waves:      ${waves.length}`);
+    console.log(`  Launched:   ${totalLaunched}`);
+    console.log(`  Completed:  ${totalCompleted}`);
+    console.log(`  Failed:     ${totalFailed}`);
+    console.log(`  Outcome:    ${formatTerminalReason(terminalReason)}`);
+    if (terminalReason === 'plan_completed') {
+      console.log(chalk.green('\n  Plan completed successfully.'));
+    } else if (terminalReason === 'deadlock') {
+      console.log(chalk.red('\n  Deadlock: remaining workstreams are blocked with unsatisfiable dependencies.'));
+      console.log(chalk.dim('  Inspect with `agentxchain mission plan show latest`.'));
+    } else if (terminalReason === 'wave_limit_reached') {
+      console.log(chalk.yellow(`\n  Wave limit reached. Run autopilot again to continue.`));
+    } else if (terminalReason === 'failure_stopped') {
+      console.log(chalk.red('\n  Stopped due to workstream failure.'));
+      console.log(chalk.dim('  Use --continue-on-failure to skip failures, or retry with `mission plan launch --workstream <id> --retry`.'));
+    } else if (terminalReason === 'plan_incomplete') {
+      console.log(chalk.yellow('\n  Autopilot exhausted all launchable work, but failed workstreams still need attention.'));
+      console.log(chalk.dim('  Retry the failed workstream or inspect the plan before running autopilot again.'));
+    } else if (terminalReason === 'interrupted') {
+      console.log(chalk.yellow('\n  Interrupted by operator.'));
+    }
+  }
+
+  if (terminalReason !== 'plan_completed') {
+    process.exit(1);
+  }
+}
+
+function formatTerminalReason(reason) {
+  switch (reason) {
+    case 'plan_completed': return chalk.green('plan completed');
+    case 'failure_stopped': return chalk.red('stopped on failure');
+    case 'plan_incomplete': return chalk.yellow('incomplete after failures');
+    case 'deadlock': return chalk.red('deadlock');
+    case 'wave_limit_reached': return chalk.yellow('wave limit reached');
+    case 'interrupted': return chalk.yellow('interrupted');
+    case 'no_ready_workstreams': return chalk.yellow('no ready workstreams');
+    default: return reason || '—';
+  }
+}
+
+function deriveAutopilotIdleOutcome(plan, continueOnFailure) {
+  const summary = getWorkstreamStatusSummary(plan);
+  const allCompleted = plan.workstreams.every((ws) => ws.launch_status === 'completed');
+  if (allCompleted) {
+    return 'plan_completed';
+  }
+
+  const hasNeedsAttention = (summary.needs_attention || 0) > 0;
+  const hasBlocked = (summary.blocked || 0) > 0;
+  const hasLaunched = (summary.launched || 0) > 0;
+
+  if (hasNeedsAttention) {
+    return continueOnFailure ? 'plan_incomplete' : 'failure_stopped';
+  }
+  if (hasBlocked && !hasLaunched) {
+    return 'deadlock';
+  }
+  return 'no_ready_workstreams';
+}
+
 // ── Plan rendering ───────────────────────────────────────────────────────────
 
 function renderPlan(plan) {

package/src/commands/resume.js

@@ -77,6 +77,8 @@ export async function resumeCommand(opts) {
   // §47: active + turns present → reject (resume assigns new turns, not re-dispatches)
   const activeCount = getActiveTurnCount(state);
   const activeTurns = getActiveTurns(state);
+  const resumeVia = opts?._via || 'resume';
+  const turnResumeVia = opts?._via || 'resume --turn';
 
   if (state.status === 'active' && activeCount > 0) {
     if (activeCount === 1) {
@@ -135,7 +137,7 @@ export async function resumeCommand(opts) {
       console.log(`  Attempt: ${retainedTurn.attempt}`);
       console.log('');
 
-      const reactivated = reactivateGovernedRun(root, state, { via: 'resume --turn', notificationConfig: config });
+      const reactivated = reactivateGovernedRun(root, state, { via: turnResumeVia, notificationConfig: config });
       if (!reactivated.ok) {
         console.log(chalk.red(`Failed to reactivate run: ${reactivated.error}`));
         process.exit(1);
@@ -195,7 +197,7 @@ export async function resumeCommand(opts) {
     console.log(`  Attempt: ${retainedTurn.attempt}`);
     console.log('');
 
-    const reactivated = reactivateGovernedRun(root, state, { via: 'resume --turn', notificationConfig: config });
+    const reactivated = reactivateGovernedRun(root, state, { via: turnResumeVia, notificationConfig: config });
     if (!reactivated.ok) {
       console.log(chalk.red(`Failed to reactivate blocked run: ${reactivated.error}`));
       process.exit(1);
@@ -234,7 +236,7 @@ export async function resumeCommand(opts) {
 
   // §47: paused + run_id exists → resume same run
   if (state.status === 'blocked' && state.run_id) {
-    const reactivated = reactivateGovernedRun(root, state, { via: 'resume', notificationConfig: config });
+    const reactivated = reactivateGovernedRun(root, state, { via: resumeVia, notificationConfig: config });
     if (!reactivated.ok) {
       console.log(chalk.red(`Failed to reactivate blocked run: ${reactivated.error}`));
       process.exit(1);
@@ -245,7 +247,7 @@ export async function resumeCommand(opts) {
 
   // §47: paused + run_id exists → resume same run
   if (state.status === 'paused' && state.run_id) {
-    const reactivated = reactivateGovernedRun(root, state, { via: 'resume', notificationConfig: config });
+    const reactivated = reactivateGovernedRun(root, state, { via: resumeVia, notificationConfig: config });
     if (!reactivated.ok) {
       console.log(chalk.red(`Failed to reactivate run: ${reactivated.error}`));
       process.exit(1);

package/src/commands/run.js

@@ -45,6 +45,7 @@ import {
   getTurnStagingResultPath,
 } from '../lib/turn-paths.js';
 import { resolveChainOptions, executeChainedRun } from '../lib/run-chain.js';
+import { resolveContinuousOptions, executeContinuousRun } from '../lib/continuous-run.js';
 
 export async function runCommand(opts) {
   const context = loadProjectContext();
@@ -53,6 +54,18 @@ export async function runCommand(opts) {
     process.exit(1);
   }
 
+  // Continuous vision-driven mode
+  const contOpts = resolveContinuousOptions(opts, context.config);
+  if (contOpts.enabled) {
+    console.log(chalk.cyan.bold('agentxchain run --continuous'));
+    console.log(chalk.dim(`  Vision: ${contOpts.visionPath}`));
+    console.log(chalk.dim(`  Max runs: ${contOpts.maxRuns}, Poll: ${contOpts.pollSeconds}s, Idle limit: ${contOpts.maxIdleCycles}`));
+    console.log(chalk.dim(`  Triage approval: ${contOpts.triageApproval}`));
+    console.log('');
+    const { exitCode } = await executeContinuousRun(context, contOpts, executeGovernedRun);
+    process.exit(exitCode);
+  }
+
   const chainOpts = resolveChainOptions(opts, context.config);
   if (chainOpts.enabled) {
     console.log(chalk.cyan.bold('agentxchain run --chain'));