@chllming/wave-orchestration 0.9.0 → 0.9.2

package/scripts/wave-orchestrator/launcher.mjs

@@ -74,6 +74,7 @@ import {
   appendTerminalEntries,
   createGlobalDashboardTerminalEntry,
   createTemporaryTerminalEntries,
+  createWaveAgentSessionName,
   killTmuxSessionIfExists,
   normalizeTerminalSurface,
   pruneOrphanLaneTemporaryTerminalEntries,
@@ -144,7 +145,7 @@ import {
   summarizeResolvedSkills,
 } from "./skills.mjs";
 import {
-  collectUnexpectedSessionFailures as collectUnexpectedSessionFailuresImpl,
+  applyLaunchResultToRun,
   launchAgentSession as launchAgentSessionImpl,
   refreshResolvedSkillsForRun,
   waitForWaveCompletion as waitForWaveCompletionImpl,
@@ -200,7 +201,7 @@ import {
   acquireLauncherLock,
   releaseLauncherLock,
   reconcileStaleLauncherArtifacts,
-  collectUnexpectedSessionFailures,
+  collectUnexpectedSessionWarnings,
   launchAgentSession,
   waitForWaveCompletion,
   monitorWaveHumanFeedback,
@@ -208,10 +209,10 @@ import {
   monitorResidentOrchestratorSession,
   launchWaveDashboardSession,
   cleanupLaneTmuxSessions,
+  cleanupLaunchedRun,
   pruneDryRunExecutorPreviewDirs,
   recordAttemptState,
   recordWaveRunState,
-  runTmux,
   syncLiveWaveSignals,
 } from "./session-supervisor.mjs";
 import { buildControlStatusPayload } from "./control-cli.mjs";
@@ -230,6 +231,10 @@ import {
   formatReconcilePreservedWaveLine,
 } from "./reconcile-format.mjs";
 import { computeReducerSnapshot } from "./reducer-snapshot.mjs";
+import {
+  launcherProgressPathForRun,
+  updateLauncherProgress,
+} from "./launcher-progress.mjs";
 
 function printUsage(lanePaths, terminalSurface) {
   console.log(`Usage: pnpm exec wave launch [options]
@@ -255,7 +260,7 @@ Options:
   --agent-launch-stagger-ms <n>
                         Delay between agent launches (default: ${DEFAULT_AGENT_LAUNCH_STAGGER_MS})
   --executor <mode>      Default agent executor mode: ${SUPPORTED_EXECUTOR_MODES.join(" | ")} (default: ${lanePaths.executors.default})
-  --codex-sandbox <mode> Codex sandbox mode: ${CODEX_SANDBOX_MODES.join(" | ")} (default: ${DEFAULT_CODEX_SANDBOX_MODE})
+  --codex-sandbox <mode> Codex sandbox mode override: ${CODEX_SANDBOX_MODES.join(" | ")} (default: lane config)
   --manifest-out <path>  Write parsed wave manifest JSON (default: ${path.relative(REPO_ROOT, lanePaths.defaultManifestPath)})
   --dry-run              Parse waves and update manifest only
   --terminal-surface <mode>
@@ -298,7 +303,7 @@ function parseArgs(argv) {
     agentRateLimitMaxDelaySeconds: DEFAULT_AGENT_RATE_LIMIT_MAX_DELAY_SECONDS,
     agentLaunchStaggerMs: DEFAULT_AGENT_LAUNCH_STAGGER_MS,
     executorMode: lanePaths.executors.default,
-    codexSandboxMode: DEFAULT_CODEX_SANDBOX_MODE,
+    codexSandboxMode: null,
     manifestOut: lanePaths.defaultManifestPath,
     dryRun: false,
     terminalSurface: resolveDefaultTerminalSurface(
@@ -319,6 +324,7 @@ function parseArgs(argv) {
   let manifestOutProvided = false;
   let orchestratorBoardProvided = false;
   let executorProvided = false;
+  let terminalSurfaceProvided = false;
 
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -332,6 +338,7 @@ function parseArgs(argv) {
       options.dryRun = true;
     } else if (arg === "--terminal-surface") {
       options.terminalSurface = normalizeTerminalSurface(argv[++i], "--terminal-surface");
+      terminalSurfaceProvided = true;
     } else if (arg === "--no-dashboard") {
       options.dashboard = false;
     } else if (arg === "--cleanup-sessions") {
@@ -360,9 +367,11 @@ function parseArgs(argv) {
         project: options.project,
         adhocRunId: options.adhocRunId,
       });
-      options.terminalSurface = resolveDefaultTerminalSurface(
-        readProjectProfile({ config, project: options.project }),
-      );
+      if (!terminalSurfaceProvided) {
+        options.terminalSurface = resolveDefaultTerminalSurface(
+          readProjectProfile({ config, project: options.project }),
+        );
+      }
     } else if (arg === "--lane") {
       options.lane = String(argv[++i] || "").trim();
       lanePaths = buildLanePaths(options.lane, {
@@ -654,7 +663,7 @@ function recoverableFailureReason(failure, summary = null) {
     return statusCode;
   }
   const terminationReason = String(summary?.terminationReason || "").trim().toLowerCase();
-  if (["timeout", "max-turns", "session-missing"].includes(terminationReason)) {
+  if (["timeout", "max-turns"].includes(terminationReason)) {
     return terminationReason;
   }
   const detailText = `${failure?.detail || ""} ${summary?.terminationHint || ""}`.toLowerCase();
@@ -747,6 +756,23 @@ export async function runLauncherCli(argv) {
     return;
   }
   const { lanePaths, options } = parsed;
+  const supervisorRunId = String(process.env.WAVE_SUPERVISOR_RUN_ID || "").trim() || null;
+  const launcherProgressPath = launcherProgressPathForRun(lanePaths, supervisorRunId);
+  const writeLauncherRunProgress = (patch = {}) => {
+    if (!launcherProgressPath || !supervisorRunId) {
+      return null;
+    }
+    return updateLauncherProgress(
+      launcherProgressPath,
+      {
+        runId: supervisorRunId,
+        ...patch,
+      },
+      {
+        runId: supervisorRunId,
+      },
+    );
+  };
   if (!options.reconcileStatus) {
     await maybeAnnouncePackageUpdate();
   }
@@ -824,7 +850,7 @@ export async function runLauncherCli(argv) {
   }
 
   try {
-    const staleArtifactCleanup = reconcileStaleLauncherArtifacts(lanePaths, {
+    const staleArtifactCleanup = await reconcileStaleLauncherArtifacts(lanePaths, {
       terminalSurface: options.terminalSurface,
     });
     const context7BundleIndex = loadContext7BundleIndex(lanePaths.context7BundleIndexPath);
@@ -1036,6 +1062,18 @@ export async function runLauncherCli(argv) {
       feedbackRequestsDir: lanePaths.feedbackRequestsDir,
     });
     writeDashboardProjections({ lanePaths, globalDashboard });
+    writeLauncherRunProgress({
+      phase: "starting",
+      waveNumber: null,
+      attemptNumber: null,
+      selectedAgentIds: [],
+      launchedAgentIds: [],
+      completedAgentIds: [],
+      resumeFromPhase: null,
+      forwardedClosureGaps: [],
+      finalized: false,
+      finalDisposition: null,
+    });
 
     if (terminalRegistryEnabled && !options.keepTerminals) {
       const removed = removeLaneTemporaryTerminalEntries(lanePaths.terminalsPath, lanePaths);
@@ -1047,7 +1085,7 @@ export async function runLauncherCli(argv) {
     }
 
     if (options.cleanupSessions) {
-      const killed = cleanupLaneTmuxSessions(lanePaths);
+      const killed = await cleanupLaneTmuxSessions(lanePaths);
       if (killed.length > 0) {
         recordGlobalDashboardEvent(globalDashboard, {
           message: `Pre-run cleanup removed ${killed.length} stale tmux sessions for lane ${lanePaths.lane}.`,
@@ -1070,7 +1108,7 @@ export async function runLauncherCli(argv) {
         globalDashboardTerminalAppended = true;
         currentWaveDashboardTerminalAppended = true;
       }
-      launchWaveDashboardSession(lanePaths, {
+      await launchWaveDashboardSession(lanePaths, {
         sessionName: globalDashboardTerminalEntry.sessionName,
         dashboardPath: lanePaths.globalDashboardPath,
       });
@@ -1154,36 +1192,18 @@ export async function runLauncherCli(argv) {
       };
 
       try {
-        terminalEntries = createTemporaryTerminalEntries(
-          lanePaths,
-          wave.wave,
-          wave.agents,
-          runTag,
-          false,
-        );
-        if (terminalRegistryEnabled) {
-          appendTerminalEntries(lanePaths.terminalsPath, terminalEntries);
-          terminalsAppended = true;
-        }
-
         const agentRuns = wave.agents.map((agent) => {
           const safeName = `wave-${wave.wave}-${agent.slug}`;
-          const terminalName = `${lanePaths.terminalNamePrefix}${wave.wave}-${agent.slug}`;
-          const sessionName = terminalEntries.find(
-            (entry) => entry.terminalName === terminalName,
-          )?.sessionName;
-          if (!sessionName) {
-            throw new Error(`Failed to resolve session name for ${agent.agentId}`);
-          }
           return {
             agent,
             lane: lanePaths.lane,
             wave: wave.wave,
             resultsDir: lanePaths.resultsDir,
-            sessionName,
+            sessionName: createWaveAgentSessionName(lanePaths, wave.wave, agent.slug),
             promptPath: path.join(lanePaths.promptsDir, `${safeName}.prompt.md`),
             logPath: path.join(lanePaths.logsDir, `${safeName}.log`),
             statusPath: path.join(lanePaths.statusDir, `${safeName}.status`),
+            runtimePath: path.join(lanePaths.statusDir, `${safeName}.runtime.json`),
             previewPath: path.join(
               lanePaths.executorOverlaysDir,
               `wave-${wave.wave}`,
@@ -1198,6 +1218,17 @@ export async function runLauncherCli(argv) {
             inboxText: derivedState.inboxesByAgentId[agent.agentId]?.text || "",
           };
         });
+        terminalEntries = createTemporaryTerminalEntries(
+          lanePaths,
+          wave.wave,
+          agentRuns,
+          runTag,
+          false,
+        );
+        if (terminalRegistryEnabled) {
+          appendTerminalEntries(lanePaths.terminalsPath, terminalEntries);
+          terminalsAppended = true;
+        }
         const roleBindings = resolveWaveRoleBindings(wave, lanePaths, wave.agents);
 
         const refreshDerivedState = (attemptNumber = 0) => {
@@ -1207,7 +1238,12 @@ export async function runLauncherCli(argv) {
           }
           const summariesByAgentId = Object.fromEntries(
             agentRuns
-              .map((run) => [run.agent.agentId, readRunExecutionSummary(run, wave)])
+              .map((run) => [
+                run.agent.agentId,
+                readRunExecutionSummary(run, wave, {
+                  securityRolePromptPath: lanePaths.securityRolePromptPath,
+                }),
+              ])
               .filter(([, summary]) => summary),
           );
           const feedbackRequests = readWaveHumanFeedbackRequests({
@@ -1396,7 +1432,7 @@ export async function runLauncherCli(argv) {
         syncWaveSignals();
 
         if (options.dashboard && currentWaveDashboardTerminalEntry) {
-          launchWaveDashboardSession(lanePaths, {
+          await launchWaveDashboardSession(lanePaths, {
             sessionName: currentWaveDashboardTerminalEntry.sessionName,
             dashboardPath,
             messageBoardPath,
@@ -1431,6 +1467,7 @@ export async function runLauncherCli(argv) {
               promptPath: residentOrchestratorRun.promptPath,
               logPath: residentOrchestratorRun.logPath,
               statusPath: residentOrchestratorRun.statusPath,
+              runtimePath: residentOrchestratorRun.runtimePath,
               messageBoardPath: derivedState.messageBoardPath,
               messageBoardSnapshot: derivedState.messageBoardText,
               sharedSummaryPath: derivedState.sharedSummaryPath,
@@ -1444,18 +1481,19 @@ export async function runLauncherCli(argv) {
               agentRateLimitMaxDelaySeconds: options.agentRateLimitMaxDelaySeconds,
               context7Enabled: options.context7Enabled,
             });
-            residentOrchestratorRun.lastPromptHash = launchResult?.promptHash || null;
-            residentOrchestratorRun.lastExecutorId =
-              launchResult?.executorId || residentOrchestratorRun.agent.executorResolved?.id || null;
+            applyLaunchResultToRun(residentOrchestratorRun, launchResult, {
+              fallbackExecutorId: residentOrchestratorRun.agent.executorResolved?.id || null,
+              fallbackSkills: summarizeResolvedSkills(residentOrchestratorRun.agent.skillsResolved),
+            });
             recordCombinedEvent({
               agentId: residentOrchestratorRun.agent.agentId,
-              message: `Resident orchestrator launched in tmux session ${residentOrchestratorRun.sessionName}`,
+              message: `Resident orchestrator launched via ${launchResult?.sessionBackend || "process"} backend`,
             });
             appendCoordination({
               event: "resident_orchestrator_start",
               waves: [wave.wave],
               status: "running",
-              details: `session=${residentOrchestratorRun.sessionName}; executor=${residentOrchestratorRun.lastExecutorId || "unknown"}`,
+              details: `backend=${launchResult?.sessionBackend || "process"}; session=${residentOrchestratorRun.sessionName}; executor=${residentOrchestratorRun.lastExecutorId || "unknown"}`,
               actionRequested: "None",
             });
             syncWaveSignals();
@@ -1497,12 +1535,36 @@ export async function runLauncherCli(argv) {
         let traceAttempt = 1;
         let completionGateSnapshot = null;
         let completionTraceDir = null;
+        const terminalAgentIdsForWave = () =>
+          agentRuns
+            .filter((run) => readStatusRecordIfPresent(run.statusPath))
+            .map((run) => run.agent.agentId);
         recordWaveRunState(lanePaths, wave.wave, "started", {
           agentIds: wave.agents.map((agent) => agent.agentId),
           runVariant: lanePaths.runVariant || "live",
         });
+        writeLauncherRunProgress({
+          waveNumber: wave.wave,
+          attemptNumber: 0,
+          phase: "wave-started",
+          selectedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+          launchedAgentIds: [],
+          completedAgentIds: terminalAgentIdsForWave(),
+          finalized: false,
+          finalDisposition: null,
+        });
 
         while (attempt <= options.maxRetriesPerWave + 1) {
+          writeLauncherRunProgress({
+            waveNumber: wave.wave,
+            attemptNumber: attempt,
+            phase: "attempt-starting",
+            selectedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+            launchedAgentIds: [],
+            completedAgentIds: [],
+            finalized: false,
+            finalDisposition: null,
+          });
           refreshDerivedState(attempt - 1);
           lastLiveCoordinationRefreshAt = Date.now();
           dashboardState.attempt = attempt;
@@ -1569,6 +1631,7 @@ export async function runLauncherCli(argv) {
                 promptPath: runInfo.promptPath,
                 logPath: runInfo.logPath,
                 statusPath: runInfo.statusPath,
+                runtimePath: runInfo.runtimePath,
                 messageBoardPath: runInfo.messageBoardPath,
                 messageBoardSnapshot: runInfo.messageBoardSnapshot || "",
                 sharedSummaryPath: runInfo.sharedSummaryPath,
@@ -1596,19 +1659,27 @@ export async function runLauncherCli(argv) {
                   attempt,
                 },
               });
-              runInfo.lastLaunchAttempt = attempt;
-              runInfo.lastPromptHash = launchResult?.promptHash || null;
-              runInfo.lastContext7 = launchResult?.context7 || null;
-              runInfo.lastExecutorId = launchResult?.executorId || runInfo.agent.executorResolved?.id || null;
-              runInfo.lastSkillProjection =
-                launchResult?.skills || summarizeResolvedSkills(runInfo.agent.skillsResolved);
+              applyLaunchResultToRun(runInfo, launchResult, {
+                attempt,
+                fallbackExecutorId: runInfo.agent.executorResolved?.id || null,
+                fallbackSkills: summarizeResolvedSkills(runInfo.agent.skillsResolved),
+              });
+              writeLauncherRunProgress({
+                waveNumber: wave.wave,
+                attemptNumber: attempt,
+                phase: "attempt-running",
+                selectedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+                launchedAgentIds: runsToLaunch
+                  .filter((run) => run.lastLaunchAttempt === attempt)
+                  .map((run) => run.agent.agentId),
+              });
               setWaveDashboardAgent(dashboardState, runInfo.agent.agentId, {
                 state: "running",
                 detail: "Session launched",
               });
               recordCombinedEvent({
                 agentId: runInfo.agent.agentId,
-                message: `Launched in tmux session ${runInfo.sessionName}`,
+                message: `Launched via ${launchResult?.sessionBackend || "process"} backend`,
               });
               const context7Mode = launchResult?.context7?.mode || "none";
               if (runInfo.agent.context7Resolved?.bundleId !== "none") {
@@ -1678,9 +1749,23 @@ export async function runLauncherCli(argv) {
             timedOut = waitResult.timedOut;
           }
 
-          materializeAgentExecutionSummaries(wave, agentRuns);
+          materializeAgentExecutionSummaries(wave, agentRuns, {
+            securityRolePromptPath: lanePaths.securityRolePromptPath,
+          });
           failures = annotateFailuresWithRecoveryHints(failures, agentRuns);
           refreshDerivedState(attempt);
+          const reducerDecisionForProgress = latestReducerSnapshot || refreshReducerSnapshot(attempt);
+          writeLauncherRunProgress({
+            waveNumber: wave.wave,
+            attemptNumber: attempt,
+            phase: failures.length === 0 ? "attempt-succeeded" : "attempt-failed",
+            selectedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+            launchedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+            completedAgentIds: terminalAgentIdsForWave(),
+            resumeFromPhase: reducerDecisionForProgress?.resumePlan?.resumeFromPhase || null,
+            forwardedClosureGaps: reducerDecisionForProgress?.resumePlan?.forwardedClosureGaps || [],
+            gateSnapshotSummary: reducerDecisionForProgress?.reducerState?.gateSnapshot?.overall || null,
+          });
           syncWaveSignals();
           lastLiveCoordinationRefreshAt = Date.now();
           emitCoordinationAlertEvents(derivedState);
@@ -1765,7 +1850,9 @@ export async function runLauncherCli(argv) {
               }
             }
             if (failures.length === 0) {
-              const implementationGate = readWaveImplementationGate(wave, agentRuns);
+              const implementationGate = readWaveImplementationGate(wave, agentRuns, {
+                securityRolePromptPath: lanePaths.securityRolePromptPath,
+              });
               if (!implementationGate.ok) {
                 failures = [
                   {
@@ -1889,7 +1976,9 @@ export async function runLauncherCli(argv) {
                     });
                     failures = closureResult.failures;
                     timedOut = timedOut || closureResult.timedOut;
-                    materializeAgentExecutionSummaries(wave, agentRuns);
+                    materializeAgentExecutionSummaries(wave, agentRuns, {
+                      securityRolePromptPath: lanePaths.securityRolePromptPath,
+                    });
                     failures = annotateFailuresWithRecoveryHints(failures, agentRuns);
                     refreshDerivedState(attempt);
                   }
@@ -2097,6 +2186,19 @@ export async function runLauncherCli(argv) {
               runs: runsToLaunch,
               failures,
               derivedState,
+              resumePlan: (latestReducerSnapshot || refreshReducerSnapshot(attempt))?.resumePlan || null,
+            });
+            writeLauncherRunProgress({
+              waveNumber: wave.wave,
+              attemptNumber: attempt,
+              phase: "waiting-shared-component",
+              selectedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+              launchedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+              completedAgentIds: terminalAgentIdsForWave(),
+              resumeFromPhase:
+                (latestReducerSnapshot || refreshReducerSnapshot(attempt))?.resumePlan?.resumeFromPhase || null,
+              forwardedClosureGaps:
+                (latestReducerSnapshot || refreshReducerSnapshot(attempt))?.resumePlan?.forwardedClosureGaps || [],
             });
             flushDashboards();
             traceAttempt += 1;
@@ -2121,6 +2223,16 @@ export async function runLauncherCli(argv) {
             updateWaveDashboardMessageBoard(dashboardState, messageBoardPath);
             flushDashboards();
             await flushWaveControlTelemetry();
+            writeLauncherRunProgress({
+              waveNumber: wave.wave,
+              attemptNumber: attempt,
+              phase: "wave-completed",
+              selectedAgentIds: [],
+              launchedAgentIds: [],
+              completedAgentIds: terminalAgentIdsForWave(),
+              resumeFromPhase: "completed",
+              forwardedClosureGaps: [],
+            });
             break;
           }
 
@@ -2179,6 +2291,7 @@ export async function runLauncherCli(argv) {
                   runs: recoveryPlan.selectedRuns,
                   failures,
                   derivedState,
+                  resumePlan: reducerDecision?.resumePlan || null,
                 });
               }
               recordAttemptState(lanePaths, wave.wave, attempt, "failed", {
@@ -2218,6 +2331,16 @@ export async function runLauncherCli(argv) {
                 actionRequested:
                   `Lane ${lanePaths.lane} owners should resume the queued targeted recovery or let autonomous relaunch the selected agents.`,
               });
+              writeLauncherRunProgress({
+                waveNumber: wave.wave,
+                attemptNumber: attempt,
+                phase: "recovery-queued",
+                selectedAgentIds: recoverySelectedAgentIds,
+                launchedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+                completedAgentIds: terminalAgentIdsForWave(),
+                resumeFromPhase: reducerDecision?.resumePlan?.resumeFromPhase || null,
+                forwardedClosureGaps: reducerDecision?.resumePlan?.forwardedClosureGaps || [],
+              });
               await flushWaveControlTelemetry();
               const error = new Error(
                 `Wave ${wave.wave} queued targeted recovery request ${queuedRecovery.requestId} after recoverable execution failures.`,
@@ -2386,6 +2509,19 @@ export async function runLauncherCli(argv) {
             runs: runsToLaunch,
             failures,
             derivedState,
+            resumePlan: (latestReducerSnapshot || refreshReducerSnapshot(attempt))?.resumePlan || null,
+          });
+          writeLauncherRunProgress({
+            waveNumber: wave.wave,
+            attemptNumber: attempt + 1,
+            phase: "retry-queued",
+            selectedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+            launchedAgentIds: [],
+            completedAgentIds: terminalAgentIdsForWave(),
+            resumeFromPhase:
+              (latestReducerSnapshot || refreshReducerSnapshot(attempt))?.resumePlan?.resumeFromPhase || null,
+            forwardedClosureGaps:
+              (latestReducerSnapshot || refreshReducerSnapshot(attempt))?.resumePlan?.forwardedClosureGaps || [],
           });
           flushDashboards();
           attempt += 1;
@@ -2418,7 +2554,7 @@ export async function runLauncherCli(argv) {
         });
       } finally {
         if (residentOrchestratorRun) {
-          killTmuxSessionIfExists(lanePaths.tmuxSocketName, residentOrchestratorRun.sessionName);
+          await cleanupLaunchedRun(lanePaths, residentOrchestratorRun);
         }
         if (terminalsAppended && !options.keepTerminals) {
           removeTerminalEntries(lanePaths.terminalsPath, terminalEntries);
@@ -2431,7 +2567,7 @@ export async function runLauncherCli(argv) {
           if (currentWaveDashboardTerminalEntry) {
             excludeSessionNames.add(currentWaveDashboardTerminalEntry.sessionName);
           }
-          cleanupLaneTmuxSessions(lanePaths, { excludeSessionNames });
+          await cleanupLaneTmuxSessions(lanePaths, { excludeSessionNames });
         }
         if (globalWave && globalWave.status === "running") {
           globalWave.status = dashboardState?.status || "failed";
@@ -2446,6 +2582,12 @@ export async function runLauncherCli(argv) {
     globalDashboard.status = "completed";
     recordGlobalDashboardEvent(globalDashboard, { message: "All selected waves completed." });
     writeDashboardProjections({ lanePaths, globalDashboard });
+    writeLauncherRunProgress({
+      phase: "completed",
+      finalized: true,
+      finalDisposition: "completed",
+      exitCode: 0,
+    });
     appendCoordination({
       event: "launcher_finish",
       waves: selectedWavesForCoordination,
@@ -2460,6 +2602,12 @@ export async function runLauncherCli(argv) {
       appendCoordination,
       error,
     );
+    writeLauncherRunProgress({
+      phase: "failed",
+      finalized: true,
+      finalDisposition: "failed",
+      exitCode: Number.isInteger(error?.exitCode) ? error.exitCode : 1,
+    });
     writeDashboardProjections({ lanePaths, globalDashboard });
     throw error;
   } finally {
@@ -2475,14 +2623,14 @@ export async function runLauncherCli(argv) {
     }
     if (options.cleanupSessions && globalDashboardTerminalEntry) {
       try {
-        killTmuxSessionIfExists(lanePaths.tmuxSocketName, globalDashboardTerminalEntry.sessionName);
+        await killTmuxSessionIfExists(lanePaths.tmuxSocketName, globalDashboardTerminalEntry.sessionName);
       } catch {
         // no-op
       }
     }
     if (options.cleanupSessions && currentWaveDashboardTerminalEntry) {
       try {
-        killTmuxSessionIfExists(
+        await killTmuxSessionIfExists(
           lanePaths.tmuxSocketName,
           currentWaveDashboardTerminalEntry.sessionName,
         );

package/scripts/wave-orchestrator/ledger.mjs

@@ -54,6 +54,7 @@ export function buildSeedWaveLedger({
   contEvalAgentId = DEFAULT_CONT_EVAL_AGENT_ID,
   integrationAgentId = DEFAULT_INTEGRATION_AGENT_ID,
   documentationAgentId = DEFAULT_DOCUMENTATION_AGENT_ID,
+  securityRolePromptPath = null,
 }) {
   const tasks = [];
   for (const agent of wave.agents) {
@@ -69,7 +70,7 @@ export function buildSeedWaveLedger({
             ? "documentation"
             : isDesignAgent(agent)
               ? "design"
-            : isSecurityReviewAgent(agent)
+            : isSecurityReviewAgent(agent, { securityRolePromptPath })
               ? "security"
               : "implementation";
     const runtime = agent.executorResolved
@@ -220,6 +221,7 @@ export function deriveWaveLedger({
   benchmarkCatalogPath = null,
   capabilityAssignments = [],
   dependencySnapshot = null,
+  securityRolePromptPath = null,
 }) {
   const seed = buildSeedWaveLedger({
     lane,
@@ -228,6 +230,7 @@ export function deriveWaveLedger({
     contEvalAgentId,
     integrationAgentId,
     documentationAgentId,
+    securityRolePromptPath,
   });
   const primaryTasks = seed.tasks.map((task) => {
     const agent = wave.agents.find((item) => item.agentId === task.owner);
@@ -343,7 +346,9 @@ export function deriveWaveLedger({
   const docAgent = wave.agents.find((agent) => agent.agentId === documentationAgentId);
   const contEvalAgent = wave.agents.find((agent) => agent.agentId === contEvalAgentId);
   const contQaAgent = wave.agents.find((agent) => agent.agentId === contQaAgentId);
-  const securityAgents = (wave.agents || []).filter((agent) => isSecurityReviewAgent(agent));
+  const securityAgents = (wave.agents || []).filter((agent) =>
+    isSecurityReviewAgent(agent, { securityRolePromptPath }),
+  );
   const contEvalValidation = (() => {
     if (!contEvalAgent) {
       return { ok: true };

package/scripts/wave-orchestrator/planner.mjs

@@ -2625,6 +2625,7 @@ async function runAgenticDraftFlow(options = {}) {
     request,
   });
   const plannerContext7Prefetch = await prefetchContext7ForSelection(plannerContext7Selection, {
+    lanePaths,
     cacheDir: lanePaths.context7CacheDir,
   });
   const promptText = buildPlannerPromptText({