@chllming/wave-orchestration 0.7.3 → 0.8.1

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,
+  });
+}

package/scripts/wave-orchestrator/routing-state.mjs

@@ -155,6 +155,82 @@ function assignmentStateForRecord(record) {
   return "open";
 }
 
+function recordText(record) {
+  return `${String(record?.summary || "")}\n${String(record?.detail || "")}`.trim().toLowerCase();
+}
+
+function targetMatchesAgent(target, agentId) {
+  const normalizedTarget = String(target || "").trim();
+  const normalizedAgentId = String(agentId || "").trim();
+  if (!normalizedTarget || !normalizedAgentId) {
+    return false;
+  }
+  return normalizedTarget === normalizedAgentId || normalizedTarget === `agent:${normalizedAgentId}`;
+}
+
+function recordTargetsAgent(record, agentId) {
+  const normalizedAgentId = String(agentId || "").trim();
+  if (!normalizedAgentId) {
+    return false;
+  }
+  if (String(record?.agentId || "").trim() === normalizedAgentId) {
+    return true;
+  }
+  return Array.isArray(record?.targets)
+    ? record.targets.some((target) => targetMatchesAgent(target, normalizedAgentId))
+    : false;
+}
+
+function requestResolutionForAssignment({
+  coordinationState,
+  requestRecord,
+  assignmentId,
+  assignedAgentId,
+  target,
+}) {
+  const requestId = String(requestRecord?.id || "").trim();
+  if (!requestId) {
+    return null;
+  }
+  const requestIdLower = requestId.toLowerCase();
+  const assignmentIdLower = String(assignmentId || "").trim().toLowerCase();
+  const requestTargets = Array.isArray(requestRecord?.targets)
+    ? requestRecord.targets.filter((entry) => String(entry || "").trim())
+    : [];
+  const requiresAssignmentSpecificMatch = requestTargets.length > 1;
+  const resolvedRecords = [...(coordinationState?.resolvedByPolicy || [])].reverse();
+  for (const record of resolvedRecords) {
+    const dependsOn = Array.isArray(record?.dependsOn)
+      ? record.dependsOn.map((value) => String(value || "").trim().toLowerCase())
+      : [];
+    const assignmentDependsOnMatch = assignmentIdLower && dependsOn.includes(assignmentIdLower);
+    const requestDependsOnMatch = dependsOn.includes(requestIdLower);
+    if (assignmentDependsOnMatch || (!requiresAssignmentSpecificMatch && requestDependsOnMatch)) {
+      return record;
+    }
+    const closureCondition = String(record?.closureCondition || "").trim().toLowerCase();
+    const assignmentClosureMatch =
+      assignmentIdLower && closureCondition.includes(assignmentIdLower);
+    const requestClosureMatch = closureCondition.includes(requestIdLower);
+    if (
+      assignmentClosureMatch ||
+      (!requiresAssignmentSpecificMatch && requestClosureMatch)
+    ) {
+      return record;
+    }
+    if (!recordTargetsAgent(record, assignedAgentId) && !targetMatchesAgent(target, record?.agentId)) {
+      continue;
+    }
+    const text = recordText(record);
+    const assignmentTextMatch = assignmentIdLower && text.includes(assignmentIdLower);
+    const requestTextMatch = text.includes(requestIdLower);
+    if (assignmentTextMatch || (!requiresAssignmentSpecificMatch && requestTextMatch)) {
+      return record;
+    }
+  }
+  return null;
+}
+
 export function buildRequestAssignments({
   coordinationState,
   agents,
@@ -179,8 +255,18 @@ export function buildRequestAssignments({
     }
     for (const target of targets) {
       const resolution = resolveTargetAssignment(target, agents, ledger, capabilityRouting);
+      const assignmentId = `assignment:${record.id}:${targetSlug(target) || "target"}`;
+      const resolvedByPolicyRecord = requestResolutionForAssignment({
+        coordinationState,
+        requestRecord: record,
+        assignmentId,
+        assignedAgentId: resolution.assignedAgentId,
+        target,
+      });
+      const resolvedByPolicy = Boolean(resolvedByPolicyRecord);
+      const effectiveStatus = resolvedByPolicy ? "resolved" : record.status;
       assignments.push({
-        id: `assignment:${record.id}:${targetSlug(target) || "target"}`,
+        id: assignmentId,
         requestId: record.id,
         recordId: record.id,
         sourceKind: record.kind,
@@ -188,20 +274,21 @@ export function buildRequestAssignments({
         summary: record.summary || "",
         detail: record.detail || "",
         priority: record.priority || "normal",
-        requestStatus: record.status,
-        state: assignmentStateForRecord(record),
+        requestStatus: effectiveStatus,
+        state: assignmentStateForRecord({ ...record, status: effectiveStatus }),
         target: resolution.target,
         targetType: resolution.targetType,
         capability: resolution.capability,
         assignedAgentId: resolution.assignedAgentId,
         assignmentReason: resolution.assignmentReason,
         assignmentDetail: resolution.detail,
-        blocking: isOpenCoordinationStatus(record.status),
+        blocking: !resolvedByPolicy && isOpenCoordinationStatus(record.status),
         artifactRefs: Array.isArray(record.artifactRefs) ? record.artifactRefs : [],
         dependsOn: Array.isArray(record.dependsOn) ? record.dependsOn : [],
         closureCondition: String(record.closureCondition || ""),
         createdAt: record.createdAt,
         updatedAt: record.updatedAt,
+        resolvedByRecordId: resolvedByPolicyRecord?.id || null,
       });
     }
   }