@chllming/wave-orchestration 0.6.2 → 0.7.0

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

@@ -2,7 +2,10 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import {
+  DEFAULT_COORDINATION_ACK_TIMEOUT_MS,
+  DEFAULT_COORDINATION_RESOLUTION_STALE_MS,
   REPO_ROOT,
+  buildLanePaths,
   compactSingleLine,
   ensureDirectory,
   readJsonOrNull,
@@ -10,6 +13,7 @@ import {
   truncate,
   writeTextAtomic,
 } from "./shared.mjs";
+import { safeQueueWaveControlEvent } from "./wave-control-client.mjs";
 
 export const COORDINATION_KIND_VALUES = [
   "request",
@@ -147,6 +151,50 @@ export function appendCoordinationRecord(filePath, rawRecord, defaults = {}) {
   const record = normalizeCoordinationRecord(rawRecord, defaults);
   ensureDirectory(path.dirname(filePath));
   fs.appendFileSync(filePath, `${JSON.stringify(record)}\n`, "utf8");
+  const runIdHint = normalizeString(rawRecord?.runId ?? defaults.runId, "");
+  try {
+    const lanePaths = buildLanePaths(record.lane, {
+      ...(runIdHint ? { adhocRunId: runIdHint } : {}),
+    });
+    if (lanePaths?.waveControl?.captureCoordinationRecords !== false) {
+      safeQueueWaveControlEvent(lanePaths, {
+        category: "coordination",
+        entityType: "coordination_record",
+        entityId: record.id,
+        action: "recorded",
+        source: record.source,
+        actor: record.agentId,
+        recordedAt: record.updatedAt || record.createdAt,
+        identity: {
+          lane: record.lane,
+          wave: record.wave,
+          attempt: record.attempt,
+          agentId: record.agentId,
+          runKind: lanePaths.runKind,
+          runId: lanePaths.runId,
+        },
+        tags: [`kind:${record.kind}`, `status:${record.status}`],
+        data: {
+          kind: record.kind,
+          status: record.status,
+          priority: record.priority,
+          confidence: record.confidence,
+          summary: record.summary,
+          detail: record.detail,
+          targets: record.targets,
+          artifactRefs: record.artifactRefs,
+          dependsOn: record.dependsOn,
+          closureCondition: record.closureCondition,
+          required: record.required,
+          executorId: record.executorId || null,
+          requesterLane: record.requesterLane || null,
+          ownerLane: record.ownerLane || null,
+        },
+      });
+    }
+  } catch {
+    // Telemetry is best-effort and must never block canonical coordination writes.
+  }
   return record;
 }
 
@@ -311,11 +359,137 @@ export function serializeCoordinationState(state) {
   };
 }
 
-function renderOpenRecord(record) {
+function parseRecordStartMs(record) {
+  const createdAtMs = Date.parse(record?.createdAt || "");
+  if (Number.isFinite(createdAtMs)) {
+    return createdAtMs;
+  }
+  const updatedAtMs = Date.parse(record?.updatedAt || "");
+  return Number.isFinite(updatedAtMs) ? updatedAtMs : null;
+}
+
+function formatAgeMs(ageMs) {
+  if (!Number.isFinite(ageMs)) {
+    return "n/a";
+  }
+  const totalSeconds = Math.max(0, Math.floor(ageMs / 1000));
+  if (totalSeconds < 60) {
+    return `${totalSeconds}s`;
+  }
+  const minutes = Math.floor(totalSeconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${minutes % 60}m`;
+}
+
+function isAckTrackedRecord(record) {
+  if (!record || typeof record !== "object") {
+    return false;
+  }
+  if (["clarification-request", "human-feedback", "human-escalation"].includes(record.kind)) {
+    return true;
+  }
+  if (record.kind !== "request") {
+    return false;
+  }
+  return record.source !== "launcher" || isClarificationLinkedRequest(record);
+}
+
+export function buildCoordinationResponseMetrics(state, options = {}) {
+  const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
+  const ackTimeoutMs = Number.isFinite(options.ackTimeoutMs)
+    ? options.ackTimeoutMs
+    : DEFAULT_COORDINATION_ACK_TIMEOUT_MS;
+  const resolutionStaleMs = Number.isFinite(options.resolutionStaleMs)
+    ? options.resolutionStaleMs
+    : DEFAULT_COORDINATION_RESOLUTION_STALE_MS;
+  const recordMetricsById = new Map();
+  const overdueAckRecordIds = [];
+  const overdueClarificationIds = new Set();
+  let oldestOpenCoordinationAgeMs = null;
+  let oldestUnackedRequestAgeMs = null;
+
+  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 ackPending = ackTracked && record.status === "open";
+    const clarificationLinked =
+      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)) {
+      oldestOpenCoordinationAgeMs =
+        oldestOpenCoordinationAgeMs === null
+          ? ageMs
+          : Math.max(oldestOpenCoordinationAgeMs, ageMs);
+      if (ackPending) {
+        oldestUnackedRequestAgeMs =
+          oldestUnackedRequestAgeMs === null
+            ? ageMs
+            : Math.max(oldestUnackedRequestAgeMs, ageMs);
+      }
+    }
+    if (overdueAck) {
+      overdueAckRecordIds.push(record.id);
+    }
+    if (staleClarification) {
+      overdueClarificationIds.add(
+        record.kind === "clarification-request"
+          ? record.id
+          : clarificationIdFromClosureCondition(record.closureCondition) || record.id,
+      );
+    }
+    recordMetricsById.set(record.id, {
+      ageMs,
+      ageLabel: formatAgeMs(ageMs),
+      ackTracked,
+      ackPending,
+      overdueAck,
+      clarificationLinked,
+      staleClarification,
+    });
+  }
+
+  return {
+    ackTimeoutMs,
+    resolutionStaleMs,
+    oldestOpenCoordinationAgeMs,
+    oldestUnackedRequestAgeMs,
+    overdueAckCount: overdueAckRecordIds.length,
+    overdueClarificationCount: overdueClarificationIds.size,
+    overdueAckRecordIds: overdueAckRecordIds.toSorted((a, b) => a.localeCompare(b)),
+    overdueClarificationIds: Array.from(overdueClarificationIds).toSorted((a, b) =>
+      a.localeCompare(b),
+    ),
+    openHumanEscalationCount: (state?.humanEscalations || []).filter((record) =>
+      isOpenCoordinationStatus(record.status),
+    ).length,
+    recordMetricsById,
+  };
+}
+
+function renderOpenRecord(record, responseMetrics = null) {
   const targets = record.targets.length > 0 ? ` -> ${record.targets.join(", ")}` : "";
   const artifacts =
     record.artifactRefs.length > 0 ? ` [artifacts: ${record.artifactRefs.join(", ")}]` : "";
-  return `- [${record.priority}] ${record.kind}/${record.status} ${record.agentId}${targets}: ${compactSingleLine(record.summary || record.detail || "no summary", 160)}${artifacts}`;
+  const recordMetrics = responseMetrics?.recordMetricsById?.get?.(record.id) || null;
+  const tags = [];
+  if (recordMetrics?.ageLabel && recordMetrics.ageLabel !== "n/a") {
+    tags.push(`age=${recordMetrics.ageLabel}`);
+  }
+  if (recordMetrics?.overdueAck) {
+    tags.push("overdue-ack");
+  }
+  if (recordMetrics?.staleClarification) {
+    tags.push("stale-clarification");
+  }
+  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}`;
 }
 
 function renderActivityRecord(record) {
@@ -345,6 +519,7 @@ export function renderCoordinationBoardProjection({
   state,
   capabilityAssignments = [],
   dependencySnapshot = null,
+  timingOptions = null,
 }) {
   const latestRecords = Array.isArray(state?.latestRecords) ? state.latestRecords : [];
   const openRecords = latestRecords.filter((record) => OPEN_COORDINATION_STATUSES.has(record.status));
@@ -352,16 +527,29 @@ export function renderCoordinationBoardProjection({
   const openAssignments = (capabilityAssignments || []).filter((assignment) => assignment.blocking);
   const openInboundDependencies = dependencySnapshot?.openInbound || [];
   const openOutboundDependencies = dependencySnapshot?.openOutbound || [];
+  const responseMetrics = buildCoordinationResponseMetrics(state, timingOptions || {});
+  const oldestOpenAge =
+    responseMetrics.oldestOpenCoordinationAgeMs === null
+      ? "none"
+      : formatAgeMs(responseMetrics.oldestOpenCoordinationAgeMs);
+  const oldestUnackedAge =
+    responseMetrics.oldestUnackedRequestAgeMs === null
+      ? "none"
+      : formatAgeMs(responseMetrics.oldestUnackedRequestAgeMs);
   return [
     `# Wave ${wave} Message Board`,
     "",
     `- Wave file: \`${waveFile}\``,
     `- Agents: ${(agents || []).map((agent) => agent.agentId).join(", ")}`,
     `- Generated: ${toIsoTimestamp()}`,
+    `- Oldest open coordination age: ${oldestOpenAge}`,
+    `- Oldest unacknowledged request age: ${oldestUnackedAge}`,
+    `- Overdue acknowledgements: ${responseMetrics.overdueAckCount}`,
+    `- Overdue clarification chains: ${responseMetrics.overdueClarificationCount}`,
     "",
     "## Open Coordination State",
     ...(openRecords.length > 0
-      ? openRecords.map((record) => renderOpenRecord(record))
+      ? openRecords.map((record) => renderOpenRecord(record, responseMetrics))
       : ["- None."]),
     "",
     "## Helper Assignments",
@@ -457,6 +645,7 @@ export function compileSharedSummary({
   capabilityAssignments = [],
   dependencySnapshot = null,
   maxChars = 4000,
+  timingOptions = null,
 }) {
   const openBlockers = state.blockers.filter((record) => OPEN_COORDINATION_STATUSES.has(record.status));
   const openRequests = state.requests.filter((record) => OPEN_COORDINATION_STATUSES.has(record.status));
@@ -469,6 +658,7 @@ export function compileSharedSummary({
   const openHelperAssignments = (capabilityAssignments || []).filter((assignment) => assignment.blocking);
   const openInboundDependencies = dependencySnapshot?.openInbound || [];
   const openOutboundDependencies = dependencySnapshot?.openOutbound || [];
+  const responseMetrics = buildCoordinationResponseMetrics(state, timingOptions || {});
   const summary = [
     `# Wave ${wave.wave} Shared Summary`,
     "",
@@ -480,6 +670,10 @@ export function compileSharedSummary({
     `- Open helper assignments: ${openHelperAssignments.length}`,
     `- Open inbound dependencies: ${openInboundDependencies.length}`,
     `- Open outbound dependencies: ${openOutboundDependencies.length}`,
+    `- Oldest open coordination age: ${responseMetrics.oldestOpenCoordinationAgeMs === null ? "none" : formatAgeMs(responseMetrics.oldestOpenCoordinationAgeMs)}`,
+    `- Oldest unacknowledged request age: ${responseMetrics.oldestUnackedRequestAgeMs === null ? "none" : formatAgeMs(responseMetrics.oldestUnackedRequestAgeMs)}`,
+    `- Overdue acknowledgements: ${responseMetrics.overdueAckCount}`,
+    `- Overdue clarification chains: ${responseMetrics.overdueClarificationCount}`,
     ...(integrationSummary
       ? [`- Integration recommendation: ${integrationSummary.recommendation || "n/a"}`]
       : []),
@@ -498,12 +692,12 @@ export function compileSharedSummary({
     "",
     "## Current blockers",
     ...(openBlockers.length > 0
-      ? openBlockers.map((record) => renderOpenRecord(record))
+      ? openBlockers.map((record) => renderOpenRecord(record, responseMetrics))
       : ["- None."]),
     "",
     "## Current clarifications",
     ...(openClarifications.length > 0
-      ? openClarifications.map((record) => renderOpenRecord(record))
+      ? openClarifications.map((record) => renderOpenRecord(record, responseMetrics))
       : ["- None."]),
     "",
     "## Helper assignments",
@@ -588,6 +782,7 @@ export function compileAgentInbox({
   capabilityAssignments = [],
   dependencySnapshot = null,
   maxChars = 8000,
+  timingOptions = null,
 }) {
   const targetedRecords = state.openRecords.filter((record) => isTargetedToAgent(record, agent));
   const ownedRecords = (state.recordsByAgentId.get(agent.agentId) || []).filter((record) =>
@@ -624,6 +819,7 @@ export function compileAgentInbox({
   const helperAssignments = (capabilityAssignments || []).filter(
     (assignment) => assignment.blocking && assignment.assignedAgentId === agent.agentId,
   );
+  const responseMetrics = buildCoordinationResponseMetrics(state, timingOptions || {});
   const dependencyItems = [
     ...((dependencySnapshot?.inbound || []).filter(
       (record) =>
@@ -641,24 +837,30 @@ export function compileAgentInbox({
   const text = [
     `# Wave ${wave.wave} Inbox for ${agent.agentId}`,
     "",
+    "## Response timing",
+    `- Oldest open coordination age: ${responseMetrics.oldestOpenCoordinationAgeMs === null ? "none" : formatAgeMs(responseMetrics.oldestOpenCoordinationAgeMs)}`,
+    `- Oldest unacknowledged request age: ${responseMetrics.oldestUnackedRequestAgeMs === null ? "none" : formatAgeMs(responseMetrics.oldestUnackedRequestAgeMs)}`,
+    `- Overdue acknowledgements: ${responseMetrics.overdueAckCount}`,
+    `- Overdue clarification chains: ${responseMetrics.overdueClarificationCount}`,
+    "",
     "## Targeted open coordination",
     ...(targetedRecords.length > 0
-      ? targetedRecords.map((record) => renderOpenRecord(record))
+      ? targetedRecords.map((record) => renderOpenRecord(record, responseMetrics))
       : ["- None."]),
     "",
     "## Your open coordination items",
     ...(ownedRecords.length > 0
-      ? ownedRecords.map((record) => renderOpenRecord(record))
+      ? ownedRecords.map((record) => renderOpenRecord(record, responseMetrics))
       : ["- None."]),
     "",
     "## Clarifications",
     ...(clarificationRecords.length > 0
-      ? clarificationRecords.map((record) => renderOpenRecord(record))
+      ? clarificationRecords.map((record) => renderOpenRecord(record, responseMetrics))
       : ["- None."]),
     "",
     "## Relevant open coordination",
     ...(relevantRecords.length > 0
-      ? relevantRecords.map((record) => renderOpenRecord(record))
+      ? relevantRecords.map((record) => renderOpenRecord(record, responseMetrics))
       : ["- None."]),
     "",
     "## Helper assignments",

package/scripts/wave-orchestrator/coordination.mjs

@@ -455,6 +455,7 @@ export function buildExecutionPrompt({
     "- Follow repository instructions in AGENTS.md and CLAUDE.md if present.",
     "- Read the compiled shared summary and your compiled inbox before taking action on every turn.",
     "- Post a coordination record on every meaningful turn with progress, decisions, blockers, handoffs, evidence, or explicit acknowledgement.",
+    "- If your inbox or the coordination log shows a targeted open request for you, your first durable action is to acknowledge it, resolve it, or emit a clarification or human-feedback request. Silent targeted requests are treated as active blockers.",
     "- Re-read the generated board projection before major edits, before commit or push, and before your final report.",
     "- If you change interfaces or contracts, include exact files and exact keys or fields affected.",
     "- If your task touches persisted state, implement the required schema or migration work instead of leaving TODOs.",
@@ -511,6 +512,89 @@ export function buildExecutionPrompt({
   ].join("\n");
 }
 
+export function buildResidentOrchestratorPrompt({
+  lane,
+  wave,
+  waveFile,
+  orchestratorId,
+  coordinationLogPath,
+  messageBoardPath,
+  sharedSummaryPath,
+  dashboardPath,
+  triagePath = null,
+  rolePrompt = "",
+}) {
+  const coordinationCommand = [
+    "pnpm exec wave coord post",
+    `--lane ${lane}`,
+    `--wave ${wave}`,
+    '--agent "launcher"',
+    '--kind "<request|ack|decision|blocker|clarification-request|orchestrator-guidance|resolved-by-policy|human-escalation|human-feedback>"',
+    '--summary "<one-line summary>"',
+    '--detail "<short detail>"',
+  ].join(" ");
+  const feedbackCommand = [
+    "pnpm exec wave-feedback ask",
+    `--lane ${lane}`,
+    `--wave ${wave}`,
+    '--agent "launcher"',
+    `--orchestrator-id ${orchestratorId}`,
+    '--question "<specific clarification needed>"',
+    '--context "<why repo-state or routed ownership was insufficient>"',
+    "--timeout-seconds 30",
+  ].join(" ");
+  const roleSection = String(rolePrompt || "").trim();
+  return [
+    `Working directory: ${REPO_ROOT}`,
+    "",
+    `You are the resident Wave orchestrator for lane ${lane}, wave ${wave}.`,
+    "Your job is to stay alive for the duration of the wave, monitor coordination state, and intervene when timing, routing, or escalation policy requires it.",
+    "The launcher remains the scheduler truth and closure authority. You are an intervention and triage role, not a product-code owner.",
+    "",
+    "Hard limits:",
+    "- Do not edit product code, test code, docs, or owned deliverables.",
+    "- Do not claim another agent's ownership slice or emit proof markers for owned implementation work.",
+    "- Do not declare the wave complete or override launcher gate results.",
+    "",
+    "Primary responsibilities:",
+    "- Monitor the canonical coordination log, shared summary, wave dashboard, and feedback triage artifacts.",
+    "- Keep clarification handling orchestrator-first: resolve from repo state, ownership, prior decisions, or targeted rerouting before opening human escalation.",
+    "- Watch for overdue acknowledgements, stale clarification chains, and pending human tickets.",
+    "- Post durable coordination records and orchestrator notes when you intervene.",
+    "- Stay available. If there is no immediate action to take, keep monitoring instead of exiting early.",
+    "",
+    "Files for this run:",
+    `- Wave file: ${waveFile}`,
+    `- Coordination log: ${coordinationLogPath}`,
+    `- Shared summary: ${sharedSummaryPath}`,
+    `- Wave dashboard: ${dashboardPath}`,
+    `- Message board projection: ${messageBoardPath}`,
+    ...(triagePath ? [`- Feedback triage log: ${triagePath}`] : []),
+    "",
+    "Action surface:",
+    `- Coordination command: \`${coordinationCommand}\``,
+    `- Human feedback command: \`${feedbackCommand}\``,
+    "- Use repository inspection and read-only analysis aggressively before escalating anything to a human.",
+    "- When you route or reroute work, name the owner, exact unblock condition, and the artifact or decision needed.",
+    "",
+    "Operating loop:",
+    "1. Read the shared summary, dashboard, and coordination log.",
+    "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.",
+    "",
+    ...(roleSection
+      ? [
+          "Resident orchestrator role prompt:",
+          "```text",
+          roleSection,
+          "```",
+          "",
+        ]
+      : []),
+  ].join("\n");
+}
+
 export function buildOrchestratorBoardTemplate(boardPath) {
   const now = toIsoTimestamp();
   return [

package/scripts/wave-orchestrator/dashboard-renderer.mjs

@@ -182,6 +182,22 @@ function paintWaveAgentSummary(summary, wave, colorize = false) {
   return paint(summary, color, colorize);
 }
 
+function formatDurationMs(value) {
+  if (!Number.isFinite(value)) {
+    return "n/a";
+  }
+  const totalSeconds = Math.max(0, Math.floor(value / 1000));
+  if (totalSeconds < 60) {
+    return `${totalSeconds}s`;
+  }
+  const minutes = Math.floor(totalSeconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${minutes % 60}m`;
+}
+
 function renderWaveDashboard({ state, dashboardPath, messageBoardPath, lane, colorize = false }) {
   if (!state) {
     return `Dashboard file not found or invalid: ${dashboardPath}`;
@@ -200,15 +216,21 @@ function renderWaveDashboard({ state, dashboardPath, messageBoardPath, lane, col
   );
   lines.push(`Run tag: ${state.runTag || "n/a"} | Wave file: ${state.waveFile || "n/a"}`);
   lines.push(`Counts: ${renderColoredCountsByState(state.agents || [], colorize) || "none"}`);
+  lines.push(
+    `Coordination: open=${state.coordinationOpen ?? 0} clarifications=${state.openClarifications ?? 0} human=${state.openHumanEscalations ?? 0} overdue-ack=${state.overdueAckCount ?? 0} overdue-clarification=${state.overdueClarificationCount ?? 0}`,
+  );
+  lines.push(
+    `Coordination age: oldest-open=${formatDurationMs(state.oldestOpenCoordinationAgeMs)} oldest-unack=${formatDurationMs(state.oldestUnackedRequestAgeMs)}`,
+  );
   const comms = analyzeMessageBoardCommunication(messageBoardPath);
   if (!comms.available) {
-    lines.push(`Comms: unavailable ${comms.reason || ""}`.trim());
+    lines.push(`Board comms: unavailable ${comms.reason || ""}`.trim());
   } else {
     lines.push(
-      `Comms: requests=${comms.actionableRequests} unresolved=${comms.unresolvedRequests} unacknowledged=${comms.unacknowledgedRequests} malformed=${comms.malformedEntries} placeholder-ts=${comms.placeholderTimestampEntries}`,
+      `Board comms: requests=${comms.actionableRequests} unresolved=${comms.unresolvedRequests} unacknowledged=${comms.unacknowledgedRequests} malformed=${comms.malformedEntries} placeholder-ts=${comms.placeholderTimestampEntries}`,
     );
     lines.push(
-      `Comms age: last-ack=${commsAgeSummary(comms.lastAcknowledgementTimestamp)} oldest-unack=${commsAgeSummary(comms.oldestUnacknowledgedTimestamp)}`,
+      `Board comms age: last-ack=${commsAgeSummary(comms.lastAcknowledgementTimestamp)} oldest-unack=${commsAgeSummary(comms.oldestUnacknowledgedTimestamp)}`,
     );
   }
   lines.push("");
@@ -306,6 +328,19 @@ function renderGlobalDashboard({ state, dashboardPath, lane, colorize = false })
         12,
       )} ${truncate(wave.lastMessage || "", 70)}`,
     );
+    if (
+      Number(wave?.coordinationOpen ?? 0) > 0 ||
+      Number(wave?.overdueAckCount ?? 0) > 0 ||
+      Number(wave?.overdueClarificationCount ?? 0) > 0 ||
+      Number(wave?.openHumanEscalations ?? 0) > 0
+    ) {
+      lines.push(
+        `      Coord: open ${wave.coordinationOpen ?? 0} clarifications ${wave.openClarifications ?? 0} human ${wave.openHumanEscalations ?? 0} overdue-ack ${wave.overdueAckCount ?? 0} overdue-clarification ${wave.overdueClarificationCount ?? 0}`,
+      );
+      lines.push(
+        `      Ages: oldest-open ${formatDurationMs(wave.oldestOpenCoordinationAgeMs)} oldest-unack ${formatDurationMs(wave.oldestUnackedRequestAgeMs)}`,
+      );
+    }
     const deployments = Array.isArray(wave.deployments) ? wave.deployments : [];
     if (deployments.length > 0) {
       const deployLine = deployments

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

@@ -149,6 +149,13 @@ export function buildWaveDashboardState({
     helperAssignmentsOpen: 0,
     inboundDependenciesOpen: 0,
     outboundDependenciesOpen: 0,
+    coordinationOpen: 0,
+    openClarifications: 0,
+    openHumanEscalations: 0,
+    oldestOpenCoordinationAgeMs: null,
+    oldestUnackedRequestAgeMs: null,
+    overdueAckCount: 0,
+    overdueClarificationCount: 0,
     agents: agentRuns.map((run) => ({
       agentId: run.agent.agentId,
       title: run.agent.title,
@@ -200,6 +207,7 @@ export function buildGlobalDashboardState({
       maxRetriesPerWave: options.maxRetriesPerWave,
       dashboard: options.dashboard,
       cleanupSessions: options.cleanupSessions,
+      residentOrchestrator: options.residentOrchestrator === true,
       orchestratorId: options.orchestratorId,
       orchestratorBoardPath: options.orchestratorBoardPath
         ? path.relative(REPO_ROOT, options.orchestratorBoardPath)
@@ -235,6 +243,13 @@ export function buildGlobalDashboardState({
       helperAssignmentsOpen: 0,
       inboundDependenciesOpen: 0,
       outboundDependenciesOpen: 0,
+      coordinationOpen: 0,
+      openClarifications: 0,
+      openHumanEscalations: 0,
+      oldestOpenCoordinationAgeMs: null,
+      oldestUnackedRequestAgeMs: null,
+      overdueAckCount: 0,
+      overdueClarificationCount: 0,
       lastMessage: "",
       deployments: [],
       infraFindings: [],
@@ -323,6 +338,13 @@ export function syncGlobalWaveFromWaveDashboard(globalState, waveDashboard) {
   entry.helperAssignmentsOpen = waveDashboard.helperAssignmentsOpen || 0;
   entry.inboundDependenciesOpen = waveDashboard.inboundDependenciesOpen || 0;
   entry.outboundDependenciesOpen = waveDashboard.outboundDependenciesOpen || 0;
+  entry.coordinationOpen = waveDashboard.coordinationOpen || 0;
+  entry.openClarifications = waveDashboard.openClarifications || 0;
+  entry.openHumanEscalations = waveDashboard.openHumanEscalations || 0;
+  entry.oldestOpenCoordinationAgeMs = waveDashboard.oldestOpenCoordinationAgeMs ?? null;
+  entry.oldestUnackedRequestAgeMs = waveDashboard.oldestUnackedRequestAgeMs ?? null;
+  entry.overdueAckCount = waveDashboard.overdueAckCount || 0;
+  entry.overdueClarificationCount = waveDashboard.overdueClarificationCount || 0;
   entry.deployments = agents
     .filter((agent) => agent.deploymentState)
     .map((agent) => ({

package/scripts/wave-orchestrator/evals.mjs

@@ -351,6 +351,12 @@ export function loadBenchmarkCatalog(options = {}) {
         id: benchmarkId,
         title: cleanText(benchmark.title) || benchmarkId,
         summary: cleanText(benchmark.summary) || null,
+        localCases: normalizeStringArray(
+          benchmark.localCases,
+          `families.${familyId}.benchmarks.${benchmarkId}.localCases`,
+        ).map((entry, index) =>
+          normalizeEvalTargetId(entry, `families.${familyId}.benchmarks.${benchmarkId}.localCases[${index}]`),
+        ),
         goal: cleanText(benchmark.goal) || null,
         failureModes: normalizeStringArray(
           benchmark.failureModes,
@@ -380,6 +386,12 @@ export function loadBenchmarkCatalog(options = {}) {
       id: familyId,
       title: cleanText(rawFamily.title) || familyId,
       summary: cleanText(rawFamily.summary) || null,
+      localCases: normalizeStringArray(
+        rawFamily.localCases,
+        `families.${familyId}.localCases`,
+      ).map((entry, index) =>
+        normalizeEvalTargetId(entry, `families.${familyId}.localCases[${index}]`),
+      ),
       category: cleanText(rawFamily.category) || null,
       coordinationModel: cleanText(rawFamily.coordinationModel) || null,
       primaryMetric: familyPrimaryMetric,
@@ -395,6 +407,17 @@ export function loadBenchmarkCatalog(options = {}) {
     absolutePath,
     families,
     benchmarkIndex,
+    localCaseIndex: Object.fromEntries(
+      Object.values(families).flatMap((family) => [
+        ...(family.localCases || []).map((caseId) => [caseId, { familyId: family.id, benchmarkId: null }]),
+        ...Object.values(family.benchmarks).flatMap((benchmark) =>
+          (benchmark.localCases || []).map((caseId) => [
+            caseId,
+            { familyId: family.id, benchmarkId: benchmark.id },
+          ]),
+        ),
+      ]),
+    ),
   };
 }
 

package/scripts/wave-orchestrator/executors.mjs

@@ -210,7 +210,8 @@ function buildClaudeLaunchSpec({ agent, promptPath, logPath, overlayDir }) {
     systemPromptPath,
     `${renderHarnessSystemPrompt(agent, "claude")}${skillText ? `\n\n${skillText}` : ""}\n`,
   );
-  const tokens = [executor.claude.command, "-p", "--no-session-persistence"];
+  const command = executor?.claude?.command || "claude";
+  const tokens = [command, "-p", "--no-session-persistence"];
   const settingsPath = buildClaudeSettingsPath(executor, overlayDir);
   appendSingleValueFlag(tokens, "--output-format", executor.claude.outputFormat || "text");
   appendSingleValueFlag(tokens, "--model", executor.claude.model || executor.model);
@@ -234,7 +235,7 @@ function buildClaudeLaunchSpec({ agent, promptPath, logPath, overlayDir }) {
   );
   return {
     executorId: "claude",
-    command: executor.claude.command,
+    command,
     useRateLimitRetries: true,
     invocationLines: [
       `task_prompt=$(cat ${shellQuote(promptPath)})`,