@chllming/wave-orchestration 0.9.11 → 0.9.13

package/scripts/wave-orchestrator/launcher.mjs

@@ -97,6 +97,7 @@ import {
   markWaveCompleted,
   parseWaveFiles,
   reconcileRunStateFromStatusFiles,
+  resolveCompletedWavesForValidation,
   resolveAutoNextWaveStart,
   validateWaveRuntimeMixAssignments,
   validateWaveComponentMatrixCurrentLevels,
@@ -265,9 +266,9 @@ Options:
   --dry-run              Parse waves and update manifest only
   --terminal-surface <mode>
                         Terminal surface: ${TERMINAL_SURFACES.join(" | ")} (default: ${terminalSurface})
-  --no-dashboard         Disable per-wave tmux dashboard session
-  --cleanup-sessions     Kill lane tmux sessions after each wave (default: on)
-  --keep-sessions        Keep lane tmux sessions after each wave
+  --no-dashboard         Disable the per-wave dashboard projection session
+  --cleanup-sessions     Clean up lane tmux dashboard/projection sessions after each wave (default: on)
+  --keep-sessions        Keep lane tmux dashboard/projection sessions after each wave
   --keep-terminals       Do not remove temporary terminal entries after each wave
   --orchestrator-id <id> Stable orchestrator identity for cross-lane coordination
   --orchestrator-board <path>
@@ -477,6 +478,15 @@ function parseArgs(argv) {
   return { help: false, lanePaths, options, config };
 }
 
+function maybePrintOptionalTmuxNote(options) {
+  if (options.dryRun || options.terminalSurface !== "tmux" || options.dashboard) {
+    return;
+  }
+  console.log(
+    "[terminal-surface] tmux is optional here: live agents still run as detached processes, and tmux only affects dashboard/projection attach when dashboards are enabled.",
+  );
+}
+
 // --- Local wrappers that bind engine calls to launcher scope ---
 
 async function runClosureSweepPhase({
@@ -872,7 +882,7 @@ export async function runLauncherCli(argv) {
       terminalSurface: options.terminalSurface,
     });
     const context7BundleIndex = loadContext7BundleIndex(lanePaths.context7BundleIndexPath);
-    const allWaves = parseWaveFiles(lanePaths.wavesDir, { laneProfile: lanePaths.laneProfile })
+    const parsedWaves = parseWaveFiles(lanePaths.wavesDir, { laneProfile: lanePaths.laneProfile })
       .map((wave) =>
         applyExecutorSelectionsToWave(wave, {
           laneProfile: lanePaths.laneProfile,
@@ -892,8 +902,34 @@ export async function runLauncherCli(argv) {
             ...resolveWaveRoleBindings(waveWithContext7, lanePaths, waveWithContext7.agents),
           };
         },
-      )
-      .map((wave) => validateWaveDefinition(wave, { laneProfile: lanePaths.laneProfile }));
+      );
+    // Read completed waves before validation so we can skip stale-promotion
+    // checks for waves that already ran, including waves recoverable from
+    // status files when run-state lags behind after a restart.
+    const preValidationCompletedWaves = new Set(
+      resolveCompletedWavesForValidation(
+        parsedWaves,
+        options.runStatePath,
+        lanePaths.statusDir,
+        {
+          logsDir: lanePaths.logsDir,
+          coordinationDir: lanePaths.coordinationDir,
+          contQaAgentId: lanePaths.contQaAgentId,
+          contEvalAgentId: lanePaths.contEvalAgentId,
+          integrationAgentId: lanePaths.integrationAgentId,
+          documentationAgentId: lanePaths.documentationAgentId,
+          requireExitContractsFromWave: lanePaths.requireExitContractsFromWave,
+          requireIntegrationStewardFromWave: lanePaths.requireIntegrationStewardFromWave,
+          requireComponentPromotionsFromWave: lanePaths.requireComponentPromotionsFromWave,
+          laneProfile: lanePaths.laneProfile,
+        },
+      ),
+    );
+    const allWaves = parsedWaves
+      .map((wave) => validateWaveDefinition(wave, {
+        laneProfile: lanePaths.laneProfile,
+        completedWaves: preValidationCompletedWaves,
+      }));
     const reconciliation = reconcileRunStateFromStatusFiles(
       allWaves,
       options.runStatePath,
@@ -1062,11 +1098,12 @@ export async function runLauncherCli(argv) {
       console.log(
         `[dry-run] prompts and executor overlays written: ${path.relative(REPO_ROOT, lanePaths.executorOverlaysDir)}`,
       );
-      console.log("Dry run enabled, skipping tmux and executor launch.");
+      console.log("Dry run enabled, skipping live execution and optional dashboard/projection launch.");
       return;
     }
 
     preflightWavesForExecutorAvailability(filteredWaves, lanePaths);
+    maybePrintOptionalTmuxNote(options);
     const terminalRegistryEnabled = terminalSurfaceUsesTerminalRegistry(
       options.terminalSurface,
     );

package/scripts/wave-orchestrator/planner.mjs

@@ -2944,9 +2944,10 @@ async function runProjectSetupFlow(options = {}) {
       ),
     );
 
-    prompt.describe("\nHow do you want to watch agent sessions?");
-    prompt.describe("  vscode — agent sessions appear as VS Code terminal tabs");
-    prompt.describe("  tmux   — agent sessions run in tmux panes (terminal-native)");
+    prompt.describe("\nHow do you want to follow live runs?");
+    prompt.describe("Live agent execution stays process-backed either way; this only changes the operator surface.");
+    prompt.describe("  vscode — VS Code gets temporary terminal entries for agent logs and dashboards");
+    prompt.describe("  tmux   — terminal-native dashboard and projection surface with no VS Code integration");
     const defaultTerminalSurface = normalizeTerminalSurface(
       await prompt.askChoice(
         "Default terminal surface",

package/scripts/wave-orchestrator/shared.mjs

@@ -277,6 +277,8 @@ export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
       laneProfile.validation.requireComponentPromotionsFromWave,
     requireAgentComponentsFromWave: laneProfile.validation.requireAgentComponentsFromWave,
     gateModeThresholds: laneProfile.validation.gateModeThresholds,
+    closureModeThresholds: laneProfile.validation.closureModeThresholds,
+    autoClosure: laneProfile.validation.autoClosure,
     executors: laneProfile.executors,
     skills: laneProfile.skills,
     capabilityRouting: laneProfile.capabilityRouting,
@@ -428,9 +430,6 @@ export function normalizeWaveVerdict(verdict) {
   const normalized = String(verdict || "")
     .trim()
     .toLowerCase();
-  if (normalized === "hold") {
-    return "concerns";
-  }
   if (normalized === "fail") {
     return "blocked";
   }

package/scripts/wave-orchestrator/swe-bench-pro-task.mjs

@@ -796,7 +796,7 @@ function buildFullWaveSolve(row, taskWorkspace, options) {
   });
   assertSuccess(doctor, "wave doctor");
   const launch = runShellCommand(
-    `node ${shellQuote(WAVE_ENTRY)} launch --lane main --start-wave 1 --end-wave 1 --no-dashboard --terminal-surface tmux`,
+    `node ${shellQuote(WAVE_ENTRY)} launch --lane main --start-wave 1 --end-wave 1 --no-dashboard`,
     {
       cwd: taskWorkspace.repoDir,
       timeoutMs: options.maxWallClockMinutes * 60 * 1000,

package/scripts/wave-orchestrator/traces.mjs

@@ -623,6 +623,7 @@ export function normalizeGateSnapshotForBundle(gateSnapshot, agentArtifacts) {
     return gateSnapshot;
   }
   const normalized = { ...gateSnapshot };
+  const overallGate = String(gateSnapshot.overall?.gate || "").trim();
   for (const key of [
     "implementationGate",
     "componentGate",
@@ -638,7 +639,27 @@ export function normalizeGateSnapshotForBundle(gateSnapshot, agentArtifacts) {
     "evaluatorGate",
     "infraGate",
   ]) {
-    normalized[key] = normalizeGateLogPath(gateSnapshot[key], agentArtifacts);
+    const nextValue = normalizeGateLogPath(gateSnapshot[key], agentArtifacts);
+    if (key === "documentationGate") {
+      normalized[key] =
+        overallGate === "documentationGate" && nextValue
+          ? {
+              ok: Boolean(nextValue.ok),
+              statusCode: nextValue.statusCode || null,
+            }
+          : null;
+      continue;
+    }
+    if (key === "integrationGate" || key === "integrationBarrier") {
+      normalized[key] = nextValue
+        ? {
+            ok: Boolean(nextValue.ok),
+            statusCode: nextValue.statusCode || null,
+          }
+        : null;
+      continue;
+    }
+    normalized[key] = nextValue;
   }
   return normalized;
 }

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

@@ -1534,9 +1534,13 @@ export function validateWaveDefinition(wave, options = {}) {
           `Wave ${wave.wave} promotes ${componentId} to ${targetLevel}, but ${componentMatrix.jsonPath} declares ${matrixPromotion.target}`,
         );
       } else if (componentMatrix.levelOrder[targetLevel] < componentMatrix.levelOrder[component.currentLevel]) {
-        errors.push(
-          `Wave ${wave.wave} promotes ${componentId} to ${targetLevel}, but ${componentMatrix.jsonPath} already records currentLevel ${component.currentLevel}`,
-        );
+        // Skip this error for already-completed waves — their promotions may have
+        // been superseded by later waves that advanced the component further.
+        if (!options?.completedWaves?.has(wave.wave)) {
+          errors.push(
+            `Wave ${wave.wave} promotes ${componentId} to ${targetLevel}, but ${componentMatrix.jsonPath} already records currentLevel ${component.currentLevel}`,
+          );
+        }
       }
     }
     const matrixWavePromotions = Object.entries(componentMatrix.components)
@@ -3294,6 +3298,13 @@ export function completedWavesFromStatusFiles(allWaves, statusDir, options = {})
   return normalizeCompletedWaves(completed);
 }
 
+export function resolveCompletedWavesForValidation(allWaves, runStatePath, statusDir, options = {}) {
+  return normalizeCompletedWaves([
+    ...readRunState(runStatePath).completedWaves,
+    ...completedWavesFromStatusFiles(allWaves, statusDir, options),
+  ]);
+}
+
 export function reconcileRunStateFromStatusFiles(allWaves, runStatePath, statusDir, options = {}) {
   const diagnostics = allWaves.map((wave) => ({
     wave: wave.wave,

package/wave.config.json

@@ -276,7 +276,18 @@
     "requireExitContractsFromWave": 6,
     "requireIntegrationStewardFromWave": 0,
     "requireComponentPromotionsFromWave": 0,
-    "requireAgentComponentsFromWave": 0
+    "requireAgentComponentsFromWave": 0,
+    "closureModeThresholds": {
+      "bootstrap": 0,
+      "standard": 4,
+      "strict": 10
+    },
+    "autoClosure": {
+      "allowInferredIntegration": true,
+      "allowAutoDocNoChange": true,
+      "allowAutoDocProjection": false,
+      "allowSkipContQaInBootstrap": true
+    }
   },
   "capabilityRouting": {
     "preferredAgents": {}
@@ -309,4 +320,4 @@
       }
     }
   }
-}
+}