agentxchain 2.112.0 → 2.114.0

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() {

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

@@ -66,12 +66,23 @@ export const WATCH_DIRECTORIES = [
   '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 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'];
   }