@chllming/wave-orchestration 0.8.3 → 0.8.4

package/scripts/wave-orchestrator/{launcher-closure.mjs → closure-engine.mjs}

@@ -5,8 +5,17 @@ import {
   setWaveDashboardAgent,
   updateWaveDashboardMessageBoard,
 } from "./dashboard-state.mjs";
+import {
+  materializeAgentExecutionSummaryForRun as materializeAgentExecutionSummaryForRunDefault,
+  readWaveComponentMatrixGate as readWaveComponentMatrixGateDefault,
+  readWaveContEvalGate as readWaveContEvalGateDefault,
+  readWaveContQaGate as readWaveContQaGateDefault,
+  readWaveDocumentationGate as readWaveDocumentationGateDefault,
+  readWaveIntegrationBarrier as readWaveIntegrationBarrierDefault,
+  readWaveSecurityGate as readWaveSecurityGateDefault,
+} from "./gate-engine.mjs";
 import { REPO_ROOT, toIsoTimestamp } from "./shared.mjs";
-import { isSecurityReviewAgent } from "./role-helpers.mjs";
+import { isSecurityReviewAgent, resolveWaveRoleBindings } from "./role-helpers.mjs";
 import { summarizeResolvedSkills } from "./skills.mjs";
 
 function failureResultFromGate(gate, fallbackLogPath) {
@@ -71,76 +80,41 @@ export async function runClosureSweepPhase({
   materializeAgentExecutionSummaryForRunFn,
   monitorWaveHumanFeedbackFn,
 }) {
-  const contQaAgentId = wave.contQaAgentId || "A0";
-  const contEvalAgentId = wave.contEvalAgentId || lanePaths.contEvalAgentId || "E0";
-  const integrationAgentId = wave.integrationAgentId || lanePaths.integrationAgentId || "A8";
-  const documentationAgentId = wave.documentationAgentId || "A9";
-  const stagedRuns = [
-    {
-      agentId: contEvalAgentId,
-      label: "cont-EVAL gate",
-      runs: closureRuns.filter((run) => run.agent.agentId === contEvalAgentId),
-      validate: () =>
-        readWaveContEvalGateFn(wave, closureRuns, {
-          contEvalAgentId,
-          mode: "live",
-          evalTargets: wave.evalTargets,
-          benchmarkCatalogPath: lanePaths.laneProfile?.paths?.benchmarkCatalogPath,
-        }),
-      actionRequested:
-        `Lane ${lanePaths.lane} owners should resolve cont-EVAL tuning gaps before integration closure.`,
-    },
-    {
-      agentId: "security",
-      label: "Security review",
-      runs: closureRuns.filter((run) => isSecurityReviewAgent(run.agent)),
-      validate: () => readWaveSecurityGateFn(wave, closureRuns),
-      actionRequested:
-        `Lane ${lanePaths.lane} owners should resolve blocked security findings or missing approvals before integration closure.`,
-    },
-    {
-      agentId: integrationAgentId,
-      label: "Integration gate",
-      runs: closureRuns.filter((run) => run.agent.agentId === integrationAgentId),
-      validate: () =>
-        readWaveIntegrationBarrierFn(
-          wave,
-          closureRuns,
-          refreshDerivedState?.(dashboardState?.attempt || 0),
-          {
-            integrationAgentId,
-            requireIntegrationStewardFromWave: lanePaths.requireIntegrationStewardFromWave,
-          },
-        ),
-      actionRequested:
-        `Lane ${lanePaths.lane} owners should resolve integration contradictions or blockers before documentation and cont-QA closure.`,
-    },
-    {
-      agentId: documentationAgentId,
-      label: "Documentation closure",
-      runs: closureRuns.filter((run) => run.agent.agentId === documentationAgentId),
-      validate: () => {
-        const documentationGate = readWaveDocumentationGateFn(wave, closureRuns);
-        if (!documentationGate.ok) {
-          return documentationGate;
-        }
-        return readWaveComponentMatrixGateFn(wave, closureRuns, {
-          laneProfile: lanePaths.laneProfile,
-          documentationAgentId,
-        });
-      },
-      actionRequested:
-        `Lane ${lanePaths.lane} owners should resolve the shared-plan or component-matrix closure state before cont-QA progression.`,
-    },
-    {
-      agentId: contQaAgentId,
-      label: "cont-QA gate",
-      runs: closureRuns.filter((run) => run.agent.agentId === contQaAgentId),
-      validate: () => readWaveContQaGateFn(wave, closureRuns, { contQaAgentId, mode: "live" }),
-      actionRequested:
-        `Lane ${lanePaths.lane} owners should resolve the cont-QA gate before wave progression.`,
-    },
-  ];
+  const materializeSummary =
+    typeof materializeAgentExecutionSummaryForRunFn === "function"
+      ? materializeAgentExecutionSummaryForRunFn
+      : materializeAgentExecutionSummaryForRunDefault;
+  const monitorHumanFeedback =
+    typeof monitorWaveHumanFeedbackFn === "function"
+      ? monitorWaveHumanFeedbackFn
+      : () => false;
+  const readContEvalGate =
+    typeof readWaveContEvalGateFn === "function"
+      ? readWaveContEvalGateFn
+      : readWaveContEvalGateDefault;
+  const readSecurityGate =
+    typeof readWaveSecurityGateFn === "function"
+      ? readWaveSecurityGateFn
+      : readWaveSecurityGateDefault;
+  const readIntegrationBarrier =
+    typeof readWaveIntegrationBarrierFn === "function"
+      ? readWaveIntegrationBarrierFn
+      : readWaveIntegrationBarrierDefault;
+  const readDocumentationGate =
+    typeof readWaveDocumentationGateFn === "function"
+      ? readWaveDocumentationGateFn
+      : readWaveDocumentationGateDefault;
+  const readComponentMatrixGate =
+    typeof readWaveComponentMatrixGateFn === "function"
+      ? readWaveComponentMatrixGateFn
+      : readWaveComponentMatrixGateDefault;
+  const readContQaGate =
+    typeof readWaveContQaGateFn === "function"
+      ? readWaveContQaGateFn
+      : readWaveContQaGateDefault;
+  const stagedRuns = planClosureStages({ lanePaths, wave, closureRuns });
+  const { contQaAgentId, contEvalAgentId, integrationAgentId, documentationAgentId } =
+    resolveWaveRoleBindings(wave, lanePaths);
   for (const stage of stagedRuns) {
     if (stage.runs.length === 0) {
       continue;
@@ -177,6 +151,11 @@ export async function runClosureSweepPhase({
         agentRateLimitBaseDelaySeconds: options.agentRateLimitBaseDelaySeconds,
         agentRateLimitMaxDelaySeconds: options.agentRateLimitMaxDelaySeconds,
         context7Enabled: options.context7Enabled,
+        attempt: dashboardState?.attempt || 1,
+        controlPlane: {
+          waveNumber: wave.wave,
+          attempt: dashboardState?.attempt || 1,
+        },
       });
       runInfo.lastLaunchAttempt = dashboardState?.attempt || null;
       runInfo.lastPromptHash = launchResult?.promptHash || null;
@@ -201,7 +180,7 @@ export async function runClosureSweepPhase({
           refreshWaveDashboardAgentStates(dashboardState, [runInfo], pendingAgentIds, (event) =>
             recordCombinedEvent(event),
           );
-          const feedbackChanged = monitorWaveHumanFeedbackFn({
+          const feedbackChanged = monitorHumanFeedback({
             lanePaths,
             waveNumber: wave.wave,
             agentRuns: [runInfo],
@@ -217,14 +196,37 @@ export async function runClosureSweepPhase({
           updateWaveDashboardMessageBoard(dashboardState, runInfo.messageBoardPath);
           flushDashboards();
         },
+        {
+          controlPlane: {
+            waveNumber: wave.wave,
+            attempt: dashboardState?.attempt || 1,
+          },
+        },
       );
-      materializeAgentExecutionSummaryForRunFn(wave, runInfo);
+      materializeSummary(wave, runInfo);
       refreshDerivedState?.(dashboardState?.attempt || 0);
       if (result.failures.length > 0) {
         return result;
       }
     }
-    const gate = stage.validate();
+    const gate = evaluateClosureStage({
+      stage,
+      wave,
+      closureRuns,
+      lanePaths,
+      dashboardState,
+      refreshDerivedState,
+      readWaveContEvalGateFn: readContEvalGate,
+      readWaveSecurityGateFn: readSecurityGate,
+      readWaveIntegrationBarrierFn: readIntegrationBarrier,
+      readWaveDocumentationGateFn: readDocumentationGate,
+      readWaveComponentMatrixGateFn: readComponentMatrixGate,
+      readWaveContQaGateFn: readContQaGate,
+      contEvalAgentId,
+      integrationAgentId,
+      documentationAgentId,
+      contQaAgentId,
+    });
     if (!gate.ok) {
       recordClosureGateFailure({
         wave,
@@ -244,6 +246,120 @@ export async function runClosureSweepPhase({
   return { failures: [], timedOut: false };
 }
 
+export function planClosureStages({ lanePaths, wave, closureRuns }) {
+  const { contQaAgentId, contEvalAgentId, integrationAgentId, documentationAgentId } =
+    resolveWaveRoleBindings(wave, lanePaths);
+  return [
+    {
+      key: "cont-eval",
+      agentId: contEvalAgentId,
+      label: "cont-EVAL gate",
+      runs: closureRuns.filter((run) => run.agent.agentId === contEvalAgentId),
+      actionRequested:
+        `Lane ${lanePaths.lane} owners should resolve cont-EVAL tuning gaps before integration closure.`,
+    },
+    {
+      key: "security-review",
+      agentId: "security",
+      label: "Security review",
+      runs: closureRuns.filter((run) => isSecurityReviewAgent(run.agent)),
+      actionRequested:
+        `Lane ${lanePaths.lane} owners should resolve blocked security findings or missing approvals before integration closure.`,
+    },
+    {
+      key: "integration",
+      agentId: integrationAgentId,
+      label: "Integration gate",
+      runs: closureRuns.filter((run) => run.agent.agentId === integrationAgentId),
+      actionRequested:
+        `Lane ${lanePaths.lane} owners should resolve integration contradictions or blockers before documentation and cont-QA closure.`,
+    },
+    {
+      key: "documentation",
+      agentId: documentationAgentId,
+      label: "Documentation closure",
+      runs: closureRuns.filter((run) => run.agent.agentId === documentationAgentId),
+      actionRequested:
+        `Lane ${lanePaths.lane} owners should resolve the shared-plan or component-matrix closure state before cont-QA progression.`,
+    },
+    {
+      key: "cont-qa",
+      agentId: contQaAgentId,
+      label: "cont-QA gate",
+      runs: closureRuns.filter((run) => run.agent.agentId === contQaAgentId),
+      actionRequested:
+        `Lane ${lanePaths.lane} owners should resolve the cont-QA gate before wave progression.`,
+    },
+  ];
+}
+
+function evaluateClosureStage({
+  stage,
+  wave,
+  closureRuns,
+  lanePaths,
+  dashboardState,
+  refreshDerivedState,
+  readWaveContEvalGateFn,
+  readWaveSecurityGateFn,
+  readWaveIntegrationBarrierFn,
+  readWaveDocumentationGateFn,
+  readWaveComponentMatrixGateFn,
+  readWaveContQaGateFn,
+  contEvalAgentId,
+  integrationAgentId,
+  documentationAgentId,
+  contQaAgentId,
+}) {
+  switch (stage.key) {
+    case "cont-eval":
+      return readWaveContEvalGateFn(wave, closureRuns, {
+        contEvalAgentId,
+        mode: "live",
+        evalTargets: wave.evalTargets,
+        benchmarkCatalogPath: lanePaths.laneProfile?.paths?.benchmarkCatalogPath,
+      });
+    case "security-review":
+      return readWaveSecurityGateFn(wave, closureRuns, { mode: "live" });
+    case "integration":
+      return readWaveIntegrationBarrierFn(
+        wave,
+        closureRuns,
+        refreshDerivedState?.(dashboardState?.attempt || 0),
+        {
+          integrationAgentId,
+          mode: "live",
+          requireIntegrationStewardFromWave: lanePaths.requireIntegrationStewardFromWave,
+        },
+      );
+    case "documentation": {
+      const documentationGate = readWaveDocumentationGateFn(wave, closureRuns, {
+        mode: "live",
+      });
+      if (!documentationGate.ok) {
+        return documentationGate;
+      }
+      return readWaveComponentMatrixGateFn(wave, closureRuns, {
+        laneProfile: lanePaths.laneProfile,
+        documentationAgentId,
+      });
+    }
+    case "cont-qa":
+      return readWaveContQaGateFn(wave, closureRuns, {
+        contQaAgentId,
+        mode: "live",
+      });
+    default:
+      return {
+        ok: true,
+        agentId: null,
+        statusCode: "pass",
+        detail: "No closure stage configured.",
+        logPath: null,
+      };
+  }
+}
+
 const NON_BLOCKING_INFRA_SIGNAL_STATES = new Set([
   "conformant",
   "setup-required",

package/scripts/wave-orchestrator/{launcher-derived-state.mjs → derived-state-engine.mjs}

@@ -4,7 +4,7 @@ import {
   materializeAgentExecutionSummaryForRun,
   materializeAgentExecutionSummaries,
   readRunExecutionSummary,
-} from "./launcher-gates.mjs";
+} from "./gate-engine.mjs";
 import {
   isOpenCoordinationStatus,
   appendCoordinationRecord,
@@ -13,9 +13,6 @@ import {
   readMaterializedCoordinationState,
   renderCoordinationBoardProjection,
   updateSeedRecords,
-  writeCompiledInbox,
-  writeCoordinationBoardProjection,
-  writeJsonArtifact,
   buildCoordinationResponseMetrics,
 } from "./coordination-store.mjs";
 import { triageClarificationRequests } from "./clarification-triage.mjs";
@@ -24,29 +21,21 @@ import {
   buildRequestAssignments,
   renderDependencySnapshotMarkdown,
   syncAssignmentRecords,
-  writeDependencySnapshotMarkdown,
 } from "./routing-state.mjs";
-import {
-  writeAssignmentSnapshot,
-  writeDependencySnapshot,
-} from "./artifact-schemas.mjs";
-import { deriveWaveLedger, readWaveLedger, writeWaveLedger } from "./ledger.mjs";
-import { buildDocsQueue, readDocsQueue, writeDocsQueue } from "./docs-queue.mjs";
-import {
-  parseStructuredSignalsFromLog,
-} from "./dashboard-state.mjs";
+import { deriveWaveLedger, readWaveLedger } from "./ledger.mjs";
+import { buildDocsQueue, readDocsQueue } from "./docs-queue.mjs";
+import { parseStructuredSignalsFromLog } from "./dashboard-state.mjs";
 import {
   isSecurityReviewAgent,
   resolveSecurityReviewReportPath,
   isContEvalImplementationOwningAgent,
+  resolveWaveRoleBindings,
 } from "./role-helpers.mjs";
 import {
   REPO_ROOT,
   compactSingleLine,
-  ensureDirectory,
   readJsonOrNull,
   toIsoTimestamp,
-  writeTextAtomic,
 } from "./shared.mjs";
 import {
   validateContEvalSummary,
@@ -307,27 +296,6 @@ export function buildWaveSecuritySummary({
   };
 }
 
-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 padReportedEntries(entries, minimumCount, label) {
   const padded = [...entries];
   for (let index = padded.length + 1; index <= minimumCount; index += 1) {
@@ -339,6 +307,7 @@ function padReportedEntries(entries, minimumCount, label) {
 function buildIntegrationEvidence({
   lanePaths,
   wave,
+  roleBindings = resolveWaveRoleBindings(wave, lanePaths),
   coordinationState,
   summariesByAgentId,
   docsQueue,
@@ -404,14 +373,14 @@ function buildIntegrationEvidence({
   for (const agent of wave.agents || []) {
     const summary = summariesByAgentId?.[agent.agentId] || null;
     const contEvalImplementationOwning =
-      agent.agentId === lanePaths.contEvalAgentId &&
+      agent.agentId === roleBindings.contEvalAgentId &&
       isContEvalImplementationOwningAgent(agent, {
-        contEvalAgentId: lanePaths.contEvalAgentId,
+        contEvalAgentId: roleBindings.contEvalAgentId,
       });
     if (isSecurityReviewAgent(agent)) {
       continue;
     }
-    if (agent.agentId === lanePaths.contEvalAgentId) {
+    if (agent.agentId === roleBindings.contEvalAgentId) {
       const validation = validateContEvalSummary(agent, summary, {
         mode: "live",
         evalTargets: wave.evalTargets,
@@ -425,11 +394,11 @@ function buildIntegrationEvidence({
     }
     if (
       ![
-        lanePaths.contQaAgentId,
-        lanePaths.integrationAgentId,
-        lanePaths.documentationAgentId,
+        roleBindings.contQaAgentId,
+        roleBindings.integrationAgentId,
+        roleBindings.documentationAgentId,
       ].includes(agent.agentId) &&
-      (agent.agentId !== lanePaths.contEvalAgentId || contEvalImplementationOwning)
+      (agent.agentId !== roleBindings.contEvalAgentId || contEvalImplementationOwning)
     ) {
       const validation = validateImplementationSummary(agent, summary);
       if (!validation.ok) {
@@ -553,10 +522,12 @@ export function buildWaveIntegrationSummary({
   dependencySnapshot = null,
   securitySummary = null,
 }) {
-  const explicitIntegration = summariesByAgentId[lanePaths.integrationAgentId]?.integration || null;
+  const roleBindings = resolveWaveRoleBindings(wave, lanePaths);
+  const explicitIntegration = summariesByAgentId[roleBindings.integrationAgentId]?.integration || null;
   const evidence = buildIntegrationEvidence({
     lanePaths,
     wave,
+    roleBindings,
     coordinationState,
     summariesByAgentId,
     docsQueue,
@@ -569,7 +540,7 @@ export function buildWaveIntegrationSummary({
     return {
       wave: wave.wave,
       lane: lanePaths.lane,
-      agentId: lanePaths.integrationAgentId,
+      agentId: roleBindings.integrationAgentId,
       attempt,
       openClaims: padReportedEntries(
         evidence.openClaims,
@@ -619,63 +590,7 @@ export function buildWaveIntegrationSummary({
   };
 }
 
-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");
-}
-
-export function writeWaveDerivedState({
+export function buildWaveDerivedState({
   lanePaths,
   wave,
   agentRuns = [],
@@ -684,6 +599,7 @@ export function writeWaveDerivedState({
   attempt = 0,
   orchestratorId = null,
 }) {
+  const roleBindings = resolveWaveRoleBindings(wave, lanePaths);
   const coordinationLogPath = waveCoordinationLogPath(lanePaths, wave.wave);
   const existingDocsQueue = readDocsQueue(waveDocsQueuePath(lanePaths, wave.wave));
   const existingIntegrationSummary = readJsonOrNull(waveIntegrationPath(lanePaths, wave.wave));
@@ -694,10 +610,10 @@ export function writeWaveDerivedState({
     agents: wave.agents,
     componentPromotions: wave.componentPromotions,
     sharedPlanDocs: lanePaths.sharedPlanDocs,
-    contQaAgentId: lanePaths.contQaAgentId,
-    contEvalAgentId: lanePaths.contEvalAgentId,
-    integrationAgentId: lanePaths.integrationAgentId,
-    documentationAgentId: lanePaths.documentationAgentId,
+    contQaAgentId: roleBindings.contQaAgentId,
+    contEvalAgentId: roleBindings.contEvalAgentId,
+    integrationAgentId: roleBindings.integrationAgentId,
+    documentationAgentId: roleBindings.documentationAgentId,
     feedbackRequests,
   });
   let coordinationState = readMaterializedCoordinationState(coordinationLogPath);
@@ -738,18 +654,6 @@ export function writeWaveDerivedState({
     ledger: existingLedger,
     capabilityRouting: lanePaths.capabilityRouting,
   });
-  writeAssignmentSnapshot(waveAssignmentsPath(lanePaths, wave.wave), capabilityAssignments, {
-    lane: lanePaths.lane,
-    wave: wave.wave,
-  });
-  writeDependencySnapshot(waveDependencySnapshotPath(lanePaths, wave.wave), dependencySnapshot, {
-    lane: lanePaths.lane,
-    wave: wave.wave,
-  });
-  writeDependencySnapshotMarkdown(
-    waveDependencySnapshotMarkdownPath(lanePaths, wave.wave),
-    dependencySnapshot,
-  );
   const runtimeAssignments = wave.agents.map((agent) => ({
     agentId: agent.agentId,
     role: agent.executorResolved?.role || null,
@@ -772,18 +676,12 @@ export function writeWaveDerivedState({
     componentPromotions: wave.componentPromotions,
     runtimeAssignments,
   });
-  writeDocsQueue(waveDocsQueuePath(lanePaths, wave.wave), docsQueue);
   const securitySummary = buildWaveSecuritySummary({
     lanePaths,
     wave,
     attempt,
     summariesByAgentId,
   });
-  writeJsonArtifact(waveSecurityPath(lanePaths, wave.wave), securitySummary);
-  writeTextAtomic(
-    waveSecurityMarkdownPath(lanePaths, wave.wave),
-    `${renderWaveSecuritySummaryMarkdown(securitySummary)}\n`,
-  );
   const integrationSummary = buildWaveIntegrationSummary({
     lanePaths,
     wave,
@@ -797,11 +695,6 @@ export function writeWaveDerivedState({
     dependencySnapshot,
     securitySummary,
   });
-  writeJsonArtifact(waveIntegrationPath(lanePaths, wave.wave), integrationSummary);
-  writeTextAtomic(
-    waveIntegrationMarkdownPath(lanePaths, wave.wave),
-    `${renderIntegrationSummaryMarkdown(integrationSummary)}\n`,
-  );
   const ledger = deriveWaveLedger({
     lane: lanePaths.lane,
     wave,
@@ -810,17 +703,15 @@ export function writeWaveDerivedState({
     integrationSummary,
     docsQueue,
     attempt,
-    contQaAgentId: lanePaths.contQaAgentId,
-    contEvalAgentId: lanePaths.contEvalAgentId,
-    integrationAgentId: lanePaths.integrationAgentId,
-    documentationAgentId: lanePaths.documentationAgentId,
+    contQaAgentId: roleBindings.contQaAgentId,
+    contEvalAgentId: roleBindings.contEvalAgentId,
+    integrationAgentId: roleBindings.integrationAgentId,
+    documentationAgentId: roleBindings.documentationAgentId,
     benchmarkCatalogPath: lanePaths.laneProfile?.paths?.benchmarkCatalogPath,
     capabilityAssignments,
     dependencySnapshot,
   });
-  writeWaveLedger(waveLedgerPath(lanePaths, wave.wave), ledger);
   const inboxDir = waveInboxDir(lanePaths, wave.wave);
-  ensureDirectory(inboxDir);
   const sharedSummary = compileSharedSummary({
     wave,
     state: coordinationState,
@@ -830,7 +721,6 @@ export function writeWaveDerivedState({
     dependencySnapshot,
   });
   const sharedSummaryPath = path.join(inboxDir, "shared-summary.md");
-  writeCompiledInbox(sharedSummaryPath, sharedSummary.text);
   const inboxesByAgentId = {};
   for (const agent of wave.agents) {
     const inbox = compileAgentInbox({
@@ -844,7 +734,6 @@ export function writeWaveDerivedState({
       dependencySnapshot,
     });
     const inboxPath = path.join(inboxDir, `${agent.agentId}.md`);
-    writeCompiledInbox(inboxPath, inbox.text);
     inboxesByAgentId[agent.agentId] = { path: inboxPath, text: inbox.text, truncated: inbox.truncated };
   }
   const boardText = renderCoordinationBoardProjection({
@@ -857,26 +746,25 @@ export function writeWaveDerivedState({
   });
   const responseMetrics = buildCoordinationResponseMetrics(coordinationState);
   const messageBoardPath = path.join(lanePaths.messageboardsDir, `wave-${wave.wave}.md`);
-  writeCoordinationBoardProjection(messageBoardPath, {
-    wave: wave.wave,
-    waveFile: wave.file,
-    agents: wave.agents,
-    state: coordinationState,
-    capabilityAssignments,
-    dependencySnapshot,
-  });
   return {
     coordinationLogPath,
     coordinationState,
     clarificationTriage,
     docsQueue,
+    docsQueuePath: waveDocsQueuePath(lanePaths, wave.wave),
     capabilityAssignments,
+    assignmentSnapshotPath: waveAssignmentsPath(lanePaths, wave.wave),
     dependencySnapshot,
+    dependencySnapshotPath: waveDependencySnapshotPath(lanePaths, wave.wave),
+    dependencySnapshotMarkdownPath: waveDependencySnapshotMarkdownPath(lanePaths, wave.wave),
     securitySummary,
+    securitySummaryPath: waveSecurityPath(lanePaths, wave.wave),
     integrationSummary,
+    integrationSummaryPath: waveIntegrationPath(lanePaths, wave.wave),
     integrationMarkdownPath: waveIntegrationMarkdownPath(lanePaths, wave.wave),
     securityMarkdownPath: waveSecurityMarkdownPath(lanePaths, wave.wave),
     ledger,
+    ledgerPath: waveLedgerPath(lanePaths, wave.wave),
     responseMetrics,
     sharedSummaryPath,
     sharedSummaryText: sharedSummary.text,