agentxchain 2.111.0 → 2.113.0

package/src/commands/run.js

@@ -56,7 +56,9 @@ export async function runCommand(opts) {
   const chainOpts = resolveChainOptions(opts, context.config);
   if (chainOpts.enabled) {
     console.log(chalk.cyan.bold('agentxchain run --chain'));
-    console.log(chalk.dim(`  Chain mode: enabled (max ${chainOpts.maxChains} continuations, on: ${chainOpts.chainOn.join(',')}, cooldown: ${chainOpts.cooldownSeconds}s)`));
+    const chainParts = [`max ${chainOpts.maxChains} continuations`, `on: ${chainOpts.chainOn.join(',')}`, `cooldown: ${chainOpts.cooldownSeconds}s`];
+    if (chainOpts.mission) chainParts.push(`mission: ${chainOpts.mission}`);
+    console.log(chalk.dim(`  Chain mode: enabled (${chainParts.join(', ')})`));
     const { exitCode } = await executeChainedRun(context, opts, chainOpts, executeGovernedRun);
     process.exit(exitCode);
   }

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

@@ -30,6 +30,8 @@ import { loadProjectContext, loadProjectState } from '../config.js';
 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',
@@ -470,6 +472,21 @@ export function createBridgeServer({ agentxchainDir, dashboardDir, port = 3847,
       return;
     }
 
+    if (pathname === '/api/missions') {
+      const limit = url.searchParams.get('limit') ? parseInt(url.searchParams.get('limit'), 10) : undefined;
+      const result = readMissionSnapshot(workspacePath, { limit });
+      writeJson(res, result.status, result.body);
+      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, resourceForRelativePath } 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,28 +36,31 @@ 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;
-        const resource = resourceForRelativePath(relativePath);
+        // 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 (!resource) {
-          if (!relativeDir && base === 'multirepo') {
+        if (resources.length === 0) {
+          if (!relativeDir && fileSegment === 'multirepo') {
             this.#watchPath('multirepo');
           }
           return;
         }
 
-        if (this.#debounceTimers.has(resource)) {
-          clearTimeout(this.#debounceTimers.get(resource));
-        }
-        this.#debounceTimers.set(resource, setTimeout(() => {
-          this.#debounceTimers.delete(resource);
-          if (!this.#closed) {
-            this.emit('invalidate', { resource });
+        for (const resource of resources) {
+          if (this.#debounceTimers.has(resource)) {
+            clearTimeout(this.#debounceTimers.get(resource));
           }
-        }, DEBOUNCE_MS));
+          this.#debounceTimers.set(resource, setTimeout(() => {
+            this.#debounceTimers.delete(resource);
+            if (!this.#closed) {
+              this.emit('invalidate', { resource });
+            }
+          }, DEBOUNCE_MS));
+        }
       });
 
       watcher.on('error', (err) => {
@@ -77,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() {

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

@@ -0,0 +1,14 @@
+import { buildMissionListSummary, loadLatestMissionSnapshot } from '../missions.js';
+
+export function readMissionSnapshot(workspacePath, { limit } = {}) {
+  const missions = buildMissionListSummary(workspacePath, limit);
+
+  return {
+    ok: true,
+    status: 200,
+    body: {
+      latest: loadLatestMissionSnapshot(workspacePath),
+      missions,
+    },
+  };
+}

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

@@ -0,0 +1,108 @@
+/**
+ * Plan reader — reads mission plan artifacts for the dashboard bridge.
+ *
+ * Provides a snapshot of all plans across all missions for the dashboard.
+ * 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 { loadAllMissionArtifacts } from '../missions.js';
+
+/**
+ * Build a dashboard-ready plan snapshot across all missions.
+ *
+ * Returns newest-first plans with per-workstream launch_status and launch_records.
+ * If missionId is provided, returns plans for that mission only.
+ *
+ * @param {string} workspacePath - project root
+ * @param {{ limit?: number, missionId?: string }} options
+ * @returns {{ ok: boolean, status: number, body: object }}
+ */
+export function readPlanSnapshot(workspacePath, { limit, missionId } = {}) {
+  const allPlans = [];
+
+  if (missionId) {
+    const plans = loadAllPlans(workspacePath, missionId);
+    allPlans.push(...plans);
+  } else {
+    const missions = loadAllMissionArtifacts(workspacePath);
+    for (const mission of missions) {
+      const plans = loadAllPlans(workspacePath, mission.mission_id);
+      allPlans.push(...plans);
+    }
+  }
+
+  // Sort newest-first across all missions
+  allPlans.sort((a, b) => {
+    const aTime = new Date(a.created_at || 0).getTime();
+    const bTime = new Date(b.created_at || 0).getTime();
+    if (bTime !== aTime) return bTime - aTime;
+    return (b.plan_id || '').localeCompare(a.plan_id || '');
+  });
+
+  const plans = limit ? allPlans.slice(0, limit) : allPlans;
+
+  // Derive summary for the latest plan
+  const latest = plans[0] || null;
+  let latestSummary = null;
+  if (latest) {
+    latestSummary = buildPlanSummary(latest);
+  }
+
+  return {
+    ok: true,
+    status: 200,
+    body: {
+      latest: latestSummary,
+      plans: plans.map(buildPlanSummary),
+    },
+  };
+}
+
+/**
+ * Build a dashboard-ready summary for a single plan.
+ */
+function buildPlanSummary(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,
+    workstreams: workstreams.map((ws) => ({
+      workstream_id: ws.workstream_id,
+      title: ws.title,
+      goal: ws.goal,
+      roles: ws.roles,
+      phases: ws.phases,
+      depends_on: ws.depends_on,
+      launch_status: ws.launch_status,
+    })),
+    launch_records: launchRecords.map((lr) => ({
+      workstream_id: lr.workstream_id,
+      chain_id: lr.chain_id,
+      launched_at: lr.launched_at,
+      completed_at: lr.completed_at || null,
+      status: lr.status,
+      terminal_reason: lr.terminal_reason || null,
+    })),
+  };
+}

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

@@ -62,19 +62,39 @@ FILE_TO_RESOURCE[normalizeRelativePath(REPO_DECISIONS_FILE)] = '/api/repo-decisi
 export const WATCH_DIRECTORIES = [
   '',
   MULTIREPO_DIR,
+  'missions',
   'reports',
 ];
 
+/**
+ * Directories that require recursive watching because they contain
+ * dynamic subdirectories (e.g., missions/plans/<mission_id>/).
+ */
+export const RECURSIVE_WATCH_DIRECTORIES = [
+  'missions/plans',
+];
+
 export function normalizeRelativePath(filePath) {
   return normalize(filePath).replace(/\\/g, '/').replace(/^\.\/+/, '');
 }
 
-export function resourceForRelativePath(filePath) {
+export function resourcesForRelativePath(filePath) {
   const normalized = normalizeRelativePath(filePath);
+  if (normalized.startsWith('missions/plans/') && normalized.endsWith('.json')) {
+    return ['/api/plans', '/api/missions'];
+  }
+  if (normalized.startsWith('missions/') && normalized.endsWith('.json')) {
+    return ['/api/missions'];
+  }
   if (normalized.startsWith('reports/chain-') && normalized.endsWith('.json')) {
-    return '/api/chain-reports';
+    return ['/api/chain-reports', '/api/missions'];
   }
-  return FILE_TO_RESOURCE[normalized] || null;
+  return FILE_TO_RESOURCE[normalized] ? [FILE_TO_RESOURCE[normalized]] : [];
+}
+
+export function resourceForRelativePath(filePath) {
+  const resources = resourcesForRelativePath(filePath);
+  return resources[0] || null;
 }
 
 /**