agentxchain 2.155.24 → 2.155.26

package/dashboard/app.js

@@ -21,6 +21,7 @@ import { render as renderChain } from './components/chain.js';
 import { render as renderRunHistory } from './components/run-history.js';
 import { render as renderTimeouts } from './components/timeouts.js';
 import { render as renderCoordinatorTimeouts } from './components/coordinator-timeouts.js';
+import { render as renderWatch } from './components/watch.js';
 import {
   buildLiveMeta,
   createLiveEventFromMessage,
@@ -42,6 +43,7 @@ const VIEWS = {
   mission: { fetch: ['missions', 'plans'], render: renderMission },
   chain: { fetch: ['chainReports'], render: renderChain },
   'run-history': { fetch: ['runHistory'], render: renderRunHistory },
+  watch: { fetch: ['watchResults'], render: renderWatch },
   timeouts: { fetch: ['timeouts'], render: renderTimeouts },
   'coordinator-timeouts': { fetch: ['coordinatorTimeouts'], render: renderCoordinatorTimeouts },
 };
@@ -70,6 +72,7 @@ const API_MAP = {
   chainReports: '/api/chain-reports',
   connectors: '/api/connectors',
   runHistory: '/api/run-history',
+  watchResults: '/api/watch-results',
   timeouts: '/api/timeouts',
   coordinatorTimeouts: '/api/coordinator/timeouts',
   gateActions: '/api/gate-actions',

package/dashboard/components/watch.js

@@ -0,0 +1,131 @@
+function esc(str) {
+  if (str == null) return '';
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function badge(label, color = 'var(--text-dim)') {
+  return `<span class="badge" style="color:${color};border-color:${color}">${esc(label)}</span>`;
+}
+
+function classify(record) {
+  if (Array.isArray(record?.errors) && record.errors.length > 0) return 'error';
+  if (record?.deduplicated === true) return 'deduplicated';
+  if (record?.route?.started === true) return 'started';
+  if (record?.route?.planned === true) return 'planned';
+  if (record?.route?.approved === true) return 'approved';
+  if (record?.route?.triaged === true) return 'triaged';
+  if (record?.route?.matched === false) return 'unrouted';
+  return 'detected';
+}
+
+function statusBadge(record) {
+  const status = classify(record);
+  const colors = {
+    error: 'var(--red)',
+    deduplicated: 'var(--yellow)',
+    started: 'var(--green)',
+    planned: 'var(--accent)',
+    approved: 'var(--accent)',
+    triaged: 'var(--text)',
+    unrouted: 'var(--text-dim)',
+    detected: 'var(--text-dim)',
+  };
+  return badge(status, colors[status] || 'var(--text-dim)');
+}
+
+function formatTime(value) {
+  if (!value) return '—';
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleString();
+}
+
+function renderResultRow(record) {
+  const payload = record.payload || {};
+  const route = record.route || {};
+  const errors = Array.isArray(record.errors) ? record.errors : [];
+  const routeDetail = route.matched === false
+    ? 'No route'
+    : [
+        route.run_id ? `run ${route.run_id}` : null,
+        route.role ? `role ${route.role}` : null,
+        route.preferred_role ? `hint ${route.preferred_role}` : null,
+      ].filter(Boolean).join(' · ') || 'Route matched';
+
+  return `<tr${errors.length > 0 ? ' style="border-left:3px solid var(--red)"' : ''}>
+    <td>
+      <div class="mono">${esc(record.result_id || '—')}</div>
+      <div class="turn-status">${esc(formatTime(record.timestamp))}</div>
+    </td>
+    <td>${statusBadge(record)}</td>
+    <td>
+      <div class="mono">${esc(payload.category || 'unknown')}</div>
+      <div class="turn-status">${esc(payload.repo || '—')}${payload.ref ? ` · ${esc(payload.ref)}` : ''}</div>
+    </td>
+    <td>
+      <div>${esc(routeDetail)}</div>
+      <div class="turn-status">Intent ${esc(record.intent_id || '—')} · Event ${esc(record.event_id || '—')}</div>
+    </td>
+    <td class="mono">${esc(record.delivery_id || '—')}</td>
+    <td>${errors.length > 0 ? esc(errors.join(' | ')) : '—'}</td>
+  </tr>`;
+}
+
+export function render({ watchResults }) {
+  if (!watchResults) {
+    return `<div class="placeholder"><h2>Watch</h2><p>No watch result data available.</p></div>`;
+  }
+
+  if (watchResults.ok === false) {
+    return `<div class="placeholder"><h2>Watch</h2><p>${esc(watchResults.error || 'Failed to load watch results.')}</p></div>`;
+  }
+
+  const recent = Array.isArray(watchResults.recent) ? watchResults.recent : [];
+  const summary = watchResults.summary || {};
+  const byStatus = summary.by_status || {};
+
+  if ((watchResults.total || 0) === 0 && (watchResults.corrupt || 0) === 0) {
+    return `<div class="placeholder"><h2>Watch</h2><p>No watch intake results yet. Use <code>agentxchain watch --listen</code>, <code>--event-file</code>, or <code>--event-dir</code> to ingest events.</p></div>`;
+  }
+
+  let html = `<div class="watch-view"><div class="run-header"><div class="run-meta">`;
+  html += badge(`${watchResults.total || 0} results`, 'var(--accent)');
+  html += badge(`${summary.routed || 0} routed`, 'var(--green)');
+  html += badge(`${summary.unrouted || 0} unrouted`, summary.unrouted ? 'var(--yellow)' : 'var(--text-dim)');
+  html += badge(`${summary.deduplicated || 0} deduped`, summary.deduplicated ? 'var(--yellow)' : 'var(--text-dim)');
+  html += badge(`${summary.errored || 0} errors`, summary.errored ? 'var(--red)' : 'var(--text-dim)');
+  if (watchResults.corrupt) html += badge(`${watchResults.corrupt} corrupt`, 'var(--red)');
+  html += `</div></div>`;
+
+  html += `<div class="section"><h3>Intake Summary</h3>
+    <p class="section-subtitle">Last result: ${esc(formatTime(summary.last_timestamp))}</p>
+    <table class="data-table">
+      <thead><tr><th>Status</th><th>Count</th></tr></thead>
+      <tbody>${Object.keys(byStatus).sort().map((status) => `<tr><td>${esc(status)}</td><td>${esc(byStatus[status])}</td></tr>`).join('')}</tbody>
+    </table>
+  </div>`;
+
+  html += `<div class="section"><h3>Recent Watch Results</h3>
+    <table class="data-table">
+      <thead>
+        <tr>
+          <th>Result</th>
+          <th>Status</th>
+          <th>Payload</th>
+          <th>Route</th>
+          <th>Delivery</th>
+          <th>Errors</th>
+        </tr>
+      </thead>
+      <tbody>${recent.map(renderResultRow).join('')}</tbody>
+    </table>
+  </div>`;
+
+  html += `</div>`;
+  return html;
+}

package/dashboard/index.html

@@ -409,6 +409,7 @@
     <a href="#mission">Mission</a>
     <a href="#chain">Chain</a>
     <a href="#run-history">Run History</a>
+    <a href="#watch">Watch</a>
     <a href="#timeouts">Timeouts</a>
     <a href="#coordinator-timeouts">Coordinator Timeouts</a>
   </nav>

package/package.json

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

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

@@ -33,6 +33,7 @@ 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';
+import { readWatchResultsSnapshot } from './watch-results-reader.js';
 
 const MIME_TYPES = {
   '.html': 'text/html; charset=utf-8',
@@ -504,6 +505,12 @@ export function createBridgeServer({ agentxchainDir, dashboardDir, port = 3847,
       return;
     }
 
+    if (pathname === '/api/watch-results') {
+      const limit = url.searchParams.get('limit') ?? undefined;
+      writeJson(res, 200, readWatchResultsSnapshot(workspacePath, { limit }));
+      return;
+    }
+
     // API routes
     if (pathname.startsWith('/api/')) {
       const result = readResource(agentxchainDir, pathname);

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

@@ -47,6 +47,10 @@ export class FileWatcher extends EventEmitter {
           if (!relativeDir && fileSegment === 'multirepo') {
             this.#watchPath('multirepo');
           }
+          if (!relativeDir && fileSegment === 'watch-results') {
+            this.#watchPath('watch-results');
+            this.emit('invalidate', { resource: '/api/watch-results' });
+          }
           return;
         }
 

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

@@ -66,6 +66,7 @@ export const WATCH_DIRECTORIES = [
   MULTIREPO_DIR,
   'missions',
   'reports',
+  'watch-results',
 ];
 
 /**
@@ -94,6 +95,9 @@ export function resourcesForRelativePath(filePath) {
   if (normalized.startsWith('reports/chain-') && normalized.endsWith('.json')) {
     return ['/api/chain-reports', '/api/missions'];
   }
+  if (normalized === 'watch-results' || (normalized.startsWith('watch-results/') && normalized.endsWith('.json'))) {
+    return ['/api/watch-results'];
+  }
   return FILE_TO_RESOURCE[normalized] ? [FILE_TO_RESOURCE[normalized]] : [];
 }
 

package/src/lib/dashboard/watch-results-reader.js

@@ -0,0 +1,86 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const DEFAULT_LIMIT = 25;
+
+export function readWatchResultsSnapshot(workspacePath, { limit = DEFAULT_LIMIT } = {}) {
+  const resultsDir = join(workspacePath, '.agentxchain', 'watch-results');
+  const parsedLimit = parseLimit(limit);
+  const records = [];
+  let corrupt = 0;
+
+  if (existsSync(resultsDir)) {
+    const entries = readdirSync(resultsDir, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.json'));
+
+    for (const entry of entries) {
+      try {
+        const record = JSON.parse(readFileSync(join(resultsDir, entry.name), 'utf8'));
+        if (!record || typeof record !== 'object' || Array.isArray(record)) {
+          corrupt += 1;
+          continue;
+        }
+        records.push(record);
+      } catch {
+        corrupt += 1;
+      }
+    }
+  }
+
+  records.sort((a, b) => String(b.timestamp || '').localeCompare(String(a.timestamp || '')));
+  const recent = parsedLimit === 0 ? records : records.slice(0, parsedLimit);
+
+  return {
+    ok: true,
+    total: records.length,
+    corrupt,
+    recent,
+    summary: summarize(records, corrupt),
+  };
+}
+
+function parseLimit(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_LIMIT;
+  return parsed;
+}
+
+function summarize(records, corrupt) {
+  const byStatus = {};
+  let errored = 0;
+  let deduplicated = 0;
+  let routed = 0;
+  let unrouted = 0;
+  let lastTimestamp = null;
+
+  for (const record of records) {
+    const status = classifyWatchResult(record);
+    byStatus[status] = (byStatus[status] || 0) + 1;
+    if (status === 'error') errored += 1;
+    if (record.deduplicated === true) deduplicated += 1;
+    if (record.route?.matched === false) unrouted += 1;
+    else if (record.route?.matched === true) routed += 1;
+    if (!lastTimestamp && record.timestamp) lastTimestamp = record.timestamp;
+  }
+
+  return {
+    by_status: byStatus,
+    errored,
+    deduplicated,
+    routed,
+    unrouted,
+    corrupt,
+    last_timestamp: lastTimestamp,
+  };
+}
+
+export function classifyWatchResult(record) {
+  if (Array.isArray(record?.errors) && record.errors.length > 0) return 'error';
+  if (record?.deduplicated === true) return 'deduplicated';
+  if (record?.route?.started === true) return 'started';
+  if (record?.route?.planned === true) return 'planned';
+  if (record?.route?.approved === true) return 'approved';
+  if (record?.route?.triaged === true) return 'triaged';
+  if (record?.route?.matched === false) return 'unrouted';
+  return 'detected';
+}