@chllming/wave-orchestration 0.8.5 → 0.8.7

package/scripts/wave-orchestrator/coordination.mjs

@@ -203,6 +203,8 @@ export function buildExecutionPrompt({
   sharedPlanDocs = null,
   designPacketPaths = null,
   designExecutionMode = null,
+  signalStatePath = null,
+  signalAckPath = null,
   contQaAgentId = "A0",
   contEvalAgentId = "E0",
   integrationAgentId = "A8",
@@ -213,6 +215,10 @@ export function buildExecutionPrompt({
     ? path.relative(REPO_ROOT, sharedSummaryPath)
     : null;
   const relativeInboxPath = inboxPath ? path.relative(REPO_ROOT, inboxPath) : null;
+  const relativeSignalStatePath = signalStatePath
+    ? path.relative(REPO_ROOT, signalStatePath)
+    : null;
+  const relativeSignalAckPath = signalAckPath ? path.relative(REPO_ROOT, signalAckPath) : null;
   const lanePlansDir = lane === DEFAULT_WAVE_LANE ? "docs/plans" : `docs/${lane}/plans`;
   const resolvedSharedPlanDocs =
     sharedPlanDocs && sharedPlanDocs.length > 0
@@ -531,6 +537,14 @@ export function buildExecutionPrompt({
           `Agent inbox repo-relative path: ${relativeInboxPath}`,
         ]
       : []),
+    ...(signalStatePath
+      ? [
+          `Signal state absolute path: ${signalStatePath}`,
+          `Signal state repo-relative path: ${relativeSignalStatePath}`,
+          `Signal ack absolute path: ${signalAckPath}`,
+          `Signal ack repo-relative path: ${relativeSignalAckPath}`,
+        ]
+      : []),
     "",
     ...(sharedSummaryText
       ? ["Current wave shared summary:", "```markdown", sharedSummaryText, "```", ""]
@@ -538,6 +552,17 @@ export function buildExecutionPrompt({
     ...(inboxText
       ? ["Current agent inbox:", "```markdown", inboxText, "```", ""]
       : []),
+    ...(signalStatePath
+      ? [
+          "Long-running signal loop:",
+          "- If you are operating as a resident or waiting agent, keep watching the signal state JSON instead of exiting early.",
+          "- When the signal `version` increases beyond the version recorded in the signal ack file, immediately write the ack file before acting.",
+          `- Write the ack file as JSON with exactly these keys: \`agentId\`, \`version\`, \`signal\`, and \`observedAt\`. Use \`${agent.agentId}\` as \`agentId\` and an ISO-8601 timestamp for \`observedAt\`.`,
+          "- After writing the ack, re-read the inbox, shared summary, and message board, then handle the new signal once.",
+          "- If the signal version has not changed, stay idle. Do not busy-loop or repeat unchanged work.",
+          "",
+        ]
+      : []),
     ...exitContractLines,
     ...promotedComponentLines,
     ...evalTargetLines,
@@ -564,6 +589,8 @@ export function buildResidentOrchestratorPrompt({
   sharedSummaryPath,
   dashboardPath,
   triagePath = null,
+  signalStatePath = null,
+  signalAckPath = null,
   rolePrompt = "",
 }) {
   const coordinationCommand = [
@@ -612,6 +639,8 @@ export function buildResidentOrchestratorPrompt({
     `- Wave dashboard: ${dashboardPath}`,
     `- Message board projection: ${messageBoardPath}`,
     ...(triagePath ? [`- Feedback triage log: ${triagePath}`] : []),
+    ...(signalStatePath ? [`- Signal state: ${signalStatePath}`] : []),
+    ...(signalAckPath ? [`- Signal ack: ${signalAckPath}`] : []),
     "",
     "Action surface:",
     `- Coordination command: \`${coordinationCommand}\``,
@@ -624,6 +653,12 @@ export function buildResidentOrchestratorPrompt({
     "2. Identify open clarifications, open clarification-linked requests, overdue acknowledgements, and human-feedback state.",
     "3. If action is needed, write a durable coordination update and explain the policy basis for the action.",
     "4. If nothing needs action, continue monitoring. Do not exit until the wave is clearly terminal or the launcher stops the session.",
+    ...(signalStatePath
+      ? [
+          "5. When the signal state `version` increases, immediately write the signal ack file before taking action so the launcher knows you observed the change.",
+          "6. After acknowledging the signal, re-read the shared summary, dashboard, coordination log, and triage artifacts before intervening.",
+        ]
+      : []),
     "",
     ...(roleSection
       ? [

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/install.mjs

@@ -27,6 +27,8 @@ export const CHANGELOG_MANIFEST_PATH = path.join(PACKAGE_ROOT, "releases", "mani
 export const WORKSPACE_PACKAGE_JSON_PATH = path.join(REPO_ROOT, "package.json");
 export const STARTER_TEMPLATE_PATHS = [
   "wave.config.json",
+  "scripts/wave-status.sh",
+  "scripts/wave-watch.sh",
   "docs/README.md",
   "docs/agents/wave-documentation-role.md",
   "docs/agents/wave-design-role.md",

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

@@ -20,6 +20,11 @@ import {
   summarizeResolvedSkills,
   writeResolvedSkillArtifacts,
 } from "./skills.mjs";
+import {
+  agentSignalAckPath,
+  agentSignalPath,
+  agentUsesSignalHygiene,
+} from "./signals.mjs";
 
 export function refreshResolvedSkillsForRun(runInfo, waveDefinition, lanePaths) {
   runInfo.agent.skillsResolved = resolveAgentSkills(
@@ -129,6 +134,12 @@ export async function launchAgentSession(lanePaths, params, { runTmuxFn }) {
         .map((waveAgent) => resolveDesignReportPath(waveAgent))
         .filter(Boolean),
       designExecutionMode,
+      signalStatePath: agentUsesSignalHygiene(agent)
+        ? agentSignalPath(lanePaths, wave, agent.agentId)
+        : null,
+      signalAckPath: agentUsesSignalHygiene(agent)
+        ? agentSignalAckPath(lanePaths, wave, agent.agentId)
+        : null,
     });
   const promptHash = hashAgentPromptFingerprint(agent);
   fs.writeFileSync(promptPath, `${prompt}\n`, "utf8");
@@ -224,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";
@@ -209,7 +211,9 @@ import {
   recordAttemptState,
   recordWaveRunState,
   runTmux,
+  syncLiveWaveSignals,
 } from "./session-supervisor.mjs";
+import { buildControlStatusPayload } from "./control-cli.mjs";
 import {
   planInitialWaveAttempt,
   planRetryWaveAttempt,
@@ -576,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) {
@@ -624,6 +722,7 @@ export async function runLauncherCli(argv) {
   ensureDirectory(lanePaths.controlDir);
   ensureDirectory(lanePaths.assignmentsDir);
   ensureDirectory(lanePaths.inboxesDir);
+  ensureDirectory(lanePaths.signalsDir);
   ensureDirectory(lanePaths.ledgerDir);
   ensureDirectory(lanePaths.integrationDir);
   ensureDirectory(lanePaths.proofDir);
@@ -1188,6 +1287,19 @@ export async function runLauncherCli(argv) {
           flushDashboards();
           return true;
         };
+        const syncWaveSignals = () =>
+          syncLiveWaveSignals({
+            lanePaths,
+            wave,
+            statusPayload: buildControlStatusPayload({
+              lanePaths,
+              wave,
+            }),
+            agentRuns,
+            residentEnabled: Boolean(residentOrchestratorRun),
+            recordCombinedEvent,
+            appendCoordination,
+          });
 
         const proofRegistryForReuse = readWaveProofRegistry(lanePaths, wave.wave);
         const initialAttemptPlan = planInitialWaveAttempt({
@@ -1217,6 +1329,7 @@ export async function runLauncherCli(argv) {
         }
         flushDashboards();
         emitCoordinationAlertEvents(derivedState);
+        syncWaveSignals();
 
         if (options.dashboard && currentWaveDashboardTerminalEntry) {
           launchWaveDashboardSession(lanePaths, {
@@ -1281,6 +1394,7 @@ export async function runLauncherCli(argv) {
               details: `session=${residentOrchestratorRun.sessionName}; executor=${residentOrchestratorRun.lastExecutorId || "unknown"}`,
               actionRequested: "None",
             });
+            syncWaveSignals();
           }
         }
 
@@ -1487,6 +1601,7 @@ export async function runLauncherCli(argv) {
                   updateWaveDashboardMessageBoard(dashboardState, messageBoardPath);
                   flushDashboards();
                 }
+                syncWaveSignals();
               },
               {
                 controlPlane: {
@@ -1500,7 +1615,9 @@ export async function runLauncherCli(argv) {
           }
 
           materializeAgentExecutionSummaries(wave, agentRuns);
+          failures = annotateFailuresWithRecoveryHints(failures, agentRuns);
           refreshDerivedState(attempt);
+          syncWaveSignals();
           lastLiveCoordinationRefreshAt = Date.now();
           emitCoordinationAlertEvents(derivedState);
           failures = reconcileFailuresAgainstSharedComponentState(wave, agentRuns, failures);
@@ -1686,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 {
@@ -1876,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,
@@ -1911,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
@@ -2055,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,

package/scripts/wave-orchestrator/ledger.mjs

@@ -18,7 +18,11 @@ import {
   isImplementationOwningDesignAgent,
   isSecurityReviewAgent,
 } from "./role-helpers.mjs";
-import { openClarificationLinkedRequests } from "./coordination-store.mjs";
+import {
+  coordinationRecordBlocksWave,
+  coordinationRecordIsHardBlocker,
+  openClarificationLinkedRequests,
+} from "./coordination-store.mjs";
 import { buildHelperTasks } from "./routing-state.mjs";
 import { readJsonOrNull, toIsoTimestamp, writeJsonAtomic } from "./shared.mjs";
 
@@ -35,16 +39,12 @@ function taskStateFromValidation(validation) {
 
 function openHighPriorityBlockers(state) {
   return (state?.blockers || []).filter(
-    (record) =>
-      ["open", "acknowledged", "in_progress"].includes(record.status) &&
-      ["high", "urgent"].includes(record.priority),
+    (record) => coordinationRecordIsHardBlocker(record),
   );
 }
 
 function openClarifications(state) {
-  return (state?.clarifications || []).filter((record) =>
-    ["open", "acknowledged", "in_progress"].includes(record.status),
-  );
+  return (state?.clarifications || []).filter((record) => coordinationRecordBlocksWave(record));
 }
 
 export function buildSeedWaveLedger({
@@ -161,7 +161,7 @@ function derivePhase({
   }
   if (
     openClarifications(state).length > 0 ||
-    openClarificationLinkedRequests(state).length > 0
+    openClarificationLinkedRequests(state).filter((record) => coordinationRecordBlocksWave(record)).length > 0
   ) {
     return "clarifying";
   }
@@ -407,7 +407,9 @@ export function deriveWaveLedger({
     tasks,
     blockers: (coordinationState?.blockers || []).map((record) => record.id),
     openClarifications: openClarifications(coordinationState).map((record) => record.id),
-    clarificationLinkedRequests: openClarificationLinkedRequests(coordinationState).map(
+    clarificationLinkedRequests: openClarificationLinkedRequests(coordinationState)
+      .filter((record) => coordinationRecordBlocksWave(record))
+      .map(
       (record) => record.id,
     ),
     openRequests: (coordinationState?.requests || [])
@@ -437,14 +439,14 @@ export function deriveWaveLedger({
       : null,
     humanFeedback: [
       ...(coordinationState?.humanFeedback || [])
-        .filter((record) => ["open", "acknowledged", "in_progress"].includes(record.status))
+        .filter((record) => coordinationRecordBlocksWave(record))
         .map((record) => record.id),
       ...(coordinationState?.humanEscalations || [])
-        .filter((record) => ["open", "acknowledged", "in_progress"].includes(record.status))
+        .filter((record) => coordinationRecordBlocksWave(record))
       .map((record) => record.id),
     ],
     humanEscalations: (coordinationState?.humanEscalations || [])
-      .filter((record) => ["open", "acknowledged", "in_progress"].includes(record.status))
+      .filter((record) => coordinationRecordBlocksWave(record))
       .map((record) => record.id),
     contEvalState: contEvalValidation.ok ? "pass" : "open",
     securityState: securityValidation.ok ? securityValidation.statusCode || "pass" : "open",

package/scripts/wave-orchestrator/reducer-snapshot.mjs

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import {
-  isOpenCoordinationStatus,
+  coordinationRecordBlocksWave,
   openClarificationLinkedRequests,
   readMaterializedCoordinationState,
 } from "./coordination-store.mjs";
@@ -66,17 +66,19 @@ function compatibilityBlockerIds(derivedState) {
   const coordinationState = derivedState?.coordinationState || {};
   return normalizeShadowIdList([
     ...(coordinationState.blockers || [])
-      .filter((record) => isOpenCoordinationStatus(record.status))
+      .filter((record) => coordinationRecordBlocksWave(record))
       .map((record) => record.id),
     ...(coordinationState.clarifications || [])
-      .filter((record) => isOpenCoordinationStatus(record.status))
+      .filter((record) => coordinationRecordBlocksWave(record))
+      .map((record) => record.id),
+    ...openClarificationLinkedRequests(coordinationState)
+      .filter((record) => coordinationRecordBlocksWave(record))
       .map((record) => record.id),
-    ...openClarificationLinkedRequests(coordinationState).map((record) => record.id),
     ...(coordinationState.humanFeedback || [])
-      .filter((record) => isOpenCoordinationStatus(record.status))
+      .filter((record) => coordinationRecordBlocksWave(record))
       .map((record) => record.id),
     ...(coordinationState.humanEscalations || [])
-      .filter((record) => isOpenCoordinationStatus(record.status))
+      .filter((record) => coordinationRecordBlocksWave(record))
       .map((record) => record.id),
     ...((derivedState?.capabilityAssignments || [])
       .filter((assignment) => assignment.blocking)