@chllming/wave-orchestration 0.8.5 → 0.8.7

package/scripts/wave-orchestrator/autonomous.mjs

@@ -27,8 +27,13 @@ import {
   maybeAnnouncePackageUpdate,
   WAVE_SUPPRESS_UPDATE_NOTICE_ENV,
 } from "./package-update-notice.mjs";
+import { buildTaskSnapshots } from "./control-plane.mjs";
+import { readWaveHumanFeedbackRequests } from "./coordination.mjs";
 import { readRunState } from "./wave-files.mjs";
-import { readDependencyTickets } from "./coordination-store.mjs";
+import {
+  readDependencyTickets,
+  readMaterializedCoordinationState,
+} from "./coordination-store.mjs";
 import { readWaveLedger } from "./ledger.mjs";
 
 const AUTONOMOUS_EXECUTOR_MODES = SUPPORTED_EXECUTOR_MODES.filter((mode) => mode !== "local");
@@ -249,7 +254,38 @@ function requiredInboundDependenciesOpen(lanePaths, lane) {
   });
 }
 
-function pendingHumanItemsForWave(lanePaths, wave) {
+function liveBlockingHumanItemsForWave(lanePaths, lane, wave) {
+  if (!lanePaths?.coordinationDir || !lanePaths?.feedbackRequestsDir) {
+    return null;
+  }
+  const coordinationState = readMaterializedCoordinationState(
+    path.join(lanePaths.coordinationDir, `wave-${wave}.jsonl`),
+  );
+  const feedbackRequests = readWaveHumanFeedbackRequests({
+    feedbackRequestsDir: lanePaths.feedbackRequestsDir,
+    lane,
+    waveNumber: wave,
+    agentIds: [],
+    orchestratorId: "",
+  });
+  return buildTaskSnapshots({
+    coordinationState,
+    feedbackRequests,
+  })
+    .filter(
+      (task) =>
+        ["human-input", "escalation"].includes(task.taskType) &&
+        task.blocking !== false &&
+        ["open", "working", "input-required"].includes(task.state),
+    )
+    .map((task) => task.taskId);
+}
+
+function pendingHumanItemsForWave(lanePaths, lane, wave) {
+  const liveItems = liveBlockingHumanItemsForWave(lanePaths, lane, wave);
+  if (Array.isArray(liveItems)) {
+    return liveItems;
+  }
   const existingLedger = readWaveLedger(path.join(lanePaths.ledgerDir, `wave-${wave}.json`));
   return [
     ...(existingLedger?.humanFeedback || []),
@@ -257,7 +293,7 @@ function pendingHumanItemsForWave(lanePaths, wave) {
   ];
 }
 
-function pendingHumanItemsForLane(lanePaths) {
+function pendingHumanItemsForLane(lanePaths, lane) {
   if (!fs.existsSync(lanePaths.ledgerDir)) {
     return [];
   }
@@ -271,7 +307,7 @@ function pendingHumanItemsForLane(lanePaths) {
     .filter((item) => Number.isFinite(item.wave))
     .sort((left, right) => left.wave - right.wave)
     .flatMap((item) =>
-      pendingHumanItemsForWave(lanePaths, item.wave).map((id) => ({
+      pendingHumanItemsForWave(lanePaths, lane, item.wave).map((id) => ({
         wave: item.wave,
         id,
       })),
@@ -292,7 +328,7 @@ export function readAutonomousBarrier(lanePaths, lane, wave = null) {
     };
   }
   if (wave === null) {
-    const pendingHumanEntries = pendingHumanItemsForLane(lanePaths);
+    const pendingHumanEntries = pendingHumanItemsForLane(lanePaths, lane);
     if (pendingHumanEntries.length > 0) {
       return {
         kind: "human-input",
@@ -303,7 +339,7 @@ export function readAutonomousBarrier(lanePaths, lane, wave = null) {
     }
     return null;
   }
-  const pendingHumanItems = pendingHumanItemsForWave(lanePaths, wave);
+  const pendingHumanItems = pendingHumanItemsForWave(lanePaths, lane, wave);
   if (pendingHumanItems.length > 0) {
     return {
       kind: "human-input",

package/scripts/wave-orchestrator/clarification-triage.mjs

@@ -4,6 +4,7 @@ import {
   appendCoordinationRecord,
   clarificationClosureCondition,
   clarificationLinkedRequests,
+  coordinationRecordBlocksWave,
   isOpenCoordinationStatus,
   readMaterializedCoordinationState,
 } from "./coordination-store.mjs";
@@ -467,14 +468,14 @@ export function triageClarificationRequests({
   ensureDirectory(lanePaths.feedbackTriageDir);
   const triagePath = triageLogPath(lanePaths, wave.wave);
   const openClarifications = (coordinationState?.clarifications || []).filter((record) =>
-    isOpenCoordinationStatus(record.status),
+    coordinationRecordBlocksWave(record),
   );
   let changed = false;
 
   for (const record of openClarifications) {
     const linkedRequests = clarificationLinkedRequests(coordinationState, record.id);
     const openLinkedRequests = linkedRequests.filter((entry) =>
-      isOpenCoordinationStatus(entry.status),
+      coordinationRecordBlocksWave(entry),
     );
     const openAckPendingLinkedRequests = openLinkedRequests.filter(
       (entry) => entry.status === "open",
@@ -487,7 +488,7 @@ export function triageClarificationRequests({
     const openEscalations = (coordinationState?.humanEscalations || []).filter(
       (entry) =>
         entry.closureCondition === clarificationClosureCondition(record.id) &&
-        isOpenCoordinationStatus(entry.status),
+        coordinationRecordBlocksWave(entry),
     );
     if (resolvedLinkedRequest || resolvedEscalation) {
       if (openEscalations.length > 0) {

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

@@ -1,6 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
-import { appendCoordinationRecord, clarificationClosureCondition, clarificationLinkedRequests, isOpenCoordinationStatus, readMaterializedCoordinationState, updateSeedRecords } from "./coordination-store.mjs";
+import {
+  appendCoordinationRecord,
+  clarificationClosureCondition,
+  clarificationLinkedRequests,
+  isOpenCoordinationStatus,
+  readMaterializedCoordinationState,
+  updateSeedRecords,
+} from "./coordination-store.mjs";
 import { answerFeedbackRequest, createFeedbackRequest } from "./feedback.mjs";
 import { readWaveHumanFeedbackRequests } from "./coordination.mjs";
 import { readWaveLedger } from "./ledger.mjs";
@@ -18,6 +25,7 @@ import {
   REPO_ROOT,
   sanitizeAdhocRunId,
   sanitizeLaneName,
+  toIsoTimestamp,
 } from "./shared.mjs";
 import {
   appendWaveControlEvent,
@@ -36,6 +44,10 @@ import { readWaveRelaunchPlanSnapshot, readWaveRetryOverride, resolveRetryOverri
 import { flushWaveControlQueue, readWaveControlQueueState } from "./wave-control-client.mjs";
 import { readAgentExecutionSummary, validateImplementationSummary } from "./agent-state.mjs";
 import { isContEvalReportOnlyAgent, isSecurityReviewAgent } from "./role-helpers.mjs";
+import {
+  buildSignalStatusLine,
+  syncWaveSignalProjections,
+} from "./signals.mjs";
 
 function printUsage() {
   console.log(`Usage:
@@ -46,7 +58,7 @@ function printUsage() {
   wave control task create --lane <lane> --wave <n> --agent <id> --kind <request|blocker|clarification|handoff|evidence|claim|decision|human-input> --summary <text> [options]
   wave control task list --lane <lane> --wave <n> [--agent <id>] [--json]
   wave control task get --lane <lane> --wave <n> --id <task-id> [--json]
-  wave control task act <start|resolve|dismiss|cancel|reassign|answer|escalate> --lane <lane> --wave <n> --id <task-id> [options]
+  wave control task act <start|resolve|dismiss|cancel|reassign|answer|escalate|defer|mark-advisory|mark-stale|resolve-policy> --lane <lane> --wave <n> --id <task-id> [options]
 
   wave control rerun request --lane <lane> --wave <n> [--agent <id> ...] [--resume-cursor <cursor>] [--reuse-attempt <id> ...] [--reuse-proof <id> ...] [--reuse-derived-summaries <true|false>] [--invalidate-component <id> ...] [--clear-reuse <id> ...] [--preserve-reuse <id> ...] [--requested-by <name>] [--reason <text>] [--json]
   wave control rerun get --lane <lane> --wave <n> [--json]
@@ -90,6 +102,8 @@ function parseArgs(argv) {
     detail: "",
     targets: [],
     priority: "normal",
+    blocking: null,
+    blockerSeverity: "",
     dependsOn: [],
     artifactRefs: [],
     status: "open",
@@ -151,6 +165,10 @@ function parseArgs(argv) {
       options.targets.push(String(args[++i] || "").trim());
     } else if (arg === "--priority") {
       options.priority = String(args[++i] || "").trim();
+    } else if (arg === "--blocking") {
+      options.blocking = normalizeBooleanish(args[++i], true);
+    } else if (arg === "--severity") {
+      options.blockerSeverity = String(args[++i] || "").trim();
     } else if (arg === "--depends-on") {
       options.dependsOn.push(String(args[++i] || "").trim());
     } else if (arg === "--artifact") {
@@ -260,7 +278,10 @@ const BLOCKING_TASK_TYPES = new Set([
 ]);
 
 function taskBlocksAgent(task) {
-  return BLOCKING_TASK_TYPES.has(String(task?.taskType || "").trim().toLowerCase());
+  return (
+    BLOCKING_TASK_TYPES.has(String(task?.taskType || "").trim().toLowerCase()) &&
+    task?.blocking !== false
+  );
 }
 
 function assignmentRelevantToAgent(assignment, agentId = "") {
@@ -458,7 +479,9 @@ function buildBlockingEdge({
       selectionTargetsAgent(task.assigneeAgentId, attemptSelection)
     );
   });
-  const pendingHuman = scopedTasks.find((task) => task.state === "input-required");
+  const pendingHuman = scopedTasks.find(
+    (task) => task.state === "input-required" && task.blocking !== false,
+  );
   if (pendingHuman) {
     return {
       kind: "human-input",
@@ -468,7 +491,10 @@ function buildBlockingEdge({
     };
   }
   const escalation = scopedTasks.find(
-    (task) => task.taskType === "escalation" && ["open", "working"].includes(task.state),
+    (task) =>
+      task.taskType === "escalation" &&
+      task.blocking !== false &&
+      ["open", "working"].includes(task.state),
   );
   if (escalation) {
     return {
@@ -479,7 +505,10 @@ function buildBlockingEdge({
     };
   }
   const clarification = scopedTasks.find(
-    (task) => task.taskType === "clarification" && ["open", "working"].includes(task.state),
+    (task) =>
+      task.taskType === "clarification" &&
+      task.blocking !== false &&
+      ["open", "working"].includes(task.state),
   );
   if (clarification) {
     return {
@@ -560,7 +589,10 @@ function buildBlockingEdge({
     };
   }
   const blocker = scopedTasks.find(
-    (task) => task.taskType === "blocker" && ["open", "working"].includes(task.state),
+    (task) =>
+      task.taskType === "blocker" &&
+      task.blocking !== false &&
+      ["open", "working"].includes(task.state),
   );
   if (blocker) {
     return {
@@ -571,7 +603,10 @@ function buildBlockingEdge({
     };
   }
   const request = scopedTasks.find(
-    (task) => task.taskType === "request" && ["open", "working"].includes(task.state),
+    (task) =>
+      task.taskType === "request" &&
+      task.blocking !== false &&
+      ["open", "working"].includes(task.state),
   );
   if (request) {
     return {
@@ -676,6 +711,7 @@ export function buildControlStatusPayload({ lanePaths, wave, agentId = "" }) {
     proofBundles: (proofRegistry?.entries || []).filter(
       (entry) => !agentId || entry.agentId === agentId,
     ),
+    feedbackRequests,
     selectionSource: selection.source,
     rerunRequest,
     relaunchPlan,
@@ -690,6 +726,7 @@ function ensureWaveStateDirs(lanePaths) {
   ensureDirectory(lanePaths.controlPlaneDir);
   ensureDirectory(lanePaths.assignmentsDir);
   ensureDirectory(lanePaths.inboxesDir);
+  ensureDirectory(lanePaths.signalsDir);
   ensureDirectory(lanePaths.messageboardsDir);
   ensureDirectory(lanePaths.docsQueueDir);
   ensureDirectory(lanePaths.ledgerDir);
@@ -714,6 +751,9 @@ function printStatus(payload) {
     ? `${payload.blockingEdge.kind} ${payload.blockingEdge.id}: ${payload.blockingEdge.detail}`
     : "none";
   console.log(`lane=${payload.lane} wave=${payload.wave} phase=${payload.phase}`);
+  if (payload.signals?.wave) {
+    console.log(buildSignalStatusLine(payload.signals.wave, payload));
+  }
   console.log(`blocking=${blocking}`);
   if (payload.nextTimer) {
     console.log(`next-timer=${payload.nextTimer.kind} ${payload.nextTimer.taskId} at ${payload.nextTimer.at}`);
@@ -729,7 +769,9 @@ function printStatus(payload) {
 function appendCoordinationStatusUpdate(logPath, record, status, options = {}) {
   return appendCoordinationRecord(logPath, {
     ...record,
+    ...(options.patch || {}),
     status,
+    updatedAt: options.updatedAt || toIsoTimestamp(),
     summary: options.summary || record.summary,
     detail: options.detail || record.detail,
     source: options.source || "operator",
@@ -814,6 +856,73 @@ function appendTaskCoordinationEvent(logPath, lanePaths, wave, record, action, o
       source: "operator",
     });
   }
+  if (action === "defer") {
+    return appendCoordinationStatusUpdate(logPath, record, record.status, {
+      detail:
+        options.detail ||
+        `${record.summary || record.id} deferred by operator; keep visible but do not block wave progression.`,
+      patch: {
+        blocking: false,
+        blockerSeverity: "soft",
+      },
+    });
+  }
+  if (action === "mark-advisory") {
+    return appendCoordinationStatusUpdate(logPath, record, record.status, {
+      detail:
+        options.detail ||
+        `${record.summary || record.id} marked advisory by operator; keep visible without blocking closure.`,
+      patch: {
+        blocking: false,
+        blockerSeverity: "advisory",
+      },
+    });
+  }
+  if (action === "mark-stale") {
+    return appendCoordinationStatusUpdate(logPath, record, record.status, {
+      detail:
+        options.detail ||
+        `${record.summary || record.id} marked stale by operator; historical context preserved without blocking.`,
+      patch: {
+        blocking: false,
+        blockerSeverity: "stale",
+      },
+    });
+  }
+  if (action === "resolve-policy") {
+    const resolvedRecord = appendCoordinationStatusUpdate(logPath, record, "resolved", {
+      detail: options.detail || `Resolved by operator policy: ${record.summary || record.id}.`,
+      patch: {
+        blocking: false,
+        blockerSeverity: "advisory",
+      },
+    });
+    const policyRecord = appendCoordinationRecord(logPath, {
+      id: `policy-${record.id}`,
+      lane: lanePaths.lane,
+      wave: wave.wave,
+      agentId: options.agent || "operator",
+      kind: "resolved-by-policy",
+      targets: record.targets,
+      priority: record.priority,
+      artifactRefs: record.artifactRefs,
+      dependsOn: Array.from(new Set([record.id, ...(record.dependsOn || [])])),
+      closureCondition:
+        record.kind === "clarification-request"
+          ? clarificationClosureCondition(record.id)
+          : record.closureCondition || "",
+      summary: record.summary,
+      detail: options.detail || `Operator resolved ${record.id} by policy.`,
+      status: "resolved",
+      source: "operator",
+      blocking: false,
+      blockerSeverity: "advisory",
+    });
+    return {
+      resolvedRecord,
+      policyRecord,
+    };
+  }
   throw new Error(`Unsupported task action: ${action}`);
 }
 
@@ -901,6 +1010,16 @@ export async function runControlCli(argv) {
       wave,
       agentId: options.agent || "",
     });
+    const signalSync = syncWaveSignalProjections({
+      lanePaths,
+      wave,
+      statusPayload: payload,
+      includeResident: Boolean(options.orchestratorId),
+    });
+    payload.signals = {
+      wave: signalSync.wave?.snapshot || null,
+      agents: (signalSync.agents || []).map((entry) => entry.snapshot),
+    };
     if (options.json) {
       console.log(JSON.stringify(payload, null, 2));
     } else {
@@ -956,6 +1075,8 @@ export async function runControlCli(argv) {
         artifactRefs: options.artifactRefs,
         status: options.status,
         source: "operator",
+        ...(options.blocking !== null ? { blocking: options.blocking } : {}),
+        ...(options.blockerSeverity ? { blockerSeverity: options.blockerSeverity } : {}),
       });
       console.log(JSON.stringify(record, null, 2));
       return;
@@ -1048,14 +1169,27 @@ export async function runControlCli(argv) {
         throw new Error(`Task not found: ${options.id}`);
       }
       const updated = appendTaskCoordinationEvent(logPath, lanePaths, wave, record, action, options);
-      if (record.kind === "clarification-request" && ["resolve", "dismiss"].includes(action)) {
+      if (record.kind === "clarification-request" && ["resolve", "dismiss", "resolve-policy"].includes(action)) {
         const nextStatus = action === "resolve" ? "resolved" : "cancelled";
+        const linkedStatus = action === "resolve-policy" ? "resolved" : nextStatus;
         for (const linked of clarificationLinkedRequests(coordinationState, record.id).filter((entry) =>
           isOpenCoordinationStatus(entry.status),
         )) {
-          appendCoordinationStatusUpdate(logPath, linked, nextStatus, {
-            detail: `${action === "resolve" ? "Resolved" : "Cancelled"} via clarification ${record.id}.`,
+          appendCoordinationStatusUpdate(logPath, linked, linkedStatus, {
+            detail:
+              action === "resolve"
+                ? `Resolved via clarification ${record.id}.`
+                : action === "resolve-policy"
+                  ? `Resolved by policy via clarification ${record.id}.`
+                  : `Cancelled via clarification ${record.id}.`,
             summary: linked.summary,
+            patch:
+              action === "resolve-policy"
+                ? {
+                    blocking: false,
+                    blockerSeverity: "advisory",
+                  }
+                : undefined,
           });
         }
       }

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}`;
 }