@chllming/wave-orchestration 0.8.6 → 0.8.8

package/scripts/wave-orchestrator/control-plane.mjs

@@ -11,6 +11,8 @@ import {
 import {
   CLARIFICATION_CLOSURE_PREFIX,
   buildCoordinationResponseMetrics,
+  coordinationBlockerSeverity,
+  coordinationRecordBlocksWave,
 } from "./coordination-store.mjs";
 import {
   DEFAULT_COORDINATION_ACK_TIMEOUT_MS,
@@ -586,6 +588,8 @@ export function buildTaskSnapshots({
     const metrics = responseMetrics.recordMetricsById.get(record.id) || {};
     const feedbackRequest = feedbackById.get(record.id) || null;
     const taskState = taskStateForCoordinationRecord(record, feedbackRequest);
+    const blocking = coordinationRecordBlocksWave(record);
+    const blockerSeverity = coordinationBlockerSeverity(record);
     tasks.push({
       taskId: record.id,
       sourceRecordId: record.id,
@@ -598,6 +602,8 @@ export function buildTaskSnapshots({
       assigneeAgentId: firstTargetAgentId(record),
       leaseOwnerAgentId:
         ["acknowledged", "in_progress"].includes(record.status) ? firstTargetAgentId(record) : null,
+      blocking,
+      blockerSeverity,
       needsHuman:
         record.kind === "human-feedback" ||
         feedbackRequest?.status === "pending" ||
@@ -627,7 +633,7 @@ export function buildTaskSnapshots({
           ? feedbackRequest?.updatedAt || record.updatedAt || record.createdAt
           : null,
       overdueAck: metrics.overdueAck === true,
-      stale: metrics.staleClarification === true,
+      stale: metrics.staleClarification === true || blockerSeverity === "stale",
       feedbackRequestId: feedbackRequest?.id || null,
       humanResponse: feedbackRequest?.responseText || null,
       humanOperator: feedbackRequest?.responseOperator || null,
@@ -648,6 +654,8 @@ export function buildTaskSnapshots({
       ownerAgentId: request.agentId || null,
       assigneeAgentId: request.agentId || null,
       leaseOwnerAgentId: null,
+      blocking: true,
+      blockerSeverity: "hard",
       needsHuman: request.status !== "answered",
       dependsOn: [],
       evidenceRefs: [],
@@ -676,6 +684,9 @@ export function buildTaskSnapshots({
 export function nextTaskDeadline(tasks) {
   const candidates = [];
   for (const task of tasks || []) {
+    if (task?.blocking === false) {
+      continue;
+    }
     for (const [kind, value] of [
       ["ack", task.ackDeadlineAt],
       ["resolve", task.resolveDeadlineAt],

package/scripts/wave-orchestrator/coordination-store.mjs

@@ -43,7 +43,17 @@ export const COORDINATION_STATUS_VALUES = [
 
 export const COORDINATION_PRIORITY_VALUES = ["low", "normal", "high", "urgent"];
 export const COORDINATION_CONFIDENCE_VALUES = ["low", "medium", "high"];
+export const COORDINATION_BLOCKER_SEVERITY_VALUES = [
+  "hard",
+  "soft",
+  "stale",
+  "advisory",
+  "proof-critical",
+  "closure-critical",
+];
 const OPEN_COORDINATION_STATUSES = new Set(["open", "acknowledged", "in_progress"]);
+const NON_BLOCKING_BLOCKER_SEVERITIES = new Set(["stale", "advisory"]);
+const HARD_BLOCKER_SEVERITIES = new Set(["hard", "proof-critical", "closure-critical"]);
 export const CLARIFICATION_CLOSURE_PREFIX = "clarification:";
 
 function normalizeString(value, fallback = "") {
@@ -65,6 +75,23 @@ function normalizeStringArray(values) {
   );
 }
 
+function normalizeOptionalBoolean(value, fallback = null) {
+  if (value === undefined || value === null || value === "") {
+    return fallback;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "n", "off"].includes(normalized)) {
+    return false;
+  }
+  return Boolean(value);
+}
+
 function validateEnum(value, allowed, label) {
   if (!allowed.includes(value)) {
     throw new Error(`${label} must be one of ${allowed.join(", ")} (got: ${value || "empty"})`);
@@ -75,6 +102,74 @@ function stableId(prefix) {
   return `${prefix}-${crypto.randomBytes(4).toString("hex")}`;
 }
 
+function defaultBlockingForKind(kind) {
+  return ["request", "blocker", "clarification-request", "human-escalation", "human-feedback"].includes(
+    kind,
+  );
+}
+
+function defaultSeverityForRecord(kind, priority, blocking) {
+  if (blocking === false) {
+    return "advisory";
+  }
+  if (kind === "human-escalation" || kind === "human-feedback") {
+    return "hard";
+  }
+  if (kind === "request" || kind === "clarification-request") {
+    return "closure-critical";
+  }
+  if (kind === "blocker") {
+    return ["high", "urgent"].includes(priority) ? "hard" : "soft";
+  }
+  return "advisory";
+}
+
+function normalizeBlockerSeverity(value, defaults = {}) {
+  const normalized = normalizeString(value ?? defaults.blockerSeverity, "").toLowerCase();
+  return normalized || null;
+}
+
+export function coordinationBlockerSeverity(record) {
+  if (!record || typeof record !== "object") {
+    return "advisory";
+  }
+  const blocking =
+    record.blocking === undefined || record.blocking === null
+      ? defaultBlockingForKind(String(record.kind || "").trim().toLowerCase())
+      : record.blocking !== false;
+  const explicitSeverity = normalizeBlockerSeverity(record.blockerSeverity);
+  const derivedSeverity =
+    explicitSeverity ||
+    defaultSeverityForRecord(
+      String(record.kind || "").trim().toLowerCase(),
+      String(record.priority || "normal").trim().toLowerCase(),
+      blocking,
+    );
+  if (COORDINATION_BLOCKER_SEVERITY_VALUES.includes(derivedSeverity)) {
+    return derivedSeverity;
+  }
+  return defaultSeverityForRecord(
+    String(record.kind || "").trim().toLowerCase(),
+    String(record.priority || "normal").trim().toLowerCase(),
+    blocking,
+  );
+}
+
+export function coordinationRecordBlocksWave(record) {
+  if (!record || !isOpenCoordinationStatus(record.status)) {
+    return false;
+  }
+  if (record.blocking === false) {
+    return false;
+  }
+  return !NON_BLOCKING_BLOCKER_SEVERITIES.has(coordinationBlockerSeverity(record));
+}
+
+export function coordinationRecordIsHardBlocker(record) {
+  return coordinationRecordBlocksWave(record) &&
+    HARD_BLOCKER_SEVERITIES.has(coordinationBlockerSeverity(record));
+}
+
 export function normalizeCoordinationRecord(rawRecord, defaults = {}) {
   if (!rawRecord || typeof rawRecord !== "object" || Array.isArray(rawRecord)) {
     throw new Error("Coordination record must be an object");
@@ -93,12 +188,25 @@ export function normalizeCoordinationRecord(rawRecord, defaults = {}) {
   ).toLowerCase();
   const priority = normalizeString(rawRecord.priority || defaults.priority || "normal").toLowerCase();
   const confidence = normalizeString(rawRecord.confidence || defaults.confidence || "medium").toLowerCase();
+  const explicitBlocking = normalizeOptionalBoolean(
+    rawRecord.blocking,
+    normalizeOptionalBoolean(defaults.blocking, null),
+  );
+  const blocking = explicitBlocking ?? defaultBlockingForKind(kind);
+  const blockerSeverity =
+    normalizeBlockerSeverity(rawRecord.blockerSeverity, defaults) ||
+    defaultSeverityForRecord(kind, priority, blocking);
   const createdAt = normalizeString(rawRecord.createdAt || defaults.createdAt || now);
   const updatedAt = normalizeString(rawRecord.updatedAt || defaults.updatedAt || createdAt);
   validateEnum(kind, COORDINATION_KIND_VALUES, "Coordination kind");
   validateEnum(status, COORDINATION_STATUS_VALUES, "Coordination status");
   validateEnum(priority, COORDINATION_PRIORITY_VALUES, "Coordination priority");
   validateEnum(confidence, COORDINATION_CONFIDENCE_VALUES, "Coordination confidence");
+  validateEnum(
+    blockerSeverity,
+    COORDINATION_BLOCKER_SEVERITY_VALUES,
+    "Coordination blockerSeverity",
+  );
   if (!lane) {
     throw new Error("Coordination lane is required");
   }
@@ -118,6 +226,8 @@ export function normalizeCoordinationRecord(rawRecord, defaults = {}) {
     targets: normalizeStringArray(rawRecord.targets ?? defaults.targets),
     status,
     priority,
+    blocking,
+    blockerSeverity,
     artifactRefs: normalizeStringArray(rawRecord.artifactRefs ?? defaults.artifactRefs),
     dependsOn: normalizeStringArray(rawRecord.dependsOn ?? defaults.dependsOn),
     closureCondition: normalizeString(rawRecord.closureCondition ?? defaults.closureCondition, ""),
@@ -180,6 +290,8 @@ export function appendCoordinationRecord(filePath, rawRecord, defaults = {}) {
           kind: record.kind,
           status: record.status,
           priority: record.priority,
+          blocking: record.blocking !== false,
+          blockerSeverity: record.blockerSeverity,
           confidence: record.confidence,
           summary: record.summary,
           detail: record.detail,
@@ -416,15 +528,16 @@ export function buildCoordinationResponseMetrics(state, options = {}) {
   for (const record of state?.openRecords || []) {
     const startMs = parseRecordStartMs(record);
     const ageMs = Number.isFinite(startMs) ? Math.max(0, nowMs - startMs) : null;
-    const ackTracked = isAckTrackedRecord(record);
+    const blocking = coordinationRecordBlocksWave(record);
+    const ackTracked = blocking && isAckTrackedRecord(record);
     const ackPending = ackTracked && record.status === "open";
     const clarificationLinked =
-      record.kind === "clarification-request" || isClarificationLinkedRequest(record);
+      blocking && (record.kind === "clarification-request" || isClarificationLinkedRequest(record));
     const overdueAck = ackPending && Number.isFinite(ageMs) && ageMs >= ackTimeoutMs;
     const staleClarification =
       clarificationLinked && Number.isFinite(ageMs) && ageMs >= resolutionStaleMs;
 
-    if (Number.isFinite(ageMs)) {
+    if (blocking && Number.isFinite(ageMs)) {
       oldestOpenCoordinationAgeMs =
         oldestOpenCoordinationAgeMs === null
           ? ageMs
@@ -454,6 +567,7 @@ export function buildCoordinationResponseMetrics(state, options = {}) {
       overdueAck,
       clarificationLinked,
       staleClarification,
+      blocking,
     });
   }
 
@@ -469,7 +583,7 @@ export function buildCoordinationResponseMetrics(state, options = {}) {
       a.localeCompare(b),
     ),
     openHumanEscalationCount: (state?.humanEscalations || []).filter((record) =>
-      isOpenCoordinationStatus(record.status),
+      coordinationRecordBlocksWave(record),
     ).length,
     recordMetricsById,
   };
@@ -490,6 +604,12 @@ function renderOpenRecord(record, responseMetrics = null) {
   if (recordMetrics?.staleClarification) {
     tags.push("stale-clarification");
   }
+  if (record.blocking === false) {
+    tags.push("non-blocking");
+  }
+  if (record.blockerSeverity) {
+    tags.push(`severity=${record.blockerSeverity}`);
+  }
   const timing = tags.length > 0 ? ` [${tags.join(", ")}]` : "";
   return `- [${record.priority}] ${record.kind}/${record.status} ${record.agentId}${targets}${timing} id=${record.id}: ${compactSingleLine(record.summary || record.detail || "no summary", 160)}${artifacts}`;
 }

package/scripts/wave-orchestrator/executors.mjs

@@ -305,6 +305,7 @@ function buildLaunchLimitsMetadata(agent) {
   const executor = agent?.executorResolved || {};
   const executorId = normalizeExecutorMode(executor.id || DEFAULT_EXECUTOR_MODE);
   const attemptTimeoutMinutes = executor?.budget?.minutes ?? null;
+  const advisoryTurnBudget = executor?.budget?.turns ?? null;
   if (executorId === "claude") {
     const source = executor?.claude?.maxTurnsSource || null;
     return {
@@ -312,9 +313,11 @@ function buildLaunchLimitsMetadata(agent) {
       knownTurnLimit: executor?.claude?.maxTurns ?? null,
       turnLimitSource: source,
       notes:
-        source === "budget.turns"
-          ? ["Known turn limit was derived from generic budget.turns."]
-          : [],
+        source
+          ? []
+          : advisoryTurnBudget !== null
+            ? ["Generic budget.turns remained advisory; Wave emitted no Claude --max-turns flag."]
+            : [],
     };
   }
   if (executorId === "opencode") {
@@ -324,9 +327,11 @@ function buildLaunchLimitsMetadata(agent) {
       knownTurnLimit: executor?.opencode?.steps ?? null,
       turnLimitSource: source,
       notes:
-        source === "budget.turns"
-          ? ["Known turn limit was derived from generic budget.turns."]
-          : [],
+        source
+          ? []
+          : advisoryTurnBudget !== null
+            ? ["Generic budget.turns remained advisory; Wave emitted no OpenCode --steps flag."]
+            : [],
     };
   }
   if (executorId === "codex") {

package/scripts/wave-orchestrator/gate-engine.mjs

@@ -49,7 +49,7 @@ import {
   validateWaveComponentMatrixCurrentLevels,
 } from "./wave-files.mjs";
 import {
-  isOpenCoordinationStatus,
+  coordinationRecordBlocksWave,
   openClarificationLinkedRequests,
 } from "./coordination-store.mjs";
 import { contradictionsBlockingGate } from "./contradiction-entity.mjs";
@@ -998,7 +998,7 @@ export function readWaveIntegrationBarrier(wave, agentRuns, derivedState, option
 
 export function readClarificationBarrier(derivedState) {
   const openClarifications = (derivedState?.coordinationState?.clarifications || []).filter(
-    (record) => isOpenCoordinationStatus(record.status),
+    (record) => coordinationRecordBlocksWave(record),
   );
   if (openClarifications.length > 0) {
     return {
@@ -1009,7 +1009,7 @@ export function readClarificationBarrier(derivedState) {
   }
   const openClarificationRequests = openClarificationLinkedRequests(
     derivedState?.coordinationState,
-  );
+  ).filter((record) => coordinationRecordBlocksWave(record));
   if (openClarificationRequests.length > 0) {
     return {
       ok: false,
@@ -1019,10 +1019,10 @@ export function readClarificationBarrier(derivedState) {
   }
   const pendingHuman = [
     ...((derivedState?.coordinationState?.humanEscalations || []).filter((record) =>
-      isOpenCoordinationStatus(record.status),
+      coordinationRecordBlocksWave(record),
     )),
     ...((derivedState?.coordinationState?.humanFeedback || []).filter((record) =>
-      isOpenCoordinationStatus(record.status),
+      coordinationRecordBlocksWave(record),
     )),
   ];
   if (pendingHuman.length > 0) {

package/scripts/wave-orchestrator/launcher-runtime.mjs

@@ -235,7 +235,7 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
       "const fs=require('node:fs'); const statusPath=process.argv[1]; const payload={code:Number(process.argv[2]),promptHash:process.argv[3]||null,orchestratorId:process.argv[4]||null,attempt:Number(process.argv[5])||1,completedAt:new Date().toISOString()}; fs.writeFileSync(statusPath, JSON.stringify(payload, null, 2)+'\\n', 'utf8');",
     )} ${shellQuote(statusPath)} "$status" ${shellQuote(promptHash)} ${shellQuote(orchestratorId || "")} ${shellQuote(String(attempt || 1))}`,
     `echo "[${lanePaths.lane}-wave-launcher] ${sessionName} finished with code $status"`,
-    "exec bash -l",
+    "exit \"$status\"",
   ].join("\n");
 
   runTmuxFn(

package/scripts/wave-orchestrator/launcher.mjs

@@ -16,6 +16,7 @@ import {
   readWaveHumanFeedbackRequests,
 } from "./coordination.mjs";
 import {
+  appendCoordinationRecord,
   buildCoordinationResponseMetrics,
 } from "./coordination-store.mjs";
 import {
@@ -122,6 +123,7 @@ import {
 import {
   clearWaveRetryOverride,
   readWaveRetryOverride,
+  writeWaveRetryOverride,
 } from "./retry-control.mjs";
 import { appendWaveControlEvent, readControlPlaneEvents } from "./control-plane.mjs";
 import { materializeContradictionsFromControlPlaneEvents } from "./contradiction-entity.mjs";
@@ -578,6 +580,100 @@ function buildFailureFromGate(gateName, gate, fallbackLogPath) {
   };
 }
 
+function normalizeFailureStatusCode(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function recoverableFailureReason(failure, summary = null) {
+  const statusCode = normalizeFailureStatusCode(failure?.statusCode);
+  if (["timeout-no-status", "timed_out", "missing-status"].includes(statusCode)) {
+    return statusCode;
+  }
+  const terminationReason = String(summary?.terminationReason || "").trim().toLowerCase();
+  if (["timeout", "max-turns", "session-missing"].includes(terminationReason)) {
+    return terminationReason;
+  }
+  const detailText = `${failure?.detail || ""} ${summary?.terminationHint || ""}`.toLowerCase();
+  if (detailText.includes("rate limit") || detailText.includes("429 too many requests")) {
+    return "rate-limit";
+  }
+  return null;
+}
+
+function annotateFailuresWithRecoveryHints(failures, agentRuns) {
+  const runsByAgentId = new Map((agentRuns || []).map((run) => [run.agent.agentId, run]));
+  return (failures || []).map((failure) => {
+    const run = failure?.agentId ? runsByAgentId.get(failure.agentId) : null;
+    const summary = run
+      ? readAgentExecutionSummary(run.statusPath, {
+          agent: run.agent,
+          statusPath: run.statusPath,
+          statusRecord: readStatusRecordIfPresent(run.statusPath),
+          logPath: fs.existsSync(run.logPath) ? run.logPath : null,
+        })
+      : null;
+    const recoveryReason = recoverableFailureReason(failure, summary);
+    return {
+      ...failure,
+      detail: failure?.detail || summary?.terminationHint || null,
+      terminationReason: summary?.terminationReason || null,
+      terminationHint: summary?.terminationHint || null,
+      observedTurnLimit:
+        Number.isFinite(Number(summary?.terminationObservedTurnLimit))
+          ? Number(summary.terminationObservedTurnLimit)
+          : null,
+      recoverable: Boolean(recoveryReason),
+      recoveryReason,
+    };
+  });
+}
+
+function failuresAreRecoverable(failures) {
+  return Array.isArray(failures) && failures.length > 0 && failures.every((failure) => failure?.recoverable);
+}
+
+function appendRepairCoordinationRequests({
+  coordinationLogPath,
+  lanePaths,
+  wave,
+  attempt,
+  runs,
+  failures,
+}) {
+  const selectedRuns = Array.isArray(runs) ? runs : [];
+  const failureByAgentId = new Map(
+    (failures || [])
+      .filter((failure) => failure?.agentId)
+      .map((failure) => [failure.agentId, failure]),
+  );
+  for (const run of selectedRuns) {
+    const agentId = run?.agent?.agentId;
+    if (!agentId) {
+      continue;
+    }
+    const failure = failureByAgentId.get(agentId) || null;
+    appendCoordinationRecord(coordinationLogPath, {
+      id: `repair-wave-${wave.wave}-attempt-${attempt}-${agentId}`,
+      lane: lanePaths.lane,
+      wave: wave.wave,
+      agentId: "launcher",
+      kind: "request",
+      targets: [`agent:${agentId}`],
+      priority: "normal",
+      summary: failure
+        ? `Repair ${agentId}: ${failure.recoveryReason || failure.statusCode}`
+        : `Repair ${agentId}: targeted follow-up`,
+      detail: failure
+        ? `Targeted recovery for ${agentId} after ${failure.recoveryReason || failure.statusCode}. ${failure.detail || "Resume the bounded follow-up work and preserve reusable proof from other agents."}`
+        : `Targeted recovery for ${agentId}. Resume the bounded follow-up work and preserve reusable proof from other agents.`,
+      status: "open",
+      source: "launcher",
+      blocking: false,
+      blockerSeverity: "soft",
+    });
+  }
+}
+
 // --- Main entry point ---
 
 export async function runLauncherCli(argv) {
@@ -1519,6 +1615,7 @@ export async function runLauncherCli(argv) {
           }
 
           materializeAgentExecutionSummaries(wave, agentRuns);
+          failures = annotateFailuresWithRecoveryHints(failures, agentRuns);
           refreshDerivedState(attempt);
           syncWaveSignals();
           lastLiveCoordinationRefreshAt = Date.now();
@@ -1706,6 +1803,7 @@ export async function runLauncherCli(argv) {
                   failures = closureResult.failures;
                   timedOut = timedOut || closureResult.timedOut;
                   materializeAgentExecutionSummaries(wave, agentRuns);
+                  failures = annotateFailuresWithRecoveryHints(failures, agentRuns);
                   refreshDerivedState(attempt);
                 }
               } else {
@@ -1896,6 +1994,14 @@ export async function runLauncherCli(argv) {
                 detail: "Queued for shared component closure",
               });
             }
+            appendRepairCoordinationRequests({
+              coordinationLogPath: derivedState.coordinationLogPath,
+              lanePaths,
+              wave,
+              attempt,
+              runs: runsToLaunch,
+              failures,
+            });
             writeWaveRelaunchProjection({
               lanePaths,
               wave,
@@ -1931,6 +2037,106 @@ export async function runLauncherCli(argv) {
           }
 
           if (attempt >= options.maxRetriesPerWave + 1) {
+            const reducerDecision =
+              latestReducerSnapshot || refreshReducerSnapshot(attempt);
+            const recoveryPlan = planRetryWaveAttempt({
+              agentRuns,
+              failures,
+              derivedState,
+              lanePaths,
+              wave,
+              retryOverride: readWaveRetryOverride(lanePaths, wave.wave),
+              waveState: reducerDecision?.reducerState || null,
+            });
+            const recoverySelectedAgentIds = Array.from(
+              new Set([
+                ...((recoveryPlan.selectedRuns || []).map((run) => run.agent.agentId)),
+                ...((reducerDecision?.resumePlan?.invalidatedAgentIds || []).filter(Boolean)),
+                ...((failures || []).map((failure) => failure.agentId).filter(Boolean)),
+              ]),
+            );
+            if (failuresAreRecoverable(failures) && recoverySelectedAgentIds.length > 0) {
+              const resumeCursor =
+                reducerDecision?.resumePlan?.resumeFromPhase &&
+                reducerDecision.resumePlan.resumeFromPhase !== "completed"
+                  ? reducerDecision.resumePlan.resumeFromPhase
+                  : null;
+              const queuedRecovery = writeWaveRetryOverride(lanePaths, wave.wave, {
+                lane: lanePaths.lane,
+                wave: wave.wave,
+                selectedAgentIds: recoverySelectedAgentIds,
+                resumeCursor,
+                clearReusableAgentIds: Array.from(
+                  new Set((failures || []).map((failure) => failure.agentId).filter(Boolean)),
+                ),
+                preserveReusableAgentIds: reducerDecision?.resumePlan?.reusableAgentIds || [],
+                reuseProofBundleIds: reducerDecision?.resumePlan?.reusableProofBundleIds || [],
+                requestedBy: "launcher-recovery",
+                reason: `Auto recovery queued after recoverable execution issue(s): ${(failures || []).map((failure) => `${failure.agentId || "wave"}:${failure.recoveryReason || failure.statusCode}`).join(", ")}.`,
+                applyOnce: true,
+              });
+              appendRepairCoordinationRequests({
+                coordinationLogPath: derivedState.coordinationLogPath,
+                lanePaths,
+                wave,
+                attempt: attempt + 1,
+                runs: agentRuns.filter((run) => recoverySelectedAgentIds.includes(run.agent.agentId)),
+                failures,
+              });
+              if (recoveryPlan.selectedRuns.length > 0) {
+                writeWaveRelaunchProjection({
+                  lanePaths,
+                  wave,
+                  attempt: attempt + 1,
+                  runs: recoveryPlan.selectedRuns,
+                  failures,
+                  derivedState,
+                });
+              }
+              recordAttemptState(lanePaths, wave.wave, attempt, "failed", {
+                selectedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
+                detail: failures
+                  .map((failure) => `${failure.agentId || "wave"}:${failure.recoveryReason || failure.statusCode}`)
+                  .join(", "),
+              });
+              recordWaveRunState(lanePaths, wave.wave, "blocked", {
+                attempts: attempt,
+                traceDir: completionTraceDir ? path.relative(REPO_ROOT, completionTraceDir) : null,
+                gateSnapshot: completionGateSnapshot,
+                recoverable: true,
+                rerunRequestId: queuedRecovery.requestId,
+                failures: failures.map((failure) => ({
+                  agentId: failure.agentId || null,
+                  statusCode: failure.statusCode,
+                  recoveryReason: failure.recoveryReason || null,
+                  detail: failure.detail || null,
+                })),
+              });
+              dashboardState.status = "blocked";
+              for (const failure of failures) {
+                setWaveDashboardAgent(dashboardState, failure.agentId, {
+                  state: "blocked",
+                  detail:
+                    failure.detail ||
+                    `Recoverable ${failure.recoveryReason || failure.statusCode}; targeted resume queued.`,
+                });
+              }
+              flushDashboards();
+              appendCoordination({
+                event: "wave_recovery_queued",
+                waves: [wave.wave],
+                status: "blocked",
+                details: `attempt=${attempt}/${options.maxRetriesPerWave + 1}; request=${queuedRecovery.requestId}; agents=${recoverySelectedAgentIds.join(",")}; reason=${(failures || []).map((failure) => failure.recoveryReason || failure.statusCode).join(",")}`,
+                actionRequested:
+                  `Lane ${lanePaths.lane} owners should resume the queued targeted recovery or let autonomous relaunch the selected agents.`,
+              });
+              await flushWaveControlTelemetry();
+              const error = new Error(
+                `Wave ${wave.wave} queued targeted recovery request ${queuedRecovery.requestId} after recoverable execution failures.`,
+              );
+              error.exitCode = 43;
+              throw error;
+            }
             recordAttemptState(lanePaths, wave.wave, attempt, "failed", {
               selectedAgentIds: runsToLaunch.map((run) => run.agent.agentId),
               detail: failures
@@ -2075,6 +2281,16 @@ export async function runLauncherCli(argv) {
               detail: "Queued for retry",
             });
           }
+          if (retryPlan.source !== "override") {
+            appendRepairCoordinationRequests({
+              coordinationLogPath: derivedState.coordinationLogPath,
+              lanePaths,
+              wave,
+              attempt: attempt + 1,
+              runs: runsToLaunch,
+              failures,
+            });
+          }
           writeWaveRelaunchProjection({
             lanePaths,
             wave,