@chllming/wave-orchestration 0.8.6 → 0.8.7

package/docs/research/coordination-failure-review.md

@@ -229,16 +229,16 @@ This is the central failure highlighted by `HiddenBench` and `Silo-Bench`, and t
 
 ### 3. Expertise routing is explicit, but shallow
 
-[scripts/wave-orchestrator/routing-state.mjs](../../scripts/wave-orchestrator/routing-state.mjs) is better than unconstrained self-organization, but it still routes mostly by:
+[scripts/wave-orchestrator/routing-state.mjs](../../scripts/wave-orchestrator/routing-state.mjs) is better than unconstrained self-organization, and it now has a light same-wave success preference, but it still routes mostly by:
 
 - explicit target
 - configured preferred agents
 - declared capability ownership
+- demonstrated same-wave completions on the capability
 - least-busy fallback
 
-It does not yet weight:
+Beyond that light historical-success preference, it still does not weight:
 
-- historical success on a capability
 - evidence quality by agent
 - confidence calibration
 - expert-leverage metrics
@@ -247,14 +247,14 @@ So the repo partially addresses the concern from `Multi-Agent Teams Hold Experts
 
 ### 4. Clarification and contradiction handling are still somewhat heuristic
 
-Clarification triage and integration evidence aggregation are real safeguards, but they still lean heavily on:
+Clarification triage, blocker taxonomy, operator downgrade controls, and integration evidence aggregation are real safeguards, but they still lean heavily on:
 
 - ownership mappings
 - artifact references
 - structured markers
 - text-level summaries and conflict extraction
 
-That is enough to make the runtime operationally safer, but it is not yet a richer semantic evidence-integration layer. Subtle contradictions or latent information asymmetries may still be missed.
+That is enough to make the runtime operationally safer. The newer hard-vs-soft blocker split also removes some unnecessary terminal failures by letting stale or advisory coordination remain visible without owning closure. But it is not yet a richer semantic evidence-integration layer, and subtle contradictions or latent information asymmetries may still be missed.
 
 ### 5. DPBench-style simultaneous coordination is only indirectly addressed
 
@@ -283,7 +283,7 @@ So the design points in the right direction, but the claim is not yet validated.
 
 If the standard is "does this repo merely claim multi-agent coordination," the answer is no. It has real machinery for blackboard-like state sharing, evidence-based closure, clarification handling, and coordination diagnostics.
 
-If the standard is "has this repo already demonstrated that its design beats the core failure modes isolated by HiddenBench, Silo-Bench, DPBench, and related work," the answer is also no. The design is substantially more credible than most MAS stacks, but the empirical proof is still missing.
+If the standard is "has this repo already demonstrated that its design beats the core failure modes isolated by HiddenBench, Silo-Bench, DPBench, and related work," the answer is also no. The design is substantially more credible than most MAS stacks, and it now also reduces avoidable failure through targeted recovery, blocker severity, and policy-safe downgrade paths, but the empirical proof is still missing.
 
 The most accurate claim today is:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chllming/wave-orchestration",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "license": "MIT",
   "description": "Generic wave-based multi-agent orchestration for repository work.",
   "repository": {

package/releases/manifest.json

@@ -2,6 +2,25 @@
   "schemaVersion": 1,
   "packageName": "@chllming/wave-orchestration",
   "releases": [
+    {
+      "version": "0.8.7",
+      "date": "2026-03-27",
+      "summary": "Policy-consistency hardening, capability-specific same-wave routing, stable per-wave tmux session reuse, and 0.8.7 release-surface alignment.",
+      "features": [
+        "Generic `budget.turns` is now documented and tested consistently as advisory metadata only; hard runtime turn ceilings come only from runtime-specific settings such as `claude.maxTurns` or `opencode.steps`.",
+        "Capability-targeted helper routing now prefers demonstrated same-wave success for the requested capability before falling back to the least-busy matching capability owner, and unrelated completed work no longer counts as routing evidence.",
+        "Advisory, stale, and other non-blocking clarification or human-input records stay visible in control and reducer projections without reopening hard blocked reducer state by themselves.",
+        "Wave-agent, resident-orchestrator, and per-wave dashboard tmux sessions now reuse stable per-wave session names, so stale launcher exits stop accumulating extra sessions for the same wave.",
+        "Structured signal extraction now also recognizes markers embedded inside JSON log lines, so wrapped executor transcripts still produce proof, doc-delta, and component evidence."
+      ],
+      "manualSteps": [
+        "Run `pnpm exec wave doctor` and `pnpm exec wave launch --lane main --dry-run --no-dashboard` after upgrading so the repo validates against the `0.8.7` routing, blocker-severity, signal-wrapper, and stable-session behavior.",
+        "If your repo copied starter scripts or operator docs, sync `scripts/wave-status.sh`, `scripts/wave-watch.sh`, `docs/guides/signal-wrappers.md`, `docs/guides/terminal-surfaces.md`, `docs/reference/cli-reference.md`, and any local tmux/session runbooks that still assume run-tagged session names.",
+        "If your repo copied planner or routing guidance, sync `docs/guides/planner.md`, `docs/reference/wave-planning-lessons.md`, `docs/plans/wave-orchestrator.md`, the `planner-agentic` bundle entry in `docs/context7/bundles.json`, and any local helper-assignment policy docs so they describe capability-specific same-wave routing evidence instead of generic prior completion.",
+        "If your repo relies on advisory `budget.turns` as if it were a hard ceiling, move that limit to the runtime-specific executor config (`claude.maxTurns` or `opencode.steps`) before you depend on deterministic turn enforcement."
+      ],
+      "breaking": false
+    },
     {
       "version": "0.8.6",
       "date": "2026-03-25",

package/scripts/wave-orchestrator/agent-state.mjs

@@ -160,6 +160,44 @@ function appendParsedStructuredSignalCandidates(lines, candidates, { requireAll
   candidates.push(...parsedCandidates);
 }
 
+function collectEmbeddedStructuredSignalTexts(value, texts) {
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectEmbeddedStructuredSignalTexts(item, texts);
+    }
+    return;
+  }
+  if (typeof value.text === "string") {
+    texts.push(value.text);
+  }
+  if (typeof value.aggregated_output === "string") {
+    texts.push(value.aggregated_output);
+  }
+  for (const nestedValue of Object.values(value)) {
+    if (nestedValue && typeof nestedValue === "object") {
+      collectEmbeddedStructuredSignalTexts(nestedValue, texts);
+    }
+  }
+}
+
+function extractEmbeddedStructuredSignalTextsFromJsonLine(line) {
+  const trimmed = String(line || "").trim();
+  if (!trimmed || !/^[{\[]/.test(trimmed)) {
+    return [];
+  }
+  try {
+    const payload = JSON.parse(trimmed);
+    const texts = [];
+    collectEmbeddedStructuredSignalTexts(payload, texts);
+    return texts.filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 function collectStructuredSignalCandidates(text) {
   if (!text) {
     return [];
@@ -167,6 +205,10 @@ function collectStructuredSignalCandidates(text) {
   const candidates = [];
   let fenceLines = null;
   for (const rawLine of String(text || "").split(/\r?\n/)) {
+    const embeddedTexts = extractEmbeddedStructuredSignalTextsFromJsonLine(rawLine);
+    for (const embeddedText of embeddedTexts) {
+      candidates.push(...collectStructuredSignalCandidates(embeddedText));
+    }
     const trimmed = rawLine.trim();
     if (/^```/.test(trimmed)) {
       if (fenceLines === null) {

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,
@@ -50,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]
@@ -94,6 +102,8 @@ function parseArgs(argv) {
     detail: "",
     targets: [],
     priority: "normal",
+    blocking: null,
+    blockerSeverity: "",
     dependsOn: [],
     artifactRefs: [],
     status: "open",
@@ -155,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") {
@@ -264,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 = "") {
@@ -462,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",
@@ -472,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 {
@@ -483,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 {
@@ -564,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 {
@@ -575,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 {
@@ -738,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",
@@ -823,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}`);
 }
 
@@ -975,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;
@@ -1067,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],