agentxchain 2.112.0 → 2.113.0

package/src/commands/mission.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { findProjectRoot } from '../lib/config.js';
+import { findProjectRoot, loadProjectContext } from '../lib/config.js';
 import {
   attachChainToMission,
   buildMissionListSummary,
@@ -10,6 +10,20 @@ import {
   loadMissionArtifact,
   loadMissionSnapshot,
 } from '../lib/missions.js';
+import {
+  approvePlanArtifact,
+  createPlanArtifact,
+  launchWorkstream,
+  markWorkstreamOutcome,
+  loadAllPlans,
+  loadLatestPlan,
+  loadPlan,
+  buildPlannerPrompt,
+  parsePlannerResponse,
+  validatePlannerOutput,
+} from '../lib/mission-plans.js';
+import { executeChainedRun } from '../lib/run-chain.js';
+import { executeGovernedRun } from './run.js';
 
 export async function missionStartCommand(opts) {
   const root = findProjectRoot(opts.dir || process.cwd());
@@ -163,6 +177,520 @@ export async function missionAttachChainCommand(chainId, opts) {
   renderMissionSnapshot(snapshot);
 }
 
+// ── Mission Plan Commands ────────────────────────────────────────────────────
+
+/**
+ * agentxchain mission plan [mission_id|latest] — generate a decomposition plan.
+ *
+ * Uses LLM-assisted one-shot generation with schema validation.
+ * Falls back to deterministic stub when no LLM is available (for testing).
+ */
+export async function missionPlanCommand(missionTarget, opts) {
+  const root = findProjectRoot(opts.dir || process.cwd());
+  if (!root) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+
+  // Resolve mission target
+  const mission = missionTarget && missionTarget !== 'latest'
+    ? loadMissionArtifact(root, missionTarget)
+    : loadLatestMissionArtifact(root);
+
+  if (!mission) {
+    if (missionTarget && missionTarget !== 'latest') {
+      console.error(chalk.red(`Mission not found: ${missionTarget}`));
+    } else {
+      console.error(chalk.red('No missions found.'));
+      console.error(chalk.dim('  Run `agentxchain mission start --title "..." --goal "..."` first.'));
+    }
+    process.exit(1);
+  }
+
+  if (!mission.goal || !mission.goal.trim()) {
+    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}`));
+    }
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify(result.plan, null, 2));
+    return;
+  }
+
+  console.log(chalk.green(`Created plan ${result.plan.plan_id} for mission ${mission.mission_id}`));
+  renderPlan(result.plan);
+}
+
+/**
+ * agentxchain mission plan show [plan_id|latest] — show a decomposition plan.
+ */
+export async function missionPlanShowCommand(planTarget, opts) {
+  const root = findProjectRoot(opts.dir || process.cwd());
+  if (!root) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+
+  // Resolve mission 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);
+  }
+
+  // Resolve plan target
+  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.log(chalk.dim('No plans found for this mission.'));
+      console.log(chalk.dim('  Run `agentxchain mission plan latest` to generate one.'));
+    }
+    return;
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify(plan, null, 2));
+    return;
+  }
+
+  renderPlan(plan);
+}
+
+/**
+ * agentxchain mission plan list — list all plans for a mission.
+ */
+export async function missionPlanListCommand(opts) {
+  const root = findProjectRoot(opts.dir || process.cwd());
+  if (!root) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+
+  const mission = opts.mission
+    ? loadMissionArtifact(root, opts.mission)
+    : loadLatestMissionArtifact(root);
+
+  if (!mission) {
+    console.error(chalk.red('No mission found.'));
+    process.exit(1);
+  }
+
+  const plans = loadAllPlans(root, mission.mission_id);
+  const limit = opts.limit ? parseInt(opts.limit, 10) : 20;
+  const limited = plans.slice(0, limit);
+
+  if (opts.json) {
+    console.log(JSON.stringify(limited, null, 2));
+    return;
+  }
+
+  if (limited.length === 0) {
+    console.log(chalk.dim('No plans found for this mission.'));
+    console.log(chalk.dim('  Run `agentxchain mission plan latest` to generate one.'));
+    return;
+  }
+
+  const header = [
+    pad('#', 4),
+    pad('Plan ID', 36),
+    pad('Status', 12),
+    pad('Workstreams', 12),
+    pad('Supersedes', 36),
+    pad('Created', 22),
+  ].join(' ');
+
+  console.log(chalk.bold(header));
+  console.log(chalk.dim('─'.repeat(header.length)));
+
+  limited.forEach((plan, i) => {
+    console.log([
+      pad(String(i + 1), 4),
+      pad(plan.plan_id || '—', 36),
+      pad(formatPlanStatus(plan.status), 12),
+      pad(String(plan.workstreams?.length || 0), 12),
+      pad(plan.supersedes_plan_id || '—', 36),
+      pad(formatTimestamp(plan.created_at), 22),
+    ].join(' '));
+  });
+
+  console.log(chalk.dim(`\n${limited.length} plan(s) shown`));
+}
+
+/**
+ * agentxchain mission plan approve [plan_id|latest] — approve a decomposition plan.
+ */
+export async function missionPlanApproveCommand(planTarget, opts) {
+  const root = findProjectRoot(opts.dir || process.cwd());
+  if (!root) {
+    console.error(chalk.red('No AgentXchain project found. Run this inside a governed project.'));
+    process.exit(1);
+  }
+
+  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 result = approvePlanArtifact(root, mission.mission_id, plan.plan_id);
+  if (!result.ok) {
+    console.error(chalk.red(result.error));
+    process.exit(1);
+  }
+
+  console.log(chalk.green(`Approved plan ${result.plan.plan_id} for mission ${mission.mission_id}`));
+  if (result.supersededPlanIds.length > 0) {
+    console.log(chalk.dim(`  Superseded: ${result.supersededPlanIds.join(', ')}`));
+  }
+  renderPlan(result.plan);
+}
+
+/**
+ * agentxchain mission plan launch [plan_id|latest] --workstream <id> — launch a workstream.
+ *
+ * Validates plan approval, workstream existence, dependency satisfaction.
+ * Records launch_record with workstream_id → chain_id binding.
+ */
+export async function missionPlanLaunchCommand(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;
+
+  if (!opts.workstream) {
+    console.error(chalk.red('--workstream <id> is required. Specify which workstream to launch.'));
+    process.exit(1);
+  }
+
+  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 launch = launchWorkstream(root, mission.mission_id, plan.plan_id, opts.workstream);
+  if (!launch.ok) {
+    console.error(chalk.red(launch.error));
+    process.exit(1);
+  }
+
+  const executor = opts._executeGovernedRun || executeGovernedRun;
+  const logger = opts._log || console.log;
+  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:${opts.workstream}`,
+    },
+  };
+
+  let execution;
+  try {
+    execution = await executeChainedRun(context, runOpts, chainOpts, executor, logger);
+  } catch (error) {
+    markWorkstreamOutcome(root, mission.mission_id, plan.plan_id, opts.workstream, {
+      terminalReason: 'execution_error',
+      completedAt: new Date().toISOString(),
+    });
+    console.error(chalk.red(`Workstream execution failed: ${error.message}`));
+    process.exit(1);
+  }
+
+  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');
+  const outcome = markWorkstreamOutcome(root, mission.mission_id, plan.plan_id, opts.workstream, {
+    terminalReason,
+    completedAt: execution?.chainReport?.completed_at || new Date().toISOString(),
+  });
+  if (!outcome.ok) {
+    console.error(chalk.red(outcome.error));
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify({
+      workstream_id: opts.workstream,
+      chain_id: launch.chainId,
+      plan_id: launch.plan.plan_id,
+      mission_id: mission.mission_id,
+      launch_record: launch.launchRecord,
+      exit_code: execution.exitCode,
+      chain_terminal_reason: execution?.chainReport?.terminal_reason || null,
+      workstream_status: outcome.workstream.launch_status,
+    }, null, 2));
+    if (execution.exitCode !== 0) {
+      process.exit(execution.exitCode);
+    }
+    return;
+  }
+
+  console.log(chalk.green(`Executed workstream ${chalk.bold(opts.workstream)} → chain ${chalk.bold(launch.chainId)}`));
+  console.log('');
+  console.log(chalk.dim(`  Mission:   ${mission.mission_id}`));
+  console.log(chalk.dim(`  Plan:      ${launch.plan.plan_id}`));
+  console.log(chalk.dim(`  Chain ID:  ${launch.chainId}`));
+  console.log(chalk.dim(`  Outcome:   ${outcome.workstream.launch_status}`));
+  console.log('');
+  renderPlan(outcome.plan);
+  if (execution.exitCode !== 0) {
+    console.error(chalk.red(`Workstream execution ended with exit code ${execution.exitCode}.`));
+    process.exit(execution.exitCode);
+  }
+}
+
+// ── Plan rendering ───────────────────────────────────────────────────────────
+
+function renderPlan(plan) {
+  console.log(chalk.bold(`Plan: ${plan.plan_id}`));
+  console.log('');
+  console.log(`  Mission:      ${plan.mission_id}`);
+  console.log(`  Status:       ${formatPlanStatus(plan.status)}`);
+  console.log(`  Goal:         ${plan.input?.goal || '—'}`);
+  console.log(`  Constraints:  ${plan.input?.constraints?.length ? plan.input.constraints.join('; ') : 'none'}`);
+  console.log(`  Role hints:   ${plan.input?.role_hints?.length ? plan.input.role_hints.join(', ') : 'none'}`);
+  console.log(`  Supersedes:   ${plan.supersedes_plan_id || '—'}`);
+  if (plan.superseded_by_plan_id) {
+    console.log(`  Superseded by:${plan.superseded_by_plan_id}`);
+  }
+  if (plan.approved_at) {
+    console.log(`  Approved:     ${plan.approved_at}`);
+  }
+  console.log(`  Created:      ${plan.created_at || '—'}`);
+  console.log('');
+
+  if (!plan.workstreams || plan.workstreams.length === 0) {
+    console.log(chalk.dim('  No workstreams.'));
+    return;
+  }
+
+  const wsHeader = [
+    pad('#', 4),
+    pad('Workstream', 28),
+    pad('Status', 10),
+    pad('Roles', 20),
+    pad('Phases', 24),
+    pad('Depends On', 28),
+    'Title',
+  ].join(' ');
+
+  console.log(chalk.bold('  Workstreams:'));
+  console.log(`  ${chalk.dim(wsHeader)}`);
+  console.log(`  ${chalk.dim('─'.repeat(wsHeader.length))}`);
+
+  plan.workstreams.forEach((ws, i) => {
+    const deps = Array.isArray(ws.depends_on) && ws.depends_on.length > 0
+      ? ws.depends_on.join(', ')
+      : '—';
+
+    console.log(`  ${[
+      pad(String(i + 1), 4),
+      pad(ws.workstream_id || '—', 28),
+      pad(formatLaunchStatus(ws.launch_status), 10),
+      pad((ws.roles || []).join(', '), 20),
+      pad((ws.phases || []).join(', '), 24),
+      pad(deps, 28),
+      ws.title || '—',
+    ].join(' ')}`);
+  });
+
+  if (plan.launch_records?.length) {
+    console.log('');
+    console.log(chalk.bold('  Launch records:'));
+    for (const rec of plan.launch_records) {
+      const statusTag = rec.status === 'completed' ? chalk.green('completed')
+        : rec.status === 'failed' ? chalk.red('failed')
+        : chalk.cyan('launched');
+      console.log(`    ${chalk.cyan(rec.workstream_id)} → ${rec.chain_id} [${statusTag}]`);
+    }
+  }
+
+  if (plan.workstreams.some((ws) => ws.acceptance_checks?.length)) {
+    console.log('');
+    console.log(chalk.bold('  Acceptance checks:'));
+    plan.workstreams.forEach((ws) => {
+      if (ws.acceptance_checks?.length) {
+        console.log(`    ${chalk.cyan(ws.workstream_id)}:`);
+        ws.acceptance_checks.forEach((check) => {
+          console.log(`      • ${check}`);
+        });
+      }
+    });
+  }
+}
+
+function formatPlanStatus(status) {
+  if (!status) return '—';
+  switch (status) {
+    case 'proposed': return chalk.blue('proposed');
+    case 'approved': return chalk.green('approved');
+    case 'superseded': return chalk.dim('superseded');
+    case 'needs_attention': return chalk.yellow('needs_attention');
+    case 'completed': return chalk.green('completed');
+    default: return status;
+  }
+}
+
+function formatLaunchStatus(status) {
+  if (!status) return '—';
+  switch (status) {
+    case 'ready': return chalk.green('ready');
+    case 'blocked': return chalk.yellow('blocked');
+    case 'launched': return chalk.cyan('launched');
+    case 'completed': return chalk.green('completed');
+    case 'needs_attention': return chalk.red('attention');
+    default: return status;
+  }
+}
+
+// ── LLM planner call ─────────────────────────────────────────────────────────
+
+async function callPlannerLLM(config, systemPrompt, userPrompt) {
+  const url = `${config.base_url.replace(/\/$/, '')}/chat/completions`;
+  const headers = { 'Content-Type': 'application/json' };
+  if (config.api_key) {
+    headers['Authorization'] = `Bearer ${config.api_key}`;
+  }
+
+  const body = {
+    model: config.model,
+    messages: [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt },
+    ],
+    temperature: 0.3,
+    max_tokens: 4096,
+  };
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => '');
+    throw new Error(`LLM API returned ${response.status}: ${text.slice(0, 200)}`);
+  }
+
+  const json = await response.json();
+  const content = json?.choices?.[0]?.message?.content;
+  if (!content) {
+    throw new Error('LLM API returned no content in response.');
+  }
+
+  return content;
+}
+
 function renderMissionSnapshot(snapshot) {
   console.log(chalk.bold(`Mission: ${snapshot.mission_id}`));
   console.log('');

package/src/lib/dashboard/bridge-server.js

@@ -31,6 +31,7 @@ import { evaluateApprovalSlaReminders } from '../notification-runner.js';
 import { readGateActionSnapshot } from './gate-action-reader.js';
 import { readChainReportSnapshot } from './chain-report-reader.js';
 import { readMissionSnapshot } from './mission-reader.js';
+import { readPlanSnapshot } from './plan-reader.js';
 
 const MIME_TYPES = {
   '.html': 'text/html; charset=utf-8',
@@ -478,6 +479,14 @@ export function createBridgeServer({ agentxchainDir, dashboardDir, port = 3847,
       return;
     }
 
+    if (pathname === '/api/plans') {
+      const limit = url.searchParams.get('limit') ? parseInt(url.searchParams.get('limit'), 10) : undefined;
+      const missionId = url.searchParams.get('mission') || undefined;
+      const result = readPlanSnapshot(workspacePath, { limit, missionId });
+      writeJson(res, result.status, result.body);
+      return;
+    }
+
     if (pathname === '/api/gate-actions') {
       const result = readGateActionSnapshot(workspacePath);
       writeJson(res, result.status, result.body);

package/src/lib/dashboard/file-watcher.js

@@ -8,7 +8,7 @@
 import { watch, existsSync } from 'fs';
 import { basename, join } from 'path';
 import { EventEmitter } from 'events';
-import { WATCH_DIRECTORIES, resourcesForRelativePath } from './state-reader.js';
+import { WATCH_DIRECTORIES, RECURSIVE_WATCH_DIRECTORIES, resourcesForRelativePath } from './state-reader.js';
 
 const DEBOUNCE_MS = 100;
 
@@ -23,7 +23,7 @@ export class FileWatcher extends EventEmitter {
     this.#agentxchainDir = agentxchainDir;
   }
 
-  #watchPath(relativeDir) {
+  #watchPath(relativeDir, { recursive = false } = {}) {
     if (this.#watchers.has(relativeDir)) {
       return;
     }
@@ -36,14 +36,15 @@ export class FileWatcher extends EventEmitter {
     }
 
     try {
-      const watcher = watch(watchPath, { recursive: false }, (eventType, filename) => {
+      const watcher = watch(watchPath, { recursive }, (eventType, filename) => {
         if (!filename || this.#closed) return;
-        const base = basename(filename);
-        const relativePath = relativeDir ? `${relativeDir}/${base}` : base;
+        // For recursive watchers, filename includes subdirectory path
+        const fileSegment = recursive ? filename.replace(/\\/g, '/') : basename(filename);
+        const relativePath = relativeDir ? `${relativeDir}/${fileSegment}` : fileSegment;
         const resources = resourcesForRelativePath(relativePath);
 
         if (resources.length === 0) {
-          if (!relativeDir && base === 'multirepo') {
+          if (!relativeDir && fileSegment === 'multirepo') {
             this.#watchPath('multirepo');
           }
           return;
@@ -79,6 +80,9 @@ export class FileWatcher extends EventEmitter {
     for (const relativeDir of WATCH_DIRECTORIES) {
       this.#watchPath(relativeDir);
     }
+    for (const relativeDir of RECURSIVE_WATCH_DIRECTORIES) {
+      this.#watchPath(relativeDir, { recursive: true });
+    }
   }
 
   stop() {