@chllming/wave-orchestration 0.7.2 → 0.8.0

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

@@ -5,6 +5,7 @@ import {
   materializeCoordinationState,
   openClarificationLinkedRequests,
 } from "./coordination-store.mjs";
+import { materializeContradictionsFromControlPlaneEvents } from "./contradiction-entity.mjs";
 import {
   buildTasksFromWaveDefinition,
   buildTasksFromCoordinationState,
@@ -13,30 +14,97 @@ import {
 } from "./task-entity.mjs";
 import {
   buildGateSnapshotPure,
-  readWaveImplementationGatePure,
-  readWaveContQaGatePure,
-  readWaveContEvalGatePure,
-  readWaveComponentGatePure,
-  readWaveComponentMatrixGatePure,
-  readWaveDocumentationGatePure,
-  readWaveSecurityGatePure,
-  readWaveIntegrationGatePure,
-  readWaveInfraGatePure,
+  readClarificationBarrier,
+  readWaveAssignmentBarrier,
 } from "./launcher-gates.mjs";
-import {
-  validateImplementationSummary,
-  validateContQaSummary,
-  validateContEvalSummary,
-  validateDocumentationClosureSummary,
-  validateSecuritySummary,
-  validateIntegrationSummary,
-} from "./agent-state.mjs";
-import {
-  isSecurityReviewAgent,
-  isContEvalImplementationOwningAgent,
-} from "./role-helpers.mjs";
+import { buildHumanInputRequests } from "./human-input-workflow.mjs";
+import { buildRequestAssignments } from "./routing-state.mjs";
+
+const REDUCER_VERSION = 2;
+
+/**
+ * Detect contradictions from control-plane events.
+ * Returns a Map<contradictionId, contradiction>.
+ */
+function detectContradictions(controlPlaneState) {
+  return materializeContradictionsFromControlPlaneEvents(controlPlaneState?.events || []);
+}
 
-const REDUCER_VERSION = 1;
+/**
+ * Build fact lineage from control-plane events.
+ * Returns a Map<factId, fact>.
+ */
+function buildFactLineage(controlPlaneState) {
+  const facts = new Map();
+  if (!controlPlaneState?.events) {
+    return facts;
+  }
+  for (const event of controlPlaneState.events) {
+    if (event.entityType !== "fact") {
+      continue;
+    }
+    const existing = facts.get(event.entityId) || {};
+    const data = event.data || {};
+    facts.set(event.entityId, {
+      factId: event.entityId,
+      contentHash: data.contentHash || existing.contentHash || null,
+      version: data.version || existing.version || 1,
+      waveNumber: event.wave ?? null,
+      lane: event.lane || null,
+      introducedBy: data.introducedBy || existing.introducedBy || null,
+      introducedAt: data.introducedAt || existing.introducedAt || event.recordedAt,
+      kind: data.kind || existing.kind || "claim",
+      content: data.content || existing.content || "",
+      sourceArtifact: data.sourceArtifact || existing.sourceArtifact || null,
+      citedBy: data.citedBy || existing.citedBy || [],
+      contradictedBy: data.contradictedBy || existing.contradictedBy || [],
+      supersedes: data.supersedes || existing.supersedes || null,
+      supersededBy: data.supersededBy || existing.supersededBy || null,
+      status: data.status || existing.status || "active",
+    });
+  }
+  return facts;
+}
+
+/**
+ * Build task graph DAG from task dependency edges.
+ * Returns { nodes: [taskId], edges: [{ from, to, kind }] }
+ */
+function buildTaskGraph(tasks) {
+  const nodes = [];
+  const edges = [];
+  for (const task of tasks || []) {
+    nodes.push(task.taskId);
+    for (const edge of task.dependencyEdges || []) {
+      if (edge.taskId) {
+        edges.push({
+          from: task.taskId,
+          to: edge.taskId,
+          kind: edge.kind || "blocks",
+        });
+      }
+    }
+  }
+  return { nodes, edges };
+}
+
+/**
+ * Build assignments Map from coordination state.
+ */
+function buildAssignments(coordinationState, agents, capabilityRouting = {}) {
+  const capabilityAssignments = buildRequestAssignments({
+    coordinationState,
+    agents,
+    capabilityRouting,
+  });
+  const assignments = new Map();
+  for (const assignment of capabilityAssignments) {
+    if (assignment?.id) {
+      assignments.set(assignment.id, assignment);
+    }
+  }
+  return { assignments, capabilityAssignments };
+}
 
 /**
  * Derive the wave phase from the current state.
@@ -74,6 +142,10 @@ function derivePhase({
     return "blocked";
   }
 
+  if (gateSnapshot?.helperAssignmentBarrier && !gateSnapshot.helperAssignmentBarrier.ok) {
+    return "blocked";
+  }
+
   const blockingHelperTasks = (tasks || []).filter(
     (task) =>
       ["helper", "dependency"].includes(task.taskType) &&
@@ -122,6 +194,16 @@ function derivePhase({
   return "running";
 }
 
+/**
+ * Map waveState from phase for end-state output.
+ */
+function deriveWaveState(phase) {
+  if (phase === "completed") return "completed";
+  if (phase === "blocked") return "blocked";
+  if (phase === "clarifying") return "blocked";
+  return "running";
+}
+
 /**
  * Build proof availability per agent from agent results and tasks.
  */
@@ -169,24 +251,19 @@ function buildProofAvailability(tasks, agentResults, controlPlaneState) {
       if (!evaluation.proven) {
         ownedSliceProven = false;
       }
-      if (
-        task.proofRequirements?.includes("implementation-exit-met") &&
-        !evaluation.proven
-      ) {
-        exitContractMet = false;
-      }
-      if (
-        task.proofRequirements?.includes("component-level-met") &&
-        !evaluation.proven
-      ) {
-        componentsMet = false;
-      }
-      if (
-        task.proofRequirements?.includes("proof-artifacts-present") &&
-        !evaluation.proven
-      ) {
-        proofArtifactsMet = false;
-        deliverablesMet = false;
+      // End-state proofRequirements is an object: { proofLevel, proofCentric, maturityTarget }
+      const pr = task.proofRequirements;
+      if (pr && typeof pr === "object" && !Array.isArray(pr)) {
+        if (!evaluation.proven) {
+          exitContractMet = false;
+          if (pr.maturityTarget) {
+            componentsMet = false;
+          }
+          if (pr.proofCentric) {
+            proofArtifactsMet = false;
+            deliverablesMet = false;
+          }
+        }
       }
     }
 
@@ -225,7 +302,11 @@ function deriveOpenBlockers(coordinationState, gateSnapshot) {
       kind: "coordination-blocker",
       id: record.id,
       detail: record.summary || record.detail || "",
-      blockedAgentIds: record.targets || [],
+      agentId: record.agentId || null,
+      blockedAgentIds:
+        Array.isArray(record.targets) && record.targets.length > 0
+          ? record.targets
+          : (record.agentId ? [record.agentId] : []),
       resolutionHint: record.resolutionHint || null,
     });
   }
@@ -238,7 +319,11 @@ function deriveOpenBlockers(coordinationState, gateSnapshot) {
       kind: "clarification",
       id: record.id,
       detail: record.summary || record.detail || "",
-      blockedAgentIds: record.targets || [],
+      agentId: record.agentId || null,
+      blockedAgentIds:
+        Array.isArray(record.targets) && record.targets.length > 0
+          ? record.targets
+          : (record.agentId ? [record.agentId] : []),
       resolutionHint: "Resolve clarification before proceeding.",
     });
   }
@@ -251,7 +336,11 @@ function deriveOpenBlockers(coordinationState, gateSnapshot) {
       kind: "human-escalation",
       id: record.id,
       detail: record.summary || record.detail || "",
-      blockedAgentIds: record.targets || [],
+      agentId: record.agentId || null,
+      blockedAgentIds:
+        Array.isArray(record.targets) && record.targets.length > 0
+          ? record.targets
+          : (record.agentId ? [record.agentId] : []),
       resolutionHint: "Human intervention required.",
     });
   }
@@ -264,7 +353,11 @@ function deriveOpenBlockers(coordinationState, gateSnapshot) {
       kind: "human-feedback",
       id: record.id,
       detail: record.summary || record.detail || "",
-      blockedAgentIds: record.targets || [],
+      agentId: record.agentId || null,
+      blockedAgentIds:
+        Array.isArray(record.targets) && record.targets.length > 0
+          ? record.targets
+          : (record.agentId ? [record.agentId] : []),
       resolutionHint: "Awaiting human feedback.",
     });
   }
@@ -289,30 +382,78 @@ function deriveOpenBlockers(coordinationState, gateSnapshot) {
 
 /**
  * Derive retry target set from gate snapshot and proof availability.
+ * Includes both agents with unproven slices AND agents identified by failed gates.
  */
 function deriveRetryTargetSet(gateSnapshot, proofAvailability) {
-  const failedAgentIds = [];
-  let reason = "";
+  const retryTargetsByAgentId = new Map();
+  const reasons = [];
+
+  const upsertRetryTarget = (agentId, nextTarget = {}) => {
+    if (!agentId) {
+      return;
+    }
+    const existing = retryTargetsByAgentId.get(agentId) || {
+      agentId,
+      reason: null,
+      gate: null,
+      statusCode: null,
+      retriesExhausted: false,
+    };
+    const merged = {
+      ...existing,
+      ...nextTarget,
+      agentId,
+      reason: nextTarget.reason || existing.reason || null,
+    };
+    retryTargetsByAgentId.set(agentId, merged);
+  };
 
+  // Include agents with unproven slices
   for (const [agentId, entry] of Object.entries(proofAvailability.byAgentId || {})) {
     if (!entry.ownedSliceProven) {
-      failedAgentIds.push(agentId);
+      upsertRetryTarget(agentId, {
+        reason: "owned-slice-not-proven",
+        statusCode: "owned-slice-not-proven",
+      });
     }
   }
 
-  if (failedAgentIds.length > 0) {
-    reason = `Agent(s) ${failedAgentIds.join(", ")} did not prove their owned slices.`;
+  if (retryTargetsByAgentId.size > 0) {
+    reasons.push(`Agent(s) ${[...retryTargetsByAgentId.keys()].sort().join(", ")} did not prove their owned slices.`);
+  }
+
+  // Include agents identified by failed gates
+  if (gateSnapshot) {
+    for (const [gateName, gate] of Object.entries(gateSnapshot)) {
+      if (gateName === "overall" || !gate || gate.ok !== false) {
+        continue;
+      }
+      if (gate.agentId) {
+        upsertRetryTarget(gate.agentId, {
+          reason: gate.statusCode || `gate-${gateName}`,
+          gate: gateName,
+          statusCode: gate.statusCode || null,
+        });
+        reasons.push(`Agent ${gate.agentId} identified by failed gate ${gateName}.`);
+      }
+    }
   }
 
+  const retryTargets = [...retryTargetsByAgentId.values()].sort((left, right) =>
+    String(left.agentId || "").localeCompare(String(right.agentId || "")),
+  );
+
   return {
-    agentIds: failedAgentIds,
-    reason,
+    agentIds: retryTargets.map((target) => target.agentId),
+    targets: retryTargets,
+    reason: reasons.join(" "),
     retryOverride: null,
   };
 }
 
 /**
  * Derive closure eligibility from gate snapshot and tasks.
+ * Includes proofBundles so buildResumePlan can access them.
  */
 function deriveClosureEligibility(gateSnapshot, tasks, proofAvailability) {
   const allGatesPass = gateSnapshot?.overall?.ok === true;
@@ -347,11 +488,14 @@ function deriveClosureEligibility(gateSnapshot, tasks, proofAvailability) {
     waveMayClose,
     ownedSliceProvenAgentIds,
     pendingAgentIds,
+    proofBundles: proofAvailability.activeProofBundles || [],
   };
 }
 
 /**
  * Mark tasks with updated closure states based on proof availability.
+ * Supports bidirectional: open -> owned_slice_proven when proved,
+ * and owned_slice_proven -> open when proof is invalidated.
  */
 function applyProofAvailabilityToTasks(tasks, proofAvailability) {
   return (tasks || []).map((task) => {
@@ -363,8 +507,13 @@ function applyProofAvailabilityToTasks(tasks, proofAvailability) {
     if (!entry) {
       return task;
     }
+    // Forward: open -> owned_slice_proven when proven
     if (task.closureState === "open" && entry.ownedSliceProven) {
-      return { ...task, closureState: "owned_slice_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) {
+      return { ...task, closureState: "open", status: "in_progress" };
     }
     return task;
   });
@@ -391,7 +540,11 @@ export function reduceWaveState({
   // Step 2: Materialize coordination state
   const coordinationState = materializeCoordinationState(coordinationRecords);
 
-  // Step 3: Build tasks
+  // Step 3: Materialize contradictions and facts from canonical control-plane events
+  const contradictions = detectContradictions(controlPlaneState);
+  const facts = buildFactLineage(controlPlaneState);
+
+  // Step 4: Build tasks
   const seedTasks = buildTasksFromWaveDefinition(waveDefinition, laneConfig);
   const coordinationTasks = buildTasksFromCoordinationState(
     coordinationState,
@@ -399,55 +552,36 @@ export function reduceWaveState({
   );
   let tasks = mergeTaskSets(seedTasks, coordinationTasks);
 
-  // Step 4: Evaluate proof availability per agent
+  // Step 5: Evaluate proof availability per agent
   const proofAvailability = buildProofAvailability(
     tasks,
     agentResults,
     controlPlaneState,
   );
 
-  // Apply proof state to tasks (auto-transition from open -> owned_slice_proven)
+  // Apply proof state to tasks (bidirectional transitions)
   tasks = applyProofAvailabilityToTasks(tasks, proofAvailability);
 
-  // Step 5: Build derived state for barriers
-  const clarificationBarrier = (() => {
-    const openClarifications = (coordinationState?.clarifications || []).filter(
-      (record) => isOpenCoordinationStatus(record.status),
-    );
-    if (openClarifications.length > 0) {
-      return {
-        ok: false,
-        statusCode: "clarification-open",
-        detail: `Open clarifications remain (${openClarifications.map((record) => record.id).join(", ")}).`,
-      };
-    }
-    const openClarificationReqs = openClarificationLinkedRequests(coordinationState);
-    if (openClarificationReqs.length > 0) {
-      return {
-        ok: false,
-        statusCode: "clarification-follow-up-open",
-        detail: `Clarification follow-up requests remain open (${openClarificationReqs.map((record) => record.id).join(", ")}).`,
-      };
-    }
-    const pendingHuman = [
-      ...(coordinationState?.humanEscalations || []).filter((record) =>
-        isOpenCoordinationStatus(record.status),
-      ),
-      ...(coordinationState?.humanFeedback || []).filter((record) =>
-        isOpenCoordinationStatus(record.status),
-      ),
-    ];
-    if (pendingHuman.length > 0) {
-      return {
-        ok: false,
-        statusCode: "human-feedback-open",
-        detail: `Pending human input remains (${pendingHuman.map((record) => record.id).join(", ")}).`,
-      };
-    }
-    return { ok: true, statusCode: "pass", detail: "" };
-  })();
+  // Step 6: Build integration summary BEFORE creating derivedState for gates
+  const integrationAgentId = laneConfig.integrationAgentId || "A8";
+  const integrationResult = agentResults?.[integrationAgentId]?.integration || null;
+  const integrationSummary = integrationResult
+    ? {
+        recommendation: integrationResult.state === "ready-for-doc-closure"
+          ? "ready-for-doc-closure"
+          : integrationResult.state || "needs-more-work",
+        detail: integrationResult.detail || null,
+      }
+    : null;
 
-  const helperAssignmentBarrier = { ok: true, statusCode: "pass", detail: "" };
+  // Step 7: Build derived state for barriers (with integrationSummary already computed)
+  const clarificationBarrier = readClarificationBarrier({ coordinationState });
+  const { assignments, capabilityAssignments } = buildAssignments(
+    coordinationState,
+    Array.isArray(waveDefinition?.agents) ? waveDefinition.agents : [],
+    laneConfig.capabilityRouting || {},
+  );
+  const helperAssignmentBarrier = readWaveAssignmentBarrier({ capabilityAssignments });
   const dependencyBarrier = (() => {
     if (!dependencyTickets) {
       return { ok: true, statusCode: "pass", detail: "" };
@@ -477,24 +611,15 @@ export function reduceWaveState({
     clarificationBarrier,
     helperAssignmentBarrier,
     dependencyBarrier,
-    integrationSummary: null,
+    integrationSummary,
     coordinationState,
+    capabilityAssignments,
     dependencySnapshot: dependencyTickets,
+    contradictions,
+    facts,
   };
 
-  // Try to derive integration summary from agent results
-  const integrationAgentId = laneConfig.integrationAgentId || "A8";
-  const integrationSummary = agentResults?.[integrationAgentId]?.integration || null;
-  if (integrationSummary) {
-    derivedState.integrationSummary = {
-      recommendation: integrationSummary.state === "ready-for-doc-closure"
-        ? "ready-for-doc-closure"
-        : integrationSummary.state || "needs-more-work",
-      detail: integrationSummary.detail || null,
-    };
-  }
-
-  // Step 5: Evaluate gates using pure variants
+  // Step 8: Evaluate gates using pure variants (integrationSummary already in derivedState)
   const gateSnapshot = buildGateSnapshotPure({
     wave: waveDefinition || { wave: 0, agents: [] },
     agentResults,
@@ -503,20 +628,20 @@ export function reduceWaveState({
     laneConfig,
   });
 
-  // Step 6: Derive open blockers
+  // Step 9: Derive open blockers
   const openBlockers = deriveOpenBlockers(coordinationState, gateSnapshot);
 
-  // Step 7: Derive retry target set
+  // Step 10: Derive retry target set (includes gate-identified agents)
   const retryTargetSet = deriveRetryTargetSet(gateSnapshot, proofAvailability);
 
-  // Step 8: Derive closure eligibility
+  // Step 11: Derive closure eligibility (with proofBundles for buildResumePlan)
   const closureEligibility = deriveClosureEligibility(
     gateSnapshot,
     tasks,
     proofAvailability,
   );
 
-  // Step 9: Derive phase
+  // Step 12: Derive phase
   const phase = derivePhase({
     tasks,
     gateSnapshot,
@@ -524,6 +649,21 @@ export function reduceWaveState({
     dependencySnapshot: dependencyTickets,
   });
 
+  // Step 13: Derive waveState from phase
+  const waveState = deriveWaveState(phase);
+
+  // Step 14: Build human inputs from coordination state and feedback requests
+  const humanInputs = new Map();
+  const humanInputList = buildHumanInputRequests(coordinationState, feedbackRequests);
+  for (const input of humanInputList) {
+    if (input.requestId) {
+      humanInputs.set(input.requestId, input);
+    }
+  }
+
+  // Step 15: Build task graph DAG
+  const taskGraph = buildTaskGraph(tasks);
+
   // Build coordination metrics
   const coordinationMetrics = buildCoordinationResponseMetrics(coordinationState);
 
@@ -546,20 +686,29 @@ export function reduceWaveState({
     lane: laneConfig.lane || "main",
     attempt: controlPlaneState?.activeAttempt?.attempt ?? 0,
     phase,
+    waveState,
 
     tasks,
     tasksByAgentId,
+    taskGraph,
 
     proofAvailability,
 
     openBlockers,
 
+    // Renamed: gateSnapshot -> gateVerdicts (end-state P1-9), keep gateSnapshot for backward compat
     gateSnapshot,
+    gateVerdicts: gateSnapshot,
 
     retryTargetSet,
 
     closureEligibility,
 
+    contradictions,
+    facts,
+    humanInputs,
+    assignments,
+
     coordinationMetrics,
     controlPlaneState,
   };

package/skills/README.md

@@ -3,6 +3,7 @@
 Skills are repo-owned procedural bundles that Wave attaches to agents at runtime. They capture durable operating knowledge such as coding norms, role checklists, runtime behavior, provider verification, and closure rules.
 
 Skills are not one-off prompts. They are reusable procedures with explicit routing metadata.
+They are runtime inputs and overlays, not canonical runtime state.
 
 ## Bundle Layout
 
@@ -130,6 +131,8 @@ Runtime behavior:
 | OpenCode | Compact catalog injected into `opencode.json`; `skill.json`, `SKILL.md`, the selected adapter, and recursive references attached via `--file`. |
 | Local | Compact catalog only. |
 
+Skills guide how agents interpret canonical state and projections. They do not become canonical runtime state, control-plane records, or replay inputs by themselves.
+
 ## Validation
 
 Run:

package/skills/repo-coding-rules/SKILL.md

@@ -21,7 +21,7 @@ Before editing any file, confirm:
 5. If the file has a corresponding test file, you will update or extend tests to cover your change.
 6. You have checked for other files that import or depend on the symbols you are changing.
 7. If the file is a config file (JSON, YAML), you have validated the resulting structure is well-formed.
-8. You are not editing generated runtime state (coordination logs, control-plane events, proof registries, trace bundles, dashboards). These are managed by the launcher and operator tooling.
+8. You are not editing generated runtime state (coordination logs, control-plane events, result artifacts, proof registries, trace bundles, dashboards). These are canonical runtime artifacts or projections managed by the orchestration runtime.
 
 ## Change Hygiene
 

package/skills/role-cont-qa/SKILL.md

@@ -10,13 +10,13 @@ Use this skill when the agent is the wave's final cont-QA closure steward.
 - Fail closed. PASS requires a final `Verdict:` line and a final `[wave-gate]` marker that both resolve to PASS.
 - Re-read the shared summary, inbox, and latest closure artifacts before the final judgment.
 - Keep verdicts consistent across the report. Do not say PASS in the verdict and CONCERNS in the gate marker.
-- Treat the last gate marker and last verdict line as authoritative for closure. Earlier markers are superseded.
+- Treat canonical state and typed closure artifacts as authoritative for closure. The final verdict line and gate marker must match that state; earlier markers are compatibility history only.
 
 ## Workflow
 
 Execute these steps in order. Do not skip steps.
 
-1. **Receive evidence** -- collect all implementation proof, coordination records, integration marker, doc closure marker, cont-EVAL marker (if present), and security marker (if present).
+1. **Receive evidence** -- collect all implementation proof, coordination records, integration output, doc closure output, cont-EVAL output (if present), and security output (if present).
 2. **Review vs exit contracts** -- walk each agent's exit contract line by line. For each line, confirm a proof artifact backs it. Record pass or gap. When the wave declares `### Proof artifacts`, verify those machine-visible artifacts are present.
 3. **Review vs promotions** -- walk each declared component promotion. Confirm evidence shows the component reached the declared target level, not just that adjacent code landed.
 4. **Verify proof registry** -- check whether operator-registered proof bundles exist. Confirm they are `active` (not `revoked` or `superseded`). Only active bundles count as evidence.

package/skills/role-deploy/SKILL.md

@@ -8,7 +8,7 @@
 - Name the exact service, package, or runtime surface being rolled out.
 - Record health, readiness, failure, and rollback state explicitly.
 - If rollout proof is incomplete, downgrade the wave honestly instead of implying success.
-- Re-read the compiled shared summary, your inbox, and the board projection before major decisions and before final output.
+- Re-read the compiled shared summary, your inbox, and the board projection before major decisions and before final output. If deployment evidence disagrees with a projection, trust the deployment evidence and canonical state.
 
 ## Workflow
 

package/skills/role-documentation/SKILL.md

@@ -8,7 +8,7 @@
 - Update status, sequencing, ownership, and proof expectations when the wave changes them.
 - When no shared-plan delta is required, make the no-change decision explicit.
 - Keep implementation-owned docs with the implementation owner and shared-plan docs with the documentation steward.
-- Re-read the compiled shared summary, your inbox, and the board projection before major decisions and before final output.
+- Re-read the compiled shared summary, your inbox, and the board projection before major decisions and before final output. If a projection looks stale, trust landed docs and canonical state.
 
 ## Workflow
 

package/skills/role-implementation/SKILL.md

@@ -15,7 +15,7 @@
 Follow this sequence for each deliverable in your exit contract:
 
 1. **Claim ownership** -- confirm the files and deliverables assigned to you in the wave definition. If anything is ambiguous, post a coordination record before starting.
-2. **Read context** -- re-read the shared summary, your inbox, and the board projection. Check for coordination records from other agents that affect your scope.
+2. **Read context** -- re-read the shared summary, your inbox, and the board projection. Check for coordination records from other agents that affect your scope, but trust landed code and canonical state if a projection looks stale.
 3. **Implement** -- make the smallest change that satisfies the exit contract. Follow repo coding rules for style, tests, and change hygiene.
 4. **Proof** -- produce durable evidence that the deliverable works:
    - Tests that pass and cover the changed behavior.

package/skills/role-infra/SKILL.md

@@ -8,7 +8,7 @@
 - Prefer exact dependency, identity, and admission proof over vague environment notes.
 - Do not improvise destructive infra changes. Keep actions explicit and approved.
 - Surface setup-required versus blocked states precisely so later closure decisions stay honest.
-- Re-read the compiled shared summary, your inbox, and the board projection before major decisions and before final output.
+- Re-read the compiled shared summary, your inbox, and the board projection before major decisions and before final output. If infra evidence disagrees with a projection, trust the canonical state and direct verification.
 
 ## Workflow
 

package/skills/role-integration/SKILL.md

@@ -14,7 +14,7 @@
 
 Execute these steps in order:
 
-1. **Collect evidence** -- re-read the compiled shared summary, your inbox, the board projection, and all coordination records posted by implementation agents and cont-EVAL (if present). Summaries refresh during execution, so use the latest version.
+1. **Collect evidence** -- re-read the compiled shared summary, your inbox, the board projection, all coordination records posted by implementation agents and cont-EVAL (if present), and the current control-plane or result-artifact state. Summaries refresh during execution, so use the latest version, but trust canonical state over stale projections.
 2. **Check contradictions** -- identify claims from different agents that conflict (e.g., two agents claiming the same file, incompatible interface assumptions, inconsistent status claims).
 3. **Verify proof gaps** -- walk each agent's exit contract and confirm proof artifacts exist. Flag any exit contract line that lacks durable evidence. When the wave declares `### Proof artifacts`, verify those artifacts are present. Check the proof registry for any revoked or superseded bundles that no longer satisfy closure.
 4. **Check helper assignments** -- verify that every helper assignment posted during the wave has a linked resolution or explicit follow-up.
@@ -37,7 +37,7 @@ Review each item. Any failure means the wave is `needs-more-work`:
 - [ ] All blockers posted during the wave have a resolution or an explicit follow-up.
 - [ ] Helper assignments are resolved or have linked follow-up work.
 - [ ] Clarification chains are closed.
-- [ ] cont-EVAL marker (if present) shows `satisfied` with matching ids.
+- [ ] cont-EVAL result state (if present) shows `satisfied` with matching ids.
 - [ ] Deploy-status markers (if present) show `healthy` or have explicit downgrade reasoning.
 - [ ] Cross-lane dependency tickets are resolved or explicitly deferred.
 - [ ] No active rerun request is pending (check via `wave control rerun get`).

package/skills/role-security/SKILL.md

@@ -8,7 +8,7 @@ Use this skill when the agent is the wave's dedicated security reviewer.
 - Default to report-only work. Route fixes to the owning agent unless the prompt explicitly gives you additional implementation ownership.
 - Fail closed on unresolved blocking findings. Do not mark the wave clear while findings or approvals remain open.
 - Prefer exact exploit paths, exact affected files or surfaces, and exact owners over broad warnings.
-- Re-read the shared summary, inbox, and board projection before final disposition.
+- Re-read the shared summary, inbox, and board projection before final disposition. If the projection diverges from landed code or canonical state, trust the canonical state.
 
 ## Workflow