@riddledc/riddle-proof 0.5.43 → 0.5.44

package/dist/{chunk-U4VNN2CT.js → chunk-4ASMX4R6.js}

@@ -381,6 +381,21 @@ function visualDeltaShipGateReason(state = {}) {
   if (reason) return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof: ${reason}`;
   return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof`;
 }
+function visualDeltaEvidenceIssueCode(state = {}, blocker = "") {
+  const visualDelta = visualDeltaForState(state || {});
+  const status = String(visualDelta.status || "").trim();
+  const reason = `${String(visualDelta.reason || "")}
+${blocker}`.toLowerCase();
+  if (status === "unmeasured") {
+    if (reason.includes("fetch") || reason.includes("allowlist") || reason.includes("registered domain") || reason.includes("high risk") || reason.includes("comparator")) {
+      return "comparator_fetch_blocked";
+    }
+    return "visual_delta_unmeasured";
+  }
+  if (status === "measured" && visualDelta.passed === false) return "semantic_proof_failed";
+  if (visualDeltaRequiredForState(state || {})) return "visual_delta_unmeasured";
+  return "semantic_proof_failed";
+}
 function requiredBaselineLabelsForState(state = {}) {
   const reference = normalizedReference(state);
   const labels = [];
@@ -570,7 +585,7 @@ var CHECKPOINT_CONTRACT_SPECS = {
       description: "JSON assessment with decision, summary, recommended_stage, continue_with_stage, escalation_target, and reasons."
     }],
     response_schema: {
-      decision: ["ready_to_ship", "needs_richer_proof"],
+      decision: ["ready_to_ship", "needs_richer_proof", "revise_capture"],
       summary: "string",
       recommended_stage: ["ship", "author", "implement", "recon", "verify"],
       continue_with_stage: ["ship", "author", "implement", "recon", "verify"],
@@ -773,9 +788,15 @@ function mergeStateFromParams(statePath, params) {
       const readyBlocker = assessment?.decision === "ready_to_ship" ? visualDeltaShipGateReason({ ...state, proof_assessment: assessment, proof_assessment_source: assessment.source }) : null;
       if (readyBlocker) {
         assessment.blocked_decision = assessment.decision;
-        assessment.decision = "needs_richer_proof";
-        if (assessment.recommended_stage === "ship") assessment.recommended_stage = "verify";
-        if (assessment.continue_with_stage === "ship") assessment.continue_with_stage = "verify";
+        assessment.decision = "revise_capture";
+        assessment.recommended_stage = "verify";
+        assessment.continue_with_stage = "verify";
+        assessment.evidence_collection_incomplete = true;
+        assessment.recovery_stage = "verify";
+        assessment.recovery_reason = readyBlocker;
+        assessment.evidence_issue_code = visualDeltaEvidenceIssueCode(state, readyBlocker);
+        assessment.visual_delta = visualDeltaForState(state);
+        assessment.suggested_repair = "Keep the same Riddle Proof run in evidence/comparison recovery: repair or retry the visual comparator/fetch path, wait for artifact readiness if applicable, or produce a measured visual_delta artifact before proof review can mark ready_to_ship.";
         const blockers = Array.isArray(assessment.blockers) ? assessment.blockers : [];
         assessment.blockers = [...blockers, readyBlocker];
       }
@@ -794,7 +815,7 @@ function mergeStateFromParams(statePath, params) {
       }
       appendProofSummaryLine(state, `Supervising proof assessment: ${state.proof_assessment.decision || "unknown"}`);
       if (readyBlocker) {
-        appendProofSummaryLine(state, `Ready-to-ship assessment blocked: ${readyBlocker}`);
+        appendProofSummaryLine(state, `Ready-to-ship assessment routed to evidence recovery: ${readyBlocker}`);
       }
       if (state.proof_assessment_summary) {
         appendProofSummaryLine(state, `Assessment summary: ${state.proof_assessment_summary}`);

package/dist/{chunk-VSLU6XNI.js → chunk-MJD37CLH.js}

@@ -25,8 +25,10 @@ import {
   recordValue
 } from "./chunk-W7VTDN4T.js";
 import {
+  visualDeltaForState,
+  visualDeltaRequiredForState,
   visualDeltaShipGateReason
-} from "./chunk-U4VNN2CT.js";
+} from "./chunk-4ASMX4R6.js";
 
 // src/engine-harness.ts
 import { execFileSync } from "child_process";
@@ -315,14 +317,36 @@ function proofAssessmentVisualBlocker(state, payload) {
     proof_assessment_source: source
   });
 }
-function blockedProofAssessmentPayload(payload, blocker) {
+function visualDeltaBlockerCode(state, blocker) {
+  const visualDelta = visualDeltaForState(state || {});
+  const status = nonEmptyString(visualDelta.status);
+  const reason = `${nonEmptyString(visualDelta.reason) || ""}
+${blocker}`.toLowerCase();
+  if (status === "unmeasured") {
+    if (reason.includes("fetch") || reason.includes("allowlist") || reason.includes("registered domain") || reason.includes("high risk") || reason.includes("comparator")) {
+      return "comparator_fetch_blocked";
+    }
+    return "visual_delta_unmeasured";
+  }
+  if (status === "measured" && visualDelta.passed === false) return "semantic_proof_failed";
+  if (visualDeltaRequiredForState(state || {})) return "visual_delta_unmeasured";
+  return "semantic_proof_failed";
+}
+function visualDeltaEvidenceRecoveryAssessment(state, payload, blocker) {
+  const visualDelta = visualDeltaForState(state || {});
   const blockers = Array.isArray(payload.blockers) ? payload.blockers.filter((item) => typeof item === "string") : [];
   return {
     ...payload,
     blocked_decision: payload.decision || "ready_to_ship",
-    decision: "needs_richer_proof",
-    recommended_stage: payload.recommended_stage === "ship" ? "verify" : payload.recommended_stage || "verify",
-    continue_with_stage: payload.continue_with_stage === "ship" ? "verify" : payload.continue_with_stage || "verify",
+    decision: "revise_capture",
+    recommended_stage: "verify",
+    continue_with_stage: "verify",
+    evidence_collection_incomplete: true,
+    recovery_stage: "verify",
+    recovery_reason: blocker,
+    evidence_issue_code: visualDeltaBlockerCode(state, blocker),
+    visual_delta: Object.keys(visualDelta).length ? visualDelta : null,
+    suggested_repair: "Keep the same Riddle Proof run in evidence/comparison recovery: repair or retry the visual comparator/fetch path, wait for artifact readiness if applicable, or produce a measured visual_delta artifact before proof review can mark ready_to_ship.",
     blockers: [...blockers, blocker]
   };
 }
@@ -887,14 +911,24 @@ async function routeCheckpoint(request, state, result, agent, input) {
       verification_mode: context.fullRiddleState?.verification_mode || request.verification_mode
     }, payload);
     if (visualBlocker) {
+      const recoveryAssessment = visualDeltaEvidenceRecoveryAssessment({
+        ...context.fullRiddleState || {},
+        verification_mode: context.fullRiddleState?.verification_mode || request.verification_mode
+      }, payload, visualBlocker);
       recordEvent(state, {
-        kind: "agent.proof_assessment.blocked",
+        kind: "agent.proof_assessment.evidence_recovery_required",
         checkpoint,
         stage: "verify",
         summary: visualBlocker,
-        details: { payload }
+        details: compactRecord({
+          evidence_collection_incomplete: true,
+          recovery_stage: "verify",
+          evidence_issue_code: recoveryAssessment.evidence_issue_code || null,
+          visual_delta: recoveryAssessment.visual_delta || null,
+          proof_assessment: recoveryAssessment
+        })
       });
-      return { next: proofAssessmentContinuation(result, blockedProofAssessmentPayload(payload, visualBlocker)) };
+      return { next: proofAssessmentContinuation(result, recoveryAssessment) };
     }
     if (effectiveShipMode(request, input.config) !== "ship" && proofAssessmentRequestsShip(payload)) {
       return {

package/dist/engine-harness.cjs

@@ -389,6 +389,21 @@ function visualDeltaShipGateReason(state = {}) {
   if (reason) return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof: ${reason}`;
   return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof`;
 }
+function visualDeltaEvidenceIssueCode(state = {}, blocker = "") {
+  const visualDelta = visualDeltaForState(state || {});
+  const status = String(visualDelta.status || "").trim();
+  const reason = `${String(visualDelta.reason || "")}
+${blocker}`.toLowerCase();
+  if (status === "unmeasured") {
+    if (reason.includes("fetch") || reason.includes("allowlist") || reason.includes("registered domain") || reason.includes("high risk") || reason.includes("comparator")) {
+      return "comparator_fetch_blocked";
+    }
+    return "visual_delta_unmeasured";
+  }
+  if (status === "measured" && visualDelta.passed === false) return "semantic_proof_failed";
+  if (visualDeltaRequiredForState(state || {})) return "visual_delta_unmeasured";
+  return "semantic_proof_failed";
+}
 function requiredBaselineLabelsForState(state = {}) {
   const reference = normalizedReference(state);
   const labels = [];
@@ -613,9 +628,15 @@ function mergeStateFromParams(statePath, params) {
       const readyBlocker = assessment?.decision === "ready_to_ship" ? visualDeltaShipGateReason({ ...state, proof_assessment: assessment, proof_assessment_source: assessment.source }) : null;
       if (readyBlocker) {
         assessment.blocked_decision = assessment.decision;
-        assessment.decision = "needs_richer_proof";
-        if (assessment.recommended_stage === "ship") assessment.recommended_stage = "verify";
-        if (assessment.continue_with_stage === "ship") assessment.continue_with_stage = "verify";
+        assessment.decision = "revise_capture";
+        assessment.recommended_stage = "verify";
+        assessment.continue_with_stage = "verify";
+        assessment.evidence_collection_incomplete = true;
+        assessment.recovery_stage = "verify";
+        assessment.recovery_reason = readyBlocker;
+        assessment.evidence_issue_code = visualDeltaEvidenceIssueCode(state, readyBlocker);
+        assessment.visual_delta = visualDeltaForState(state);
+        assessment.suggested_repair = "Keep the same Riddle Proof run in evidence/comparison recovery: repair or retry the visual comparator/fetch path, wait for artifact readiness if applicable, or produce a measured visual_delta artifact before proof review can mark ready_to_ship.";
         const blockers = Array.isArray(assessment.blockers) ? assessment.blockers : [];
         assessment.blockers = [...blockers, readyBlocker];
       }
@@ -634,7 +655,7 @@ function mergeStateFromParams(statePath, params) {
       }
       appendProofSummaryLine(state, `Supervising proof assessment: ${state.proof_assessment.decision || "unknown"}`);
       if (readyBlocker) {
-        appendProofSummaryLine(state, `Ready-to-ship assessment blocked: ${readyBlocker}`);
+        appendProofSummaryLine(state, `Ready-to-ship assessment routed to evidence recovery: ${readyBlocker}`);
       }
       if (state.proof_assessment_summary) {
         appendProofSummaryLine(state, `Assessment summary: ${state.proof_assessment_summary}`);
@@ -908,7 +929,7 @@ var init_proof_run_core = __esm({
           description: "JSON assessment with decision, summary, recommended_stage, continue_with_stage, escalation_target, and reasons."
         }],
         response_schema: {
-          decision: ["ready_to_ship", "needs_richer_proof"],
+          decision: ["ready_to_ship", "needs_richer_proof", "revise_capture"],
           summary: "string",
           recommended_stage: ["ship", "author", "implement", "recon", "verify"],
           continue_with_stage: ["ship", "author", "implement", "recon", "verify"],
@@ -1713,10 +1734,10 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
   const primaryShipGateNextAction = (shipGate) => {
     const reasons = shipGate.reasons || [];
     if (reasons.some((reason) => reason.includes("proof_assessment"))) {
-      return "resume with riddle_proof_review using decision=ready_to_ship only after the screenshots and semantic evidence visibly prove the request; otherwise choose needs_implementation or needs_richer_proof";
+      return "resume with riddle_proof_review using decision=ready_to_ship only after screenshots, semantic evidence, and required comparison metrics prove the request; otherwise choose needs_implementation, revise_capture, or needs_richer_proof for the specific missing stage";
     }
     if (reasons.some((reason) => reason.includes("visual_delta"))) {
-      return "rerun verify with a measured before/after visual delta, or choose needs_richer_proof instead of ready_to_ship for this visual proof";
+      return "keep the run in verify/evidence recovery until a measured before/after visual_delta exists; choose revise_capture rather than ready_to_ship or generic needs_richer_proof for this visual proof";
     }
     if (reasons.some((reason) => reason.includes("after_cdn") || reason.includes("verify_status"))) {
       return "rerun verify with stronger proof framing so after evidence is captured before shipping";
@@ -3692,14 +3713,36 @@ function proofAssessmentVisualBlocker(state, payload) {
     proof_assessment_source: source
   });
 }
-function blockedProofAssessmentPayload(payload, blocker) {
+function visualDeltaBlockerCode(state, blocker) {
+  const visualDelta = visualDeltaForState(state || {});
+  const status = nonEmptyString(visualDelta.status);
+  const reason = `${nonEmptyString(visualDelta.reason) || ""}
+${blocker}`.toLowerCase();
+  if (status === "unmeasured") {
+    if (reason.includes("fetch") || reason.includes("allowlist") || reason.includes("registered domain") || reason.includes("high risk") || reason.includes("comparator")) {
+      return "comparator_fetch_blocked";
+    }
+    return "visual_delta_unmeasured";
+  }
+  if (status === "measured" && visualDelta.passed === false) return "semantic_proof_failed";
+  if (visualDeltaRequiredForState(state || {})) return "visual_delta_unmeasured";
+  return "semantic_proof_failed";
+}
+function visualDeltaEvidenceRecoveryAssessment(state, payload, blocker) {
+  const visualDelta = visualDeltaForState(state || {});
   const blockers = Array.isArray(payload.blockers) ? payload.blockers.filter((item) => typeof item === "string") : [];
   return {
     ...payload,
     blocked_decision: payload.decision || "ready_to_ship",
-    decision: "needs_richer_proof",
-    recommended_stage: payload.recommended_stage === "ship" ? "verify" : payload.recommended_stage || "verify",
-    continue_with_stage: payload.continue_with_stage === "ship" ? "verify" : payload.continue_with_stage || "verify",
+    decision: "revise_capture",
+    recommended_stage: "verify",
+    continue_with_stage: "verify",
+    evidence_collection_incomplete: true,
+    recovery_stage: "verify",
+    recovery_reason: blocker,
+    evidence_issue_code: visualDeltaBlockerCode(state, blocker),
+    visual_delta: Object.keys(visualDelta).length ? visualDelta : null,
+    suggested_repair: "Keep the same Riddle Proof run in evidence/comparison recovery: repair or retry the visual comparator/fetch path, wait for artifact readiness if applicable, or produce a measured visual_delta artifact before proof review can mark ready_to_ship.",
     blockers: [...blockers, blocker]
   };
 }
@@ -4264,14 +4307,24 @@ async function routeCheckpoint(request, state, result, agent, input) {
       verification_mode: context.fullRiddleState?.verification_mode || request.verification_mode
     }, payload);
     if (visualBlocker) {
+      const recoveryAssessment = visualDeltaEvidenceRecoveryAssessment({
+        ...context.fullRiddleState || {},
+        verification_mode: context.fullRiddleState?.verification_mode || request.verification_mode
+      }, payload, visualBlocker);
       recordEvent(state, {
-        kind: "agent.proof_assessment.blocked",
+        kind: "agent.proof_assessment.evidence_recovery_required",
         checkpoint,
         stage: "verify",
         summary: visualBlocker,
-        details: { payload }
+        details: compactRecord({
+          evidence_collection_incomplete: true,
+          recovery_stage: "verify",
+          evidence_issue_code: recoveryAssessment.evidence_issue_code || null,
+          visual_delta: recoveryAssessment.visual_delta || null,
+          proof_assessment: recoveryAssessment
+        })
       });
-      return { next: proofAssessmentContinuation(result, blockedProofAssessmentPayload(payload, visualBlocker)) };
+      return { next: proofAssessmentContinuation(result, recoveryAssessment) };
     }
     if (effectiveShipMode(request, input.config) !== "ship" && proofAssessmentRequestsShip(payload)) {
       return {

package/dist/engine-harness.js

@@ -2,11 +2,11 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-VSLU6XNI.js";
+} from "./chunk-MJD37CLH.js";
 import "./chunk-RI25RGQP.js";
 import "./chunk-7S7O3NKF.js";
 import "./chunk-W7VTDN4T.js";
-import "./chunk-U4VNN2CT.js";
+import "./chunk-4ASMX4R6.js";
 export {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,

package/dist/index.cjs

@@ -389,6 +389,21 @@ function visualDeltaShipGateReason(state = {}) {
   if (reason) return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof: ${reason}`;
   return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof`;
 }
+function visualDeltaEvidenceIssueCode(state = {}, blocker = "") {
+  const visualDelta = visualDeltaForState(state || {});
+  const status = String(visualDelta.status || "").trim();
+  const reason = `${String(visualDelta.reason || "")}
+${blocker}`.toLowerCase();
+  if (status === "unmeasured") {
+    if (reason.includes("fetch") || reason.includes("allowlist") || reason.includes("registered domain") || reason.includes("high risk") || reason.includes("comparator")) {
+      return "comparator_fetch_blocked";
+    }
+    return "visual_delta_unmeasured";
+  }
+  if (status === "measured" && visualDelta.passed === false) return "semantic_proof_failed";
+  if (visualDeltaRequiredForState(state || {})) return "visual_delta_unmeasured";
+  return "semantic_proof_failed";
+}
 function requiredBaselineLabelsForState(state = {}) {
   const reference = normalizedReference(state);
   const labels = [];
@@ -613,9 +628,15 @@ function mergeStateFromParams(statePath, params) {
       const readyBlocker = assessment?.decision === "ready_to_ship" ? visualDeltaShipGateReason({ ...state, proof_assessment: assessment, proof_assessment_source: assessment.source }) : null;
       if (readyBlocker) {
         assessment.blocked_decision = assessment.decision;
-        assessment.decision = "needs_richer_proof";
-        if (assessment.recommended_stage === "ship") assessment.recommended_stage = "verify";
-        if (assessment.continue_with_stage === "ship") assessment.continue_with_stage = "verify";
+        assessment.decision = "revise_capture";
+        assessment.recommended_stage = "verify";
+        assessment.continue_with_stage = "verify";
+        assessment.evidence_collection_incomplete = true;
+        assessment.recovery_stage = "verify";
+        assessment.recovery_reason = readyBlocker;
+        assessment.evidence_issue_code = visualDeltaEvidenceIssueCode(state, readyBlocker);
+        assessment.visual_delta = visualDeltaForState(state);
+        assessment.suggested_repair = "Keep the same Riddle Proof run in evidence/comparison recovery: repair or retry the visual comparator/fetch path, wait for artifact readiness if applicable, or produce a measured visual_delta artifact before proof review can mark ready_to_ship.";
         const blockers = Array.isArray(assessment.blockers) ? assessment.blockers : [];
         assessment.blockers = [...blockers, readyBlocker];
       }
@@ -634,7 +655,7 @@ function mergeStateFromParams(statePath, params) {
       }
       appendProofSummaryLine(state, `Supervising proof assessment: ${state.proof_assessment.decision || "unknown"}`);
       if (readyBlocker) {
-        appendProofSummaryLine(state, `Ready-to-ship assessment blocked: ${readyBlocker}`);
+        appendProofSummaryLine(state, `Ready-to-ship assessment routed to evidence recovery: ${readyBlocker}`);
       }
       if (state.proof_assessment_summary) {
         appendProofSummaryLine(state, `Assessment summary: ${state.proof_assessment_summary}`);
@@ -908,7 +929,7 @@ var init_proof_run_core = __esm({
           description: "JSON assessment with decision, summary, recommended_stage, continue_with_stage, escalation_target, and reasons."
         }],
         response_schema: {
-          decision: ["ready_to_ship", "needs_richer_proof"],
+          decision: ["ready_to_ship", "needs_richer_proof", "revise_capture"],
           summary: "string",
           recommended_stage: ["ship", "author", "implement", "recon", "verify"],
           continue_with_stage: ["ship", "author", "implement", "recon", "verify"],
@@ -1713,10 +1734,10 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
   const primaryShipGateNextAction = (shipGate) => {
     const reasons = shipGate.reasons || [];
     if (reasons.some((reason) => reason.includes("proof_assessment"))) {
-      return "resume with riddle_proof_review using decision=ready_to_ship only after the screenshots and semantic evidence visibly prove the request; otherwise choose needs_implementation or needs_richer_proof";
+      return "resume with riddle_proof_review using decision=ready_to_ship only after screenshots, semantic evidence, and required comparison metrics prove the request; otherwise choose needs_implementation, revise_capture, or needs_richer_proof for the specific missing stage";
     }
     if (reasons.some((reason) => reason.includes("visual_delta"))) {
-      return "rerun verify with a measured before/after visual delta, or choose needs_richer_proof instead of ready_to_ship for this visual proof";
+      return "keep the run in verify/evidence recovery until a measured before/after visual_delta exists; choose revise_capture rather than ready_to_ship or generic needs_richer_proof for this visual proof";
     }
     if (reasons.some((reason) => reason.includes("after_cdn") || reason.includes("verify_status"))) {
       return "rerun verify with stronger proof framing so after evidence is captured before shipping";
@@ -4270,14 +4291,36 @@ function proofAssessmentVisualBlocker(state, payload) {
     proof_assessment_source: source
   });
 }
-function blockedProofAssessmentPayload(payload, blocker) {
+function visualDeltaBlockerCode(state, blocker) {
+  const visualDelta = visualDeltaForState(state || {});
+  const status = nonEmptyString(visualDelta.status);
+  const reason = `${nonEmptyString(visualDelta.reason) || ""}
+${blocker}`.toLowerCase();
+  if (status === "unmeasured") {
+    if (reason.includes("fetch") || reason.includes("allowlist") || reason.includes("registered domain") || reason.includes("high risk") || reason.includes("comparator")) {
+      return "comparator_fetch_blocked";
+    }
+    return "visual_delta_unmeasured";
+  }
+  if (status === "measured" && visualDelta.passed === false) return "semantic_proof_failed";
+  if (visualDeltaRequiredForState(state || {})) return "visual_delta_unmeasured";
+  return "semantic_proof_failed";
+}
+function visualDeltaEvidenceRecoveryAssessment(state, payload, blocker) {
+  const visualDelta = visualDeltaForState(state || {});
   const blockers = Array.isArray(payload.blockers) ? payload.blockers.filter((item) => typeof item === "string") : [];
   return {
     ...payload,
     blocked_decision: payload.decision || "ready_to_ship",
-    decision: "needs_richer_proof",
-    recommended_stage: payload.recommended_stage === "ship" ? "verify" : payload.recommended_stage || "verify",
-    continue_with_stage: payload.continue_with_stage === "ship" ? "verify" : payload.continue_with_stage || "verify",
+    decision: "revise_capture",
+    recommended_stage: "verify",
+    continue_with_stage: "verify",
+    evidence_collection_incomplete: true,
+    recovery_stage: "verify",
+    recovery_reason: blocker,
+    evidence_issue_code: visualDeltaBlockerCode(state, blocker),
+    visual_delta: Object.keys(visualDelta).length ? visualDelta : null,
+    suggested_repair: "Keep the same Riddle Proof run in evidence/comparison recovery: repair or retry the visual comparator/fetch path, wait for artifact readiness if applicable, or produce a measured visual_delta artifact before proof review can mark ready_to_ship.",
     blockers: [...blockers, blocker]
   };
 }
@@ -4842,14 +4885,24 @@ async function routeCheckpoint(request, state, result, agent, input) {
       verification_mode: context.fullRiddleState?.verification_mode || request.verification_mode
     }, payload);
     if (visualBlocker) {
+      const recoveryAssessment = visualDeltaEvidenceRecoveryAssessment({
+        ...context.fullRiddleState || {},
+        verification_mode: context.fullRiddleState?.verification_mode || request.verification_mode
+      }, payload, visualBlocker);
       recordEvent(state, {
-        kind: "agent.proof_assessment.blocked",
+        kind: "agent.proof_assessment.evidence_recovery_required",
         checkpoint,
         stage: "verify",
         summary: visualBlocker,
-        details: { payload }
+        details: compactRecord({
+          evidence_collection_incomplete: true,
+          recovery_stage: "verify",
+          evidence_issue_code: recoveryAssessment.evidence_issue_code || null,
+          visual_delta: recoveryAssessment.visual_delta || null,
+          proof_assessment: recoveryAssessment
+        })
       });
-      return { next: proofAssessmentContinuation(result, blockedProofAssessmentPayload(payload, visualBlocker)) };
+      return { next: proofAssessmentContinuation(result, recoveryAssessment) };
     }
     if (effectiveShipMode(request, input.config) !== "ship" && proofAssessmentRequestsShip(payload)) {
       return {

package/dist/index.js

@@ -25,7 +25,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-VSLU6XNI.js";
+} from "./chunk-MJD37CLH.js";
 import {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
@@ -67,7 +67,7 @@ import {
   extractPlayabilityEvidence,
   isRiddleProofPlayabilityMode
 } from "./chunk-NSWT3VSV.js";
-import "./chunk-U4VNN2CT.js";
+import "./chunk-4ASMX4R6.js";
 export {
   DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
   DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,

package/dist/proof-run-core.cjs

@@ -440,6 +440,21 @@ function visualDeltaShipGateReason(state = {}) {
   if (reason) return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof: ${reason}`;
   return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof`;
 }
+function visualDeltaEvidenceIssueCode(state = {}, blocker = "") {
+  const visualDelta = visualDeltaForState(state || {});
+  const status = String(visualDelta.status || "").trim();
+  const reason = `${String(visualDelta.reason || "")}
+${blocker}`.toLowerCase();
+  if (status === "unmeasured") {
+    if (reason.includes("fetch") || reason.includes("allowlist") || reason.includes("registered domain") || reason.includes("high risk") || reason.includes("comparator")) {
+      return "comparator_fetch_blocked";
+    }
+    return "visual_delta_unmeasured";
+  }
+  if (status === "measured" && visualDelta.passed === false) return "semantic_proof_failed";
+  if (visualDeltaRequiredForState(state || {})) return "visual_delta_unmeasured";
+  return "semantic_proof_failed";
+}
 function requiredBaselineLabelsForState(state = {}) {
   const reference = normalizedReference(state);
   const labels = [];
@@ -629,7 +644,7 @@ var CHECKPOINT_CONTRACT_SPECS = {
       description: "JSON assessment with decision, summary, recommended_stage, continue_with_stage, escalation_target, and reasons."
     }],
     response_schema: {
-      decision: ["ready_to_ship", "needs_richer_proof"],
+      decision: ["ready_to_ship", "needs_richer_proof", "revise_capture"],
       summary: "string",
       recommended_stage: ["ship", "author", "implement", "recon", "verify"],
       continue_with_stage: ["ship", "author", "implement", "recon", "verify"],
@@ -832,9 +847,15 @@ function mergeStateFromParams(statePath, params) {
       const readyBlocker = assessment?.decision === "ready_to_ship" ? visualDeltaShipGateReason({ ...state, proof_assessment: assessment, proof_assessment_source: assessment.source }) : null;
       if (readyBlocker) {
         assessment.blocked_decision = assessment.decision;
-        assessment.decision = "needs_richer_proof";
-        if (assessment.recommended_stage === "ship") assessment.recommended_stage = "verify";
-        if (assessment.continue_with_stage === "ship") assessment.continue_with_stage = "verify";
+        assessment.decision = "revise_capture";
+        assessment.recommended_stage = "verify";
+        assessment.continue_with_stage = "verify";
+        assessment.evidence_collection_incomplete = true;
+        assessment.recovery_stage = "verify";
+        assessment.recovery_reason = readyBlocker;
+        assessment.evidence_issue_code = visualDeltaEvidenceIssueCode(state, readyBlocker);
+        assessment.visual_delta = visualDeltaForState(state);
+        assessment.suggested_repair = "Keep the same Riddle Proof run in evidence/comparison recovery: repair or retry the visual comparator/fetch path, wait for artifact readiness if applicable, or produce a measured visual_delta artifact before proof review can mark ready_to_ship.";
         const blockers = Array.isArray(assessment.blockers) ? assessment.blockers : [];
         assessment.blockers = [...blockers, readyBlocker];
       }
@@ -853,7 +874,7 @@ function mergeStateFromParams(statePath, params) {
       }
       appendProofSummaryLine(state, `Supervising proof assessment: ${state.proof_assessment.decision || "unknown"}`);
       if (readyBlocker) {
-        appendProofSummaryLine(state, `Ready-to-ship assessment blocked: ${readyBlocker}`);
+        appendProofSummaryLine(state, `Ready-to-ship assessment routed to evidence recovery: ${readyBlocker}`);
       }
       if (state.proof_assessment_summary) {
         appendProofSummaryLine(state, `Assessment summary: ${state.proof_assessment_summary}`);

package/dist/proof-run-core.js

@@ -24,7 +24,7 @@ import {
   visualDeltaShipGateReason,
   workflowFile,
   writeState
-} from "./chunk-U4VNN2CT.js";
+} from "./chunk-4ASMX4R6.js";
 export {
   BUNDLED_RIDDLE_PROOF_DIR,
   CHECKPOINT_CONTRACT_VERSION,

package/dist/proof-run-engine.cjs

@@ -422,6 +422,21 @@ function visualDeltaShipGateReason(state = {}) {
   if (reason) return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof: ${reason}`;
   return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof`;
 }
+function visualDeltaEvidenceIssueCode(state = {}, blocker = "") {
+  const visualDelta = visualDeltaForState(state || {});
+  const status = String(visualDelta.status || "").trim();
+  const reason = `${String(visualDelta.reason || "")}
+${blocker}`.toLowerCase();
+  if (status === "unmeasured") {
+    if (reason.includes("fetch") || reason.includes("allowlist") || reason.includes("registered domain") || reason.includes("high risk") || reason.includes("comparator")) {
+      return "comparator_fetch_blocked";
+    }
+    return "visual_delta_unmeasured";
+  }
+  if (status === "measured" && visualDelta.passed === false) return "semantic_proof_failed";
+  if (visualDeltaRequiredForState(state || {})) return "visual_delta_unmeasured";
+  return "semantic_proof_failed";
+}
 function requiredBaselineLabelsForState(state = {}) {
   const reference = normalizedReference(state);
   const labels = [];
@@ -611,7 +626,7 @@ var CHECKPOINT_CONTRACT_SPECS = {
       description: "JSON assessment with decision, summary, recommended_stage, continue_with_stage, escalation_target, and reasons."
     }],
     response_schema: {
-      decision: ["ready_to_ship", "needs_richer_proof"],
+      decision: ["ready_to_ship", "needs_richer_proof", "revise_capture"],
       summary: "string",
       recommended_stage: ["ship", "author", "implement", "recon", "verify"],
       continue_with_stage: ["ship", "author", "implement", "recon", "verify"],
@@ -814,9 +829,15 @@ function mergeStateFromParams(statePath, params) {
       const readyBlocker = assessment?.decision === "ready_to_ship" ? visualDeltaShipGateReason({ ...state, proof_assessment: assessment, proof_assessment_source: assessment.source }) : null;
       if (readyBlocker) {
         assessment.blocked_decision = assessment.decision;
-        assessment.decision = "needs_richer_proof";
-        if (assessment.recommended_stage === "ship") assessment.recommended_stage = "verify";
-        if (assessment.continue_with_stage === "ship") assessment.continue_with_stage = "verify";
+        assessment.decision = "revise_capture";
+        assessment.recommended_stage = "verify";
+        assessment.continue_with_stage = "verify";
+        assessment.evidence_collection_incomplete = true;
+        assessment.recovery_stage = "verify";
+        assessment.recovery_reason = readyBlocker;
+        assessment.evidence_issue_code = visualDeltaEvidenceIssueCode(state, readyBlocker);
+        assessment.visual_delta = visualDeltaForState(state);
+        assessment.suggested_repair = "Keep the same Riddle Proof run in evidence/comparison recovery: repair or retry the visual comparator/fetch path, wait for artifact readiness if applicable, or produce a measured visual_delta artifact before proof review can mark ready_to_ship.";
         const blockers = Array.isArray(assessment.blockers) ? assessment.blockers : [];
         assessment.blockers = [...blockers, readyBlocker];
       }
@@ -835,7 +856,7 @@ function mergeStateFromParams(statePath, params) {
       }
       appendProofSummaryLine(state, `Supervising proof assessment: ${state.proof_assessment.decision || "unknown"}`);
       if (readyBlocker) {
-        appendProofSummaryLine(state, `Ready-to-ship assessment blocked: ${readyBlocker}`);
+        appendProofSummaryLine(state, `Ready-to-ship assessment routed to evidence recovery: ${readyBlocker}`);
       }
       if (state.proof_assessment_summary) {
         appendProofSummaryLine(state, `Assessment summary: ${state.proof_assessment_summary}`);
@@ -1711,10 +1732,10 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
   const primaryShipGateNextAction = (shipGate) => {
     const reasons = shipGate.reasons || [];
     if (reasons.some((reason) => reason.includes("proof_assessment"))) {
-      return "resume with riddle_proof_review using decision=ready_to_ship only after the screenshots and semantic evidence visibly prove the request; otherwise choose needs_implementation or needs_richer_proof";
+      return "resume with riddle_proof_review using decision=ready_to_ship only after screenshots, semantic evidence, and required comparison metrics prove the request; otherwise choose needs_implementation, revise_capture, or needs_richer_proof for the specific missing stage";
     }
     if (reasons.some((reason) => reason.includes("visual_delta"))) {
-      return "rerun verify with a measured before/after visual delta, or choose needs_richer_proof instead of ready_to_ship for this visual proof";
+      return "keep the run in verify/evidence recovery until a measured before/after visual_delta exists; choose revise_capture rather than ready_to_ship or generic needs_richer_proof for this visual proof";
     }
     if (reasons.some((reason) => reason.includes("after_cdn") || reason.includes("verify_status"))) {
       return "rerun verify with stronger proof framing so after evidence is captured before shipping";

package/dist/proof-run-engine.js

@@ -14,7 +14,7 @@ import {
   validateShipGate,
   workflowFile,
   writeState
-} from "./chunk-U4VNN2CT.js";
+} from "./chunk-4ASMX4R6.js";
 
 // src/proof-run-engine.ts
 import { execFileSync } from "child_process";
@@ -768,10 +768,10 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
   const primaryShipGateNextAction = (shipGate) => {
     const reasons = shipGate.reasons || [];
     if (reasons.some((reason) => reason.includes("proof_assessment"))) {
-      return "resume with riddle_proof_review using decision=ready_to_ship only after the screenshots and semantic evidence visibly prove the request; otherwise choose needs_implementation or needs_richer_proof";
+      return "resume with riddle_proof_review using decision=ready_to_ship only after screenshots, semantic evidence, and required comparison metrics prove the request; otherwise choose needs_implementation, revise_capture, or needs_richer_proof for the specific missing stage";
     }
     if (reasons.some((reason) => reason.includes("visual_delta"))) {
-      return "rerun verify with a measured before/after visual delta, or choose needs_richer_proof instead of ready_to_ship for this visual proof";
+      return "keep the run in verify/evidence recovery until a measured before/after visual_delta exists; choose revise_capture rather than ready_to_ship or generic needs_richer_proof for this visual proof";
     }
     if (reasons.some((reason) => reason.includes("after_cdn") || reason.includes("verify_status"))) {
       return "rerun verify with stronger proof framing so after evidence is captured before shipping";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.5.43",
+  "version": "0.5.44",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",