@chllming/wave-orchestration 0.8.3 → 0.8.4

package/scripts/wave-orchestrator/projection-writer.mjs

@@ -0,0 +1,256 @@
+import path from "node:path";
+import {
+  writeAssignmentSnapshot,
+  writeDependencySnapshot,
+} from "./artifact-schemas.mjs";
+import {
+  syncGlobalWaveFromWaveDashboard,
+  writeGlobalDashboard,
+  writeWaveDashboard,
+} from "./dashboard-state.mjs";
+import { writeDocsQueue } from "./docs-queue.mjs";
+import { writeWaveLedger } from "./ledger.mjs";
+import { writeDependencySnapshotMarkdown } from "./routing-state.mjs";
+import {
+  writeCompiledInbox,
+  writeCoordinationBoardProjection,
+  writeJsonArtifact,
+} from "./coordination-store.mjs";
+import { parseStructuredSignalsFromLog } from "./dashboard-state.mjs";
+import { readRunExecutionSummary } from "./gate-engine.mjs";
+import { waveProofRegistryPath } from "./proof-registry.mjs";
+import { relaunchReasonBuckets, writeWaveRelaunchPlan } from "./retry-engine.mjs";
+import { toIsoTimestamp, writeTextAtomic } from "./shared.mjs";
+import { buildQualityMetrics, writeTraceBundle } from "./traces.mjs";
+
+export function writeWaveDerivedProjections({ lanePaths, wave, derivedState }) {
+  if (!derivedState) {
+    return null;
+  }
+  writeAssignmentSnapshot(derivedState.assignmentSnapshotPath, derivedState.capabilityAssignments, {
+    lane: lanePaths.lane,
+    wave: wave.wave,
+  });
+  writeDependencySnapshot(
+    derivedState.dependencySnapshotPath,
+    derivedState.dependencySnapshot,
+    {
+      lane: lanePaths.lane,
+      wave: wave.wave,
+    },
+  );
+  writeDependencySnapshotMarkdown(
+    derivedState.dependencySnapshotMarkdownPath,
+    derivedState.dependencySnapshot,
+  );
+  writeDocsQueue(derivedState.docsQueuePath, derivedState.docsQueue);
+  writeJsonArtifact(derivedState.securitySummaryPath, derivedState.securitySummary);
+  writeTextAtomic(
+    derivedState.securityMarkdownPath,
+    `${derivedState.securitySummary ? renderWaveSecuritySummaryMarkdown(derivedState.securitySummary) : ""}\n`,
+  );
+  writeJsonArtifact(derivedState.integrationSummaryPath, derivedState.integrationSummary);
+  writeTextAtomic(
+    derivedState.integrationMarkdownPath,
+    `${derivedState.integrationSummary ? renderIntegrationSummaryMarkdown(derivedState.integrationSummary) : ""}\n`,
+  );
+  writeWaveLedger(derivedState.ledgerPath, derivedState.ledger);
+  writeCompiledInbox(derivedState.sharedSummaryPath, derivedState.sharedSummaryText);
+  for (const inbox of Object.values(derivedState.inboxesByAgentId || {})) {
+    writeCompiledInbox(inbox.path, inbox.text);
+  }
+  writeCoordinationBoardProjection(derivedState.messageBoardPath, {
+    wave: wave.wave,
+    waveFile: wave.file,
+    agents: wave.agents,
+    state: derivedState.coordinationState,
+    capabilityAssignments: derivedState.capabilityAssignments,
+    dependencySnapshot: derivedState.dependencySnapshot,
+  });
+  return derivedState;
+}
+
+export function writeDashboardProjections({
+  lanePaths,
+  globalDashboard = null,
+  dashboardState = null,
+  dashboardPath = null,
+}) {
+  if (dashboardState && dashboardPath) {
+    writeWaveDashboard(dashboardPath, dashboardState);
+  }
+  if (globalDashboard && dashboardState) {
+    syncGlobalWaveFromWaveDashboard(globalDashboard, dashboardState);
+  }
+  if (globalDashboard) {
+    writeGlobalDashboard(lanePaths.globalDashboardPath, globalDashboard);
+  }
+}
+
+export function writeWaveAttemptTraceProjection({
+  lanePaths,
+  wave,
+  attempt,
+  launcherOptions,
+  derivedState,
+  manifest,
+  agentRuns,
+  gateSnapshot,
+  tracesDir,
+}) {
+  const structuredSignals = Object.fromEntries(
+    agentRuns.map((run) => [run.agent.agentId, parseStructuredSignalsFromLog(run.logPath)]),
+  );
+  const summariesByAgentId = Object.fromEntries(
+    agentRuns
+      .map((run) => [run.agent.agentId, readRunExecutionSummary(run, wave, { mode: "compat" })])
+      .filter(([, summary]) => summary),
+  );
+  const traceDir = writeTraceBundle({
+    tracesDir,
+    lanePaths,
+    launcherOptions,
+    wave,
+    attempt,
+    manifest,
+    coordinationLogPath: derivedState.coordinationLogPath,
+    coordinationState: derivedState.coordinationState,
+    ledger: derivedState.ledger,
+    docsQueue: derivedState.docsQueue,
+    capabilityAssignments: derivedState.capabilityAssignments,
+    dependencySnapshot: derivedState.dependencySnapshot,
+    securitySummary: derivedState.securitySummary,
+    integrationSummary: derivedState.integrationSummary,
+    integrationMarkdownPath: derivedState.integrationMarkdownPath,
+    proofRegistryPath: lanePaths.proofDir ? waveProofRegistryPath(lanePaths, wave.wave) : null,
+    controlPlanePath: path.join(lanePaths.controlPlaneDir, `wave-${wave.wave}.jsonl`),
+    clarificationTriage: derivedState.clarificationTriage,
+    agentRuns,
+    structuredSignals,
+    gateSnapshot,
+    quality: buildQualityMetrics({
+      tracesDir,
+      wave,
+      coordinationState: derivedState.coordinationState,
+      integrationSummary: derivedState.integrationSummary,
+      ledger: derivedState.ledger,
+      docsQueue: derivedState.docsQueue,
+      capabilityAssignments: derivedState.capabilityAssignments,
+      dependencySnapshot: derivedState.dependencySnapshot,
+      summariesByAgentId,
+      agentRuns,
+      gateSnapshot,
+      attempt,
+      coordinationLogPath: derivedState.coordinationLogPath,
+    }),
+  });
+  return {
+    traceDir,
+    structuredSignals,
+    summariesByAgentId,
+  };
+}
+
+export function writeWaveRelaunchProjection({
+  lanePaths,
+  wave,
+  attempt,
+  runs,
+  failures,
+  derivedState,
+}) {
+  writeWaveRelaunchPlan(lanePaths, wave.wave, {
+    wave: wave.wave,
+    attempt,
+    phase: derivedState?.ledger?.phase || null,
+    selectedAgentIds: runs.map((run) => run.agent.agentId),
+    reasonBuckets: relaunchReasonBuckets(runs, failures, derivedState),
+    executorStates: Object.fromEntries(
+      runs.map((run) => [run.agent.agentId, run.agent.executorResolved || null]),
+    ),
+    fallbackHistory: Object.fromEntries(
+      runs.map((run) => [
+        run.agent.agentId,
+        run.agent.executorResolved?.executorHistory || [],
+      ]),
+    ),
+    createdAt: toIsoTimestamp(),
+  });
+}
+
+function renderWaveSecuritySummaryMarkdown(securitySummary) {
+  return [
+    `# Wave ${securitySummary.wave} Security Summary`,
+    "",
+    `- State: ${securitySummary.overallState || "unknown"}`,
+    `- Detail: ${securitySummary.detail || "n/a"}`,
+    `- Total findings: ${securitySummary.totalFindings || 0}`,
+    `- Total approvals: ${securitySummary.totalApprovals || 0}`,
+    `- Reviewers: ${(securitySummary.agents || []).length}`,
+    "",
+    "## Reviews",
+    ...((securitySummary.agents || []).length > 0
+      ? securitySummary.agents.map(
+          (entry) =>
+            `- ${entry.agentId}: state=${entry.state || "unknown"} findings=${entry.findings || 0} approvals=${entry.approvals || 0}${entry.reportPath ? ` report=${entry.reportPath}` : ""}${entry.detail ? ` detail=${entry.detail}` : ""}`,
+        )
+      : ["- None."]),
+    "",
+  ].join("\n");
+}
+
+function renderIntegrationSection(title, items) {
+  return [
+    title,
+    ...((items || []).length > 0 ? items.map((item) => `- ${item}`) : ["- None."]),
+    "",
+  ];
+}
+
+function renderIntegrationSummaryMarkdown(integrationSummary) {
+  return [
+    `# Wave ${integrationSummary.wave} Integration Summary`,
+    "",
+    `- Recommendation: ${integrationSummary.recommendation || "unknown"}`,
+    `- Detail: ${integrationSummary.detail || "n/a"}`,
+    `- Open claims: ${(integrationSummary.openClaims || []).length}`,
+    `- Conflicting claims: ${(integrationSummary.conflictingClaims || []).length}`,
+    `- Unresolved blockers: ${(integrationSummary.unresolvedBlockers || []).length}`,
+    `- Changed interfaces: ${(integrationSummary.changedInterfaces || []).length}`,
+    `- Cross-component impacts: ${(integrationSummary.crossComponentImpacts || []).length}`,
+    `- Proof gaps: ${(integrationSummary.proofGaps || []).length}`,
+    `- Deploy risks: ${(integrationSummary.deployRisks || []).length}`,
+    `- Documentation gaps: ${(integrationSummary.docGaps || []).length}`,
+    `- Security review: ${integrationSummary.securityState || "not-applicable"}`,
+    `- Security findings: ${(integrationSummary.securityFindings || []).length}`,
+    `- Security approvals: ${(integrationSummary.securityApprovals || []).length}`,
+    `- Inbound dependencies: ${(integrationSummary.inboundDependencies || []).length}`,
+    `- Outbound dependencies: ${(integrationSummary.outboundDependencies || []).length}`,
+    `- Helper assignments: ${(integrationSummary.helperAssignments || []).length}`,
+    "",
+    ...renderIntegrationSection("## Open Claims", integrationSummary.openClaims),
+    ...renderIntegrationSection("## Conflicting Claims", integrationSummary.conflictingClaims),
+    ...renderIntegrationSection("## Unresolved Blockers", integrationSummary.unresolvedBlockers),
+    ...renderIntegrationSection("## Changed Interfaces", integrationSummary.changedInterfaces),
+    ...renderIntegrationSection(
+      "## Cross-Component Impacts",
+      integrationSummary.crossComponentImpacts,
+    ),
+    ...renderIntegrationSection("## Proof Gaps", integrationSummary.proofGaps),
+    ...renderIntegrationSection("## Deploy Risks", integrationSummary.deployRisks),
+    ...renderIntegrationSection("## Security Findings", integrationSummary.securityFindings),
+    ...renderIntegrationSection("## Security Approvals", integrationSummary.securityApprovals),
+    ...renderIntegrationSection("## Inbound Dependencies", integrationSummary.inboundDependencies),
+    ...renderIntegrationSection("## Outbound Dependencies", integrationSummary.outboundDependencies),
+    ...renderIntegrationSection("## Helper Assignments", integrationSummary.helperAssignments),
+    "## Runtime Assignments",
+    ...((integrationSummary.runtimeAssignments || []).length > 0
+      ? integrationSummary.runtimeAssignments.map(
+          (assignment) =>
+            `- ${assignment.agentId}: executor=${assignment.executorId || "n/a"} role=${assignment.role || "n/a"} profile=${assignment.profile || "none"} fallback_used=${assignment.fallbackUsed ? "yes" : "no"}`,
+        )
+      : ["- None."]),
+    "",
+    ...renderIntegrationSection("## Documentation Gaps", integrationSummary.docGaps),
+  ].join("\n");
+}

package/scripts/wave-orchestrator/reconcile-format.mjs

@@ -0,0 +1,32 @@
+import { compactSingleLine } from "./shared.mjs";
+
+export function formatReconcileBlockedWaveLine(blockedWave) {
+  const parts = Array.isArray(blockedWave?.reasons)
+    ? blockedWave.reasons
+        .map((reason) => {
+          const code = compactSingleLine(reason?.code || "", 80);
+          const detail = compactSingleLine(reason?.detail || "", 240);
+          return code && detail ? `${code}=${detail}` : "";
+        })
+        .filter(Boolean)
+    : [];
+  return `[reconcile] wave ${blockedWave?.wave ?? "unknown"} not reconstructable: ${
+    parts.join("; ") || "unknown reason"
+  }`;
+}
+
+export function formatReconcilePreservedWaveLine(preservedWave) {
+  const parts = Array.isArray(preservedWave?.reasons)
+    ? preservedWave.reasons
+        .map((reason) => {
+          const code = compactSingleLine(reason?.code || "", 80);
+          const detail = compactSingleLine(reason?.detail || "", 240);
+          return code && detail ? `${code}=${detail}` : "";
+        })
+        .filter(Boolean)
+    : [];
+  const previousState = compactSingleLine(preservedWave?.previousState || "completed", 80);
+  return `[reconcile] wave ${preservedWave?.wave ?? "unknown"} preserved as ${previousState}: ${
+    parts.join("; ") || "unknown reason"
+  }`;
+}

package/scripts/wave-orchestrator/reducer-snapshot.mjs

@@ -0,0 +1,297 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  isOpenCoordinationStatus,
+  openClarificationLinkedRequests,
+  readMaterializedCoordinationState,
+} from "./coordination-store.mjs";
+import { readWaveHumanFeedbackRequests } from "./coordination.mjs";
+import { readControlPlaneEvents } from "./control-plane.mjs";
+import {
+  readWaveAssignmentBarrier,
+  readWaveDependencyBarrier,
+  readRunResultEnvelope,
+} from "./gate-engine.mjs";
+import { buildResumePlan } from "./retry-engine.mjs";
+import { reduceWaveState } from "./wave-state-reducer.mjs";
+import { resolveWaveRoleBindings } from "./role-helpers.mjs";
+import {
+  readWaveStateSnapshot,
+  writeWaveStateSnapshot,
+} from "./artifact-schemas.mjs";
+import { ensureDirectory } from "./shared.mjs";
+
+function normalizeShadowGate(gate) {
+  if (!gate || typeof gate !== "object") {
+    return null;
+  }
+  return {
+    ok: gate.ok === true,
+    agentId: gate.agentId || null,
+    componentId: gate.componentId || null,
+    statusCode: gate.statusCode || null,
+    detail: gate.detail || null,
+    waitingOnAgentIds: Array.isArray(gate.waitingOnAgentIds)
+      ? [...new Set(gate.waitingOnAgentIds.filter(Boolean))].sort()
+      : [],
+  };
+}
+
+function normalizeShadowIdList(values) {
+  return [...new Set((values || []).filter(Boolean))].sort();
+}
+
+function shadowSlice(compatibility, reducer) {
+  return {
+    matches: JSON.stringify(compatibility) === JSON.stringify(reducer),
+    compatibility,
+    reducer,
+  };
+}
+
+function contradictionIds(value) {
+  if (value instanceof Map) {
+    return [...value.keys()];
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => entry?.contradictionId || entry?.id).filter(Boolean);
+  }
+  if (value && typeof value === "object") {
+    return Object.keys(value);
+  }
+  return [];
+}
+
+function compatibilityBlockerIds(derivedState) {
+  const coordinationState = derivedState?.coordinationState || {};
+  return normalizeShadowIdList([
+    ...(coordinationState.blockers || [])
+      .filter((record) => isOpenCoordinationStatus(record.status))
+      .map((record) => record.id),
+    ...(coordinationState.clarifications || [])
+      .filter((record) => isOpenCoordinationStatus(record.status))
+      .map((record) => record.id),
+    ...openClarificationLinkedRequests(coordinationState).map((record) => record.id),
+    ...(coordinationState.humanFeedback || [])
+      .filter((record) => isOpenCoordinationStatus(record.status))
+      .map((record) => record.id),
+    ...(coordinationState.humanEscalations || [])
+      .filter((record) => isOpenCoordinationStatus(record.status))
+      .map((record) => record.id),
+    ...((derivedState?.capabilityAssignments || [])
+      .filter((assignment) => assignment.blocking)
+      .map((assignment) => assignment.requestId || assignment.id)),
+    ...((derivedState?.dependencySnapshot?.requiredInbound || []).map((record) => record.id)),
+    ...((derivedState?.dependencySnapshot?.requiredOutbound || []).map((record) => record.id)),
+    ...((derivedState?.dependencySnapshot?.unresolvedInboundAssignments || []).map((record) => record.id)),
+  ]);
+}
+
+function buildReducerShadowDiff({
+  derivedState,
+  compatibilityGateSnapshot = null,
+  compatibilityRelaunchResolution = null,
+  reducerState,
+  resumePlan,
+}) {
+  const helperCompatibility = compatibilityGateSnapshot
+    ? normalizeShadowGate(compatibilityGateSnapshot.helperAssignmentBarrier)
+    : normalizeShadowGate(readWaveAssignmentBarrier(derivedState));
+  const dependencyCompatibility = compatibilityGateSnapshot
+    ? normalizeShadowGate(compatibilityGateSnapshot.dependencyBarrier)
+    : normalizeShadowGate(readWaveDependencyBarrier(derivedState));
+  const overallCompatibility = compatibilityGateSnapshot
+    ? normalizeShadowGate(compatibilityGateSnapshot.overall)
+    : null;
+  const retryCompatibility = compatibilityRelaunchResolution
+    ? {
+        selectedAgentIds: normalizeShadowIdList(
+          (compatibilityRelaunchResolution.runs || []).map((run) => run.agent.agentId),
+        ),
+        barrier: compatibilityRelaunchResolution.barrier
+          ? {
+              statusCode: compatibilityRelaunchResolution.barrier.statusCode || null,
+              detail: compatibilityRelaunchResolution.barrier.detail || null,
+            }
+          : null,
+      }
+    : null;
+  const blockerCompatibility = compatibilityBlockerIds(derivedState);
+  const contradictionCompatibility = normalizeShadowIdList(
+    contradictionIds(derivedState?.contradictions),
+  );
+  const blockerReducer = normalizeShadowIdList(
+    (reducerState?.openBlockers || []).map(
+      (blocker) => blocker.id || blocker.taskId || blocker.title || blocker.detail,
+    ),
+  );
+  const contradictionReducer = normalizeShadowIdList(
+    contradictionIds(reducerState?.contradictions),
+  );
+  const retryReducer = {
+    selectedAgentIds: normalizeShadowIdList(
+      reducerState?.retryTargetSet?.agentIds || resumePlan?.invalidatedAgentIds || [],
+    ),
+    barrier:
+      reducerState?.gateSnapshot?.helperAssignmentBarrier?.ok === false
+        ? {
+            statusCode: reducerState.gateSnapshot.helperAssignmentBarrier.statusCode || null,
+            detail: reducerState.gateSnapshot.helperAssignmentBarrier.detail || null,
+          }
+        : reducerState?.gateSnapshot?.dependencyBarrier?.ok === false
+          ? {
+              statusCode: reducerState.gateSnapshot.dependencyBarrier.statusCode || null,
+              detail: reducerState.gateSnapshot.dependencyBarrier.detail || null,
+            }
+          : null,
+    resumeFromPhase: resumePlan?.resumeFromPhase || null,
+  };
+  const shadowDiff = {
+    helperAssignmentBarrier: shadowSlice(
+      helperCompatibility,
+      normalizeShadowGate(reducerState?.gateSnapshot?.helperAssignmentBarrier),
+    ),
+    dependencyBarrier: shadowSlice(
+      dependencyCompatibility,
+      normalizeShadowGate(reducerState?.gateSnapshot?.dependencyBarrier),
+    ),
+    overallGate: shadowSlice(
+      overallCompatibility,
+      normalizeShadowGate(reducerState?.gateSnapshot?.overall),
+    ),
+    blockers: shadowSlice(blockerCompatibility, blockerReducer),
+    contradictions: shadowSlice(contradictionCompatibility, contradictionReducer),
+    closureReadiness: shadowSlice(
+      overallCompatibility
+        ? { allGatesPass: overallCompatibility.ok === true }
+        : null,
+      {
+        allGatesPass: reducerState?.closureEligibility?.allGatesPass === true,
+        waveMayClose: reducerState?.closureEligibility?.waveMayClose === true,
+        pendingAgentIds: normalizeShadowIdList(
+          reducerState?.closureEligibility?.pendingAgentIds || [],
+        ),
+      },
+    ),
+    retryPlan: shadowSlice(retryCompatibility, retryReducer),
+  };
+  const comparedSlices = Object.values(shadowDiff).filter(
+    (slice) => slice.compatibility !== null && slice.reducer !== null,
+  );
+  return {
+    comparedSliceCount: comparedSlices.length,
+    matches: comparedSlices.every((slice) => slice.matches),
+    slices: shadowDiff,
+  };
+}
+
+export function computeReducerSnapshot({
+  lanePaths,
+  wave,
+  agentRuns,
+  derivedState,
+  attempt,
+  options = {},
+  compatibilityGateSnapshot = null,
+  compatibilityRelaunchResolution = null,
+}) {
+  const agentEnvelopes = {};
+  for (const run of agentRuns) {
+    const envelopeResult = readRunResultEnvelope(run, wave, { mode: "live" });
+    if (envelopeResult?.valid && envelopeResult.envelope) {
+      agentEnvelopes[run.agent.agentId] = envelopeResult.envelope;
+    }
+  }
+
+  const controlPlaneLogPath = path.join(
+    lanePaths.controlPlaneDir,
+    `wave-${wave.wave}.jsonl`,
+  );
+  const controlPlaneEvents = fs.existsSync(controlPlaneLogPath)
+    ? readControlPlaneEvents(controlPlaneLogPath)
+    : [];
+
+  const coordinationLogPath = path.join(
+    lanePaths.coordinationDir,
+    `wave-${wave.wave}.jsonl`,
+  );
+  const coordinationRecords = fs.existsSync(coordinationLogPath)
+    ? readMaterializedCoordinationState(coordinationLogPath)
+    : null;
+
+  const feedbackRequests = readWaveHumanFeedbackRequests({
+    feedbackRequestsDir: lanePaths.feedbackRequestsDir,
+    lane: lanePaths.lane,
+    waveNumber: wave.wave,
+    agentIds: (agentRuns || []).map((run) => run.agent.agentId),
+    orchestratorId: options.orchestratorId,
+  });
+  const roleBindings = resolveWaveRoleBindings(wave, lanePaths, wave.agents);
+
+  const reducerState = reduceWaveState({
+    controlPlaneEvents,
+    coordinationRecords: coordinationRecords?.latestRecords || [],
+    agentEnvelopes,
+    waveDefinition: wave,
+    dependencyTickets: derivedState?.dependencySnapshot || null,
+    feedbackRequests: feedbackRequests || [],
+    laneConfig: {
+      lane: lanePaths.lane,
+      contQaAgentId: roleBindings.contQaAgentId,
+      contEvalAgentId: roleBindings.contEvalAgentId,
+      integrationAgentId: roleBindings.integrationAgentId,
+      documentationAgentId: roleBindings.documentationAgentId,
+      validationMode: "live",
+      evalTargets: wave.evalTargets,
+      benchmarkCatalogPath: lanePaths.laneProfile?.paths?.benchmarkCatalogPath,
+      laneProfile: lanePaths.laneProfile,
+      requireIntegrationStewardFromWave: lanePaths.requireIntegrationStewardFromWave,
+      capabilityRouting: lanePaths.capabilityRouting,
+    },
+  });
+
+  const resumePlan = buildResumePlan(reducerState, {
+    waveDefinition: wave,
+    lanePaths,
+  });
+  const shadowDiff = buildReducerShadowDiff({
+    derivedState,
+    compatibilityGateSnapshot,
+    compatibilityRelaunchResolution,
+    reducerState,
+    resumePlan,
+  });
+
+  const stateDir = path.join(lanePaths.stateDir, "reducer");
+  ensureDirectory(stateDir);
+  const snapshotPath = path.join(stateDir, `wave-${wave.wave}.json`);
+  writeWaveStateSnapshot(
+    snapshotPath,
+    {
+      ...reducerState,
+      attempt,
+      resumePlan,
+      shadowDiff,
+    },
+    {
+      lane: lanePaths.lane,
+      wave: wave.wave,
+    },
+  );
+
+  return {
+    reducerState,
+    resumePlan,
+    shadowDiff,
+    snapshotPath,
+  };
+}
+
+export function readPersistedReducerSnapshot(lanePaths, waveNumber) {
+  const stateDir = path.join(lanePaths.stateDir, "reducer");
+  const snapshotPath = path.join(stateDir, `wave-${waveNumber}.json`);
+  return readWaveStateSnapshot(snapshotPath, {
+    lane: lanePaths.lane,
+    wave: waveNumber,
+  });
+}

package/scripts/wave-orchestrator/replay.mjs

@@ -1,7 +1,8 @@
 import path from "node:path";
 import { augmentSummaryWithProofRegistry } from "./proof-registry.mjs";
 import { readJsonOrNull } from "./shared.mjs";
-import { buildGateSnapshot } from "./launcher.mjs";
+import { buildGateSnapshot } from "./gate-engine.mjs";
+import { materializeContradictionsFromControlPlaneEvents } from "./contradiction-entity.mjs";
 import {
   buildQualityMetrics,
   loadTraceBundle,
@@ -188,6 +189,7 @@ export function replayTraceBundle(dir) {
     capabilityAssignments: bundle.capabilityAssignments || [],
     dependencySnapshot: bundle.dependencySnapshot || null,
     integrationSummary: bundle.integrationSummary,
+    contradictions: materializeContradictionsFromControlPlaneEvents(bundle.controlPlaneEvents),
   };
   const gateSnapshot = normalizeGateSnapshotForBundle(
     buildGateSnapshot({