agentxchain 2.114.0 → 2.116.0

package/bin/agentxchain.js

@@ -122,7 +122,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'));
@@ -491,12 +491,25 @@ missionPlanCmd
   .description('Launch workstream(s) from an approved plan (default: latest plan)')
   .option('-w, --workstream <id>', 'Workstream ID to launch (mutually exclusive with --all-ready)')
   .option('--all-ready', 'Launch all ready workstreams sequentially (mutually exclusive with --workstream)')
+  .option('--retry', 'Retry a failed workstream (requires --workstream, only for needs_attention status)')
   .option('-m, --mission <mission_id>', 'Explicit mission ID')
   .option('--auto-approve', 'Auto-approve run gates while executing the launched workstream')
   .option('-j, --json', 'Output as JSON')
   .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')

package/package.json

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

package/src/commands/mission.js

@@ -18,6 +18,7 @@ import {
   getReadyWorkstreams,
   getWorkstreamStatusSummary,
   launchWorkstream,
+  retryWorkstream,
   markWorkstreamOutcome,
   loadAllPlans,
   loadLatestPlan,
@@ -423,6 +424,16 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
     process.exit(1);
   }
 
+  if (opts.retry && !opts.workstream) {
+    console.error(chalk.red('--retry requires --workstream <id>. Specify which failed workstream to retry.'));
+    process.exit(1);
+  }
+
+  if (opts.retry && opts.allReady) {
+    console.error(chalk.red('--retry and --all-ready are mutually exclusive. Retry targets a specific workstream.'));
+    process.exit(1);
+  }
+
   if (!opts.allReady && !opts.workstream) {
     console.error(chalk.red('--workstream <id> or --all-ready is required. Specify which workstream(s) to launch.'));
     process.exit(1);
@@ -457,7 +468,9 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
     process.exit(1);
   }
 
-  const launch = launchWorkstream(root, mission.mission_id, plan.plan_id, opts.workstream);
+  const launch = opts.retry
+    ? retryWorkstream(root, mission.mission_id, plan.plan_id, opts.workstream)
+    : launchWorkstream(root, mission.mission_id, plan.plan_id, opts.workstream);
   if (!launch.ok) {
     console.error(chalk.red(launch.error));
     process.exit(1);
@@ -727,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) {
@@ -949,6 +1289,8 @@ function renderMissionPlanError(error) {
 }
 
 function renderMissionSnapshot(snapshot) {
+  const latestPlan = snapshot.latest_plan || null;
+
   console.log(chalk.bold(`Mission: ${snapshot.mission_id}`));
   console.log('');
   console.log(`  Title:                 ${snapshot.title || '—'}`);
@@ -967,10 +1309,19 @@ function renderMissionSnapshot(snapshot) {
     console.log(`  Missing chains:        ${snapshot.missing_chain_ids.join(', ')}`);
   }
 
+  if (latestPlan) {
+    console.log('');
+    console.log(chalk.bold('  Latest plan:'));
+    console.log(`    Plan ID:             ${latestPlan.plan_id || '—'}`);
+    console.log(`    Status:              ${formatPlanStatus(latestPlan.status)}`);
+    console.log(`    Completion:          ${latestPlan.completion_percentage}% (${latestPlan.completed_count}/${latestPlan.workstream_count} completed)`);
+    console.log(`    Workstream summary:  ready ${latestPlan.ready_count}, blocked ${latestPlan.blocked_count}, launched ${latestPlan.launched_count}, completed ${latestPlan.completed_count}, needs_attention ${latestPlan.needs_attention_count}`);
+  }
+
   if (!snapshot.chains || snapshot.chains.length === 0) {
     console.log('');
     console.log(chalk.dim('  No chains attached.'));
-    console.log(chalk.dim('  Use `agentxchain mission attach-chain latest` after a chained run.'));
+    console.log(chalk.dim('  Use `agentxchain run --chain --mission latest` for new work, or `agentxchain mission attach-chain latest` to repair an unbound chain.'));
     return;
   }
 

package/src/lib/dashboard/plan-reader.js

@@ -5,9 +5,7 @@
  * Plans are advisory repo-local artifacts; this reader is not protocol-normative.
  */
 
-import { existsSync, readdirSync } from 'fs';
-import { join } from 'path';
-import { loadAllPlans, loadLatestPlan } from '../mission-plans.js';
+import { buildPlanProgressSummary, loadAllPlans } from '../mission-plans.js';
 import { loadAllMissionArtifacts } from '../missions.js';
 
 /**
@@ -65,28 +63,12 @@ export function readPlanSnapshot(workspacePath, { limit, missionId } = {}) {
  * Build a dashboard-ready summary for a single plan.
  */
 function buildPlanSummary(plan) {
+  const summary = buildPlanProgressSummary(plan);
   const workstreams = Array.isArray(plan.workstreams) ? plan.workstreams : [];
   const launchRecords = Array.isArray(plan.launch_records) ? plan.launch_records : [];
 
-  const statusCounts = {};
-  for (const ws of workstreams) {
-    const status = ws.launch_status || 'unknown';
-    statusCounts[status] = (statusCounts[status] || 0) + 1;
-  }
-
   return {
-    plan_id: plan.plan_id,
-    mission_id: plan.mission_id,
-    status: plan.status,
-    created_at: plan.created_at,
-    updated_at: plan.updated_at,
-    approved_at: plan.approved_at || null,
-    supersedes_plan_id: plan.supersedes_plan_id || null,
-    superseded_by_plan_id: plan.superseded_by_plan_id || null,
-    input_goal: plan.input?.goal || null,
-    workstream_count: workstreams.length,
-    launch_record_count: launchRecords.length,
-    workstream_status_counts: statusCounts,
+    ...summary,
     workstreams: workstreams.map((ws) => ({
       workstream_id: ws.workstream_id,
       title: ws.title,

package/src/lib/mission-plans.js

@@ -306,6 +306,38 @@ export function loadPlan(root, missionId, planId) {
   return plans.find((p) => p.plan_id === planId) || null;
 }
 
+export function buildPlanProgressSummary(plan) {
+  if (!plan || typeof plan !== 'object') return null;
+
+  const workstreams = Array.isArray(plan.workstreams) ? plan.workstreams : [];
+  const launchRecords = Array.isArray(plan.launch_records) ? plan.launch_records : [];
+  const workstreamStatusCounts = getWorkstreamStatusSummary(plan);
+  const completedCount = workstreamStatusCounts.completed || 0;
+
+  return {
+    plan_id: plan.plan_id,
+    mission_id: plan.mission_id,
+    status: plan.status,
+    created_at: plan.created_at,
+    updated_at: plan.updated_at,
+    approved_at: plan.approved_at || null,
+    supersedes_plan_id: plan.supersedes_plan_id || null,
+    superseded_by_plan_id: plan.superseded_by_plan_id || null,
+    input_goal: plan.input?.goal || null,
+    workstream_count: workstreams.length,
+    launch_record_count: launchRecords.length,
+    workstream_status_counts: workstreamStatusCounts,
+    ready_count: workstreamStatusCounts.ready || 0,
+    blocked_count: workstreamStatusCounts.blocked || 0,
+    launched_count: workstreamStatusCounts.launched || 0,
+    completed_count: completedCount,
+    needs_attention_count: workstreamStatusCounts.needs_attention || 0,
+    completion_percentage: workstreams.length === 0
+      ? 0
+      : Math.round((completedCount / workstreams.length) * 100),
+  };
+}
+
 // ── Workstream launch ───────────────────────────────────────────────────────
 
 export function didChainFinishSuccessfully(chainReport) {
@@ -358,8 +390,12 @@ export function launchWorkstream(root, missionId, planId, workstreamId, options
   if (!plan) {
     return { ok: false, error: `Plan not found: ${planId}` };
   }
-  if (plan.status !== 'approved') {
-    return { ok: false, error: `Plan ${planId} is not approved (status: "${plan.status}"). Approve the plan before launching workstreams.` };
+  const allowNeedsAttention = options.allowNeedsAttention === true;
+  if (plan.status !== 'approved' && !(allowNeedsAttention && plan.status === 'needs_attention')) {
+    return {
+      ok: false,
+      error: `Plan ${planId} is not approved (status: "${plan.status}"). Approve the plan before launching workstreams.`,
+    };
   }
 
   const ws = plan.workstreams.find((w) => w.workstream_id === workstreamId);
@@ -443,6 +479,12 @@ export function markWorkstreamOutcome(root, missionId, planId, workstreamId, { t
         }
       }
     }
+
+    // Auto-complete plan when all workstreams are completed
+    const allCompleted = plan.workstreams.every((w) => w.launch_status === 'completed');
+    if (allCompleted) {
+      plan.status = 'completed';
+    }
   } else {
     ws.launch_status = 'needs_attention';
     plan.status = 'needs_attention';
@@ -454,6 +496,62 @@ export function markWorkstreamOutcome(root, missionId, planId, workstreamId, { t
   return { ok: true, plan, workstream: ws };
 }
 
+/**
+ * Retry a failed workstream by resetting its status and creating a new launch record.
+ *
+ * Only workstreams with launch_status === 'needs_attention' can be retried.
+ * The old launch record is preserved for audit. A new launch record with a new
+ * chain_id is created. If the plan was in 'needs_attention' status, it returns
+ * to 'approved' since the retry represents a new attempt.
+ *
+ * @returns {{ ok: boolean, plan?: object, workstream?: object, chainId?: string, launchRecord?: object, error?: string }}
+ */
+export function retryWorkstream(root, missionId, planId, workstreamId, options = {}) {
+  const plan = loadPlan(root, missionId, planId);
+  if (!plan) {
+    return { ok: false, error: `Plan not found: ${planId}` };
+  }
+
+  const ws = plan.workstreams.find((w) => w.workstream_id === workstreamId);
+  if (!ws) {
+    return { ok: false, error: `Workstream not found: ${workstreamId}` };
+  }
+
+  if (ws.launch_status !== 'needs_attention') {
+    return {
+      ok: false,
+      error: `Workstream ${workstreamId} cannot be retried (status: "${ws.launch_status}"). Only "needs_attention" workstreams can be retried.`,
+    };
+  }
+
+  // Generate new chain ID for the retry
+  const chainId = options.chainId || `chain-${randomUUID().slice(0, 8)}`;
+  const now = new Date().toISOString();
+  const launchRecord = {
+    workstream_id: workstreamId,
+    chain_id: chainId,
+    launched_at: now,
+    status: 'launched',
+    retry: true,
+  };
+
+  if (!Array.isArray(plan.launch_records)) {
+    plan.launch_records = [];
+  }
+  plan.launch_records.push(launchRecord);
+  ws.launch_status = 'launched';
+
+  // Restore plan status from needs_attention to approved (retry in progress)
+  if (plan.status === 'needs_attention') {
+    plan.status = 'approved';
+  }
+
+  plan.updated_at = now;
+  writePlanArtifact(root, missionId, plan);
+
+  return { ok: true, plan, workstream: ws, chainId, launchRecord };
+}
+
 // ── Batch launch helpers ───────────────────────────────────────────────────
 
 /**

package/src/lib/missions.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { loadAllChainReports, loadChainReport, loadLatestChainReport } from './chain-reports.js';
+import { buildPlanProgressSummary, loadLatestPlan } from './mission-plans.js';
 import { getActiveRepoDecisions } from './repo-decisions.js';
 
 const MISSION_ATTENTION_TERMINALS = new Set(['operator_abort', 'parent_validation_failed']);
@@ -139,6 +140,7 @@ export function buildMissionSnapshot(root, missionArtifact) {
   const totalRuns = chains.reduce((sum, chain) => sum + (chain.runs?.length || 0), 0);
   const totalTurns = chains.reduce((sum, chain) => sum + (chain.total_turns || 0), 0);
   const latestChain = chains[0] || null;
+  const latestPlan = loadLatestPlan(root, missionArtifact.mission_id);
   const activeRepoDecisions = getActiveRepoDecisions(root);
 
   return {
@@ -151,6 +153,7 @@ export function buildMissionSnapshot(root, missionArtifact) {
     total_turns: totalTurns,
     latest_chain_id: latestChain?.chain_id || null,
     latest_terminal_reason: latestChain?.terminal_reason || null,
+    latest_plan: buildPlanProgressSummary(latestPlan),
     active_repo_decisions_count: activeRepoDecisions.length,
     chains,
   };