agentxchain 2.133.0 → 2.134.1

package/package.json

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

package/scripts/release-postflight.sh

@@ -2,8 +2,9 @@
 # Release postflight — run this after publish succeeds.
 # Verifies: release tag exists, npm registry serves the version, metadata is present,
 # the published package resolves through npx, the published package can execute its
-# CLI entrypoint from the tarball, and runner package exports are importable in a
-# clean consumer project.
+# CLI entrypoint from the tarball, runner package exports are importable in a
+# clean consumer project, and the installed CLI can scaffold and validate a fresh
+# governed workspace.
 # Usage: bash scripts/release-postflight.sh --target-version <semver> [--tag vX.Y.Z]
 set -uo pipefail
 
@@ -260,6 +261,64 @@ EOF
   return "$node_status"
 }
 
+run_operator_frontdoor_smoke() {
+  if [[ -z "$TARBALL_URL" ]]; then
+    echo "registry tarball metadata unavailable for operator front-door smoke" >&2
+    return 1
+  fi
+
+  local smoke_root
+  local workspace
+  local bin_path
+  local smoke_npmrc
+  local install_status
+  local init_output
+  local init_status
+  local validate_output
+  local validate_status
+
+  smoke_root="$(mktemp -d "${TMPDIR:-/tmp}/agentxchain-operator-postflight.XXXXXX")"
+  workspace="${smoke_root}/workspace"
+  bin_path="${smoke_root}/bin/${PACKAGE_BIN_NAME}"
+  smoke_npmrc="${smoke_root}/.npmrc"
+  echo "registry=https://registry.npmjs.org/" > "$smoke_npmrc"
+
+  env -u NODE_AUTH_TOKEN NPM_CONFIG_USERCONFIG="$smoke_npmrc" \
+    npm install --global --prefix "$smoke_root" "$TARBALL_URL" >/dev/null 2>&1
+  install_status=$?
+  if [[ "$install_status" -ne 0 ]]; then
+    rm -rf "$smoke_root"
+    return "$install_status"
+  fi
+
+  if [[ ! -x "$bin_path" ]]; then
+    echo "installed binary missing at ${bin_path}" >&2
+    rm -rf "$smoke_root"
+    return 1
+  fi
+
+  init_output="$(
+    env -u NODE_AUTH_TOKEN NPM_CONFIG_USERCONFIG="$smoke_npmrc" \
+      "$bin_path" init --governed --template cli-tool --goal "Release operator smoke" --dir "$workspace" -y 2>&1
+  )"
+  init_status=$?
+  if [[ "$init_status" -ne 0 ]]; then
+    printf '%s\n' "$init_output"
+    rm -rf "$smoke_root"
+    return "$init_status"
+  fi
+
+  validate_output="$(
+    cd "$workspace" || exit 1
+    env -u NODE_AUTH_TOKEN NPM_CONFIG_USERCONFIG="$smoke_npmrc" \
+      "$bin_path" validate --mode kickoff --json 2>&1
+  )"
+  validate_status=$?
+  printf '%s\n' "$validate_output"
+  rm -rf "$smoke_root"
+  return "$validate_status"
+}
+
 run_with_retry() {
   local __output_var="$1"
   local description="$2"
@@ -313,17 +372,17 @@ run_with_retry() {
 
 echo "AgentXchain v${TARGET_VERSION} Release Postflight"
 echo "====================================="
-echo "Checks release truth after publish: tag, registry visibility, metadata, npx smoke, CLI install smoke, and package export smoke."
+echo "Checks release truth after publish: tag, registry visibility, metadata, npx smoke, CLI install smoke, package export smoke, and operator front-door smoke."
 echo ""
 
-echo "[1/7] Git tag"
+echo "[1/8] Git tag"
 if git rev-parse -q --verify "refs/tags/${TAG}" >/dev/null 2>&1; then
   pass "Git tag ${TAG} exists locally"
 else
   fail "Git tag ${TAG} is missing locally"
 fi
 
-echo "[2/7] Registry version"
+echo "[2/8] Registry version"
 if run_with_retry VERSION_OUTPUT "registry version" equals "${TARGET_VERSION}" npm view "${PACKAGE_NAME}@${TARGET_VERSION}" version; then
   PUBLISHED_VERSION="$(trim_last_line "$VERSION_OUTPUT")"
   if [[ "$PUBLISHED_VERSION" == "$TARGET_VERSION" ]]; then
@@ -336,7 +395,7 @@ else
   printf '%s\n' "$VERSION_OUTPUT" | tail -20
 fi
 
-echo "[3/7] Registry tarball metadata"
+echo "[3/8] Registry tarball metadata"
 if run_with_retry TARBALL_OUTPUT "registry tarball metadata" nonempty "" npm view "${PACKAGE_NAME}@${TARGET_VERSION}" dist.tarball; then
   TARBALL_URL="$(trim_last_line "$TARBALL_OUTPUT")"
   if [[ -n "$TARBALL_URL" ]]; then
@@ -349,7 +408,7 @@ else
   printf '%s\n' "$TARBALL_OUTPUT" | tail -20
 fi
 
-echo "[4/7] Registry checksum metadata"
+echo "[4/8] Registry checksum metadata"
 if run_with_retry INTEGRITY_OUTPUT "registry checksum metadata" nonempty "" npm view "${PACKAGE_NAME}@${TARGET_VERSION}" dist.integrity; then
   REGISTRY_CHECKSUM="$(trim_last_line "$INTEGRITY_OUTPUT")"
 fi
@@ -364,7 +423,7 @@ else
   fail "registry did not return checksum metadata"
 fi
 
-echo "[5/7] npx smoke"
+echo "[5/8] npx smoke"
 if run_with_retry NPX_OUTPUT "npx smoke" nonempty "" run_npx_smoke; then
   NPX_VERSION="$(extract_matching_line "$NPX_OUTPUT" "$TARGET_VERSION" 2>/dev/null || trim_last_line "$NPX_OUTPUT")"
   if [[ "$NPX_VERSION" == "$TARGET_VERSION" ]]; then
@@ -377,7 +436,7 @@ else
   printf '%s\n' "$NPX_OUTPUT" | tail -20
 fi
 
-echo "[6/7] Install smoke"
+echo "[6/8] Install smoke"
 if run_with_retry EXEC_OUTPUT "install smoke" nonempty "" run_install_smoke; then
   EXEC_VERSION="$(trim_last_line "$EXEC_OUTPUT")"
   if [[ "$EXEC_VERSION" == "$TARGET_VERSION" ]]; then
@@ -390,7 +449,7 @@ else
   printf '%s\n' "$EXEC_OUTPUT" | tail -20
 fi
 
-echo "[7/7] Package export smoke"
+echo "[7/8] Package export smoke"
 if run_with_retry RUNNER_EXPORT_OUTPUT "runner export smoke" nonempty "" run_runner_export_smoke; then
   RUNNER_EXPORT_JSON="$(trim_last_line "$RUNNER_EXPORT_OUTPUT")"
   RUNNER_EXPORT_VERSION="$(printf '%s' "$RUNNER_EXPORT_JSON" | node --input-type=module -e "process.stdin.setEncoding('utf8'); let raw=''; process.stdin.on('data', (chunk) => raw += chunk); process.stdin.on('end', () => { const parsed = JSON.parse(raw); console.log(parsed.runner_interface_version || ''); });")"
@@ -410,6 +469,20 @@ else
   printf '%s\n' "$RUNNER_EXPORT_OUTPUT" | tail -20
 fi
 
+echo "[8/8] Operator front-door smoke"
+if run_with_retry OPERATOR_OUTPUT "operator front-door smoke" nonempty "" run_operator_frontdoor_smoke; then
+  OPERATOR_OK="$(printf '%s' "$OPERATOR_OUTPUT" | node --input-type=module -e "process.stdin.setEncoding('utf8'); let raw=''; process.stdin.on('data', (chunk) => raw += chunk); process.stdin.on('end', () => { const parsed = JSON.parse(raw); console.log(parsed.ok ? 'true' : 'false'); });" 2>/dev/null || true)"
+  OPERATOR_PROTOCOL_MODE="$(printf '%s' "$OPERATOR_OUTPUT" | node --input-type=module -e "process.stdin.setEncoding('utf8'); let raw=''; process.stdin.on('data', (chunk) => raw += chunk); process.stdin.on('end', () => { const parsed = JSON.parse(raw); console.log(parsed.protocol_mode || ''); });" 2>/dev/null || true)"
+  if [[ "$OPERATOR_OK" == "true" && "$OPERATOR_PROTOCOL_MODE" == "governed" ]]; then
+    pass "published CLI scaffolds and validates a governed workspace"
+  else
+    fail "published operator front-door smoke did not validate a governed workspace"
+  fi
+else
+  fail "published operator front-door smoke failed"
+  printf '%s\n' "$OPERATOR_OUTPUT" | tail -20
+fi
+
 echo ""
 echo "====================================="
 echo "Results: ${PASS} passed, ${FAIL} failed"

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

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { readFileSync } from 'fs';
-import { resolve } from 'path';
+import { join, resolve } from 'path';
 import { findProjectRoot, loadProjectContext } from '../lib/config.js';
 import {
   attachChainToMission,
@@ -37,6 +37,8 @@ import { executeChainedRun } from '../lib/run-chain.js';
 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());
@@ -144,6 +146,50 @@ export async function missionStartCommand(opts) {
   renderMissionSnapshot(snapshot);
 }
 
+function loadAcceptedRepoTurn(repoPath, turnId) {
+  try {
+    const historyPath = join(repoPath, '.agentxchain', 'history.jsonl');
+    const content = readFileSync(historyPath, 'utf8').trim();
+    if (!content) return null;
+    const entries = content
+      .split('\n')
+      .map((line) => JSON.parse(line))
+      .filter((entry) => entry?.turn_id === turnId)
+      .filter((entry) => Boolean(entry?.accepted_at) || entry?.status === 'accepted' || entry?.status === 'completed');
+    return entries.at(-1) || null;
+  } catch {
+    return null;
+  }
+}
+
+function projectAcceptedCoordinatorTurn(workspacePath, coordinatorConfig, repoId, turnId, workstreamId, fallbackState) {
+  const acceptedTurn = loadAcceptedRepoTurn(coordinatorConfig.repos?.[repoId]?.resolved_path, turnId);
+  if (!acceptedTurn) {
+    return { ok: false, error: `Accepted turn ${turnId} not found in repo-local history for ${repoId}.` };
+  }
+
+  const currentState = loadCoordinatorState(workspacePath) || fallbackState;
+  if (!currentState) {
+    return { ok: false, error: `Coordinator state not found at ${workspacePath}.` };
+  }
+
+  return projectRepoAcceptance(
+    workspacePath,
+    currentState,
+    coordinatorConfig,
+    repoId,
+    acceptedTurn,
+    workstreamId,
+  );
+}
+
+function buildCoordinatorProjectionWarning(message) {
+  return {
+    code: 'coordinator_acceptance_projection_incomplete',
+    message,
+  };
+}
+
 export async function missionListCommand(opts) {
   const root = findProjectRoot(opts.dir || process.cwd());
   if (!root) {
@@ -578,6 +624,7 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
       }
 
       const executor = opts._executeGovernedRun || executeGovernedRun;
+      const childLog = opts.json ? noop : (opts._log || console.log);
       const repoContext = loadProjectContext(retry.retryResult.repo_path);
       if (!repoContext) {
         console.error(chalk.red(`Cannot load project context for retried repo at ${retry.retryResult.repo_path}.`));
@@ -586,6 +633,7 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
 
       const runOpts = {
         autoApprove: !!opts.autoApprove,
+        log: childLog,
         provenance: {
           trigger: 'manual',
           created_by: 'operator',
@@ -594,6 +642,7 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
       };
 
       let execution;
+      const retryWarnings = [];
       try {
         execution = await executor(repoContext, runOpts);
       } catch (error) {
@@ -619,6 +668,34 @@ export async function missionPlanLaunchCommand(planTarget, opts) {
         process.exit(1);
       }
 
+      if ((execution?.exitCode ?? 0) === 0) {
+        const projection = projectAcceptedCoordinatorTurn(
+          mission.coordinator.workspace_path,
+          coordinatorConfigResult.config,
+          retry.retryResult.repo_id,
+          retry.retryResult.reissued_turn_id,
+          opts.workstream,
+          loadCoordinatorState(mission.coordinator.workspace_path),
+        );
+        if (!projection.ok) {
+          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,
+            },
+          });
+        }
+      }
+
       const syncedRetry = synchronizeCoordinatorPlanState(root, mission, retry.plan);
       const retriedPlan = syncedRetry.ok ? syncedRetry.plan : retry.plan;
       const retriedWorkstream = retriedPlan.workstreams.find((ws) => ws.workstream_id === opts.workstream);
@@ -643,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);
@@ -659,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) {
@@ -1385,7 +1467,7 @@ async function dispatchAndExecuteCoordinatorWorkstream(
   root, mission, plan, workstreamId, coordinatorConfig, coordinatorState, opts,
 ) {
   const executor = opts._executeGovernedRun || executeGovernedRun;
-  const logger = opts._log || console.log;
+  const logger = opts.json ? noop : (opts._log || console.log);
 
   // 1. Select assignment
   const assignment = selectAssignmentForWorkstream(
@@ -1456,6 +1538,26 @@ async function dispatchAndExecuteCoordinatorWorkstream(
     };
   }
 
+  if ((execution?.exitCode ?? 0) === 0) {
+    const projection = projectAcceptedCoordinatorTurn(
+      mission.coordinator.workspace_path,
+      coordinatorConfig,
+      dispatch.repo_id,
+      dispatch.turn_id,
+      workstreamId,
+      loadCoordinatorState(mission.coordinator.workspace_path) || coordinatorState,
+    );
+    if (!projection.ok) {
+      return {
+        ok: false,
+        status: 'projection_error',
+        repo_id: dispatch.repo_id,
+        turn_id: dispatch.turn_id,
+        error: projection.error,
+      };
+    }
+  }
+
   // 5. Sync plan state from coordinator (updates barriers, accepted repos, failures)
   const synced = synchronizeCoordinatorPlanState(root, mission, launch.plan);
 
@@ -2285,3 +2387,5 @@ function formatTimestamp(value) {
 function pad(value, width) {
   return String(value).padEnd(width);
 }
+
+function noop() {}

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-dispatch.js

@@ -1,7 +1,7 @@
 import { appendFileSync, copyFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { loadProjectContext, loadProjectState } from './config.js';
-import { assignGovernedTurn, getActiveTurnCount } from './governed-state.js';
+import { assignGovernedTurn, getActiveTurnCount, initializeGovernedRun } from './governed-state.js';
 import { writeDispatchBundle } from './dispatch-bundle.js';
 import { getDispatchTurnDir } from './turn-paths.js';
 import { readBarriers, readCoordinatorHistory, recordCoordinatorDecision } from './coordinator-state.js';
@@ -253,6 +253,17 @@ export function dispatchCoordinatorTurn(workspacePath, state, config, assignment
     return { ok: false, error: runtime.detail };
   }
 
+  let repoState = runtime.state;
+  if (repoState.status === 'idle' || repoState.status === 'completed') {
+    const initResult = initializeGovernedRun(runtime.root, runtime.config, {
+      allow_terminal_restart: repoState.status === 'completed',
+    });
+    if (!initResult.ok) {
+      return { ok: false, error: initResult.error };
+    }
+    repoState = initResult.state;
+  }
+
   const assignResult = assignGovernedTurn(runtime.root, runtime.config, assignment.role);
   if (!assignResult.ok) {
     return { ok: false, error: assignResult.error };

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/mission-plans.js

@@ -12,7 +12,7 @@ import { join } from 'path';
 import { loadChainReport } from './chain-reports.js';
 import { writeDispatchBundle } from './dispatch-bundle.js';
 import { loadProjectContext, loadProjectState } from './config.js';
-import { reissueTurn } from './governed-state.js';
+import { reactivateGovernedRun, reissueTurn } from './governed-state.js';
 import { emitRunEvent } from './run-events.js';
 import { readBarriers, readCoordinatorHistory, recordCoordinatorDecision } from './coordinator-state.js';
 import { loadCoordinatorConfig } from './coordinator-config.js';
@@ -1074,7 +1074,19 @@ export function retryCoordinatorWorkstream(root, mission, planId, workstreamId,
     return { ok: false, error: reissued.error };
   }
 
-  const bundleResult = writeDispatchBundle(repoTurn.root, reissued.state, repoTurn.config, {
+  let repoStateForBundle = reissued.state;
+  if (reissued.state?.status === 'blocked' || reissued.state?.status === 'paused') {
+    const reactivated = reactivateGovernedRun(repoTurn.root, reissued.state, {
+      via: 'mission plan launch --retry',
+      notificationConfig: repoTurn.config,
+    });
+    if (!reactivated.ok) {
+      return { ok: false, error: `Turn reissued but blocked run could not be reactivated: ${reactivated.error}` };
+    }
+    repoStateForBundle = reactivated.state;
+  }
+
+  const bundleResult = writeDispatchBundle(repoTurn.root, repoStateForBundle, repoTurn.config, {
     turnId: reissued.newTurn.turn_id,
   });
   if (!bundleResult.ok) {

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',