@chllming/wave-orchestration 0.9.13 → 0.9.15

package/scripts/wave-orchestrator/closure-adjudicator.mjs

@@ -0,0 +1,311 @@
+import fs from "node:fs";
+import path from "node:path";
+import { writeClosureAdjudication } from "./artifact-schemas.mjs";
+import { REPO_ROOT, ensureDirectory } from "./shared.mjs";
+import { parseStructuredSignalCandidate } from "./structured-signal-parser.mjs";
+import { validateImplementationSummary } from "./agent-state.mjs";
+
+function isOpenCoordinationStatus(status) {
+  return ["open", "acknowledged", "in_progress"].includes(String(status || "").trim().toLowerCase());
+}
+
+function blockingCoordinationForAgent(derivedState, agentId) {
+  const latestRecords = Array.isArray(derivedState?.coordinationState?.latestRecords)
+    ? derivedState.coordinationState.latestRecords
+    : [];
+  return latestRecords.some((record) => {
+    if (!isOpenCoordinationStatus(record?.status) || record?.blocking === false) {
+      return false;
+    }
+    if (record?.agentId === agentId) {
+      return true;
+    }
+    return (record?.targets || []).some((target) => String(target || "").trim() === `agent:${agentId}`);
+  });
+}
+
+function buildEvidence(summary, envelope, derivedState) {
+  return [
+    { kind: "exit-code", value: summary?.exitCode ?? null },
+    {
+      kind: "deliverables",
+      value: (summary?.deliverables || []).map((deliverable) => ({
+        path: deliverable.path,
+        exists: deliverable.exists === true,
+      })),
+    },
+    {
+      kind: "proof-artifacts",
+      value: (summary?.proofArtifacts || []).map((artifact) => ({
+        path: artifact.path,
+        exists: artifact.exists === true,
+      })),
+    },
+    {
+      kind: "envelope-role",
+      value: envelope?.role || null,
+    },
+    {
+      kind: "integration-summary",
+      value: derivedState?.integrationSummary?.recommendation || null,
+    },
+  ];
+}
+
+function synthesizedSignals(summary) {
+  const signals = [];
+  if (summary?.proof) {
+    signals.push(
+      `[wave-proof] completion=${summary.proof.completion} durability=${summary.proof.durability} proof=${summary.proof.proof} state=${summary.proof.state}${summary.proof.detail ? ` detail=${summary.proof.detail}` : ""}`,
+    );
+  }
+  if (summary?.docDelta) {
+    signals.push(
+      `[wave-doc-delta] state=${summary.docDelta.state}${(summary.docDelta.paths || []).length > 0 ? ` paths=${summary.docDelta.paths.join(",")}` : ""}${summary.docDelta.detail ? ` detail=${summary.docDelta.detail}` : ""}`,
+    );
+  }
+  for (const component of summary?.components || []) {
+    signals.push(
+      `[wave-component] component=${component.componentId} level=${component.level} state=${component.state}${component.detail ? ` detail=${component.detail}` : ""}`,
+    );
+  }
+  return signals;
+}
+
+function cleanText(value) {
+  return String(value || "").trim();
+}
+
+function cleanState(value) {
+  const normalized = cleanText(value).toLowerCase();
+  return normalized === "complete" ? "met" : normalized;
+}
+
+function proofLineFromRawValues(rawValues) {
+  const completion = cleanText(rawValues?.completion).toLowerCase();
+  const durability = cleanText(rawValues?.durability).toLowerCase();
+  const proof = cleanText(rawValues?.proof).toLowerCase();
+  const state = cleanState(rawValues?.state);
+  const line = `[wave-proof] completion=${completion} durability=${durability} proof=${proof} state=${state}`;
+  const candidate = parseStructuredSignalCandidate(line);
+  return candidate?.accepted ? candidate.normalizedLine : null;
+}
+
+function docDeltaLineFromRawValues(rawValues) {
+  const state = cleanText(rawValues?.state).toLowerCase();
+  const line = `[wave-doc-delta] state=${state}`;
+  const candidate = parseStructuredSignalCandidate(line);
+  return candidate?.accepted ? candidate.normalizedLine : null;
+}
+
+function componentLineFromRawValues(rawValues) {
+  const componentId = cleanText(rawValues?.component);
+  const level = cleanText(rawValues?.level).toLowerCase();
+  const state = cleanState(rawValues?.state);
+  const line = `[wave-component] component=${componentId} level=${level} state=${state}`;
+  const candidate = parseStructuredSignalCandidate(line);
+  return candidate?.accepted ? candidate.normalizedLine : null;
+}
+
+function rejectedStructuredSignalSamples(summary, key) {
+  const bucket = summary?.structuredSignalDiagnostics?.[key];
+  return Array.isArray(bucket?.rejectedSamples) ? bucket.rejectedSamples : [];
+}
+
+function recoverStructuredSignalLine(gate, summary, agentRun) {
+  if (gate?.statusCode === "invalid-wave-proof-format") {
+    for (const sample of rejectedStructuredSignalSamples(summary, "proof")) {
+      const line = proofLineFromRawValues(sample?.rawValues);
+      if (line) {
+        return line;
+      }
+    }
+    return null;
+  }
+  if (gate?.statusCode === "invalid-doc-delta-format") {
+    for (const sample of rejectedStructuredSignalSamples(summary, "docDelta")) {
+      const line = docDeltaLineFromRawValues(sample?.rawValues);
+      if (line) {
+        return line;
+      }
+    }
+    return null;
+  }
+  if (gate?.statusCode === "invalid-wave-component-format") {
+    const ownedComponents = new Set(Array.isArray(agentRun?.agent?.components) ? agentRun.agent.components : []);
+    for (const sample of rejectedStructuredSignalSamples(summary, "component")) {
+      if (!ownedComponents.has(cleanText(sample?.componentId))) {
+        continue;
+      }
+      const line = componentLineFromRawValues(sample?.rawValues);
+      if (line) {
+        return line;
+      }
+    }
+    return null;
+  }
+  return null;
+}
+
+function recoverSummaryFromRejectedSignals(gate, summary, agentRun) {
+  const recoveredLine = recoverStructuredSignalLine(gate, summary, agentRun);
+  if (!recoveredLine) {
+    return null;
+  }
+  const candidate = parseStructuredSignalCandidate(recoveredLine);
+  if (!candidate?.accepted) {
+    return null;
+  }
+  const recoveredSummary = {
+    ...summary,
+  };
+  if (candidate.kind === "proof") {
+    recoveredSummary.proof = {
+      completion: candidate.rawValues.completion.toLowerCase(),
+      durability: candidate.rawValues.durability.toLowerCase(),
+      proof: candidate.rawValues.proof.toLowerCase(),
+      state: cleanState(candidate.rawValues.state),
+      detail: "",
+    };
+  } else if (candidate.kind === "docDelta") {
+    recoveredSummary.docDelta = {
+      state: candidate.rawValues.state.toLowerCase(),
+      paths: [],
+      detail: "",
+    };
+  } else if (candidate.kind === "component") {
+    const recoveredComponent = {
+      componentId: cleanText(candidate.rawValues.component),
+      level: cleanText(candidate.rawValues.level).toLowerCase(),
+      state: cleanState(candidate.rawValues.state),
+      detail: "",
+    };
+    const existingComponents = Array.isArray(summary?.components) ? summary.components : [];
+    recoveredSummary.components = [
+      ...existingComponents.filter((component) => component.componentId !== recoveredComponent.componentId),
+      recoveredComponent,
+    ];
+  }
+  return {
+    recoveredLine,
+    recoveredSummary,
+    recoveredValidation: validateImplementationSummary(agentRun?.agent || null, recoveredSummary),
+  };
+}
+
+export function closureAdjudicationPath(lanePaths, waveNumber, attempt, agentId) {
+  return path.join(
+    lanePaths.statusDir,
+    "..",
+    "closure",
+    `wave-${waveNumber}`,
+    `attempt-${attempt || 1}`,
+    `${agentId}.json`,
+  );
+}
+
+export function evaluateClosureAdjudication({
+  wave,
+  lanePaths,
+  gate,
+  summary,
+  derivedState,
+  agentRun,
+  envelope,
+}) {
+  if (gate?.failureClass !== "transport-failure" || gate?.eligibleForAdjudication !== true) {
+    return {
+      status: "ambiguous",
+      reason: "not-eligible",
+      detail: "Closure failure is not eligible for deterministic adjudication.",
+      evidence: [],
+      synthesizedSignals: [],
+    };
+  }
+  if (summary?.proof?.state === "gap" || (summary?.gaps || []).length > 0) {
+    return {
+      status: "rework-required",
+      reason: "semantic-negative-signal",
+      detail: "Explicit negative semantic proof signals remain.",
+      evidence: buildEvidence(summary, envelope, derivedState),
+      synthesizedSignals: synthesizedSignals(summary),
+    };
+  }
+  if (blockingCoordinationForAgent(derivedState, agentRun?.agent?.agentId)) {
+    return {
+      status: "ambiguous",
+      reason: "blocking-coordination",
+      detail: "Blocking coordination owned by the same agent slice remains open.",
+      evidence: buildEvidence(summary, envelope, derivedState),
+      synthesizedSignals: synthesizedSignals(summary),
+    };
+  }
+  const recovered = recoverSummaryFromRejectedSignals(gate, summary, agentRun);
+  if (!recovered) {
+    return {
+      status: "rework-required",
+      reason: "reconstruction-failed",
+      detail: "Rejected marker text did not preserve enough safe contract data to reconstruct a canonical closure signal.",
+      evidence: buildEvidence(summary, envelope, derivedState),
+      synthesizedSignals: synthesizedSignals(summary),
+    };
+  }
+  if (!recovered.recoveredValidation?.ok) {
+    return {
+      status: "rework-required",
+      reason: "recovered-signal-failed-validation",
+      detail: recovered.recoveredValidation?.detail || "Recovered closure signal still does not satisfy the implementation exit contract.",
+      evidence: buildEvidence(summary, envelope, derivedState),
+      synthesizedSignals: [...synthesizedSignals(summary), recovered.recoveredLine],
+    };
+  }
+  return {
+    status: "pass",
+    reason: "recovered-canonical-signal",
+    detail: "Rejected marker text preserved enough contract data to recover a canonical closure signal that satisfies the implementation exit contract.",
+    evidence: buildEvidence(summary, envelope, derivedState),
+    synthesizedSignals: [...synthesizedSignals(summary), recovered.recoveredLine],
+  };
+}
+
+export function persistClosureAdjudication({
+  lanePaths,
+  waveNumber,
+  attempt,
+  agentId,
+  payload,
+}) {
+  const filePath = closureAdjudicationPath(lanePaths, waveNumber, attempt, agentId);
+  ensureDirectory(path.dirname(filePath));
+  return {
+    filePath,
+    adjudication: writeClosureAdjudication(
+      filePath,
+      {
+        lane: lanePaths?.lane || null,
+        wave: waveNumber,
+        attempt,
+        agentId,
+        ...payload,
+      },
+      {
+        lane: lanePaths?.lane || null,
+        wave: waveNumber,
+        attempt,
+        agentId,
+      },
+    ),
+  };
+}
+
+export function readPersistedClosureAdjudication(filePath, defaults = {}) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    return null;
+  }
+  const payload = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  return {
+    ...payload,
+    filePath: path.isAbsolute(filePath) ? path.relative(REPO_ROOT, filePath) : filePath,
+    ...defaults,
+  };
+}

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

@@ -39,9 +39,11 @@ import {
   registerWaveProofBundle,
   waveProofRegistryPath,
 } from "./proof-registry.mjs";
+import { closureAdjudicationPath, evaluateClosureAdjudication } from "./closure-adjudicator.mjs";
 import { readWaveRelaunchPlanSnapshot, readWaveRetryOverride, resolveRetryOverrideAgentIds, writeWaveRetryOverride, clearWaveRetryOverride } from "./retry-control.mjs";
 import { flushWaveControlQueue, readWaveControlQueueState } from "./wave-control-client.mjs";
 import { readAgentExecutionSummary, validateImplementationSummary } from "./agent-state.mjs";
+import { readClosureAdjudication } from "./artifact-schemas.mjs";
 import { isContEvalReportOnlyAgent, isSecurityReviewAgentForLane } from "./role-helpers.mjs";
 import {
   buildSignalStatusLine,
@@ -68,6 +70,8 @@ function printUsage() {
   wave control proof get --project <id> --lane <lane> --wave <n> [--agent <id>] [--id <bundle-id>] [--json]
   wave control proof supersede --project <id> --lane <lane> --wave <n> --id <bundle-id> --agent <id> --artifact <path> [--artifact <path> ...] [options]
   wave control proof revoke --project <id> --lane <lane> --wave <n> --id <bundle-id> [--operator <name>] [--detail <text>] [--json]
+
+  wave control adjudication get --project <id> --lane <lane> --wave <n> [--agent <id>] [--json]
 `);
 }
 
@@ -135,7 +139,7 @@ function parseArgs(argv) {
       ? 1
       : surface === "telemetry"
         ? 2
-        : surface === "task" || surface === "rerun" || surface === "proof"
+        : surface === "task" || surface === "rerun" || surface === "proof" || surface === "adjudication"
           ? operation === "act"
             ? 3
             : 2
@@ -256,6 +260,42 @@ function ledgerPath(lanePaths, waveNumber) {
   return path.join(lanePaths.ledgerDir, `wave-${waveNumber}.json`);
 }
 
+function readWaveClosureAdjudications(lanePaths, waveNumber, agentId = "") {
+  const samplePath = closureAdjudicationPath(lanePaths, waveNumber, 1, agentId || "sample");
+  const attemptsRoot = path.dirname(path.dirname(samplePath));
+  if (!fs.existsSync(attemptsRoot)) {
+    return [];
+  }
+  const adjudications = [];
+  for (const attemptEntry of fs.readdirSync(attemptsRoot, { withFileTypes: true })) {
+    if (!attemptEntry.isDirectory()) {
+      continue;
+    }
+    const attemptDir = path.join(attemptsRoot, attemptEntry.name);
+    for (const fileEntry of fs.readdirSync(attemptDir, { withFileTypes: true })) {
+      if (!fileEntry.isFile() || !fileEntry.name.endsWith(".json")) {
+        continue;
+      }
+      const filePath = path.join(attemptDir, fileEntry.name);
+      const payload = readClosureAdjudication(filePath, {
+        lane: lanePaths.lane,
+        wave: waveNumber,
+      });
+      if (!payload) {
+        continue;
+      }
+      if (agentId && payload.agentId !== agentId) {
+        continue;
+      }
+      adjudications.push({
+        ...payload,
+        filePath: path.relative(process.cwd(), filePath),
+      });
+    }
+  }
+  return adjudications.sort((left, right) => String(left.createdAt || "").localeCompare(String(right.createdAt || "")));
+}
+
 function targetAgentId(target) {
   const value = String(target || "").trim();
   return value.startsWith("agent:") ? value.slice("agent:".length) : value;
@@ -342,6 +382,7 @@ function buildLogicalAgents({
   lanePaths,
   wave,
   tasks,
+  coordinationState,
   dependencySnapshot,
   capabilityAssignments,
   selection,
@@ -371,6 +412,36 @@ function buildLogicalAgents({
       !isContEvalReportOnlyAgent(agent, { contEvalAgentId: lanePaths.contEvalAgentId })
         ? validateImplementationSummary(agent, summary ? summary : null)
         : { ok: statusRecord?.code === 0, statusCode: statusRecord?.code === 0 ? "pass" : "pending" };
+    const adjudicationPath = closureAdjudicationPath(
+      lanePaths,
+      wave.wave,
+      statusRecord?.attempt || 1,
+      agent.agentId,
+    );
+    const persistedAdjudication = readClosureAdjudication(adjudicationPath, {
+      lane: lanePaths.lane,
+      wave: wave.wave,
+      attempt: statusRecord?.attempt || 1,
+      agentId: agent.agentId,
+    });
+    const adjudication =
+      proofValidation.eligibleForAdjudication && !proofValidation.ok
+        ? persistedAdjudication ||
+          evaluateClosureAdjudication({
+            wave,
+            lanePaths,
+            gate: proofValidation,
+            summary,
+            derivedState: {
+              coordinationState,
+            },
+            agentRun: {
+              agent,
+              logPath,
+            },
+            envelope: null,
+          })
+        : null;
     const targetedTasks = tasks.filter(
       (task) =>
         task.ownerAgentId === agent.agentId ||
@@ -387,19 +458,29 @@ function buildLogicalAgents({
     const satisfiedByStatus =
       statusRecord?.code === 0 &&
       (proofValidation.ok ||
+        adjudication?.status === "pass" ||
         isSecurityReviewAgentForLane(agent, lanePaths) ||
         isContEvalReportOnlyAgent(agent, { contEvalAgentId: lanePaths.contEvalAgentId }));
+    const executionState =
+      selection?.source === "active-attempt" && selectedAgentIds.has(agent.agentId)
+        ? "active"
+        : Number.isInteger(statusRecord?.code)
+          ? "settled"
+          : "pending";
     let state = "planned";
     let reason = "";
+    let closureState = "pending";
     if (selection?.source === "active-attempt" && selectedAgentIds.has(agent.agentId)) {
       state = "working";
       reason = selection?.detail || "Selected by the active launcher attempt.";
+      closureState = "evaluating";
     } else if (selectedAgentIds.has(agent.agentId)) {
       state = "needs-rerun";
       reason =
         selection?.source === "relaunch-plan"
           ? "Selected by the persisted relaunch plan."
           : "Selected by active rerun request.";
+      closureState = "failed";
     } else if (completedPhase && satisfiedByStatus) {
       state = [
         lanePaths.contEvalAgentId || "E0",
@@ -410,9 +491,11 @@ function buildLogicalAgents({
         ? "closed"
         : "satisfied";
       reason = "Completed wave preserves the latest satisfied agent state.";
+      closureState = "passed";
     } else if (targetedBlockingTasks.some((task) => task.state === "working")) {
       state = "working";
       reason = targetedBlockingTasks.find((task) => task.state === "working")?.title || "";
+      closureState = "evaluating";
     } else if (targetedBlockingTasks.length > 0 || helperAssignment || dependency) {
       state = "blocked";
       reason =
@@ -421,6 +504,7 @@ function buildLogicalAgents({
         helperAssignment?.summary ||
         dependency?.summary ||
         "";
+      closureState = "blocked";
     } else if (satisfiedByStatus) {
       state = [
         lanePaths.contEvalAgentId || "E0",
@@ -431,14 +515,26 @@ function buildLogicalAgents({
         ? "closed"
         : "satisfied";
       reason = "Latest attempt satisfied current control-plane state.";
+      closureState = "passed";
+    } else if (adjudication?.status === "ambiguous") {
+      state = "awaiting-adjudication";
+      reason = adjudication.detail || proofValidation.detail || "Closure transport is awaiting deterministic adjudication.";
+      closureState = "awaiting-adjudication";
+    } else if (adjudication?.status === "rework-required") {
+      state = "needs-rerun";
+      reason = adjudication.detail || proofValidation.detail || "Closure adjudication requires more work.";
+      closureState = "failed";
     } else if (Number.isInteger(statusRecord?.code) && statusRecord.code !== 0) {
       state = "needs-rerun";
       reason = `Latest attempt exited with code ${statusRecord.code}.`;
+      closureState = "failed";
     }
     return {
       agentId: agent.agentId,
       state,
       reason: reason || null,
+      executionState,
+      closureState,
       taskIds: targetedTasks.map((task) => task.taskId),
       selectedForRerun: selectedAgentIds.has(agent.agentId) && selection?.source !== "active-attempt",
       selectedForActiveAttempt: selection?.source === "active-attempt" && selectedAgentIds.has(agent.agentId),
@@ -453,6 +549,53 @@ function buildLogicalAgents({
   });
 }
 
+function hasLiveSupervisorRuntime(supervisor) {
+  const runtimeSummary = Array.isArray(supervisor?.agentRuntimeSummary) ? supervisor.agentRuntimeSummary : [];
+  return runtimeSummary.some((runtime) => !["completed", "failed", "terminated"].includes(String(runtime?.terminalDisposition || "").trim().toLowerCase()));
+}
+
+function deriveExecutionState({ phase, activeAttempt, supervisor, logicalAgents }) {
+  if (activeAttempt || hasLiveSupervisorRuntime(supervisor)) {
+    return "active";
+  }
+  if (
+    isCompletedPhase(phase) ||
+    (Array.isArray(logicalAgents) && logicalAgents.some((agent) => agent.executionState === "settled" || agent.closureState === "passed"))
+  ) {
+    return "settled";
+  }
+  return "pending";
+}
+
+function deriveControllerState({ executionState, relaunchPlan, supervisor }) {
+  if (executionState === "active") {
+    return "active";
+  }
+  if (relaunchPlan?.selectedAgentIds?.length > 0) {
+    return "relaunch-planned";
+  }
+  if (["degraded", "failed"].includes(String(supervisor?.recoveryState || "").trim().toLowerCase())) {
+    return "stale";
+  }
+  return "idle";
+}
+
+function deriveClosureState({ executionState, blockingEdge, logicalAgents, relaunchPlan, phase }) {
+  if ((logicalAgents || []).some((agent) => agent.closureState === "awaiting-adjudication")) {
+    return "awaiting-adjudication";
+  }
+  if ((logicalAgents || []).some((agent) => agent.closureState === "failed") || blockingEdge || relaunchPlan?.selectedAgentIds?.length > 0) {
+    return "blocked";
+  }
+  if (isCompletedPhase(phase) || (logicalAgents || []).every((agent) => agent.closureState === "passed")) {
+    return "passed";
+  }
+  if (executionState === "active" || (logicalAgents || []).some((agent) => agent.closureState === "evaluating")) {
+    return "evaluating";
+  }
+  return "pending";
+}
+
 function selectionTargetsAgent(agentId, selectionSet) {
   return Boolean(agentId) && selectionSet.has(agentId);
 }
@@ -682,11 +825,30 @@ export function buildControlStatusPayload({ lanePaths, wave, agentId = "" }) {
     rerunRequest,
     relaunchPlan,
   });
-  return {
-    lane: lanePaths.lane,
-    wave: wave.wave,
+  const logicalAgents = buildLogicalAgents({
+    lanePaths,
+    wave,
+    tasks,
+    dependencySnapshot,
+    capabilityAssignments,
+    selection,
+    proofRegistry,
     phase,
-    agentId: agentId || null,
+    coordinationState,
+  }).filter((agent) => !agentId || agent.agentId === agentId);
+  const executionState = deriveExecutionState({
+    phase,
+    activeAttempt: controlState.activeAttempt,
+    supervisor,
+    logicalAgents,
+  });
+  const controllerState = deriveControllerState({
+    executionState,
+    relaunchPlan,
+    supervisor,
+  });
+  const closureState = deriveClosureState({
+    executionState,
     blockingEdge: buildBlockingEdge({
       tasks,
       capabilityAssignments,
@@ -697,16 +859,30 @@ export function buildControlStatusPayload({ lanePaths, wave, agentId = "" }) {
       agentId,
       phase,
     }),
-    logicalAgents: buildLogicalAgents({
-      lanePaths,
-      wave,
-      tasks,
-      dependencySnapshot,
-      capabilityAssignments,
-      selection,
-      proofRegistry,
-      phase,
-    }).filter((agent) => !agentId || agent.agentId === agentId),
+    logicalAgents,
+    relaunchPlan,
+    phase,
+  });
+  const blockingEdge = buildBlockingEdge({
+    tasks,
+    capabilityAssignments,
+    dependencySnapshot,
+    activeAttempt: controlState.activeAttempt,
+    rerunRequest,
+    relaunchPlan,
+    agentId,
+    phase,
+  });
+  return {
+    lane: lanePaths.lane,
+    wave: wave.wave,
+    phase,
+    agentId: agentId || null,
+    executionState,
+    closureState,
+    controllerState,
+    blockingEdge,
+    logicalAgents,
     tasks,
     helperAssignments: (capabilityAssignments || []).filter(
       (assignment) => assignment.blocking && assignmentRelevantToAgent(assignment, agentId),
@@ -764,6 +940,9 @@ function printStatus(payload) {
     ? `${payload.blockingEdge.kind} ${payload.blockingEdge.id}: ${payload.blockingEdge.detail}`
     : "none";
   console.log(`lane=${payload.lane} wave=${payload.wave} phase=${payload.phase}`);
+  console.log(
+    `execution=${payload.executionState || "unknown"} closure=${payload.closureState || "unknown"} controller=${payload.controllerState || "unknown"}`,
+  );
   if (payload.signals?.wave) {
     console.log(buildSignalStatusLine(payload.signals.wave, payload));
   }
@@ -801,7 +980,9 @@ function printStatus(payload) {
   if (payload.logicalAgents.length > 0) {
     console.log("logical-agents:");
     for (const agent of payload.logicalAgents) {
-      console.log(`- ${agent.agentId} ${agent.state}${agent.reason ? `: ${agent.reason}` : ""}`);
+      console.log(
+        `- ${agent.agentId} ${agent.state} execution=${agent.executionState || "unknown"} closure=${agent.closureState || "unknown"}${agent.reason ? `: ${agent.reason}` : ""}`,
+      );
     }
   }
 }
@@ -991,8 +1172,8 @@ export async function runControlCli(argv) {
     printUsage();
     return;
   }
-  if (surface !== "status" && !["telemetry", "task", "rerun", "proof"].includes(surface)) {
-    throw new Error("Expected control surface: status | telemetry | task | rerun | proof");
+  if (surface !== "status" && !["telemetry", "task", "rerun", "adjudication", "proof"].includes(surface)) {
+    throw new Error("Expected control surface: status | telemetry | task | rerun | adjudication | proof");
   }
   if (options.runId) {
     const context = resolveRunContext(options.runId, options.project, options.lane);
@@ -1291,6 +1472,19 @@ export async function runControlCli(argv) {
     throw new Error("Expected rerun operation: request | get | clear");
   }
 
+  if (surface === "adjudication") {
+    if (operation !== "get") {
+      throw new Error("Expected adjudication operation: get");
+    }
+    const adjudications = readWaveClosureAdjudications(lanePaths, wave.wave, options.agent || "");
+    console.log(JSON.stringify({
+      lane: lanePaths.lane,
+      wave: wave.wave,
+      adjudications,
+    }, null, 2));
+    return;
+  }
+
   if (surface === "proof") {
     if (operation === "get") {
       const registry = readWaveProofRegistry(lanePaths, wave.wave);