@chllming/wave-orchestration 0.7.3 → 0.8.0

package/scripts/wave-orchestrator/launcher-retry.mjs

@@ -226,6 +226,33 @@ export function relaunchReasonBuckets(runs, failures, derivedState) {
   };
 }
 
+const HUMAN_INPUT_BLOCKER_KINDS = new Set([
+  "human-input",
+  "human-feedback",
+  "human-escalation",
+]);
+
+function isHumanInputBlocker(blocker) {
+  return HUMAN_INPUT_BLOCKER_KINDS.has(String(blocker?.kind || "").trim().toLowerCase());
+}
+
+function normalizeRetryTargets(retryTargetSet) {
+  if (Array.isArray(retryTargetSet)) {
+    return retryTargetSet;
+  }
+  if (Array.isArray(retryTargetSet?.targets)) {
+    return retryTargetSet.targets;
+  }
+  if (Array.isArray(retryTargetSet?.agentIds)) {
+    return retryTargetSet.agentIds.map((agentId) => ({
+      agentId,
+      reason: retryTargetSet.reason || null,
+      retryOverride: retryTargetSet.retryOverride || null,
+    }));
+  }
+  return [];
+}
+
 export function applySharedComponentWaitStateToDashboard(componentGate, dashboardState) {
   const waitingSummary = (componentGate?.waitingOnAgentIds || []).join("/");
   if (!waitingSummary) {
@@ -769,7 +796,7 @@ function classifyResumeReason(waveState) {
     return "all-gates-pass";
   }
   const humanBlockers = (waveState.openBlockers || []).filter(
-    (blocker) => blocker.kind === "human-input",
+    (blocker) => isHumanInputBlocker(blocker),
   );
   if (humanBlockers.length > 0) {
     return "human-request";
@@ -792,11 +819,14 @@ function classifyResumeReason(waveState) {
 
 function collectResumeHumanInputBlockers(waveState) {
   return (waveState.openBlockers || [])
-    .filter((b) => b.kind === "human-input")
+    .filter((b) => isHumanInputBlocker(b))
     .map((b) => ({
       taskId: b.taskId || b.id || null,
       title: b.title || b.detail || null,
-      assigneeAgentId: b.agentId || b.assigneeAgentId || null,
+      assigneeAgentId:
+        b.agentId ||
+        b.assigneeAgentId ||
+        (Array.isArray(b.blockedAgentIds) ? b.blockedAgentIds[0] || null : null),
     }));
 }
 
@@ -813,13 +843,13 @@ function collectResumeGateBlockers(gateSnapshot) {
 }
 
 function collectResumeExecutorChanges(waveState) {
-  const retryTargets = waveState.retryTargetSet || [];
-  return (Array.isArray(retryTargets) ? retryTargets : [])
+  const retryTargets = normalizeRetryTargets(waveState.retryTargetSet);
+  return retryTargets
     .filter((t) => t.reason === "rate-limit-exhausted" || t.reason === "rate-limit" || t.retriesExhausted === true)
     .map((t) => ({
       agentId: t.agentId,
       currentExecutor: t.currentExecutor || t.executor || null,
-      suggestedFallback: "claude",
+      suggestedFallback: t.retryOverride?.executorId || "claude",
       reason: t.reason || "rate-limit-exhausted",
     }));
 }

package/scripts/wave-orchestrator/launcher.mjs

@@ -145,9 +145,11 @@ import {
   resolveRetryOverrideRuns,
   waveRelaunchPlanPath,
 } from "./retry-control.mjs";
-import { appendWaveControlEvent } from "./control-plane.mjs";
+import { appendWaveControlEvent, readControlPlaneEvents } from "./control-plane.mjs";
+import { materializeContradictionsFromControlPlaneEvents } from "./contradiction-entity.mjs";
 import { buildQualityMetrics, writeTraceBundle } from "./traces.mjs";
 import { flushWaveControlQueue } from "./wave-control-client.mjs";
+import { reduceWaveState } from "./wave-state-reducer.mjs";
 import { triageClarificationRequests } from "./clarification-triage.mjs";
 import { readProjectProfile, resolveDefaultTerminalSurface } from "./project-profile.mjs";
 import {
@@ -167,9 +169,11 @@ import {
   writeDependencySnapshotMarkdown,
 } from "./routing-state.mjs";
 import {
+  readWaveStateSnapshot,
   writeAssignmentSnapshot,
   writeDependencySnapshot,
   writeRelaunchPlan,
+  writeWaveStateSnapshot,
 } from "./artifact-schemas.mjs";
 import {
   collectUnexpectedSessionFailures as collectUnexpectedSessionFailuresImpl,
@@ -238,6 +242,7 @@ export {
 
 // --- Re-exports from launcher-retry.mjs ---
 import {
+  buildResumePlan,
   readWaveRelaunchPlan,
   writeWaveRelaunchPlan,
   clearWaveRelaunchPlan,
@@ -1070,6 +1075,18 @@ export async function runLauncherCli(argv) {
             attempt: attemptNumber,
             orchestratorId: options.orchestratorId,
           });
+          const controlPlaneLogPath = path.join(
+            lanePaths.controlPlaneDir,
+            `wave-${wave.wave}.jsonl`,
+          );
+          const controlPlaneEvents = fs.existsSync(controlPlaneLogPath)
+            ? readControlPlaneEvents(controlPlaneLogPath)
+            : [];
+          derivedState = {
+            ...derivedState,
+            controlPlaneEvents,
+            contradictions: materializeContradictionsFromControlPlaneEvents(controlPlaneEvents),
+          };
           for (const run of agentRuns) {
             run.messageBoardSnapshot = derivedState.messageBoardText;
             run.sharedSummaryPath = derivedState.sharedSummaryPath;
@@ -1988,6 +2005,22 @@ export async function runLauncherCli(argv) {
             validationMode: "live",
           });
           completionGateSnapshot = gateSnapshot;
+          try {
+            computeReducerSnapshot({
+              lanePaths,
+              wave,
+              agentRuns,
+              derivedState,
+              attempt,
+              options,
+            });
+          } catch (error) {
+            recordCombinedEvent({
+              level: "warn",
+              agentId: lanePaths.integrationAgentId,
+              message: `Reducer shadow snapshot failed for wave ${wave.wave}: ${error instanceof Error ? error.message : String(error)}`,
+            });
+          }
           const traceDir = writeTraceBundle({
             tracesDir: lanePaths.tracesDir,
             lanePaths,
@@ -2039,7 +2072,11 @@ export async function runLauncherCli(argv) {
               traceDir: path.relative(REPO_ROOT, traceDir),
               gateSnapshot,
               qualitySummary: {
-                contradictionCount: gateSnapshot?.integration?.conflictingClaims?.length || 0,
+                contradictionCount: Array.isArray(derivedState?.contradictions)
+                  ? derivedState.contradictions.length
+                  : derivedState?.contradictions instanceof Map
+                    ? derivedState.contradictions.size
+                    : 0,
                 finalRecommendation: derivedState.integrationSummary?.recommendation || "unknown",
               },
             },
@@ -2409,3 +2446,127 @@ export async function runLauncherCli(argv) {
     }
   }
 }
+
+/**
+ * Compute and persist a reducer snapshot alongside the traditional gate evaluation.
+ * Shadow mode: the reducer runs and its output is written to disk, but decisions
+ * still come from the traditional gate readers. This enables comparison and validation.
+ *
+ * @param {object} params
+ * @param {object} params.lanePaths
+ * @param {object} params.wave - Wave definition
+ * @param {object} params.agentRuns - Array of run info objects
+ * @param {object} params.derivedState - Current derived state
+ * @param {number} params.attempt - Current attempt number
+ * @param {object} params.options - Launcher options
+ * @returns {object} { reducerState, resumePlan, snapshotPath }
+ */
+export function computeReducerSnapshot({
+  lanePaths,
+  wave,
+  agentRuns,
+  derivedState,
+  attempt,
+  options = {},
+}) {
+  // Build agentResults from agentRuns
+  const agentResults = {};
+  for (const run of agentRuns) {
+    const summary = readRunExecutionSummary(run, wave);
+    if (summary) {
+      agentResults[run.agent.agentId] = summary;
+    }
+  }
+
+  // Load canonical event sources
+  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,
+  });
+
+  // Build dependency tickets from derivedState
+  const dependencyTickets = derivedState?.dependencySnapshot || null;
+
+  // Run the reducer
+  const reducerState = reduceWaveState({
+    controlPlaneEvents,
+    coordinationRecords: coordinationRecords?.latestRecords || [],
+    agentResults,
+    waveDefinition: wave,
+    dependencyTickets,
+    feedbackRequests: feedbackRequests || [],
+    laneConfig: {
+      lane: lanePaths.lane,
+      contQaAgentId: lanePaths.contQaAgentId || "A0",
+      contEvalAgentId: lanePaths.contEvalAgentId || "E0",
+      integrationAgentId: lanePaths.integrationAgentId || "A8",
+      documentationAgentId: lanePaths.documentationAgentId || "A9",
+      validationMode: "live",
+      evalTargets: wave.evalTargets,
+      benchmarkCatalogPath: lanePaths.laneProfile?.paths?.benchmarkCatalogPath,
+      laneProfile: lanePaths.laneProfile,
+      requireIntegrationStewardFromWave: lanePaths.requireIntegrationStewardFromWave,
+      capabilityRouting: lanePaths.capabilityRouting,
+    },
+  });
+
+  // Build resume plan
+  const resumePlan = buildResumePlan(reducerState, {
+    waveDefinition: wave,
+    lanePaths,
+  });
+
+  // Persist snapshot
+  const stateDir = path.join(lanePaths.stateDir, "reducer");
+  ensureDirectory(stateDir);
+  const snapshotPath = path.join(stateDir, `wave-${wave.wave}.json`);
+  writeWaveStateSnapshot(snapshotPath, {
+    ...reducerState,
+    attempt,
+    resumePlan,
+  }, {
+    lane: lanePaths.lane,
+    wave: wave.wave,
+  });
+
+  return {
+    reducerState,
+    resumePlan,
+    snapshotPath,
+  };
+}
+
+/**
+ * Read a previously persisted reducer snapshot from disk.
+ *
+ * @param {object} lanePaths
+ * @param {number} waveNumber
+ * @returns {object|null} The persisted snapshot, or null if not found
+ */
+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,
+  });
+}