agentxchain 2.113.0 → 2.114.0

package/bin/agentxchain.js

@@ -430,6 +430,10 @@ missionCmd
   .requiredOption('--title <text>', 'Mission title')
   .requiredOption('--goal <text>', 'Mission goal')
   .option('--id <mission_id>', 'Override the derived mission ID')
+  .option('--plan', 'Generate a proposed mission plan immediately after mission creation')
+  .option('--constraint <text>', 'Add a constraint to the planner when using --plan (repeatable)', collectOption, [])
+  .option('--role-hint <role>', 'Hint available roles to the planner when using --plan (repeatable)', collectOption, [])
+  .option('--planner-output-file <path>', 'Read planner JSON output from a file instead of calling the configured planner')
   .option('-j, --json', 'Output as JSON')
   .option('-d, --dir <path>', 'Project directory')
   .action(missionStartCommand);
@@ -462,6 +466,7 @@ const missionPlanCmd = missionCmd
   .description('Generate a decomposition plan for a mission (default: latest mission)')
   .option('--constraint <text>', 'Add a constraint to the planner (repeatable)', collectOption, [])
   .option('--role-hint <role>', 'Hint available roles to the planner (repeatable)', collectOption, [])
+  .option('--planner-output-file <path>', 'Read planner JSON output from a file instead of calling the configured planner')
   .option('-j, --json', 'Output as JSON')
   .option('-d, --dir <path>', 'Project directory')
   .action(missionPlanCommand);
@@ -483,8 +488,9 @@ missionPlanCmd
 
 missionPlanCmd
   .command('launch [plan_id]')
-  .description('Launch a workstream from an approved plan (default: latest plan)')
-  .requiredOption('-w, --workstream <id>', 'Workstream ID to launch')
+  .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('-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')

package/package.json

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

package/src/commands/mission.js

@@ -1,4 +1,6 @@
 import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
 import { findProjectRoot, loadProjectContext } from '../lib/config.js';
 import {
   attachChainToMission,
@@ -13,6 +15,8 @@ import {
 import {
   approvePlanArtifact,
   createPlanArtifact,
+  getReadyWorkstreams,
+  getWorkstreamStatusSummary,
   launchWorkstream,
   markWorkstreamOutcome,
   loadAllPlans,
@@ -54,6 +58,26 @@ export async function missionStartCommand(opts) {
   }
 
   const snapshot = buildMissionSnapshot(root, result.mission);
+  if (opts.plan) {
+    try {
+      const plan = await createMissionPlan(root, result.mission, opts);
+      if (opts.json) {
+        console.log(JSON.stringify({ mission: snapshot, plan }, null, 2));
+        return;
+      }
+
+      console.log(chalk.green(`Created mission ${snapshot.mission_id}`));
+      console.log(chalk.dim(`  Goal: ${snapshot.goal}`));
+      console.log(chalk.green(`Created plan ${plan.plan_id} for mission ${snapshot.mission_id}`));
+      renderPlan(plan);
+      return;
+    } catch (error) {
+      console.error(chalk.yellow(`Mission ${snapshot.mission_id} was created, but automatic plan generation failed.`));
+      renderMissionPlanError(error);
+      process.exit(1);
+    }
+  }
+
   if (opts.json) {
     console.log(JSON.stringify(snapshot, null, 2));
     return;
@@ -211,66 +235,21 @@ export async function missionPlanCommand(missionTarget, opts) {
     console.error(chalk.red(`Mission "${mission.mission_id}" has no goal text. The planner cannot operate on missing mission intent.`));
     process.exit(1);
   }
-
-  const constraints = Array.isArray(opts.constraint) ? opts.constraint : (opts.constraint ? [opts.constraint] : []);
-  const roleHints = Array.isArray(opts.roleHint) ? opts.roleHint : (opts.roleHint ? [opts.roleHint] : []);
-
-  // Build prompt and attempt LLM call, or use deterministic fallback
-  let plannerOutput;
-  const { systemPrompt, userPrompt } = buildPlannerPrompt(mission, constraints, roleHints);
-
-  if (opts._plannerOutput) {
-    // Injected planner output for testing — skip LLM call
-    plannerOutput = opts._plannerOutput;
-  } else {
-    // Attempt to use the configured api_proxy adapter for decomposition
-    try {
-      const { loadConfig } = await import('../lib/config.js');
-      const config = loadConfig(root);
-      const plannerConfig = config?.mission_planner || config?.api_proxy;
-
-      if (plannerConfig && plannerConfig.base_url && plannerConfig.model) {
-        const response = await callPlannerLLM(plannerConfig, systemPrompt, userPrompt);
-        const parsed = parsePlannerResponse(response);
-        if (!parsed.ok) {
-          console.error(chalk.red(`Planner response parse error: ${parsed.error}`));
-          process.exit(1);
-        }
-        plannerOutput = parsed.data;
-      } else {
-        console.error(chalk.red('No mission planner or api_proxy configured.'));
-        console.error(chalk.dim('  Add "mission_planner" or "api_proxy" to agentxchain.json with base_url and model.'));
-        console.error(chalk.dim('  Or pass planner output via --planner-output-file <path> for offline use.'));
-        process.exit(1);
-      }
-    } catch (err) {
-      console.error(chalk.red(`Planner call failed: ${err.message}`));
-      process.exit(1);
-    }
-  }
-
-  // Validate and create plan artifact
-  const result = createPlanArtifact(root, mission, {
-    constraints,
-    roleHints,
-    plannerOutput,
-  });
-
-  if (!result.ok) {
-    console.error(chalk.red('Plan validation failed:'));
-    for (const err of result.errors) {
-      console.error(chalk.red(`  • ${err}`));
-    }
+  let plan;
+  try {
+    plan = await createMissionPlan(root, mission, opts);
+  } catch (error) {
+    renderMissionPlanError(error);
     process.exit(1);
   }
 
   if (opts.json) {
-    console.log(JSON.stringify(result.plan, null, 2));
+    console.log(JSON.stringify(plan, null, 2));
     return;
   }
 
-  console.log(chalk.green(`Created plan ${result.plan.plan_id} for mission ${mission.mission_id}`));
-  renderPlan(result.plan);
+  console.log(chalk.green(`Created plan ${plan.plan_id} for mission ${mission.mission_id}`));
+  renderPlan(plan);
 }
 
 /**
@@ -438,11 +417,22 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
   }
   const { root } = context;
 
-  if (!opts.workstream) {
-    console.error(chalk.red('--workstream <id> is required. Specify which workstream to launch.'));
+  // Mutual exclusivity guard
+  if (opts.allReady && opts.workstream) {
+    console.error(chalk.red('--all-ready and --workstream are mutually exclusive. Use one or the other.'));
     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);
+  }
+
+  // Dispatch to batch launch if --all-ready
+  if (opts.allReady) {
+    return missionPlanLaunchAllReady(planTarget, opts, context);
+  }
+
   const mission = opts.mission
     ? loadMissionArtifact(root, opts.mission)
     : loadLatestMissionArtifact(root);
@@ -548,6 +538,195 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
   }
 }
 
+// ── Batch launch (--all-ready) ──────────────────────────────────────────────
+
+async function missionPlanLaunchAllReady(planTarget, opts, context) {
+  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);
+  }
+
+  if (plan.status !== 'approved') {
+    console.error(chalk.red(`Plan ${plan.plan_id} is not approved (status: "${plan.status}"). Approve the plan before launching workstreams.`));
+    process.exit(1);
+  }
+
+  const readyWorkstreams = getReadyWorkstreams(plan);
+  if (readyWorkstreams.length === 0) {
+    const summary = getWorkstreamStatusSummary(plan);
+    const parts = Object.entries(summary).map(([status, count]) => `${count} ${status}`);
+    console.error(chalk.red(`No ready workstreams to launch. Current distribution: ${parts.join(', ')}.`));
+    process.exit(1);
+  }
+
+  const executor = opts._executeGovernedRun || executeGovernedRun;
+  const logger = opts._log || console.log;
+  const results = [];
+  let hadFailure = false;
+
+  if (!opts.json) {
+    console.log(chalk.bold(`Launching ${readyWorkstreams.length} ready workstream(s) from plan ${plan.plan_id}...\n`));
+  }
+
+  for (let i = 0; i < readyWorkstreams.length; i++) {
+    const ws = readyWorkstreams[i];
+    const prefix = `[${i + 1}/${readyWorkstreams.length}]`;
+
+    // Skip remaining if a prior workstream failed
+    if (hadFailure) {
+      results.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;
+    }
+
+    // Launch bookkeeping
+    const launch = launchWorkstream(root, mission.mission_id, plan.plan_id, ws.workstream_id);
+    if (!launch.ok) {
+      hadFailure = true;
+      results.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;
+    }
+
+    if (!opts.json) {
+      process.stdout.write(`${prefix} ${chalk.cyan(ws.workstream_id)} → ${launch.chainId} ... `);
+    }
+
+    // Execute
+    const chainOpts = {
+      enabled: true,
+      maxChains: 0,
+      chainOn: ['completed'],
+      cooldownSeconds: 0,
+      mission: mission.mission_id,
+      chainId: launch.chainId,
+    };
+    const runOpts = {
+      autoApprove: !!opts.autoApprove,
+      provenance: {
+        trigger: 'manual',
+        created_by: 'operator',
+        trigger_reason: `mission:${mission.mission_id} workstream:${ws.workstream_id} batch:all-ready`,
+      },
+    };
+
+    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(),
+      });
+      hadFailure = true;
+      results.push({
+        workstream_id: ws.workstream_id,
+        chain_id: launch.chainId,
+        status: 'needs_attention',
+        error: error.message,
+        exit_code: 1,
+      });
+      if (!opts.json) {
+        console.log(chalk.red(`needs_attention ✗ (${error.message})`));
+      }
+      continue;
+    }
+
+    // Record outcome
+    const lastRun = execution?.chainReport?.runs?.[execution.chainReport.runs.length - 1] || null;
+    const terminalReason = lastRun?.status === 'completed'
+      ? 'completed'
+      : (lastRun?.status || execution?.chainReport?.terminal_reason || 'execution_error');
+
+    markWorkstreamOutcome(root, mission.mission_id, plan.plan_id, ws.workstream_id, {
+      terminalReason,
+      completedAt: execution?.chainReport?.completed_at || new Date().toISOString(),
+    });
+
+    const wsStatus = terminalReason === 'completed' ? 'completed' : 'needs_attention';
+    if (wsStatus === 'needs_attention') {
+      hadFailure = true;
+    }
+
+    results.push({
+      workstream_id: ws.workstream_id,
+      chain_id: launch.chainId,
+      status: wsStatus,
+      exit_code: execution.exitCode || 0,
+    });
+
+    if (!opts.json) {
+      if (wsStatus === 'completed') {
+        console.log(chalk.green('completed ✓'));
+      } else {
+        console.log(chalk.red(`needs_attention ✗`));
+      }
+    }
+  }
+
+  // Summary
+  const completed = results.filter((r) => r.status === 'completed').length;
+  const failed = results.filter((r) => r.status === 'needs_attention' || r.status === 'launch_error').length;
+  const skipped = results.filter((r) => r.status === 'skipped').length;
+
+  if (opts.json) {
+    console.log(JSON.stringify({
+      plan_id: plan.plan_id,
+      mission_id: mission.mission_id,
+      results,
+      summary: {
+        total: results.length,
+        completed,
+        failed,
+        skipped,
+      },
+    }, null, 2));
+  } else {
+    console.log('');
+    console.log(chalk.bold(`Summary: ${completed} completed, ${failed} failed, ${skipped} skipped`));
+    if (hadFailure) {
+      console.log(chalk.dim('  Inspect plan state with `agentxchain mission plan show latest`'));
+    }
+  }
+
+  if (hadFailure) {
+    process.exit(1);
+  }
+}
+
 // ── Plan rendering ───────────────────────────────────────────────────────────
 
 function renderPlan(plan) {
@@ -691,6 +870,84 @@ async function callPlannerLLM(config, systemPrompt, userPrompt) {
   return content;
 }
 
+async function createMissionPlan(root, mission, opts = {}) {
+  const { constraints, roleHints } = normalizePlannerOptions(opts);
+  const plannerOutput = await resolvePlannerOutput(root, mission, constraints, roleHints, opts);
+  const result = createPlanArtifact(root, mission, {
+    constraints,
+    roleHints,
+    plannerOutput,
+  });
+
+  if (!result.ok) {
+    const error = new Error('Plan validation failed.');
+    error.validationErrors = result.errors;
+    throw error;
+  }
+
+  return result.plan;
+}
+
+function normalizePlannerOptions(opts = {}) {
+  return {
+    constraints: Array.isArray(opts.constraint) ? opts.constraint : (opts.constraint ? [opts.constraint] : []),
+    roleHints: Array.isArray(opts.roleHint) ? opts.roleHint : (opts.roleHint ? [opts.roleHint] : []),
+  };
+}
+
+async function resolvePlannerOutput(root, mission, constraints, roleHints, opts = {}) {
+  const { systemPrompt, userPrompt } = buildPlannerPrompt(mission, constraints, roleHints);
+
+  if (opts._plannerOutput) {
+    return opts._plannerOutput;
+  }
+
+  if (opts.plannerOutputFile) {
+    const plannerOutputPath = resolve(opts.plannerOutputFile);
+    let raw;
+    try {
+      raw = readFileSync(plannerOutputPath, 'utf8');
+    } catch (error) {
+      throw new Error(`Planner output file read error: ${error.message}`);
+    }
+
+    const parsed = parsePlannerResponse(raw);
+    if (!parsed.ok) {
+      throw new Error(`Planner output file parse error: ${parsed.error}`);
+    }
+    return parsed.data;
+  }
+
+  const { loadConfig } = await import('../lib/config.js');
+  const config = loadConfig(root);
+  const plannerConfig = config?.mission_planner || config?.api_proxy;
+
+  if (!plannerConfig || !plannerConfig.base_url || !plannerConfig.model) {
+    throw new Error('No mission planner or api_proxy configured.\n  Add "mission_planner" or "api_proxy" to agentxchain.json with base_url and model.\n  Or pass planner output via --planner-output-file <path> for offline use.');
+  }
+
+  const response = await callPlannerLLM(plannerConfig, systemPrompt, userPrompt);
+  const parsed = parsePlannerResponse(response);
+  if (!parsed.ok) {
+    throw new Error(`Planner response parse error: ${parsed.error}`);
+  }
+  return parsed.data;
+}
+
+function renderMissionPlanError(error) {
+  const message = error?.message || 'Mission planning failed.';
+  const [firstLine, ...rest] = String(message).split('\n');
+  console.error(chalk.red(firstLine));
+  for (const line of rest) {
+    console.error(chalk.dim(line));
+  }
+  if (Array.isArray(error?.validationErrors) && error.validationErrors.length > 0) {
+    for (const validationError of error.validationErrors) {
+      console.error(chalk.red(`  • ${validationError}`));
+    }
+  }
+}
+
 function renderMissionSnapshot(snapshot) {
   console.log(chalk.bold(`Mission: ${snapshot.mission_id}`));
   console.log('');

package/src/lib/mission-plans.js

@@ -454,6 +454,29 @@ export function markWorkstreamOutcome(root, missionId, planId, workstreamId, { t
   return { ok: true, plan, workstream: ws };
 }
 
+// ── Batch launch helpers ───────────────────────────────────────────────────
+
+/**
+ * Return all workstreams with launch_status === 'ready', in plan order.
+ */
+export function getReadyWorkstreams(plan) {
+  if (!plan || !Array.isArray(plan.workstreams)) return [];
+  return plan.workstreams.filter((ws) => ws.launch_status === 'ready');
+}
+
+/**
+ * Return a summary of workstream status distribution for operator messaging.
+ */
+export function getWorkstreamStatusSummary(plan) {
+  if (!plan || !Array.isArray(plan.workstreams)) return {};
+  const summary = {};
+  for (const ws of plan.workstreams) {
+    const status = ws.launch_status || 'unknown';
+    summary[status] = (summary[status] || 0) + 1;
+  }
+  return summary;
+}
+
 // ── LLM planner prompt ──────────────────────────────────────────────────────
 
 /**