agentxchain 2.134.0 → 2.134.1

package/package.json

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

package/src/commands/events.js

@@ -88,7 +88,10 @@ function printEvent(evt) {
   const coordinatorRetryDetail = evt.event_type === 'coordinator_retry' && evt.payload
     ? ` — ws ${evt.payload.workstream_id || '?'} repo ${evt.payload.repo_id || '?'} (retry of ${evt.payload.failed_turn_id || '?'})`
     : '';
-  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${intentInfo}${conflictDetail}${conflictResolvedDetail}${rejectionDetail}${acceptanceFailedDetail}${phaseTransitionDetail}${gateFailedDetail}${humanEscalationDetail}${coordinatorRetryDetail}`);
+  const projectionWarningDetail = evt.event_type === 'coordinator_retry_projection_warning' && evt.payload
+    ? ` — ws ${evt.payload.workstream_id || '?'} repo ${evt.payload.repo_id || '?'} (reconciliation required)`
+    : '';
+  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${intentInfo}${conflictDetail}${conflictResolvedDetail}${rejectionDetail}${acceptanceFailedDetail}${phaseTransitionDetail}${gateFailedDetail}${humanEscalationDetail}${coordinatorRetryDetail}${projectionWarningDetail}`);
 }
 
 function formatConflictDetail(evt) {
@@ -150,6 +153,7 @@ function colorEventType(type) {
     gate_failed: chalk.red,
     budget_exceeded_warn: chalk.yellowBright,
     coordinator_retry: chalk.cyan.bold,
+    coordinator_retry_projection_warning: chalk.yellow.bold,
     turn_checkpointed: chalk.green,
     dispatch_progress: chalk.blue.dim,
   };

package/src/commands/mission.js

@@ -38,6 +38,7 @@ import { executeGovernedRun } from './run.js';
 import { dispatchCoordinatorTurn, selectAssignmentForWorkstream } from '../lib/coordinator-dispatch.js';
 import { loadCoordinatorState } from '../lib/coordinator-state.js';
 import { projectRepoAcceptance } from '../lib/coordinator-acceptance.js';
+import { emitRunEvent } from '../lib/run-events.js';
 
 export async function missionStartCommand(opts) {
   const root = findProjectRoot(opts.dir || process.cwd());
@@ -182,6 +183,13 @@ function projectAcceptedCoordinatorTurn(workspacePath, coordinatorConfig, repoId
   );
 }
 
+function buildCoordinatorProjectionWarning(message) {
+  return {
+    code: 'coordinator_acceptance_projection_incomplete',
+    message,
+  };
+}
+
 export async function missionListCommand(opts) {
   const root = findProjectRoot(opts.dir || process.cwd());
   if (!root) {
@@ -634,6 +642,7 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
       };
 
       let execution;
+      const retryWarnings = [];
       try {
         execution = await executor(repoContext, runOpts);
       } catch (error) {
@@ -669,7 +678,21 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
           loadCoordinatorState(mission.coordinator.workspace_path),
         );
         if (!projection.ok) {
-          console.error(chalk.yellow(`Coordinator retry projection warning: ${projection.error}`));
+          const warning = buildCoordinatorProjectionWarning(projection.error);
+          retryWarnings.push(warning);
+          console.error(chalk.yellow(`Coordinator retry projection warning: ${warning.message}`));
+          emitRunEvent(mission.coordinator.workspace_path, 'coordinator_retry_projection_warning', {
+            run_id: mission.coordinator.super_run_id,
+            phase: coordinatorConfigResult.config?.workstreams?.[opts.workstream]?.phase || null,
+            status: 'active',
+            payload: {
+              workstream_id: opts.workstream,
+              repo_id: retry.retryResult.repo_id,
+              reissued_turn_id: retry.retryResult.reissued_turn_id,
+              warning_code: warning.code,
+              warning_message: warning.message,
+            },
+          });
         }
       }
 
@@ -697,6 +720,8 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
           workstream_status: retriedWorkstream?.launch_status || 'launched',
           launch_record: retriedLaunchRecord,
           exit_code: execution?.exitCode ?? 0,
+          warnings: retryWarnings,
+          reconciliation_required: retryWarnings.length > 0,
         }, null, 2));
         if ((execution?.exitCode ?? 0) !== 0) {
           process.exit(execution.exitCode);
@@ -713,6 +738,9 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
       console.log(chalk.dim(`  Old Turn:     ${retry.retryResult.failed_turn_id}`));
       console.log(chalk.dim(`  New Turn:     ${retry.retryResult.reissued_turn_id}`));
       console.log(chalk.dim(`  Workstream:   ${retriedWorkstream?.launch_status || 'launched'}`));
+      if (retryWarnings.length > 0) {
+        console.log(chalk.yellow(`  Warning:      ${retryWarnings[0].message}`));
+      }
       console.log('');
       renderPlan(retriedPlan);
       if ((execution?.exitCode ?? 0) !== 0) {

package/src/commands/status.js

@@ -24,6 +24,7 @@ import { getDashboardPid, getDashboardSession } from './dashboard.js';
 import { readPreemptionMarker, findPendingApprovedIntents } from '../lib/intake.js';
 import { readContinuousSession } from '../lib/continuous-run.js';
 import { readAllDispatchProgress } from '../lib/dispatch-progress.js';
+import { readCoordinatorWarnings } from '../lib/coordinator-warnings.js';
 
 export async function statusCommand(opts) {
   const context = loadStatusContext();
@@ -111,10 +112,22 @@ function loadStatusContext(dir = process.cwd()) {
     return null;
   }
 
+  const fallbackConfig = {
+    ...rawConfig,
+    files: {
+      talk: rawConfig.files?.talk || 'TALK.md',
+      history: rawConfig.files?.history || '.agentxchain/history.jsonl',
+      state: rawConfig.files?.state || '.agentxchain/state.json',
+      log: Object.prototype.hasOwnProperty.call(rawConfig.files || {}, 'log')
+        ? rawConfig.files.log
+        : null,
+    },
+  };
+
   return {
     root,
     rawConfig,
-    config: rawConfig,
+    config: fallbackConfig,
     version: 4,
   };
 }
@@ -122,6 +135,7 @@ function loadStatusContext(dir = process.cwd()) {
 function renderGovernedStatus(context, opts) {
   const { root, config, version } = context;
   const state = loadProjectState(root, config);
+  const stateRunId = state?.run_id || readRawStateRunId(root, config);
   const continuity = getContinuityStatus(root, state);
   const connectorHealth = getConnectorHealth(root, config, state);
   const recovery = deriveRecoveryDescriptor(state, config);
@@ -147,6 +161,9 @@ function renderGovernedStatus(context, opts) {
   const activeTurns = getActiveTurns(state);
   const dispatchProgress = filterDispatchProgressForActiveTurns(readAllDispatchProgress(root), activeTurns);
 
+  // Coordinator warning surfacing — DEC-COORD-RETRY-PROJECTION-EVENT-001
+  const coordinatorWarnings = readCoordinatorWarnings(root, { runId: stateRunId || null });
+
   if (opts.json) {
     const dashPid = getDashboardPid(root);
     const dashSession = getDashboardSession(root);
@@ -183,6 +200,7 @@ function renderGovernedStatus(context, opts) {
       dashboard_session: dashboardSessionObj,
       binding_drift: detectActiveTurnBindingDrift(state, config),
       bundle_integrity: detectStateBundleDesync(root, state),
+      coordinator_warnings: coordinatorWarnings,
     }, null, 2));
     return;
   }
@@ -284,6 +302,7 @@ function renderGovernedStatus(context, opts) {
   renderContinuityStatus(continuity, state);
   renderConnectorHealthStatus(connectorHealth);
   renderRecentEventSummary(recentEventSummary);
+  renderCoordinatorWarnings(coordinatorWarnings);
 
   // BUG-18: State/bundle integrity check
   const desync = detectStateBundleDesync(root, state);
@@ -908,3 +927,37 @@ function formatUsd(value) {
   if (typeof value !== 'number' || Number.isNaN(value)) return '0.00';
   return value.toFixed(2);
 }
+
+/**
+ * Read coordinator retry projection warnings from the event log.
+ * Returns a structured summary for both JSON and CLI output.
+ */
+function renderCoordinatorWarnings(warnings) {
+  if (!warnings || warnings.count === 0) return;
+  console.log(chalk.yellow.bold(`  ⚠ Coordinator reconciliation required (${warnings.count} projection warning${warnings.count !== 1 ? 's' : ''})`));
+  for (const w of warnings.warnings) {
+    const wsLabel = w.workstream_id ? `ws:${w.workstream_id}` : '';
+    const repoLabel = w.repo_id ? `repo:${w.repo_id}` : '';
+    const parts = [wsLabel, repoLabel].filter(Boolean).join(' ');
+    console.log(`    ${chalk.yellow('●')} ${parts} — ${w.warning_code}`);
+  }
+  console.log(chalk.dim('  Run `agentxchain mission plan show latest --json` to force plan sync and verify.'));
+  console.log('');
+}
+
+function readRawStateRunId(root, config) {
+  const relPath = config?.files?.state || '.agentxchain/state.json';
+  const filePath = join(root, relPath);
+  if (!existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    return typeof parsed?.run_id === 'string' && parsed.run_id.trim().length > 0
+      ? parsed.run_id.trim()
+      : null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/coordinator-warnings.js

@@ -0,0 +1,31 @@
+import { readRunEvents } from './run-events.js';
+
+function normalizeCoordinatorWarning(event) {
+  return {
+    event_id: event.event_id,
+    timestamp: event.timestamp,
+    run_id: event.run_id || null,
+    workstream_id: event.payload?.workstream_id || null,
+    repo_id: event.payload?.repo_id || null,
+    reissued_turn_id: event.payload?.reissued_turn_id || null,
+    warning_code: event.payload?.warning_code || 'coordinator_acceptance_projection_incomplete',
+    warning_message: event.payload?.warning_message || null,
+  };
+}
+
+export function readCoordinatorWarnings(root, { runId = null } = {}) {
+  const events = readRunEvents(root, { type: 'coordinator_retry_projection_warning' });
+  const filtered = runId
+    ? events.filter((event) => event.run_id === runId)
+    : events;
+
+  if (filtered.length === 0) {
+    return { count: 0, reconciliation_required: false, warnings: [] };
+  }
+
+  return {
+    count: filtered.length,
+    reconciliation_required: true,
+    warnings: filtered.map(normalizeCoordinatorWarning),
+  };
+}

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

@@ -7,6 +7,8 @@
 
 import { buildPlanProgressSummary, loadAllPlans } from '../mission-plans.js';
 import { loadAllMissionArtifacts } from '../missions.js';
+import { loadCoordinatorState } from '../coordinator-state.js';
+import { readCoordinatorWarnings } from '../coordinator-warnings.js';
 
 /**
  * Build a dashboard-ready plan snapshot across all missions.
@@ -49,12 +51,19 @@ export function readPlanSnapshot(workspacePath, { limit, missionId } = {}) {
     latestSummary = buildPlanSummary(latest);
   }
 
+  // Surface coordinator projection warnings for dashboard consumers
+  const coordinatorState = loadCoordinatorState(workspacePath);
+  const coordinatorWarnings = readCoordinatorWarnings(workspacePath, {
+    runId: coordinatorState?.super_run_id || null,
+  });
+
   return {
     ok: true,
     status: 200,
     body: {
       latest: latestSummary,
       plans: plans.map(buildPlanSummary),
+      coordinator_warnings: coordinatorWarnings,
     },
   };
 }

package/src/lib/recent-event-summary.js

@@ -47,6 +47,11 @@ function describeEvent(eventType, entry) {
       const retryRepo = trimToNull(entry.payload?.repo_id);
       return `${prefix}${eventType}${wsId ? ` ${wsId}` : ''}${retryRepo ? ` (${retryRepo})` : ''}`;
     }
+    case 'coordinator_retry_projection_warning': {
+      const wsIdWarn = trimToNull(entry.payload?.workstream_id);
+      const warnRepo = trimToNull(entry.payload?.repo_id);
+      return `${prefix}${eventType}${wsIdWarn ? ` ${wsIdWarn}` : ''}${warnRepo ? ` (${warnRepo})` : ''} — reconciliation required`;
+    }
     case 'turn_checkpointed':
       return `${prefix}${eventType}${roleId ? ` [${roleId}]` : ''}`;
     case 'dispatch_progress':

package/src/lib/run-events.js

@@ -23,6 +23,7 @@ export const VALID_RUN_EVENTS = [
   'turn_reissued',
   'turn_checkpointed',
   'coordinator_retry',
+  'coordinator_retry_projection_warning',
   'run_blocked',
   'run_completed',
   'escalation_raised',