@chllming/wave-orchestration 0.8.3 → 0.8.4

package/scripts/wave-orchestrator/{launcher-supervisor.mjs → session-supervisor.mjs}

@@ -14,9 +14,11 @@ import {
 import {
   readStatusCodeIfPresent,
 } from "./dashboard-state.mjs";
+import { appendWaveControlEvent } from "./control-plane.mjs";
 import {
   REPO_ROOT,
   readJsonOrNull,
+  readStatusRecordIfPresent,
   ensureDirectory,
   shellQuote,
   PACKAGE_ROOT,
@@ -31,8 +33,8 @@ import {
 } from "./terminals.mjs";
 import {
   recordGlobalDashboardEvent,
-  writeGlobalDashboard,
 } from "./dashboard-state.mjs";
+import { buildHumanFeedbackWorkflowUpdate } from "./human-input-workflow.mjs";
 import {
   collectUnexpectedSessionFailures as collectUnexpectedSessionFailuresImpl,
   launchAgentSession as launchAgentSessionImpl,
@@ -51,6 +53,108 @@ function isProcessAlive(pid) {
   }
 }
 
+function relativeArtifactPath(filePath) {
+  return filePath ? path.relative(REPO_ROOT, filePath) : null;
+}
+
+export function recordWaveRunState(lanePaths, waveNumber, state, data = {}) {
+  return appendWaveControlEvent(lanePaths, waveNumber, {
+    entityType: "wave_run",
+    entityId: `wave-${waveNumber}`,
+    action: state,
+    source: "session-supervisor",
+    actor: "session-supervisor",
+    data: {
+      waveId: `wave-${waveNumber}`,
+      waveNumber,
+      updatedAt: toIsoTimestamp(),
+      ...data,
+    },
+  });
+}
+
+export function recordAttemptState(lanePaths, waveNumber, attemptNumber, state, data = {}) {
+  return appendWaveControlEvent(lanePaths, waveNumber, {
+    entityType: "attempt",
+    entityId: `wave-${waveNumber}-attempt-${attemptNumber}`,
+    action: state,
+    source: "session-supervisor",
+    actor: "session-supervisor",
+    attempt: attemptNumber,
+    data: {
+      attemptId: `wave-${waveNumber}-attempt-${attemptNumber}`,
+      attemptNumber,
+      state,
+      selectedAgentIds: data.selectedAgentIds || [],
+      detail: data.detail || null,
+      updatedAt: toIsoTimestamp(),
+      ...(data.createdAt ? { createdAt: data.createdAt } : {}),
+    },
+  });
+}
+
+export function recordAgentRunStarted(lanePaths, { waveNumber, attempt, runInfo }) {
+  if (!runInfo?.agent?.agentId || !Number.isFinite(Number(waveNumber))) {
+    return null;
+  }
+  return appendWaveControlEvent(lanePaths, waveNumber, {
+    entityType: "agent_run",
+    entityId: `wave-${waveNumber}-attempt-${attempt}-agent-${runInfo.agent.agentId}`,
+    action: "started",
+    source: "session-supervisor",
+    actor: "session-supervisor",
+    attempt,
+    data: {
+      agentId: runInfo.agent.agentId,
+      attemptNumber: attempt,
+      sessionName: runInfo.sessionName || null,
+      executorId: runInfo.lastExecutorId || runInfo.agent.executorResolved?.id || null,
+      promptPath: relativeArtifactPath(runInfo.promptPath),
+      statusPath: relativeArtifactPath(runInfo.statusPath),
+      logPath: relativeArtifactPath(runInfo.logPath),
+      startedAt: toIsoTimestamp(),
+    },
+  });
+}
+
+export function recordAgentRunFinished(
+  lanePaths,
+  { waveNumber, attempt, runInfo, failure = null, statusRecord = null },
+) {
+  if (!runInfo?.agent?.agentId || !Number.isFinite(Number(waveNumber))) {
+    return null;
+  }
+  const effectiveStatusRecord = statusRecord || readStatusRecordIfPresent(runInfo.statusPath);
+  const timedOut =
+    failure?.statusCode === "timeout-no-status" || failure?.statusCode === "timed_out";
+  const action =
+    timedOut
+      ? "timed_out"
+      : Number(effectiveStatusRecord?.code) === 0
+        ? "completed"
+        : "failed";
+  return appendWaveControlEvent(lanePaths, waveNumber, {
+    entityType: "agent_run",
+    entityId: `wave-${waveNumber}-attempt-${attempt}-agent-${runInfo.agent.agentId}`,
+    action,
+    source: "session-supervisor",
+    actor: "session-supervisor",
+    attempt,
+    data: {
+      agentId: runInfo.agent.agentId,
+      attemptNumber: attempt,
+      exitCode: effectiveStatusRecord?.code ?? null,
+      completedAt: effectiveStatusRecord?.completedAt || toIsoTimestamp(),
+      promptHash: effectiveStatusRecord?.promptHash || runInfo.lastPromptHash || null,
+      executorId: runInfo.lastExecutorId || runInfo.agent.executorResolved?.id || null,
+      statusCode: failure?.statusCode || null,
+      detail: failure?.detail || null,
+      logPath: relativeArtifactPath(runInfo.logPath),
+      statusPath: relativeArtifactPath(runInfo.statusPath),
+    },
+  });
+}
+
 export function markLauncherFailed(
   globalDashboard,
   lanePaths,
@@ -64,7 +168,6 @@ export function markLauncherFailed(
       level: "error",
       message: error instanceof Error ? error.message : String(error),
     });
-    writeGlobalDashboard(lanePaths.globalDashboardPath, globalDashboard);
   }
   appendCoordination({
     event: "launcher_finish",
@@ -553,13 +656,46 @@ export function launchWaveDashboardSession(lanePaths, { sessionName, dashboardPa
 }
 
 export async function launchAgentSession(lanePaths, params) {
-  return launchAgentSessionImpl(lanePaths, params, { runTmuxFn: runTmux });
+  const result = await launchAgentSessionImpl(lanePaths, params, { runTmuxFn: runTmux });
+  const controlPlane = params?.controlPlane || null;
+  if (!params?.dryRun && controlPlane?.waveNumber !== undefined && controlPlane?.attempt) {
+    recordAgentRunStarted(lanePaths, {
+      waveNumber: controlPlane.waveNumber,
+      attempt: controlPlane.attempt,
+      runInfo: {
+        ...params,
+        lastExecutorId: result?.executorId || params?.agent?.executorResolved?.id || null,
+      },
+    });
+  }
+  return result;
 }
 
-export async function waitForWaveCompletion(lanePaths, agentRuns, timeoutMinutes, onProgress = null) {
-  return waitForWaveCompletionImpl(lanePaths, agentRuns, timeoutMinutes, onProgress, {
+export async function waitForWaveCompletion(
+  lanePaths,
+  agentRuns,
+  timeoutMinutes,
+  onProgress = null,
+  options = {},
+) {
+  const result = await waitForWaveCompletionImpl(lanePaths, agentRuns, timeoutMinutes, onProgress, {
     collectUnexpectedSessionFailuresFn: collectUnexpectedSessionFailures,
   });
+  const controlPlane = options?.controlPlane || null;
+  if (controlPlane?.waveNumber !== undefined && controlPlane?.attempt) {
+    const failuresByAgentId = new Map(
+      (result?.failures || []).map((failure) => [failure.agentId, failure]),
+    );
+    for (const runInfo of agentRuns || []) {
+      recordAgentRunFinished(lanePaths, {
+        waveNumber: controlPlane.waveNumber,
+        attempt: controlPlane.attempt,
+        runInfo,
+        failure: failuresByAgentId.get(runInfo.agent.agentId) || null,
+      });
+    }
+  }
+  return result;
 }
 
 export function monitorWaveHumanFeedback({
@@ -592,111 +728,50 @@ export function monitorWaveHumanFeedback({
     const context = request.context ? `; context=${request.context}` : "";
     const responseOperator = request.responseOperator || "human-operator";
     const responseText = request.responseText || "(empty response)";
+    const escalationId = `escalation-${request.id}`;
+    const existingEscalation =
+      (fs.existsSync(triageLogPath)
+        ? readMaterializedCoordinationState(triageLogPath).byId.get(escalationId)
+        : null) ||
+      readMaterializedCoordinationState(coordinationLogPath).byId.get(escalationId) ||
+      null;
+    const workflowUpdate = buildHumanFeedbackWorkflowUpdate({
+      request,
+      lane: lanePaths.lane,
+      waveNumber,
+      existingEscalation,
+    });
     if (request.status === "pending") {
-      recordCombinedEvent({
-        level: "warn",
-        agentId: request.agentId,
-        message: `Human feedback requested (${request.id}): ${question}`,
-      });
-      console.warn(
-        `[human-feedback] wave=${waveNumber} agent=${request.agentId} request=${request.id} pending: ${question}`,
-      );
-      console.warn(
-        `[human-feedback] respond with: pnpm exec wave control task act answer --lane ${lanePaths.lane} --wave ${waveNumber} --id ${request.id} --response "<answer>" --operator "<name>"`,
-      );
-      appendCoordination({
-        event: "human_feedback_requested",
-        waves: [waveNumber],
-        status: "waiting-human",
-        details: `request_id=${request.id}; agent=${request.agentId}; question=${question}${context}`,
-        actionRequested: `Launcher operator should ask or answer in the parent session, then run: pnpm exec wave control task act answer --lane ${lanePaths.lane} --wave ${waveNumber} --id ${request.id} --response "<answer>" --operator "<name>"`,
-      });
+      if (workflowUpdate?.combinedEvent) {
+        recordCombinedEvent(workflowUpdate.combinedEvent);
+      }
+      for (const line of workflowUpdate?.consoleLines || []) {
+        console.warn(line);
+      }
+      if (workflowUpdate?.coordinationNotice) {
+        appendCoordination(workflowUpdate.coordinationNotice);
+      }
       if (coordinationLogPath) {
-        appendCoordinationRecord(coordinationLogPath, {
-          id: request.id,
-          lane: lanePaths.lane,
-          wave: waveNumber,
-          agentId: request.agentId || "human",
-          kind: "human-feedback",
-          targets: request.agentId ? [`agent:${request.agentId}`] : [],
-          priority: "high",
-          summary: question,
-          detail: request.context || "",
-          status: "open",
-          source: "feedback",
-        });
+        for (const update of workflowUpdate?.coordinationUpdates || []) {
+          appendCoordinationRecord(coordinationLogPath, update);
+        }
       }
     } else if (request.status === "answered") {
-      recordCombinedEvent({
-        level: "info",
-        agentId: request.agentId,
-        message: `Human feedback answered (${request.id}) by ${responseOperator}: ${responseText}`,
-      });
-      appendCoordination({
-        event: "human_feedback_answered",
-        waves: [waveNumber],
-        status: "resolved",
-        details: `request_id=${request.id}; agent=${request.agentId}; operator=${responseOperator}; response=${responseText}`,
-      });
+      if (workflowUpdate?.combinedEvent) {
+        recordCombinedEvent(workflowUpdate.combinedEvent);
+      }
+      if (workflowUpdate?.coordinationNotice) {
+        appendCoordination(workflowUpdate.coordinationNotice);
+      }
       if (coordinationLogPath) {
-        const escalationId = `escalation-${request.id}`;
-        const existingEscalation =
-          (fs.existsSync(triageLogPath)
-            ? readMaterializedCoordinationState(triageLogPath).byId.get(escalationId)
-            : null) ||
-          readMaterializedCoordinationState(coordinationLogPath).byId.get(escalationId) ||
-          null;
         if (fs.existsSync(triageLogPath)) {
-          appendCoordinationRecord(triageLogPath, {
-            id: escalationId,
-            lane: lanePaths.lane,
-            wave: waveNumber,
-            agentId: request.agentId || "human",
-            kind: "human-escalation",
-            targets:
-              existingEscalation?.targets ||
-              (request.agentId ? [`agent:${request.agentId}`] : []),
-            dependsOn: existingEscalation?.dependsOn || [],
-            closureCondition: existingEscalation?.closureCondition || "",
-            priority: "high",
-            summary: question,
-            detail: responseText,
-            artifactRefs: [request.id],
-            status: "resolved",
-            source: "feedback",
-          });
+          for (const update of workflowUpdate?.triageUpdates || []) {
+            appendCoordinationRecord(triageLogPath, update);
+          }
+        }
+        for (const update of workflowUpdate?.coordinationUpdates || []) {
+          appendCoordinationRecord(coordinationLogPath, update);
         }
-        appendCoordinationRecord(coordinationLogPath, {
-          id: escalationId,
-          lane: lanePaths.lane,
-          wave: waveNumber,
-          agentId: request.agentId || "human",
-          kind: "human-escalation",
-          targets:
-            existingEscalation?.targets ||
-            (request.agentId ? [`agent:${request.agentId}`] : []),
-          dependsOn: existingEscalation?.dependsOn || [],
-          closureCondition: existingEscalation?.closureCondition || "",
-          priority: "high",
-          summary: question,
-          detail: responseText,
-          artifactRefs: [request.id],
-          status: "resolved",
-          source: "feedback",
-        });
-        appendCoordinationRecord(coordinationLogPath, {
-          id: request.id,
-          lane: lanePaths.lane,
-          wave: waveNumber,
-          agentId: request.agentId || "human",
-          kind: "human-feedback",
-          targets: request.agentId ? [`agent:${request.agentId}`] : [],
-          priority: "high",
-          summary: question,
-          detail: responseText,
-          status: "resolved",
-          source: "feedback",
-        });
       }
     }
   }

package/scripts/wave-orchestrator/shared.mjs

@@ -201,6 +201,7 @@ export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
     inboxesDir: path.join(stateDir, "inboxes"),
     ledgerDir: path.join(stateDir, "ledger"),
     integrationDir: path.join(stateDir, "integration"),
+    resultsDir: path.join(stateDir, "results"),
     proofDir: path.join(stateDir, "proof"),
     securityDir: path.join(stateDir, "security"),
     dependencySnapshotsDir: path.join(stateDir, "dependencies"),

package/scripts/wave-orchestrator/traces.mjs

@@ -55,6 +55,9 @@ function fileHashOrNull(filePath) {
   if (!filePath || !fs.existsSync(filePath)) {
     return null;
   }
+  if (!fs.statSync(filePath).isFile()) {
+    return null;
+  }
   return hashText(fs.readFileSync(filePath, "utf8"));
 }
 
@@ -62,6 +65,9 @@ function copyFileIfExists(sourcePath, destPath) {
   if (!sourcePath || !fs.existsSync(sourcePath)) {
     return false;
   }
+  if (!fs.statSync(sourcePath).isFile()) {
+    return false;
+  }
   ensureDirectory(path.dirname(destPath));
   fs.copyFileSync(sourcePath, destPath);
   return true;
@@ -603,7 +609,10 @@ function normalizeGateLogPath(gate, agentArtifacts) {
   }
   return {
     ...gate,
-    logPath: artifact.path,
+    // Log artifacts are already described in the bundle manifest. Nulling the
+    // inline path keeps replay parity focused on gate semantics instead of the
+    // copied artifact layout.
+    logPath: null,
   };
 }
 

package/scripts/wave-orchestrator/wave-files.mjs

@@ -1253,7 +1253,11 @@ export function loadComponentCutoverMatrix(options = {}) {
   const matrixJsonPath =
     options.componentMatrixJsonPath ||
     (laneProfile
-      ? path.resolve(REPO_ROOT, laneProfile.paths.componentCutoverMatrixJsonPath)
+      ? path.resolve(
+          REPO_ROOT,
+          laneProfile?.paths?.componentCutoverMatrixJsonPath ||
+            "trace-bundle/component-cutover-matrix.json",
+        )
       : "trace-bundle/component-cutover-matrix.json");
   const payload =
     options.componentMatrixPayload !== undefined
@@ -1366,8 +1370,8 @@ export function requiredDocumentationStewardPathsForWave(waveNumber, options = {
   const componentThreshold = laneProfile.validation.requireComponentPromotionsFromWave;
   if (componentThreshold !== null && waveNumber >= componentThreshold) {
     out.push(
-      laneProfile.paths.componentCutoverMatrixDocPath,
-      laneProfile.paths.componentCutoverMatrixJsonPath,
+      laneProfile?.paths?.componentCutoverMatrixDocPath,
+      laneProfile?.paths?.componentCutoverMatrixJsonPath,
     );
   }
   return Array.from(new Set(out));
@@ -2353,18 +2357,16 @@ export function validateWaveComponentMatrixCurrentLevels(wave, options = {}) {
       securityRolePromptPath,
     }),
   );
-  if (
-    promotions.length === 0 &&
-    ((componentThreshold === null || wave.wave < componentThreshold) ||
-      implementationOwningAgents.length === 0)
-  ) {
+  if (promotions.length === 0) {
     return {
       ok: true,
       statusCode: "pass",
       detail:
         implementationOwningAgents.length === 0
           ? `Wave ${wave.wave} has no implementation-owned component promotions to reconcile.`
-          : "Component current-level gate is not active for this wave.",
+          : componentThreshold === null || wave.wave < componentThreshold
+            ? "Component current-level gate is not active for this wave."
+            : `Wave ${wave.wave} declares no promoted components to reconcile against the component matrix.`,
       componentId: null,
     };
   }

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

@@ -16,12 +16,27 @@ import {
   buildGateSnapshotPure,
   readClarificationBarrier,
   readWaveAssignmentBarrier,
-} from "./launcher-gates.mjs";
+} from "./gate-engine.mjs";
 import { buildHumanInputRequests } from "./human-input-workflow.mjs";
+import { projectLegacySummaryFromEnvelope } from "./result-envelope.mjs";
 import { buildRequestAssignments } from "./routing-state.mjs";
+import { resolveSecurityReviewReportPath } from "./role-helpers.mjs";
 
 const REDUCER_VERSION = 2;
 
+function resolveReducerReportPath(waveDefinition, agent) {
+  if (!waveDefinition || !agent) {
+    return null;
+  }
+  if (agent.agentId === (waveDefinition.contQaAgentId || "A0")) {
+    return waveDefinition.contQaReportPath || null;
+  }
+  if (agent.agentId === (waveDefinition.contEvalAgentId || "E0")) {
+    return waveDefinition.contEvalReportPath || null;
+  }
+  return resolveSecurityReviewReportPath(agent);
+}
+
 /**
  * Detect contradictions from control-plane events.
  * Returns a Map<contradictionId, contradiction>.
@@ -117,6 +132,7 @@ function derivePhase({
   gateSnapshot,
   coordinationState,
   dependencySnapshot,
+  clarificationBarrier,
 }) {
   const blockers = (coordinationState?.blockers || []).filter(
     (record) =>
@@ -134,6 +150,9 @@ function derivePhase({
   if (openClarifications.length > 0 || openClarificationRequests.length > 0) {
     return "clarifying";
   }
+  if (clarificationBarrier?.statusCode === "human-feedback-open") {
+    return "clarifying";
+  }
 
   const dependencyBlockers =
     (dependencySnapshot?.requiredInbound || []).length +
@@ -528,12 +547,34 @@ function applyProofAvailabilityToTasks(tasks, proofAvailability) {
 export function reduceWaveState({
   controlPlaneEvents = [],
   coordinationRecords = [],
-  agentResults = {},
+  agentEnvelopes = null,
+  agentResults = null,
   waveDefinition = null,
   dependencyTickets = null,
   feedbackRequests = [],
   laneConfig = {},
 }) {
+  const resolvedAgentResults =
+    agentResults && typeof agentResults === "object" && !Array.isArray(agentResults)
+      ? agentResults
+      : Object.fromEntries(
+          Object.entries(agentEnvelopes || {})
+            .map(([agentId, envelope]) => {
+              const agent =
+                (Array.isArray(waveDefinition?.agents) ? waveDefinition.agents : []).find(
+                  (candidate) => candidate?.agentId === agentId,
+                ) || { agentId };
+              return [
+                agentId,
+                projectLegacySummaryFromEnvelope(envelope, {
+                  agent,
+                  waveNumber: waveDefinition?.wave ?? null,
+                  reportPath: resolveReducerReportPath(waveDefinition, agent),
+                }),
+              ];
+            })
+            .filter(([, summary]) => Boolean(summary)),
+        );
   // Step 1: Materialize control-plane state
   const controlPlaneState = materializeControlPlaneState(controlPlaneEvents);
 
@@ -555,7 +596,7 @@ export function reduceWaveState({
   // Step 5: Evaluate proof availability per agent
   const proofAvailability = buildProofAvailability(
     tasks,
-    agentResults,
+    resolvedAgentResults,
     controlPlaneState,
   );
 
@@ -564,7 +605,7 @@ export function reduceWaveState({
 
   // Step 6: Build integration summary BEFORE creating derivedState for gates
   const integrationAgentId = laneConfig.integrationAgentId || "A8";
-  const integrationResult = agentResults?.[integrationAgentId]?.integration || null;
+  const integrationResult = resolvedAgentResults?.[integrationAgentId]?.integration || null;
   const integrationSummary = integrationResult
     ? {
         recommendation: integrationResult.state === "ready-for-doc-closure"
@@ -622,7 +663,7 @@ export function reduceWaveState({
   // Step 8: Evaluate gates using pure variants (integrationSummary already in derivedState)
   const gateSnapshot = buildGateSnapshotPure({
     wave: waveDefinition || { wave: 0, agents: [] },
-    agentResults,
+    agentResults: resolvedAgentResults,
     derivedState,
     validationMode: laneConfig.validationMode || "live",
     laneConfig,
@@ -647,6 +688,7 @@ export function reduceWaveState({
     gateSnapshot,
     coordinationState,
     dependencySnapshot: dependencyTickets,
+    clarificationBarrier,
   });
 
   // Step 13: Derive waveState from phase
@@ -708,6 +750,11 @@ export function reduceWaveState({
     facts,
     humanInputs,
     assignments,
+    agentEnvelopes: agentEnvelopes || null,
+    capabilityAssignments,
+    coordinationState,
+    dependencySnapshot: dependencyTickets,
+    integrationSummary,
 
     coordinationMetrics,
     controlPlaneState,