agentxchain 2.31.0 → 2.32.0

package/dashboard/app.js

@@ -13,6 +13,7 @@ import { render as renderGate } from './components/gate.js';
 import { render as renderInitiative } from './components/initiative.js';
 import { render as renderCrossRepo } from './components/cross-repo.js';
 import { render as renderBlockers } from './components/blockers.js';
+import { render as renderArtifacts } from './components/artifacts.js';
 
 const VIEWS = {
   timeline: { fetch: ['state', 'history', 'audit', 'annotations'], render: renderTimeline },
@@ -23,6 +24,7 @@ const VIEWS = {
   initiative: { fetch: ['coordinatorState', 'coordinatorBarriers', 'barrierLedger', 'coordinatorBlockers'], render: renderInitiative },
   'cross-repo': { fetch: ['coordinatorState', 'coordinatorHistory'], render: renderCrossRepo },
   blockers: { fetch: ['coordinatorBlockers'], render: renderBlockers },
+  artifacts: { fetch: ['workflowKitArtifacts'], render: renderArtifacts },
 };
 
 const API_MAP = {
@@ -37,6 +39,7 @@ const API_MAP = {
   barrierLedger: '/api/coordinator/barrier-ledger',
   coordinatorAudit: '/api/coordinator/hooks/audit',
   coordinatorBlockers: '/api/coordinator/blockers',
+  workflowKitArtifacts: '/api/workflow-kit-artifacts',
 };
 
 const viewState = {

package/dashboard/components/artifacts.js

@@ -0,0 +1,113 @@
+/**
+ * Workflow-Kit Artifacts view — renders live workflow-kit artifact status.
+ *
+ * Pure render function: takes data from /api/workflow-kit-artifacts, returns HTML.
+ * Ownership resolution and file-existence checks are server-side. This view
+ * renders the snapshot without reimplementing any logic.
+ *
+ * See: WORKFLOW_KIT_DASHBOARD_SPEC.md
+ */
+
+function esc(str) {
+  if (!str) 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 statusIndicator(exists) {
+  if (exists) {
+    return `<span style="color:var(--green);font-weight:600" title="File exists">✓ exists</span>`;
+  }
+  return `<span style="color:var(--red);font-weight:600" title="File missing">✗ missing</span>`;
+}
+
+function renderArtifactRow(artifact) {
+  const isMissingRequired = !artifact.exists && artifact.required;
+  const rowStyle = isMissingRequired
+    ? ' style="border-left:3px solid var(--red)"'
+    : '';
+
+  return `<tr${rowStyle}>
+    <td class="mono">${esc(artifact.path)}</td>
+    <td>${artifact.required ? badge('required', 'var(--yellow)') : badge('optional', 'var(--text-dim)')}</td>
+    <td>${artifact.semantics ? `<span class="mono">${esc(artifact.semantics)}</span>` : '<span style="color:var(--text-dim)">—</span>'}</td>
+    <td>${artifact.owned_by ? esc(artifact.owned_by) : '<span style="color:var(--text-dim)">—</span>'}</td>
+    <td>${artifact.owner_resolution ? badge(artifact.owner_resolution, artifact.owner_resolution === 'explicit' ? 'var(--accent)' : 'var(--text-dim)') : '—'}</td>
+    <td>${statusIndicator(artifact.exists)}</td>
+  </tr>`;
+}
+
+export function render({ workflowKitArtifacts }) {
+  if (!workflowKitArtifacts) {
+    return `<div class="placeholder"><h2>Workflow Artifacts</h2><p>No workflow artifact data available. Ensure a governed run is active.</p></div>`;
+  }
+
+  if (workflowKitArtifacts.ok === false) {
+    const hint = workflowKitArtifacts.code === 'config_missing' || workflowKitArtifacts.code === 'state_missing'
+      ? ' Run <code>agentxchain init --governed</code> to get started.'
+      : '';
+    return `<div class="placeholder"><h2>Workflow Artifacts</h2><p>${esc(workflowKitArtifacts.error || 'Failed to load workflow artifact data.')}${hint}</p></div>`;
+  }
+
+  const data = workflowKitArtifacts;
+  const artifacts = data.artifacts;
+
+  // No workflow_kit configured
+  if (artifacts === null) {
+    return `<div class="placeholder"><h2>Workflow Artifacts</h2><p>No <code>workflow_kit</code> configured in <code>agentxchain.json</code>. Add a <code>workflow_kit</code> section to track phase artifacts.</p></div>`;
+  }
+
+  // Phase has no artifacts
+  if (!Array.isArray(artifacts) || artifacts.length === 0) {
+    return `<div class="placeholder"><h2>Workflow Artifacts</h2><p>Current phase <strong>${esc(data.phase || 'unknown')}</strong> has no workflow-kit artifacts defined.</p></div>`;
+  }
+
+  const missingRequired = artifacts.filter((a) => a.required && !a.exists).length;
+  const totalExists = artifacts.filter((a) => a.exists).length;
+
+  let html = `<div class="artifacts-view">`;
+
+  // Header
+  html += `<div class="run-header"><div class="run-meta">`;
+  if (data.phase) {
+    html += `<span class="phase-label">Phase: <strong>${esc(data.phase)}</strong></span>`;
+  }
+  html += `<span class="turn-count">${artifacts.length} artifact${artifacts.length !== 1 ? 's' : ''}</span>`;
+  html += `<span class="turn-count">${totalExists}/${artifacts.length} present</span>`;
+  if (missingRequired > 0) {
+    html += badge(`${missingRequired} missing required`, 'var(--red)');
+  }
+  html += `</div></div>`;
+
+  // Table
+  html += `<div class="section"><h3>Workflow-Kit Artifacts</h3>
+    <table class="data-table">
+      <thead>
+        <tr>
+          <th>Path</th>
+          <th>Required</th>
+          <th>Semantics</th>
+          <th>Owner</th>
+          <th>Resolution</th>
+          <th>Status</th>
+        </tr>
+      </thead>
+      <tbody>`;
+
+  for (const artifact of artifacts) {
+    html += renderArtifactRow(artifact);
+  }
+
+  html += `</tbody></table></div>`;
+
+  html += `</div>`;
+  return html;
+}

package/dashboard/index.html

@@ -382,6 +382,7 @@
     <a href="#blocked">Blocked</a>
     <a href="#gate">Gates</a>
     <a href="#blockers">Blockers</a>
+    <a href="#artifacts">Artifacts</a>
   </nav>
   <main id="view-container">
     <div class="placeholder">

package/package.json

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

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

@@ -18,6 +18,7 @@ import { readResource } from './state-reader.js';
 import { FileWatcher } from './file-watcher.js';
 import { approvePendingDashboardGate } from './actions.js';
 import { readCoordinatorBlockerSnapshot } from './coordinator-blockers.js';
+import { readWorkflowKitArtifacts } from './workflow-kit-artifacts.js';
 
 const MIME_TYPES = {
   '.html': 'text/html; charset=utf-8',
@@ -279,6 +280,12 @@ export function createBridgeServer({ agentxchainDir, dashboardDir, port = 3847 }
       return;
     }
 
+    if (pathname === '/api/workflow-kit-artifacts') {
+      const result = readWorkflowKitArtifacts(workspacePath);
+      writeJson(res, result.status, result.body);
+      return;
+    }
+
     // API routes
     if (pathname.startsWith('/api/')) {
       const result = readResource(agentxchainDir, pathname);

package/src/lib/dashboard/workflow-kit-artifacts.js

@@ -0,0 +1,131 @@
+/**
+ * Workflow-kit artifact status — computed dashboard endpoint.
+ *
+ * Reads agentxchain.json config and .agentxchain/state.json to derive
+ * current-phase workflow-kit artifact status for live dashboard observation.
+ *
+ * Per DEC-WK-REPORT-002: ownership resolution uses explicit owned_by first,
+ * then falls back to routing[phase].entry_role.
+ *
+ * See: WORKFLOW_KIT_DASHBOARD_SPEC.md
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { loadConfig } from '../config.js';
+import { readJsonFile } from './state-reader.js';
+
+/**
+ * Read workflow-kit artifact status for the current phase.
+ *
+ * @param {string} workspacePath — project root (parent of .agentxchain/)
+ * @returns {{ ok: boolean, status: number, body: object }}
+ */
+export function readWorkflowKitArtifacts(workspacePath) {
+  const configResult = loadConfig(workspacePath);
+  if (!configResult) {
+    return {
+      ok: false,
+      status: 404,
+      body: {
+        ok: false,
+        code: 'config_missing',
+        error: 'Project config not found. Run `agentxchain init --governed` first.',
+      },
+    };
+  }
+
+  const agentxchainDir = join(workspacePath, '.agentxchain');
+  const state = readJsonFile(agentxchainDir, 'state.json');
+  if (!state) {
+    return {
+      ok: false,
+      status: 404,
+      body: {
+        ok: false,
+        code: 'state_missing',
+        error: 'Run state not found. Run `agentxchain init --governed` first.',
+      },
+    };
+  }
+
+  const config = configResult.config;
+  const phase = state.phase || null;
+
+  if (!config.workflow_kit) {
+    return {
+      ok: true,
+      status: 200,
+      body: {
+        ok: true,
+        phase,
+        artifacts: null,
+      },
+    };
+  }
+
+  if (!phase) {
+    return {
+      ok: true,
+      status: 200,
+      body: {
+        ok: true,
+        phase: null,
+        artifacts: [],
+      },
+    };
+  }
+
+  const phaseConfig = config.workflow_kit.phases?.[phase];
+  if (!phaseConfig) {
+    return {
+      ok: true,
+      status: 200,
+      body: {
+        ok: true,
+        phase,
+        artifacts: [],
+      },
+    };
+  }
+
+  const artifacts = Array.isArray(phaseConfig.artifacts) ? phaseConfig.artifacts : [];
+  if (artifacts.length === 0) {
+    return {
+      ok: true,
+      status: 200,
+      body: {
+        ok: true,
+        phase,
+        artifacts: [],
+      },
+    };
+  }
+
+  const entryRole = config.routing?.[phase]?.entry_role || null;
+
+  const result = artifacts
+    .filter((a) => a && typeof a.path === 'string')
+    .map((a) => {
+      const hasExplicitOwner = typeof a.owned_by === 'string' && a.owned_by.length > 0;
+      return {
+        path: a.path,
+        required: a.required !== false,
+        semantics: a.semantics || null,
+        owned_by: hasExplicitOwner ? a.owned_by : entryRole,
+        owner_resolution: hasExplicitOwner ? 'explicit' : 'entry_role',
+        exists: existsSync(join(workspacePath, a.path)),
+      };
+    })
+    .sort((a, b) => a.path.localeCompare(b.path, 'en'));
+
+  return {
+    ok: true,
+    status: 200,
+    body: {
+      ok: true,
+      phase,
+      artifacts: result,
+    },
+  };
+}