@chllming/wave-orchestration 0.6.0 → 0.6.2

package/scripts/wave-orchestrator/launcher.mjs

@@ -81,6 +81,7 @@ import {
   writeTextAtomic,
 } from "./shared.mjs";
 import {
+  createCurrentWaveDashboardTerminalEntry,
   appendTerminalEntries,
   createGlobalDashboardTerminalEntry,
   createTemporaryTerminalEntries,
@@ -1449,11 +1450,94 @@ export function readWaveImplementationGate(wave, agentRuns) {
   };
 }
 
+function analyzePromotedComponentOwners(componentId, agentRuns, summariesByAgentId) {
+  const ownerRuns = (agentRuns || []).filter((runInfo) =>
+    runInfo.agent.components?.includes(componentId),
+  );
+  const ownerAgentIds = ownerRuns.map((runInfo) => runInfo.agent.agentId);
+  const satisfiedAgentIds = [];
+  const waitingOnAgentIds = [];
+  const failedOwnContractAgentIds = [];
+  for (const runInfo of ownerRuns) {
+    const summary = summariesByAgentId?.[runInfo.agent.agentId] || null;
+    const implementationValidation = validateImplementationSummary(runInfo.agent, summary);
+    const componentMarkers = new Map(
+      Array.isArray(summary?.components)
+        ? summary.components.map((component) => [component.componentId, component])
+        : [],
+    );
+    const marker = componentMarkers.get(componentId);
+    const expectedLevel = runInfo.agent.componentTargets?.[componentId] || null;
+    const componentSatisfied =
+      marker &&
+      marker.state === "met" &&
+      (!expectedLevel || marker.level === expectedLevel);
+    if (implementationValidation.ok && componentSatisfied) {
+      satisfiedAgentIds.push(runInfo.agent.agentId);
+      continue;
+    }
+    waitingOnAgentIds.push(runInfo.agent.agentId);
+    if (!implementationValidation.ok) {
+      failedOwnContractAgentIds.push(runInfo.agent.agentId);
+    }
+  }
+  return {
+    componentId,
+    ownerRuns,
+    ownerAgentIds,
+    satisfiedAgentIds,
+    waitingOnAgentIds,
+    failedOwnContractAgentIds,
+  };
+}
+
+function buildSharedComponentSiblingPendingFailure(componentState) {
+  if (
+    !componentState ||
+    componentState.satisfiedAgentIds.length === 0 ||
+    componentState.waitingOnAgentIds.length === 0
+  ) {
+    return null;
+  }
+  const landedSummary =
+    componentState.satisfiedAgentIds.length === 1
+      ? `${componentState.satisfiedAgentIds[0]} desired-state slice landed`
+      : `${componentState.satisfiedAgentIds.join(", ")} desired-state slices landed`;
+  const ownerRun =
+    componentState.ownerRuns.find((runInfo) =>
+      componentState.waitingOnAgentIds.includes(runInfo.agent.agentId),
+    ) ||
+    componentState.ownerRuns[0] ||
+    null;
+  return {
+    ok: false,
+    agentId: componentState.waitingOnAgentIds[0] || ownerRun?.agent?.agentId || null,
+    componentId: componentState.componentId || null,
+    statusCode: "shared-component-sibling-pending",
+    detail: `${landedSummary}; shared component closure still depends on ${componentState.waitingOnAgentIds.join("/")}.`,
+    logPath: ownerRun ? path.relative(REPO_ROOT, ownerRun.logPath) : null,
+    ownerAgentIds: componentState.ownerAgentIds,
+    satisfiedAgentIds: componentState.satisfiedAgentIds,
+    waitingOnAgentIds: componentState.waitingOnAgentIds,
+    failedOwnContractAgentIds: componentState.failedOwnContractAgentIds,
+  };
+}
+
 export function readWaveComponentGate(wave, agentRuns, options = {}) {
   const summariesByAgentId = Object.fromEntries(
     agentRuns.map((runInfo) => [runInfo.agent.agentId, readRunExecutionSummary(runInfo, wave)]),
   );
   const validation = validateWaveComponentPromotions(wave, summariesByAgentId, options);
+  const sharedPending = (wave.componentPromotions || [])
+    .map((promotion) =>
+      buildSharedComponentSiblingPendingFailure(
+        analyzePromotedComponentOwners(promotion.componentId, agentRuns, summariesByAgentId),
+      ),
+    )
+    .find(Boolean);
+  if (sharedPending) {
+    return sharedPending;
+  }
   if (validation.ok) {
     return {
       ok: true,
@@ -1464,8 +1548,12 @@ export function readWaveComponentGate(wave, agentRuns, options = {}) {
       logPath: null,
     };
   }
-  const ownerRun =
-    agentRuns.find((runInfo) => runInfo.agent.components?.includes(validation.componentId)) ?? null;
+  const componentState = analyzePromotedComponentOwners(
+    validation.componentId,
+    agentRuns,
+    summariesByAgentId,
+  );
+  const ownerRun = componentState.ownerRuns[0] ?? null;
   return {
     ok: false,
     agentId: ownerRun?.agent?.agentId || null,
@@ -1473,6 +1561,10 @@ export function readWaveComponentGate(wave, agentRuns, options = {}) {
     statusCode: validation.statusCode,
     detail: validation.detail,
     logPath: ownerRun ? path.relative(REPO_ROOT, ownerRun.logPath) : null,
+    ownerAgentIds: componentState.ownerAgentIds,
+    satisfiedAgentIds: componentState.satisfiedAgentIds,
+    waitingOnAgentIds: componentState.waitingOnAgentIds,
+    failedOwnContractAgentIds: componentState.failedOwnContractAgentIds,
   };
 }
 
@@ -1799,6 +1891,38 @@ function removeOrphanWaveDashboards(lanePaths, activeSessionNames) {
   return removedDashboardPaths;
 }
 
+function pruneDryRunExecutorPreviewDirs(lanePaths, waves) {
+  if (!fs.existsSync(lanePaths.executorOverlaysDir)) {
+    return [];
+  }
+  const expectedSlugsByWave = new Map(
+    (waves || []).map((wave) => [wave.wave, new Set((wave.agents || []).map((agent) => agent.slug))]),
+  );
+  const removedPaths = [];
+  for (const entry of fs.readdirSync(lanePaths.executorOverlaysDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !/^wave-\d+$/.test(entry.name)) {
+      continue;
+    }
+    const waveNumber = Number.parseInt(entry.name.slice("wave-".length), 10);
+    const waveDir = path.join(lanePaths.executorOverlaysDir, entry.name);
+    const expectedSlugs = expectedSlugsByWave.get(waveNumber);
+    if (!expectedSlugs) {
+      fs.rmSync(waveDir, { recursive: true, force: true });
+      removedPaths.push(path.relative(REPO_ROOT, waveDir));
+      continue;
+    }
+    for (const child of fs.readdirSync(waveDir, { withFileTypes: true })) {
+      if (!child.isDirectory() || expectedSlugs.has(child.name)) {
+        continue;
+      }
+      const childPath = path.join(waveDir, child.name);
+      fs.rmSync(childPath, { recursive: true, force: true });
+      removedPaths.push(path.relative(REPO_ROOT, childPath));
+    }
+  }
+  return removedPaths.toSorted();
+}
+
 export function reconcileStaleLauncherArtifacts(lanePaths, options = {}) {
   const outcome = {
     removedLock: false,
@@ -2162,9 +2286,63 @@ function relaunchReasonBuckets(runs, failures, derivedState) {
     closureGate: (failures || []).some(
       (failure) => failure.agentId && selectedAgentIds.has(failure.agentId),
     ),
+    sharedComponentSiblingWait: (failures || []).some(
+      (failure) =>
+        failure.statusCode === "shared-component-sibling-pending" &&
+        (failure.waitingOnAgentIds || []).some((agentId) => selectedAgentIds.has(agentId)),
+    ),
   };
 }
 
+function applySharedComponentWaitStateToDashboard(componentGate, dashboardState) {
+  const waitingSummary = (componentGate?.waitingOnAgentIds || []).join("/");
+  if (!waitingSummary) {
+    return;
+  }
+  for (const agentId of componentGate?.satisfiedAgentIds || []) {
+    setWaveDashboardAgent(dashboardState, agentId, {
+      state: "completed",
+      detail: `Desired-state slice landed; waiting on ${waitingSummary} for shared component closure`,
+    });
+  }
+}
+
+function reconcileFailuresAgainstSharedComponentState(wave, agentRuns, failures) {
+  if (!Array.isArray(failures) || failures.length === 0) {
+    return failures;
+  }
+  const summariesByAgentId = Object.fromEntries(
+    (agentRuns || []).map((runInfo) => [runInfo.agent.agentId, readRunExecutionSummary(runInfo, wave)]),
+  );
+  const failureAgentIds = new Set(failures.map((failure) => failure.agentId).filter(Boolean));
+  const consumedSatisfiedAgentIds = new Set();
+  const synthesizedFailures = [];
+  for (const promotion of wave?.componentPromotions || []) {
+    const componentState = analyzePromotedComponentOwners(
+      promotion.componentId,
+      agentRuns,
+      summariesByAgentId,
+    );
+    if (
+      componentState.satisfiedAgentIds.length === 0 ||
+      componentState.waitingOnAgentIds.length === 0 ||
+      !componentState.satisfiedAgentIds.some((agentId) => failureAgentIds.has(agentId))
+    ) {
+      continue;
+    }
+    for (const agentId of componentState.satisfiedAgentIds) {
+      if (failureAgentIds.has(agentId)) {
+        consumedSatisfiedAgentIds.add(agentId);
+      }
+    }
+    synthesizedFailures.push(buildSharedComponentSiblingPendingFailure(componentState));
+  }
+  return [
+    ...synthesizedFailures.filter(Boolean),
+    ...failures.filter((failure) => !consumedSatisfiedAgentIds.has(failure.agentId)),
+  ];
+}
+
 export function hasReusableSuccessStatus(agent, statusPath, options = {}) {
   const statusRecord = readStatusRecordIfPresent(statusPath);
   const basicReuseOk = Boolean(
@@ -2272,7 +2450,11 @@ function buildFallbackExecutorState(executorState, executorId, attempt, reason)
 }
 
 function applyRetryFallbacks(agentRuns, failures, lanePaths, attemptNumber, waveDefinition = null) {
-  const failedAgentIds = new Set(failures.map((failure) => failure.agentId));
+  const failedAgentIds = new Set(
+    failures
+      .filter((failure) => failure.statusCode !== "shared-component-sibling-pending")
+      .map((failure) => failure.agentId),
+  );
   let changed = false;
   const outcomes = new Map();
   for (const run of agentRuns) {
@@ -2733,6 +2915,20 @@ export function resolveRelaunchRuns(agentRuns, failures, derivedState, lanePaths
       barrier: null,
     };
   }
+  const sharedComponentWaitingAgentIds = new Set(
+    (failures || [])
+      .filter((failure) => failure.statusCode === "shared-component-sibling-pending")
+      .flatMap((failure) => failure.waitingOnAgentIds || [])
+      .filter((agentId) => runsByAgentId.has(agentId)),
+  );
+  if (sharedComponentWaitingAgentIds.size > 0) {
+    return {
+      runs: Array.from(sharedComponentWaitingAgentIds)
+        .map((agentId) => runsByAgentId.get(agentId))
+        .filter(Boolean),
+      barrier: null,
+    };
+  }
   const failedAgentIds = new Set(failures.map((failure) => failure.agentId));
   return {
     runs: agentRuns.filter((run) => failedAgentIds.has(run.agent.agentId)),
@@ -2779,6 +2975,8 @@ export async function runLauncherCli(argv) {
   let globalDashboard = null;
   let globalDashboardTerminalEntry = null;
   let globalDashboardTerminalAppended = false;
+  let currentWaveDashboardTerminalEntry = null;
+  let currentWaveDashboardTerminalAppended = false;
   let selectedWavesForCoordination = [];
 
   const appendCoordination = ({
@@ -2976,6 +3174,7 @@ export async function runLauncherCli(argv) {
     });
 
     if (options.dryRun) {
+      pruneDryRunExecutorPreviewDirs(lanePaths, allWaves);
       for (const wave of filteredWaves) {
         const derivedState = writeWaveDerivedState({
           lanePaths,
@@ -3072,9 +3271,14 @@ export async function runLauncherCli(argv) {
         lanePaths,
         globalDashboard.runId || "global",
       );
+      currentWaveDashboardTerminalEntry = createCurrentWaveDashboardTerminalEntry(lanePaths);
       if (terminalRegistryEnabled) {
-        appendTerminalEntries(lanePaths.terminalsPath, [globalDashboardTerminalEntry]);
+        appendTerminalEntries(lanePaths.terminalsPath, [
+          globalDashboardTerminalEntry,
+          currentWaveDashboardTerminalEntry,
+        ]);
         globalDashboardTerminalAppended = true;
+        currentWaveDashboardTerminalAppended = true;
       }
       launchWaveDashboardSession(lanePaths, {
         sessionName: globalDashboardTerminalEntry.sessionName,
@@ -3152,7 +3356,7 @@ export async function runLauncherCli(argv) {
           wave.wave,
           wave.agents,
           runTag,
-          options.dashboard,
+          false,
         );
         if (terminalRegistryEnabled) {
           appendTerminalEntries(lanePaths.terminalsPath, terminalEntries);
@@ -3265,12 +3469,9 @@ export async function runLauncherCli(argv) {
         }
         flushDashboards();
 
-        const dashboardEntry = terminalEntries.find(
-          (entry) => entry.terminalName === `${lanePaths.dashboardTerminalNamePrefix}${wave.wave}`,
-        );
-        if (options.dashboard && dashboardEntry) {
+        if (options.dashboard && currentWaveDashboardTerminalEntry) {
           launchWaveDashboardSession(lanePaths, {
-            sessionName: dashboardEntry.sessionName,
+            sessionName: currentWaveDashboardTerminalEntry.sessionName,
             dashboardPath,
             messageBoardPath,
           });
@@ -3442,6 +3643,12 @@ export async function runLauncherCli(argv) {
 
           materializeAgentExecutionSummaries(wave, agentRuns);
           refreshDerivedState(attempt);
+          failures = reconcileFailuresAgainstSharedComponentState(wave, agentRuns, failures);
+          for (const failure of failures) {
+            if (failure.statusCode === "shared-component-sibling-pending") {
+              applySharedComponentWaitStateToDashboard(failure, dashboardState);
+            }
+          }
 
           if (failures.length > 0) {
             for (const failure of failures) {
@@ -3483,12 +3690,20 @@ export async function runLauncherCli(argv) {
                 laneProfile: lanePaths.laneProfile,
               });
               if (!componentGate.ok) {
+                if (componentGate.statusCode === "shared-component-sibling-pending") {
+                  applySharedComponentWaitStateToDashboard(componentGate, dashboardState);
+                }
                 failures = [
                   {
                     agentId: componentGate.agentId,
                     statusCode: componentGate.statusCode,
                     logPath:
                       componentGate.logPath || path.relative(REPO_ROOT, messageBoardPath),
+                    detail: componentGate.detail,
+                    ownerAgentIds: componentGate.ownerAgentIds || [],
+                    satisfiedAgentIds: componentGate.satisfiedAgentIds || [],
+                    waitingOnAgentIds: componentGate.waitingOnAgentIds || [],
+                    failedOwnContractAgentIds: componentGate.failedOwnContractAgentIds || [],
                   },
                 ];
                 recordCombinedEvent({
@@ -4045,6 +4260,9 @@ export async function runLauncherCli(argv) {
           if (globalDashboardTerminalEntry) {
             excludeSessionNames.add(globalDashboardTerminalEntry.sessionName);
           }
+          if (currentWaveDashboardTerminalEntry) {
+            excludeSessionNames.add(currentWaveDashboardTerminalEntry.sessionName);
+          }
           cleanupLaneTmuxSessions(lanePaths, { excludeSessionNames });
         }
         if (globalWave && globalWave.status === "running") {
@@ -4079,6 +4297,13 @@ export async function runLauncherCli(argv) {
     if (globalDashboardTerminalAppended && globalDashboardTerminalEntry && !options.keepTerminals) {
       removeTerminalEntries(lanePaths.terminalsPath, [globalDashboardTerminalEntry]);
     }
+    if (
+      currentWaveDashboardTerminalAppended &&
+      currentWaveDashboardTerminalEntry &&
+      !options.keepTerminals
+    ) {
+      removeTerminalEntries(lanePaths.terminalsPath, [currentWaveDashboardTerminalEntry]);
+    }
     if (options.cleanupSessions && globalDashboardTerminalEntry) {
       try {
         killTmuxSessionIfExists(lanePaths.tmuxSocketName, globalDashboardTerminalEntry.sessionName);
@@ -4086,6 +4311,16 @@ export async function runLauncherCli(argv) {
         // no-op
       }
     }
+    if (options.cleanupSessions && currentWaveDashboardTerminalEntry) {
+      try {
+        killTmuxSessionIfExists(
+          lanePaths.tmuxSocketName,
+          currentWaveDashboardTerminalEntry.sessionName,
+        );
+      } catch {
+        // no-op
+      }
+    }
     if (lockHeld) {
       releaseLauncherLock(lanePaths.launcherLockPath);
     }

package/scripts/wave-orchestrator/terminals.mjs

@@ -61,11 +61,18 @@ export function writeTerminalsConfig(filePath, config) {
 function isLaneTemporaryTerminalName(name, lanePaths) {
   return (
     name === lanePaths.globalDashboardTerminalName ||
+    name === currentWaveDashboardTerminalName(lanePaths) ||
     name.startsWith(lanePaths.terminalNamePrefix) ||
     name.startsWith(lanePaths.dashboardTerminalNamePrefix)
   );
 }
 
+function currentWaveDashboardTerminalName(lanePaths) {
+  return lanePaths.lane === "main"
+    ? "Current Wave Dashboard"
+    : `Current Wave Dashboard (${lanePaths.lane})`;
+}
+
 function extractTmuxSessionName(command, socketName) {
   const text = String(command || "").trim();
   const marker = `tmux -L ${socketName} new -As `;
@@ -138,6 +145,24 @@ export function createGlobalDashboardTerminalEntry(lanePaths, runTag) {
   };
 }
 
+export function createCurrentWaveDashboardTerminalEntry(lanePaths) {
+  const sessionName = `${lanePaths.tmuxDashboardSessionPrefix}_current`.replace(
+    /[^a-zA-Z0-9:_-]/g,
+    "_",
+  );
+  const terminalName = currentWaveDashboardTerminalName(lanePaths);
+  return {
+    terminalName,
+    sessionName,
+    config: {
+      name: terminalName,
+      icon: DASHBOARD_TERMINAL_ICON,
+      color: DASHBOARD_TERMINAL_COLOR,
+      command: `TMUX= tmux -L ${lanePaths.tmuxSocketName} new -As ${sessionName}`,
+    },
+  };
+}
+
 export function appendTerminalEntries(terminalsPath, entries) {
   const config = readTerminalsConfig(terminalsPath);
   const namesToReplace = new Set(entries.map((entry) => entry.terminalName));

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

@@ -13,6 +13,7 @@ import {
   DEFAULT_INTEGRATION_ROLE_PROMPT_PATH,
   DEFAULT_SECURITY_ROLE_PROMPT_PATH,
   DEFAULT_WAVE_LANE,
+  normalizeClaudeEffort,
   loadWaveConfig,
   normalizeCodexSandboxMode,
   normalizeExecutorMode,
@@ -700,6 +701,7 @@ export function normalizeAgentExecutorConfig(rawSettings, filePath, label) {
     "claude.agent",
     "claude.permission_mode",
     "claude.permission_prompt_tool",
+    "claude.effort",
     "claude.max_turns",
     "claude.mcp_config",
     "claude.settings",
@@ -827,6 +829,11 @@ export function normalizeAgentExecutorConfig(rawSettings, filePath, label) {
         ...(executorConfig.claude || {}),
         permissionPromptTool: value,
       };
+    } else if (key === "claude.effort") {
+      executorConfig.claude = {
+        ...(executorConfig.claude || {}),
+        effort: normalizeClaudeEffort(value, `${label}.claude.effort`),
+      };
     } else if (key === "claude.max_turns") {
       executorConfig.claude = {
         ...(executorConfig.claude || {}),
@@ -2038,6 +2045,28 @@ export function resolveAgentExecutor(agent, options = {}) {
       profile?.budget?.minutes ??
       null,
   };
+  const claudeMaxTurnsSource =
+    executorConfig?.claude?.maxTurns !== null && executorConfig?.claude?.maxTurns !== undefined
+      ? "claude.maxTurns"
+      : profile?.claude?.maxTurns !== null && profile?.claude?.maxTurns !== undefined
+        ? "claude.maxTurns"
+        : runtimeBudget.turns !== null
+          ? "budget.turns"
+          : laneProfile.executors.claude.maxTurns !== null &&
+              laneProfile.executors.claude.maxTurns !== undefined
+            ? "claude.maxTurns"
+            : null;
+  const opencodeStepsSource =
+    executorConfig?.opencode?.steps !== null && executorConfig?.opencode?.steps !== undefined
+      ? "opencode.steps"
+      : profile?.opencode?.steps !== null && profile?.opencode?.steps !== undefined
+        ? "opencode.steps"
+        : runtimeBudget.turns !== null
+          ? "budget.turns"
+          : laneProfile.executors.opencode.steps !== null &&
+              laneProfile.executors.opencode.steps !== undefined
+            ? "opencode.steps"
+            : null;
   return {
     id: executorId,
     initialExecutorId: executorId,
@@ -2122,6 +2151,7 @@ export function resolveAgentExecutor(agent, options = {}) {
         profile?.claude?.maxTurns ??
         runtimeBudget.turns ??
         laneProfile.executors.claude.maxTurns,
+      maxTurnsSource: claudeMaxTurnsSource,
     },
     opencode: {
       ...mergeExecutorSections(
@@ -2139,6 +2169,7 @@ export function resolveAgentExecutor(agent, options = {}) {
         profile?.opencode?.steps ??
         runtimeBudget.turns ??
         laneProfile.executors.opencode.steps,
+      stepsSource: opencodeStepsSource,
     },
   };
 }