@chllming/wave-orchestration 0.8.5 → 0.8.7

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

@@ -10,7 +10,7 @@ import {
   readWaveDependencyBarrier,
 } from "./gate-engine.mjs";
 import {
-  isOpenCoordinationStatus,
+  coordinationRecordBlocksWave,
   openClarificationLinkedRequests,
 } from "./coordination-store.mjs";
 import {
@@ -197,6 +197,7 @@ export function relaunchReasonBuckets(runs, failures, derivedState) {
   const selectedAgentIds = new Set((runs || []).map((run) => run.agent.agentId));
   return {
     clarification: openClarificationLinkedRequests(derivedState?.coordinationState)
+      .filter((record) => coordinationRecordBlocksWave(record))
       .flatMap((record) => record.targets || [])
       .some((target) => {
         const agentId = String(target || "").startsWith("agent:")
@@ -212,7 +213,7 @@ export function relaunchReasonBuckets(runs, failures, derivedState) {
     )),
     blocker: (derivedState?.coordinationState?.blockers || []).some(
       (record) =>
-        isOpenCoordinationStatus(record.status) &&
+        coordinationRecordBlocksWave(record) &&
         (selectedAgentIds.has(record.agentId) ||
           (record.targets || []).some((target) => {
             const agentId = String(target || "").startsWith("agent:")
@@ -239,7 +240,10 @@ const HUMAN_INPUT_BLOCKER_KINDS = new Set([
 ]);
 
 function isHumanInputBlocker(blocker) {
-  return HUMAN_INPUT_BLOCKER_KINDS.has(String(blocker?.kind || "").trim().toLowerCase());
+  return (
+    blocker?.blocking !== false &&
+    HUMAN_INPUT_BLOCKER_KINDS.has(String(blocker?.kind || "").trim().toLowerCase())
+  );
 }
 
 function normalizeRetryTargets(retryTargetSet) {
@@ -672,10 +676,10 @@ function resolveRelaunchRunsLegacy(agentRuns, failures, derivedState, lanePaths,
   const roleBindings = resolveWaveRoleBindings(waveDefinition, lanePaths, waveDefinition?.agents);
   const runsByAgentId = new Map(agentRuns.map((run) => [run.agent.agentId, run]));
   const pendingFeedback = (derivedState?.coordinationState?.humanFeedback || []).filter((record) =>
-    isOpenCoordinationStatus(record.status),
+    coordinationRecordBlocksWave(record),
   );
   const pendingHumanEscalations = (derivedState?.coordinationState?.humanEscalations || []).filter(
-    (record) => isOpenCoordinationStatus(record.status),
+    (record) => coordinationRecordBlocksWave(record),
   );
   if (pendingFeedback.length > 0 || pendingHumanEscalations.length > 0) {
     return { runs: [], barrier: null };
@@ -693,7 +697,9 @@ function resolveRelaunchRunsLegacy(agentRuns, failures, derivedState, lanePaths,
     return { runs: [], barrier: retryBarrier };
   }
   const clarificationTargets = new Set();
-  for (const record of openClarificationLinkedRequests(derivedState?.coordinationState)) {
+  for (const record of openClarificationLinkedRequests(derivedState?.coordinationState).filter((entry) =>
+    coordinationRecordBlocksWave(entry),
+  )) {
     for (const target of record.targets || []) {
       if (String(target).startsWith("agent:")) {
         clarificationTargets.add(String(target).slice("agent:".length));
@@ -782,7 +788,7 @@ function resolveRelaunchRunsLegacy(agentRuns, failures, derivedState, lanePaths,
   }
   const blockerAgentIds = new Set();
   for (const record of derivedState?.coordinationState?.blockers || []) {
-    if (!isOpenCoordinationStatus(record.status)) {
+    if (!coordinationRecordBlocksWave(record)) {
       continue;
     }
     blockerAgentIds.add(record.agentId);
@@ -867,10 +873,10 @@ function resolveRelaunchRunsFromWaveState(
 ) {
   const roleBindings = resolveWaveRoleBindings(waveDefinition, lanePaths, waveDefinition?.agents);
   const pendingFeedback = (waveState?.coordinationState?.humanFeedback || []).filter((record) =>
-    isOpenCoordinationStatus(record.status),
+    coordinationRecordBlocksWave(record),
   );
   const pendingHumanEscalations = (waveState?.coordinationState?.humanEscalations || []).filter(
-    (record) => isOpenCoordinationStatus(record.status),
+    (record) => coordinationRecordBlocksWave(record),
   );
   if (pendingFeedback.length > 0 || pendingHumanEscalations.length > 0) {
     return { runs: [], barrier: null };
@@ -890,7 +896,9 @@ function resolveRelaunchRunsFromWaveState(
   }
 
   const clarificationTargets = new Set();
-  for (const record of openClarificationLinkedRequests(waveState?.coordinationState)) {
+  for (const record of openClarificationLinkedRequests(waveState?.coordinationState).filter((entry) =>
+    coordinationRecordBlocksWave(entry),
+  )) {
     for (const target of record.targets || []) {
       if (String(target).startsWith("agent:")) {
         clarificationTargets.add(String(target).slice("agent:".length));
@@ -967,7 +975,7 @@ function resolveRelaunchRunsFromWaveState(
 
   const blockerAgentIds = new Set();
   for (const record of waveState?.coordinationState?.blockers || []) {
-    if (!isOpenCoordinationStatus(record.status)) {
+    if (!coordinationRecordBlocksWave(record)) {
       continue;
     }
     blockerAgentIds.add(record.agentId);

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

@@ -2,6 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import {
   appendCoordinationRecord,
+  coordinationBlockerSeverity,
+  coordinationRecordBlocksWave,
   isOpenCoordinationStatus,
   materializeCoordinationState,
   readCoordinationLog,
@@ -29,6 +31,32 @@ function openTaskCountForAgent(ledger, agentId) {
   ).length;
 }
 
+function completedTaskCountForAgent(ledger, agentId) {
+  return (ledger?.tasks || []).filter(
+    (task) => task.owner === agentId && ["done", "closed", "resolved"].includes(task.state),
+  ).length;
+}
+
+function completedCapabilityCountForAgent(ledger, agentId, capability) {
+  const normalizedCapability = normalizeCapability(capability);
+  if (!normalizedCapability) {
+    return 0;
+  }
+  const taskCount = (ledger?.tasks || []).filter(
+    (task) =>
+      task.owner === agentId &&
+      ["done", "closed", "resolved"].includes(task.state) &&
+      normalizeCapability(task.capability) === normalizedCapability,
+  ).length;
+  const assignmentCount = (ledger?.capabilityAssignments || []).filter(
+    (assignment) =>
+      assignment.assignedAgentId === agentId &&
+      ["done", "closed", "resolved"].includes(String(assignment.state || "").trim().toLowerCase()) &&
+      normalizeCapability(assignment.capability) === normalizedCapability,
+  ).length;
+  return taskCount + assignmentCount;
+}
+
 function resolveTargetAssignment(target, agents, ledger, capabilityRouting = {}) {
   const normalizedTarget = String(target || "").trim();
   if (!normalizedTarget) {
@@ -94,6 +122,12 @@ function resolveTargetAssignment(target, agents, ledger, capabilityRouting = {})
       (agent) => Array.isArray(agent.capabilities) && agent.capabilities.includes(capability),
     );
     candidates.sort((left, right) => {
+      const capabilityCompletionDiff =
+        completedCapabilityCountForAgent(ledger, right.agentId, capability) -
+        completedCapabilityCountForAgent(ledger, left.agentId, capability);
+      if (capabilityCompletionDiff !== 0) {
+        return capabilityCompletionDiff;
+      }
       const taskDiff = openTaskCountForAgent(ledger, left.agentId) - openTaskCountForAgent(ledger, right.agentId);
       if (taskDiff !== 0) {
         return taskDiff;
@@ -101,14 +135,25 @@ function resolveTargetAssignment(target, agents, ledger, capabilityRouting = {})
       return String(left.agentId).localeCompare(String(right.agentId));
     });
     if (candidates[0]) {
+      const demonstratedCapabilityCompletions = completedCapabilityCountForAgent(
+        ledger,
+        candidates[0].agentId,
+        capability,
+      );
       return {
         assignedAgentId: candidates[0].agentId,
         target: normalizedTarget,
         targetType: "capability",
         capability,
-        assignmentReason: "least-busy-capability",
+        assignmentReason:
+          demonstratedCapabilityCompletions > 0
+            ? "same-wave-capability-owner"
+            : "least-busy-capability",
         blocking: true,
-        detail: `Capability ${capability} routed to ${candidates[0].agentId}.`,
+        detail:
+          demonstratedCapabilityCompletions > 0
+            ? `Capability ${capability} routed to ${candidates[0].agentId} based on demonstrated same-wave capability work (${demonstratedCapabilityCompletions}).`
+            : `Capability ${capability} routed to ${candidates[0].agentId}.`,
       };
     }
     return {
@@ -265,6 +310,7 @@ export function buildRequestAssignments({
       });
       const resolvedByPolicy = Boolean(resolvedByPolicyRecord);
       const effectiveStatus = resolvedByPolicy ? "resolved" : record.status;
+      const blocking = !resolvedByPolicy && coordinationRecordBlocksWave(record);
       assignments.push({
         id: assignmentId,
         requestId: record.id,
@@ -282,7 +328,8 @@ export function buildRequestAssignments({
         assignedAgentId: resolution.assignedAgentId,
         assignmentReason: resolution.assignmentReason,
         assignmentDetail: resolution.detail,
-        blocking: !resolvedByPolicy && isOpenCoordinationStatus(record.status),
+        blocking,
+        blockerSeverity: coordinationBlockerSeverity(record),
         artifactRefs: Array.isArray(record.artifactRefs) ? record.artifactRefs : [],
         dependsOn: Array.isArray(record.dependsOn) ? record.dependsOn : [],
         closureCondition: String(record.closureCondition || ""),

package/scripts/wave-orchestrator/session-supervisor.mjs

@@ -27,6 +27,7 @@ import {
   writeJsonAtomic,
 } from "./shared.mjs";
 import {
+  createWaveAgentSessionName,
   killTmuxSessionIfExists,
   terminalSurfaceUsesTerminalRegistry,
   pruneOrphanLaneTemporaryTerminalEntries,
@@ -40,6 +41,13 @@ import {
   launchAgentSession as launchAgentSessionImpl,
   waitForWaveCompletion as waitForWaveCompletionImpl,
 } from "./launcher-runtime.mjs";
+import {
+  agentUsesSignalHygiene,
+  buildSignalStatusLine,
+  residentSignalAckPath,
+  residentSignalPath,
+  syncWaveSignalProjections,
+} from "./signals.mjs";
 
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) {
@@ -342,9 +350,10 @@ export function buildResidentOrchestratorRun({
     executorResolved,
   };
   const baseName = `wave-${wave.wave}-resident-orchestrator`;
-  const sessionName = `${lanePaths.tmuxSessionPrefix}${wave.wave}_resident_orchestrator_${runTag}`.replace(
-    /[^a-zA-Z0-9_-]/g,
-    "_",
+  const sessionName = createWaveAgentSessionName(
+    lanePaths,
+    wave.wave,
+    "resident_orchestrator",
   );
   return {
     run: {
@@ -363,6 +372,8 @@ export function buildResidentOrchestratorRun({
         sharedSummaryPath: derivedState.sharedSummaryPath,
         dashboardPath,
         triagePath: derivedState.clarificationTriage?.triagePath || null,
+        signalStatePath: residentSignalPath(lanePaths, wave.wave),
+        signalAckPath: residentSignalAckPath(lanePaths, wave.wave),
         rolePrompt: agent.prompt,
       }),
     },
@@ -434,15 +445,9 @@ function isWaveDashboardBackedByLiveSession(lanePaths, dashboardPath, activeSess
   if (!Number.isFinite(waveNumber)) {
     return false;
   }
-  const dashboardState = readJsonOrNull(dashboardPath);
-  const runTag = String(dashboardState?.runTag || "").trim();
   const agentPrefix = `${lanePaths.tmuxSessionPrefix}${waveNumber}_`;
-  const dashboardPrefix = `${lanePaths.tmuxDashboardSessionPrefix}${waveNumber}_`;
   for (const sessionName of activeSessionNames) {
-    if (!(sessionName.startsWith(agentPrefix) || sessionName.startsWith(dashboardPrefix))) {
-      continue;
-    }
-    if (!runTag || sessionName.endsWith(`_${runTag}`)) {
+    if (sessionName.startsWith(agentPrefix)) {
       return true;
     }
   }
@@ -777,3 +782,107 @@ export function monitorWaveHumanFeedback({
   }
   return changed;
 }
+
+export function syncLiveWaveSignals({
+  lanePaths,
+  wave,
+  statusPayload,
+  agentRuns,
+  residentEnabled = false,
+  recordCombinedEvent,
+  appendCoordination,
+}) {
+  const activeSignalAgents = new Set(
+    (Array.isArray(agentRuns) ? agentRuns : [])
+      .filter((run) => agentUsesSignalHygiene(run?.agent))
+      .map((run) => run.agent.agentId),
+  );
+  const syncResult = syncWaveSignalProjections({
+    lanePaths,
+    wave,
+    statusPayload,
+    includeResident: residentEnabled,
+  });
+  if (syncResult.wave?.changed) {
+    appendWaveControlEvent(lanePaths, wave.wave, {
+      entityType: "wave_signal",
+      entityId: `wave-${wave.wave}`,
+      action: "updated",
+      source: "session-supervisor",
+      actor: "session-supervisor",
+      data: syncResult.wave.snapshot,
+    });
+    if (typeof recordCombinedEvent === "function") {
+      recordCombinedEvent({
+        level: syncResult.wave.snapshot.shouldWake ? "warn" : "info",
+        message: `Wave signal updated: ${buildSignalStatusLine(syncResult.wave.snapshot)}`,
+      });
+    }
+  }
+  for (const agentResult of syncResult.agents || []) {
+    if (!agentResult.changed) {
+      continue;
+    }
+    appendWaveControlEvent(lanePaths, wave.wave, {
+      entityType: "agent_signal",
+      entityId: `wave-${wave.wave}-agent-${agentResult.agentId}`,
+      action: "updated",
+      source: "session-supervisor",
+      actor: "session-supervisor",
+      data: agentResult.snapshot,
+    });
+    if (
+      agentResult.snapshot?.shouldWake &&
+      activeSignalAgents.has(agentResult.agentId) &&
+      typeof recordCombinedEvent === "function"
+    ) {
+      recordCombinedEvent({
+        level: "info",
+        agentId: agentResult.agentId,
+        message: `Signal changed: ${buildSignalStatusLine(agentResult.snapshot, {
+          lane: lanePaths.lane,
+          wave: wave.wave,
+          agentId: agentResult.agentId,
+        })}`,
+      });
+    }
+  }
+  if (syncResult.resident?.changed) {
+    appendWaveControlEvent(lanePaths, wave.wave, {
+      entityType: "agent_signal",
+      entityId: `wave-${wave.wave}-agent-resident-orchestrator`,
+      action: "updated",
+      source: "session-supervisor",
+      actor: "session-supervisor",
+      data: syncResult.resident.snapshot,
+    });
+    if (syncResult.resident.snapshot?.shouldWake && typeof recordCombinedEvent === "function") {
+      recordCombinedEvent({
+        level: "info",
+        agentId: "ORCH",
+        message: `Resident orchestrator signal changed: ${buildSignalStatusLine(
+          syncResult.resident.snapshot,
+          {
+            lane: lanePaths.lane,
+            wave: wave.wave,
+            agentId: "resident-orchestrator",
+          },
+        )}`,
+      });
+    }
+    if (
+      syncResult.resident.snapshot?.shouldWake &&
+      typeof appendCoordination === "function"
+    ) {
+      appendCoordination({
+        event: "resident_signal_updated",
+        waves: [wave.wave],
+        status: "running",
+        details: syncResult.resident.snapshot.reason || syncResult.resident.snapshot.signal,
+        actionRequested:
+          "Resident orchestrator should re-read the signal snapshot, shared summary, dashboard, and coordination log.",
+      });
+    }
+  }
+  return syncResult;
+}

package/scripts/wave-orchestrator/shared.mjs

@@ -199,6 +199,7 @@ export function buildLanePaths(laneInput = DEFAULT_WAVE_LANE, options = {}) {
     telemetryDir: path.join(stateDir, "control-plane", "telemetry"),
     assignmentsDir: path.join(stateDir, "assignments"),
     inboxesDir: path.join(stateDir, "inboxes"),
+    signalsDir: path.join(stateDir, "signals"),
     ledgerDir: path.join(stateDir, "ledger"),
     integrationDir: path.join(stateDir, "integration"),
     resultsDir: path.join(stateDir, "results"),