@chllming/wave-orchestration 0.8.4 → 0.8.6

package/scripts/wave-orchestrator/task-entity.mjs

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import { toIsoTimestamp } from "./shared.mjs";
 import {
+  validateDesignSummary,
   validateImplementationSummary,
   validateContQaSummary,
   validateContEvalSummary,
@@ -11,6 +12,8 @@ import {
 import {
   isContEvalImplementationOwningAgent,
   isContEvalReportOnlyAgent,
+  isDesignAgent,
+  isImplementationOwningDesignAgent,
   isSecurityReviewAgent,
 } from "./role-helpers.mjs";
 import {
@@ -19,6 +22,7 @@ import {
 } from "./coordination-store.mjs";
 
 export const TASK_TYPES = new Set([
+  "design",
   "implementation",
   "integration",
   "documentation",
@@ -484,7 +488,8 @@ export function buildTasksFromWaveDefinition(waveDefinition, laneConfig = {}) {
 
   for (const agent of agents) {
     const agentId = agent.agentId;
-    const taskType =
+    const hybridDesignAgent = isImplementationOwningDesignAgent(agent);
+    const baseTaskType =
       agentId === contQaAgentId
         ? "cont-qa"
         : agentId === contEvalAgentId
@@ -493,9 +498,11 @@ export function buildTasksFromWaveDefinition(waveDefinition, laneConfig = {}) {
             ? "integration"
             : agentId === documentationAgentId
               ? "documentation"
-              : isSecurityReviewAgent(agent)
-                ? "security"
-                : "implementation";
+              : isDesignAgent(agent)
+                ? "design"
+                : isSecurityReviewAgent(agent)
+                  ? "security"
+                  : "implementation";
     const exitContract =
       agent.exitContract && typeof agent.exitContract === "object"
         ? { ...agent.exitContract }
@@ -509,7 +516,7 @@ export function buildTasksFromWaveDefinition(waveDefinition, laneConfig = {}) {
     const proofLevel = exitContract?.proof || "unit";
     let proofCentric = false;
     let maturityTarget = null;
-    if (taskType === "implementation") {
+    if (baseTaskType === "implementation" || hybridDesignAgent) {
       if (Array.isArray(agent.deliverables) && agent.deliverables.length > 0) {
         proofCentric = true;
       }
@@ -539,48 +546,54 @@ export function buildTasksFromWaveDefinition(waveDefinition, laneConfig = {}) {
     const scope = agent.title
       ? normalizeText(agent.title).toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "")
       : "primary";
-    const semanticId = buildSemanticTaskId(waveNumber, agentId, scope);
-
-    tasks.push(
-      normalizeTask(
-        {
-          taskId: semanticId,
-          taskType,
-          title: `${agentId}: ${agent.title || ""}`.trim(),
-          detail: agent.detail || "",
-          ownerAgentId: agentId,
-          assigneeAgentId: agentId,
-          waveNumber,
-          lane,
-          artifactContract: {
-            deliverables,
-            proofArtifacts,
-            requiredPaths: normalizeStringArray(agent.ownedPaths || []),
-            exitContract,
-            componentTargets,
+    const pushAgentTask = (taskType, taskScope, overrides = {}) => {
+      tasks.push(
+        normalizeTask(
+          {
+            taskId: buildSemanticTaskId(waveNumber, agentId, `${scope}-${taskScope}`),
+            taskType,
+            title: `${agentId}: ${agent.title || ""}`.trim(),
+            detail: agent.detail || "",
+            ownerAgentId: agentId,
+            assigneeAgentId: agentId,
+            waveNumber,
+            lane,
+            artifactContract: {
+              deliverables,
+              proofArtifacts,
+              requiredPaths: normalizeStringArray(agent.ownedPaths || []),
+              exitContract,
+              componentTargets,
+            },
+            proofRequirements: {
+              proofLevel,
+              proofCentric,
+              maturityTarget,
+            },
+            dependencyEdges: [],
+            components,
+            status: "pending",
+            closureState: "open",
+            priority: taskType === "implementation" ? "normal" : "high",
+            ...overrides,
           },
-          proofRequirements: {
-            proofLevel,
-            proofCentric,
-            maturityTarget,
+          {
+            createdAt: seededAt,
+            updatedAt: seededAt,
+            waveNumber,
+            lane,
           },
-          dependencyEdges: [],
-          components,
-          status: "pending",
-          closureState: "open",
-          priority:
-            taskType === "implementation"
-              ? "normal"
-              : "high",
-        },
-        {
-          createdAt: seededAt,
-          updatedAt: seededAt,
-          waveNumber,
-          lane,
-        },
-      ),
-    );
+        ),
+      );
+    };
+
+    if (hybridDesignAgent && baseTaskType === "design") {
+      pushAgentTask("design", "design");
+      pushAgentTask("implementation", "implementation");
+      continue;
+    }
+
+    pushAgentTask(baseTaskType, baseTaskType);
   }
 
   for (const promotion of waveDefinition.componentPromotions || []) {
@@ -837,6 +850,13 @@ export function evaluateOwnedSliceProven(task, agentResult, proofBundles = []) {
     return { proven: true, reason: "Exit contract satisfied" };
   }
 
+  if (task.taskType === "design") {
+    const validation = validateDesignSummary(agent, agentResult);
+    return validation.ok
+      ? { proven: true, reason: "Design packet satisfied" }
+      : { proven: false, reason: validation.detail || validation.statusCode };
+  }
+
   if (task.taskType === "component") {
     // Component promotion task: validate that all relevant owners have promoted
     const componentTargets = task.artifactContract?.componentTargets || {};

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

@@ -13,6 +13,8 @@ export const WAVE_CONTROL_ENTITY_TYPES = new Set([
   "fact",
   "wave_run",
   "agent_run",
+  "wave_signal",
+  "agent_signal",
   "coordination_record",
   "gate",
   "artifact",

package/scripts/wave-orchestrator/wave-files.mjs

@@ -7,6 +7,7 @@ import {
   DEFAULT_CONT_EVAL_ROLE_PROMPT_PATH,
   DEFAULT_CONT_QA_AGENT_ID,
   DEFAULT_CONT_QA_ROLE_PROMPT_PATH,
+  DEFAULT_DESIGN_ROLE_PROMPT_PATH,
   DEFAULT_DOCUMENTATION_AGENT_ID,
   DEFAULT_DOCUMENTATION_ROLE_PROMPT_PATH,
   DEFAULT_INTEGRATION_AGENT_ID,
@@ -60,6 +61,11 @@ import {
   isContEvalReportOnlyAgent,
   isContEvalReportPath,
   isContQaReportPath,
+  isDesignAgent,
+  isDocsOnlyDesignAgent,
+  isImplementationOwningDesignAgent,
+  isDesignRolePromptPath,
+  resolveDesignReportPath,
   isSecurityRolePromptPath,
   isSecurityReviewAgent,
   resolveSecurityReviewReportPath,
@@ -77,6 +83,7 @@ export const WAVE_CONT_EVAL_ROLE_PROMPT_PATH = DEFAULT_CONT_EVAL_ROLE_PROMPT_PAT
 export const WAVE_INTEGRATION_ROLE_PROMPT_PATH = DEFAULT_INTEGRATION_ROLE_PROMPT_PATH;
 export const WAVE_DOCUMENTATION_ROLE_PROMPT_PATH = DEFAULT_DOCUMENTATION_ROLE_PROMPT_PATH;
 export const WAVE_SECURITY_ROLE_PROMPT_PATH = DEFAULT_SECURITY_ROLE_PROMPT_PATH;
+export const WAVE_DESIGN_ROLE_PROMPT_PATH = DEFAULT_DESIGN_ROLE_PROMPT_PATH;
 export const SHARED_PLAN_DOC_PATHS = [
   "docs/plans/current-state.md",
   "docs/plans/master-plan.md",
@@ -113,6 +120,10 @@ function resolveSecurityRolePromptPath(laneProfile) {
   return laneProfile?.roles?.securityRolePromptPath || DEFAULT_SECURITY_ROLE_PROMPT_PATH;
 }
 
+function resolveDesignRolePromptPath(laneProfile) {
+  return laneProfile?.roles?.designRolePromptPath || DEFAULT_DESIGN_ROLE_PROMPT_PATH;
+}
+
 function normalizeSecurityCapabilities(capabilities, rolePromptPaths, securityRolePromptPath) {
   const normalized = Array.isArray(capabilities) ? [...capabilities] : [];
   const hasSecurityRolePrompt = Array.isArray(rolePromptPaths)
@@ -129,6 +140,22 @@ function normalizeSecurityCapabilities(capabilities, rolePromptPaths, securityRo
   return normalized;
 }
 
+function normalizeDesignCapabilities(capabilities, rolePromptPaths, designRolePromptPath) {
+  const normalized = Array.isArray(capabilities) ? [...capabilities] : [];
+  const hasDesignRolePrompt = Array.isArray(rolePromptPaths)
+    ? rolePromptPaths.some((rolePromptPath) =>
+        isDesignRolePromptPath(rolePromptPath, designRolePromptPath),
+      )
+    : false;
+  if (
+    hasDesignRolePrompt &&
+    !normalized.some((capability) => String(capability || "").trim().toLowerCase() === "design")
+  ) {
+    normalized.push("design");
+  }
+  return normalized;
+}
+
 export function waveNumberFromFileName(fileName) {
   const match = fileName.match(/^wave-(\d+)\.md$/);
   if (!match) {
@@ -1166,12 +1193,14 @@ function isImplementationOwningWaveAgent(
     contEvalAgentId,
     integrationAgentId,
     documentationAgentId,
+    designRolePromptPath,
     securityRolePromptPath,
   },
 ) {
   return (
     ![contQaAgentId, integrationAgentId, documentationAgentId].includes(agent.agentId) &&
     !isContEvalReportOnlyAgent(agent, { contEvalAgentId }) &&
+    !isDocsOnlyDesignAgent(agent, { designRolePromptPath }) &&
     !isSecurityReviewAgent(agent, { securityRolePromptPath })
   );
 }
@@ -1184,6 +1213,12 @@ function resolveAgentSummaryReportPath(wave, agentId, { contQaAgentId, contEvalA
     return path.resolve(REPO_ROOT, wave.contEvalReportPath);
   }
   const agent = wave?.agents?.find((entry) => entry.agentId === agentId);
+  if (isDesignAgent(agent)) {
+    const designReportPath = resolveDesignReportPath(agent);
+    if (designReportPath) {
+      return path.resolve(REPO_ROOT, designReportPath);
+    }
+  }
   if (isSecurityReviewAgent(agent)) {
     const securityReportPath = resolveSecurityReviewReportPath(agent);
     if (securityReportPath) {
@@ -1387,6 +1422,7 @@ export function validateWaveDefinition(wave, options = {}) {
   const documentationAgentId =
     laneProfile.roles.documentationAgentId || DEFAULT_DOCUMENTATION_AGENT_ID;
   const securityRolePromptPath = resolveSecurityRolePromptPath(laneProfile);
+  const designRolePromptPath = resolveDesignRolePromptPath(laneProfile);
   const documentationThreshold = laneProfile.validation.requireDocumentationStewardFromWave;
   const context7Threshold = laneProfile.validation.requireContext7DeclarationsFromWave;
   const exitContractThreshold = laneProfile.validation.requireExitContractsFromWave;
@@ -1437,6 +1473,7 @@ export function validateWaveDefinition(wave, options = {}) {
       contEvalAgentId,
       integrationAgentId,
       documentationAgentId,
+      designRolePromptPath,
       securityRolePromptPath,
     }),
   );
@@ -1497,6 +1534,10 @@ export function validateWaveDefinition(wave, options = {}) {
     }
   }
   for (const agent of wave.agents) {
+    const docsOnlyDesignAgent = isDocsOnlyDesignAgent(agent, { designRolePromptPath });
+    const implementationOwningDesignAgent = isImplementationOwningDesignAgent(agent, {
+      designRolePromptPath,
+    });
     if (!Array.isArray(agent.ownedPaths) || agent.ownedPaths.length === 0) {
       errors.push(`Agent ${agent.agentId} must declare at least one owned path`);
       continue;
@@ -1556,6 +1597,7 @@ export function validateWaveDefinition(wave, options = {}) {
     if (
       [contQaAgentId, integrationAgentId, documentationAgentId].includes(agent.agentId) ||
       isContEvalReportOnlyAgent(agent, { contEvalAgentId }) ||
+      docsOnlyDesignAgent ||
       isSecurityReviewAgent(agent, { securityRolePromptPath })
     ) {
       if (Array.isArray(agent.components) && agent.components.length > 0) {
@@ -1587,6 +1629,7 @@ export function validateWaveDefinition(wave, options = {}) {
       if (
         ![contQaAgentId, integrationAgentId, documentationAgentId].includes(agent.agentId) &&
         !isContEvalReportOnlyAgent(agent, { contEvalAgentId }) &&
+        !docsOnlyDesignAgent &&
         !isSecurityReviewAgent(agent, { securityRolePromptPath })
       ) {
         if (!agent.exitContract) {
@@ -1608,6 +1651,7 @@ export function validateWaveDefinition(wave, options = {}) {
       (!Array.isArray(agent.proofArtifacts) || agent.proofArtifacts.length === 0) &&
       ![contQaAgentId, integrationAgentId, documentationAgentId].includes(agent.agentId) &&
       !isContEvalReportOnlyAgent(agent, { contEvalAgentId }) &&
+      !docsOnlyDesignAgent &&
       !isSecurityReviewAgent(agent, { securityRolePromptPath })
     ) {
       errors.push(
@@ -1675,6 +1719,29 @@ export function validateWaveDefinition(wave, options = {}) {
       errors.push(`Security reviewer ${securityReviewer.agentId} must own a security review report path`);
     }
   }
+  const designAgents = wave.agents.filter((agent) =>
+    isDesignAgent(agent, { designRolePromptPath }),
+  );
+  for (const designAgent of designAgents) {
+    const hybridDesignAgent = isImplementationOwningDesignAgent(designAgent, {
+      designRolePromptPath,
+    });
+    if (!designAgent.rolePromptPaths?.includes(designRolePromptPath)) {
+      errors.push(
+        `Design agent ${designAgent.agentId} must import ${designRolePromptPath}`,
+      );
+    }
+    if (!resolveDesignReportPath(designAgent)) {
+      errors.push(`Design agent ${designAgent.agentId} must own a design packet path`);
+    }
+    if (
+      !hybridDesignAgent &&
+      Array.isArray(designAgent.components) &&
+      designAgent.components.length > 0
+    ) {
+      errors.push(`Design agent ${designAgent.agentId} must stay docs/spec-only unless it explicitly owns implementation files`);
+    }
+  }
   if (integrationRuleActive) {
     const integrationStewards = wave.agents.filter((agent) =>
       agent.rolePromptPaths?.includes(laneProfile.roles.integrationRolePromptPath),
@@ -1749,6 +1816,7 @@ export function validateWaveDefinition(wave, options = {}) {
 export function parseWaveContent(content, filePath, options = {}) {
   const laneProfile = resolveLaneProfileForOptions(options);
   const securityRolePromptPath = resolveSecurityRolePromptPath(laneProfile);
+  const designRolePromptPath = resolveDesignRolePromptPath(laneProfile);
   const fileName = path.basename(filePath);
   const waveNumber = waveNumberFromFileName(fileName);
   const commitMessageMatch = content.match(/\*\*Commit message\*\*:\s*`([^`]+)`/);
@@ -1778,7 +1846,11 @@ export function parseWaveContent(content, filePath, options = {}) {
     const executorConfig = extractExecutorConfigFromSection(sectionText, filePath, current.agentId);
     const components = extractAgentComponentsFromSection(sectionText, filePath, current.agentId);
     const capabilities = normalizeSecurityCapabilities(
-      extractAgentCapabilitiesFromSection(sectionText, filePath, current.agentId),
+      normalizeDesignCapabilities(
+        extractAgentCapabilitiesFromSection(sectionText, filePath, current.agentId),
+        rolePromptPaths,
+        designRolePromptPath,
+      ),
       rolePromptPaths,
       securityRolePromptPath,
     );
@@ -1923,6 +1995,13 @@ function inferAgentRuntimeRole(agent, laneProfile) {
   if (agent?.agentId === laneProfile.roles.documentationAgentId) {
     return "documentation";
   }
+  if (
+    isDesignAgent(agent, {
+      designRolePromptPath: laneProfile?.roles?.designRolePromptPath,
+    })
+  ) {
+    return "design";
+  }
   if (isSecurityReviewAgent(agent)) {
     return "security";
   }
@@ -2274,12 +2353,14 @@ export function validateWaveComponentPromotions(wave, summariesByAgentId = {}, o
   const documentationAgentId =
     roles.documentationAgentId || DEFAULT_DOCUMENTATION_AGENT_ID;
   const securityRolePromptPath = resolveSecurityRolePromptPath(laneProfile);
+  const designRolePromptPath = resolveDesignRolePromptPath(laneProfile);
   const implementationOwningAgents = (wave.agents || []).filter((agent) =>
     isImplementationOwningWaveAgent(agent, {
       contQaAgentId,
       contEvalAgentId,
       integrationAgentId,
       documentationAgentId,
+      designRolePromptPath,
       securityRolePromptPath,
     }),
   );
@@ -2302,6 +2383,7 @@ export function validateWaveComponentPromotions(wave, summariesByAgentId = {}, o
       contEvalAgentId,
       integrationAgentId,
       documentationAgentId,
+      designRolePromptPath,
       securityRolePromptPath,
     })) {
       continue;
@@ -2348,12 +2430,14 @@ export function validateWaveComponentMatrixCurrentLevels(wave, options = {}) {
   const integrationAgentId = roles.integrationAgentId || DEFAULT_INTEGRATION_AGENT_ID;
   const documentationAgentId = roles.documentationAgentId || DEFAULT_DOCUMENTATION_AGENT_ID;
   const securityRolePromptPath = resolveSecurityRolePromptPath(laneProfile);
+  const designRolePromptPath = resolveDesignRolePromptPath(laneProfile);
   const implementationOwningAgents = (wave.agents || []).filter((agent) =>
     isImplementationOwningWaveAgent(agent, {
       contQaAgentId,
       contEvalAgentId,
       integrationAgentId,
       documentationAgentId,
+      designRolePromptPath,
       securityRolePromptPath,
     }),
   );

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

@@ -181,6 +181,18 @@ function derivePhase({
   const implementationTasks = (tasks || []).filter(
     (task) => task.taskType === "implementation",
   );
+  const designTasks = (tasks || []).filter(
+    (task) => task.taskType === "design",
+  );
+  const allDesignReady = designTasks.every(
+    (task) =>
+      task.closureState === "owned_slice_proven" ||
+      task.closureState === "wave_closure_ready" ||
+      task.closureState === "closed",
+  );
+  if (!allDesignReady && designTasks.length > 0) {
+    return "design";
+  }
   const allImplementationProven = implementationTasks.every(
     (task) =>
       task.closureState === "owned_slice_proven" ||
@@ -191,6 +203,9 @@ function derivePhase({
     return "running";
   }
 
+  if (gateSnapshot?.designGate && !gateSnapshot.designGate.ok) {
+    return "design";
+  }
   if (gateSnapshot?.contEvalGate && !gateSnapshot.contEvalGate.ok) {
     return "cont-eval";
   }
@@ -228,6 +243,7 @@ function deriveWaveState(phase) {
  */
 function buildProofAvailability(tasks, agentResults, controlPlaneState) {
   const byAgentId = {};
+  const byTaskId = {};
   const agentTasks = new Map();
 
   for (const task of tasks || []) {
@@ -267,6 +283,10 @@ function buildProofAvailability(tasks, agentResults, controlPlaneState) {
 
     for (const task of agentTaskList) {
       const evaluation = evaluateOwnedSliceProven(task, result);
+      byTaskId[task.taskId] = {
+        proven: evaluation.proven,
+        reason: evaluation.reason || null,
+      };
       if (!evaluation.proven) {
         ownedSliceProven = false;
       }
@@ -302,6 +322,7 @@ function buildProofAvailability(tasks, agentResults, controlPlaneState) {
 
   return {
     byAgentId,
+    byTaskId,
     allOwnedSlicesProven,
     activeProofBundles,
   };
@@ -518,20 +539,16 @@ function deriveClosureEligibility(gateSnapshot, tasks, proofAvailability) {
  */
 function applyProofAvailabilityToTasks(tasks, proofAvailability) {
   return (tasks || []).map((task) => {
-    const agentId = task.assigneeAgentId || task.ownerAgentId;
-    if (!agentId) {
-      return task;
-    }
-    const entry = proofAvailability.byAgentId?.[agentId];
+    const entry = proofAvailability.byTaskId?.[task.taskId];
     if (!entry) {
       return task;
     }
     // Forward: open -> owned_slice_proven when proven
-    if (task.closureState === "open" && entry.ownedSliceProven) {
+    if (task.closureState === "open" && entry.proven) {
       return { ...task, closureState: "owned_slice_proven", status: "proven" };
     }
     // Bidirectional: owned_slice_proven -> open when proof is invalidated
-    if (task.closureState === "owned_slice_proven" && !entry.ownedSliceProven) {
+    if (task.closureState === "owned_slice_proven" && !entry.proven) {
       return { ...task, closureState: "open", status: "in_progress" };
     }
     return task;

package/scripts/wave-status.sh

@@ -0,0 +1,200 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+lane="main"
+wave=""
+agent=""
+run_id=""
+dry_run="0"
+json_output="0"
+
+usage() {
+  cat <<'EOF'
+Usage:
+  scripts/wave-status.sh [--lane <lane>] [--wave <n>] [--agent <id>] [--run <id>] [--dry-run] [--json]
+
+Exit codes:
+  0   completed
+  10  waiting or running
+  20  input required
+  40  failed
+EOF
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --lane)
+      lane="${2:-}"
+      shift 2
+      ;;
+    --wave)
+      wave="${2:-}"
+      shift 2
+      ;;
+    --agent)
+      agent="${2:-}"
+      shift 2
+      ;;
+    --run)
+      run_id="${2:-}"
+      shift 2
+      ;;
+    --dry-run)
+      dry_run="1"
+      shift
+      ;;
+    --json)
+      json_output="1"
+      shift
+      ;;
+    --help|-h)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      usage >&2
+      exit 2
+      ;;
+  esac
+done
+
+run_wave_cli() {
+  if [ -n "${WAVE_WRAPPER_ENTRY:-}" ]; then
+    node "$WAVE_WRAPPER_ENTRY" "$@"
+    return
+  fi
+  if [ -f "scripts/wave.mjs" ]; then
+    node "scripts/wave.mjs" "$@"
+    return
+  fi
+  if [ -f "node_modules/@chllming/wave-orchestration/scripts/wave.mjs" ]; then
+    node "node_modules/@chllming/wave-orchestration/scripts/wave.mjs" "$@"
+    return
+  fi
+  if command -v pnpm >/dev/null 2>&1; then
+    pnpm exec wave "$@"
+    return
+  fi
+  echo "Unable to locate Wave CLI. Set WAVE_WRAPPER_ENTRY or install the package locally." >&2
+  exit 2
+}
+
+infer_wave() {
+  node - "$lane" "$run_id" "$dry_run" <<'NODE'
+const fs = require("node:fs");
+const path = require("node:path");
+
+const lane = process.argv[2] || "main";
+const runId = process.argv[3] || "";
+const dryRun = process.argv[4] === "1";
+const stateDir = runId
+  ? path.join(process.cwd(), ".tmp", `${lane}-wave-launcher`, "adhoc", runId, dryRun ? "dry-run" : "")
+  : path.join(process.cwd(), ".tmp", `${lane}-wave-launcher`, dryRun ? "dry-run" : "");
+const runStatePath = path.join(stateDir, "run-state.json");
+let payload = null;
+try {
+  payload = JSON.parse(fs.readFileSync(runStatePath, "utf8"));
+} catch {
+  payload = null;
+}
+const waves = Object.values(payload?.waves || {})
+  .filter((entry) => entry && typeof entry === "object")
+  .map((entry) => ({
+    wave: Number.parseInt(String(entry.wave ?? ""), 10),
+    state: String(entry.currentState || "").trim().toLowerCase(),
+  }))
+  .filter((entry) => Number.isFinite(entry.wave))
+  .sort((left, right) => left.wave - right.wave);
+const active = waves.findLast(
+  (entry) => !["completed", "failed", "timed_out", "timed-out"].includes(entry.state),
+);
+if (active) {
+  process.stdout.write(String(active.wave));
+  process.exit(0);
+}
+const completed = Array.isArray(payload?.completedWaves)
+  ? payload.completedWaves
+      .map((value) => Number.parseInt(String(value), 10))
+      .filter((value) => Number.isFinite(value))
+      .sort((left, right) => left - right)
+  : [];
+process.stdout.write(String(completed.at(-1) ?? 0));
+NODE
+}
+
+if [ -z "$wave" ]; then
+  wave="$(infer_wave)"
+fi
+
+status_args=(control status --lane "$lane" --wave "$wave" --json)
+if [ -n "$agent" ]; then
+  status_args+=(--agent "$agent")
+fi
+if [ -n "$run_id" ]; then
+  status_args+=(--run "$run_id")
+fi
+if [ "$dry_run" = "1" ]; then
+  status_args+=(--dry-run)
+fi
+
+payload="$(run_wave_cli "${status_args[@]}")"
+
+if [ "$json_output" = "1" ]; then
+  printf '%s\n' "$payload"
+  exit 0
+fi
+
+PAYLOAD="$payload" node - "$lane" "$wave" "$agent" <<'NODE'
+const fs = require("node:fs");
+
+const lane = process.argv[2] || "main";
+const wave = Number.parseInt(String(process.argv[3] || "0"), 10) || 0;
+const agentId = String(process.argv[4] || "").trim();
+const payload = JSON.parse(process.env.PAYLOAD || "{}");
+const signals = payload?.signals || {};
+const snapshot = agentId
+  ? (Array.isArray(signals.agents) ? signals.agents.find((entry) => entry.agentId === agentId) : null)
+  : signals.wave;
+const effective = snapshot || {
+  signal: payload?.blockingEdge?.kind === "human-input" ? "feedback-requested" : "waiting",
+  lane,
+  wave,
+  phase: payload?.phase || "unknown",
+  status: payload?.blockingEdge ? "blocked" : "running",
+  blocking: payload?.blockingEdge || null,
+  attempt: payload?.activeAttempt?.attemptNumber || 0,
+  targetAgentIds: agentId ? [agentId] : [],
+  shouldWake: agentId ? true : null,
+  version: 0,
+};
+const targetKey = agentId ? "agent" : "agents";
+const targetValue = agentId || (effective.targetAgentIds || []).join(",") || "none";
+const blocking = effective?.blocking?.kind || "none";
+const shouldWake =
+  typeof effective.shouldWake === "boolean" ? (effective.shouldWake ? "yes" : "no") : "n/a";
+console.log(
+  [
+    `signal=${effective.signal || "waiting"}`,
+    `lane=${lane}`,
+    `wave=${wave}`,
+    `phase=${effective.phase || "unknown"}`,
+    `status=${effective.status || "running"}`,
+    `blocking=${blocking}`,
+    `attempt=${effective.attempt || 0}`,
+    `${targetKey}=${targetValue}`,
+    `version=${effective.version || 0}`,
+    `should_wake=${shouldWake}`,
+  ].join(" "),
+);
+if (String(effective.signal || "").trim().toLowerCase() === "completed") {
+  process.exit(0);
+}
+if (String(effective.signal || "").trim().toLowerCase() === "failed") {
+  process.exit(40);
+}
+if (String(effective.signal || "").trim().toLowerCase() === "feedback-requested") {
+  process.exit(20);
+}
+process.exit(10);
+NODE