@riddledc/riddle-proof 0.5.43 → 0.5.45

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";
@@ -2751,6 +2772,8 @@ __export(index_exports, {
   assessPlayabilityEvidence: () => assessPlayabilityEvidence,
   authorPacketPayloadFromCheckpointResponse: () => authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket: () => buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult: () => buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket: () => buildProofAssessmentCheckpointPacket,
   buildVisualProofSession: () => buildVisualProofSession,
   checkpointResponseIdentity: () => checkpointResponseIdentity,
   checkpointSummaryFromState: () => checkpointSummaryFromState,
@@ -3309,6 +3332,47 @@ function responseSchemaForAuthorPacket() {
     }
   };
 }
+function responseSchemaForProofAssessmentPacket() {
+  return {
+    type: "object",
+    required: ["version", "run_id", "checkpoint", "decision", "summary", "created_at"],
+    additionalProperties: false,
+    properties: {
+      version: { const: RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION },
+      run_id: { type: "string" },
+      checkpoint: { type: "string" },
+      resume_token: { type: "string" },
+      decision: {
+        type: "string",
+        enum: [
+          "ready_to_ship",
+          "needs_richer_proof",
+          "revise_capture",
+          "needs_recon",
+          "needs_implementation",
+          "blocked",
+          "human_review"
+        ]
+      },
+      summary: { type: "string" },
+      payload: {
+        type: "object",
+        description: "Optional structured assessment details, including recommended_stage, continue_with_stage, visual_delta notes, or blocker diagnostics."
+      },
+      reasons: { type: "array", items: { type: "string" } },
+      continue_with_stage: { type: "string", enum: ["ship", "author", "implement", "recon", "verify"] },
+      source: {
+        type: "object",
+        properties: {
+          kind: { type: "string" },
+          session_id: { type: "string" },
+          user_id: { type: "string" }
+        }
+      },
+      created_at: { type: "string" }
+    }
+  };
+}
 function resumeTokenFor(input) {
   const hash = import_node_crypto.default.createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 24);
   return `rpchk_${hash}`;
@@ -3392,6 +3456,124 @@ function buildAuthorCheckpointPacket(input) {
     created_at: input.created_at || timestamp2()
   };
 }
+function visualDeltaFromState(fullState) {
+  const bundle = recordValue(fullState.evidence_bundle);
+  const after = recordValue(bundle?.after);
+  const afterDelta = recordValue(after?.visual_delta);
+  if (afterDelta && Object.keys(afterDelta).length) return afterDelta;
+  const proofAssessmentRequest = recordValue(fullState.proof_assessment_request);
+  return recordValue(proofAssessmentRequest?.visual_delta) || null;
+}
+function verificationModeRequiresVisualDelta(value) {
+  const mode = String(value || "proof").trim().toLowerCase();
+  return [
+    "visual",
+    "render",
+    "interaction",
+    "ui",
+    "layout",
+    "screenshot",
+    "canvas",
+    "animation"
+  ].includes(mode);
+}
+function visualDeltaIssueCode(visualDelta, required) {
+  const status = String(visualDelta?.status || "").trim();
+  const reason = String(visualDelta?.reason || "").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 (required && status !== "measured") return "visual_delta_unmeasured";
+  return null;
+}
+function buildProofAssessmentCheckpointPacket(input) {
+  const checkpoint = nonEmptyString(input.engineResult.checkpoint) || "verify_supervisor_judgment";
+  const stage = "verify";
+  const runId = input.runState.run_id || "unknown";
+  const fullState = input.fullRiddleState || {};
+  const proofAssessmentRequest = recordValue(fullState.proof_assessment_request) || recordValue(recordValue(fullState.verify_decision_request)?.assessment_request) || recordValue(input.engineResult.decisionRequest?.details) || {};
+  const bundle = recordValue(fullState.evidence_bundle);
+  const artifactContract = recordValue(proofAssessmentRequest.artifact_contract) || recordValue(bundle?.artifact_contract);
+  const requiredSignals = recordValue(recordValue(artifactContract)?.required);
+  const visualDelta = visualDeltaFromState(fullState);
+  const verificationMode = nonEmptyString(input.request.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(bundle?.verification_mode) || "proof";
+  const visualDeltaRequired = requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode);
+  const evidenceIssueCode = visualDeltaIssueCode(visualDelta, visualDeltaRequired);
+  const summary = nonEmptyString(input.engineResult.summary) || nonEmptyString(fullState.verify_summary) || "Verify captured evidence and needs a supervising proof assessment.";
+  const recoveryHint = evidenceIssueCode ? "Required visual_delta evidence is incomplete. Keep this same run in verify/evidence recovery with decision=revise_capture and continue_with_stage=verify unless the evidence proves an implementation or recon problem." : "Assess whether the current artifacts prove the requested change, then choose the next stage.";
+  return {
+    version: RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
+    run_id: runId,
+    state_path: input.runState.state_path,
+    stage,
+    checkpoint,
+    kind: evidenceIssueCode ? "recover_evidence" : "assess_proof",
+    summary,
+    question: `Assess the current Riddle Proof evidence. ${recoveryHint} Return a CheckpointResponse using one allowed decision.`,
+    change_request: input.request.change_request || nonEmptyString(fullState.change_request) || "",
+    context: input.request.context,
+    artifacts: artifactsFromState(fullState),
+    state_excerpt: compactRecord({
+      repo: input.request.repo || fullState.repo,
+      branch: input.request.branch || fullState.branch,
+      verification_mode: verificationMode,
+      reference: input.request.reference || fullState.reference,
+      server_path: fullState.server_path,
+      wait_for_selector: fullState.wait_for_selector,
+      implementation_status: fullState.implementation_status,
+      implementation_summary: fullState.implementation_summary,
+      changed_files: jsonCloneValue(fullState.changed_files),
+      proof_plan: compactText(fullState.proof_plan, 1200)
+    }),
+    evidence_excerpt: compactRecord({
+      before_cdn: fullState.before_cdn || null,
+      prod_cdn: fullState.prod_cdn || null,
+      after_cdn: fullState.after_cdn || null,
+      visual_delta_required: visualDeltaRequired,
+      visual_delta_ready: visualDelta?.status === "measured" && visualDelta?.passed === true,
+      visual_delta: jsonCloneRecord(visualDelta),
+      evidence_issue_code: evidenceIssueCode,
+      proof_assessment_request: jsonCloneRecord(proofAssessmentRequest),
+      verify_decision_request: jsonCloneRecord(fullState.verify_decision_request),
+      checkpoint_contract: jsonCloneRecord(input.engineResult.checkpointContract)
+    }),
+    artifact_contract: jsonCloneRecord(artifactContract),
+    allowed_decisions: [
+      "ready_to_ship",
+      "needs_richer_proof",
+      "revise_capture",
+      "needs_recon",
+      "needs_implementation",
+      "blocked",
+      "human_review"
+    ],
+    response_schema: responseSchemaForProofAssessmentPacket(),
+    routing_hint: {
+      suggested_role: evidenceIssueCode ? "proof_judge" : "proof_judge",
+      visibility: input.visibility || "quiet",
+      urgency: evidenceIssueCode ? "high" : "normal",
+      can_auto_answer: input.visibility !== "manual"
+    },
+    resume_token: resumeTokenFor({
+      runId,
+      statePath: input.engineResult.state_path || input.request.engine_state_path || null,
+      checkpoint,
+      stage
+    }),
+    created_at: input.created_at || timestamp2()
+  };
+}
+function buildCheckpointPacketForEngineResult(input) {
+  const checkpoint = nonEmptyString(input.engineResult.checkpoint) || "";
+  if (checkpoint === "verify_supervisor_judgment" || checkpoint === "verify_supervisor_judgment_required" || checkpoint === "verify_human_escalation") {
+    return buildProofAssessmentCheckpointPacket(input);
+  }
+  return buildAuthorCheckpointPacket(input);
+}
 function normalizeCheckpointResponse(value) {
   const record = recordValue(value);
   if (!record) return null;
@@ -4261,6 +4443,39 @@ function proofAssessmentContinuation(result, payload) {
   const proof_assessment_json = jsonParam(payload);
   return { ...baseContinuation(result), proof_assessment_json };
 }
+function defaultStageForProofCheckpointDecision(decision) {
+  if (decision === "ready_to_ship") return "ship";
+  if (decision === "needs_implementation") return "implement";
+  if (decision === "needs_recon") return "recon";
+  if (decision === "revise_capture") return "verify";
+  if (decision === "needs_richer_proof") return "author";
+  return null;
+}
+function proofAssessmentPayloadFromCheckpointResponse(response) {
+  if (![
+    "ready_to_ship",
+    "needs_richer_proof",
+    "revise_capture",
+    "needs_recon",
+    "needs_implementation"
+  ].includes(response.decision)) {
+    return null;
+  }
+  const payload = recordValue(response.payload) || {};
+  const stage = nonEmptyString(payload.continue_with_stage) || response.continue_with_stage || nonEmptyString(payload.recommended_stage) || defaultStageForProofCheckpointDecision(response.decision);
+  return compactRecord({
+    ...payload,
+    decision: response.decision,
+    summary: response.summary,
+    recommended_stage: nonEmptyString(payload.recommended_stage) || stage || void 0,
+    continue_with_stage: stage || void 0,
+    escalation_target: nonEmptyString(payload.escalation_target) || "agent",
+    reasons: Array.isArray(response.reasons) ? response.reasons : Array.isArray(payload.reasons) ? payload.reasons : [],
+    source: "supervising_agent",
+    checkpoint_response_source: response.source || null,
+    checkpoint_response_created_at: response.created_at
+  });
+}
 function proofAssessmentVisualBlocker(state, payload) {
   if (!proofAssessmentRequestsShip(payload)) return null;
   const source = nonEmptyString(payload.source) || "supervising_agent";
@@ -4270,14 +4485,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]
   };
 }
@@ -4377,7 +4614,7 @@ function blockerResult(state, result, blocker) {
   });
 }
 function checkpointAwaitingResult(state, result, visibility) {
-  const packet = buildAuthorCheckpointPacket({
+  const packet = buildCheckpointPacketForEngineResult({
     request: state.request,
     runState: state,
     engineResult: result,
@@ -4542,8 +4779,30 @@ function checkpointResponseContinuation(state, value) {
   }
   if (response.decision === "needs_recon") {
     appendCheckpointResponse(state, response);
+    if (packet.kind === "assess_proof" || packet.kind === "recover_evidence" || packet.stage === "verify") {
+      const assessment = proofAssessmentPayloadFromCheckpointResponse(response);
+      if (assessment) return { next: { ...base, proof_assessment_json: jsonParam(assessment) } };
+    }
     return { next: { ...base, advance_stage: "recon" } };
   }
+  if (packet.kind === "assess_proof" || packet.kind === "recover_evidence" || packet.stage === "verify") {
+    const assessment = proofAssessmentPayloadFromCheckpointResponse(response);
+    if (assessment) {
+      appendCheckpointResponse(state, response);
+      return { next: { ...base, proof_assessment_json: jsonParam(assessment) } };
+    }
+    if (response.decision === "blocked" || response.decision === "human_review") {
+      appendCheckpointResponse(state, response, { clear_packet: false });
+      return {
+        blocker: {
+          code: `checkpoint_response_${response.decision}`,
+          checkpoint: packet.checkpoint,
+          message: response.summary || `Checkpoint response stopped the run with decision=${response.decision}.`,
+          details: { stage: packet.stage, response }
+        }
+      };
+    }
+  }
   appendCheckpointResponse(state, response, { clear_packet: false });
   return {
     blocker: {
@@ -4826,9 +5085,24 @@ async function routeCheckpoint(request, state, result, agent, input) {
     return { next: { action: "run", state_path: String(result.state_path || ""), advance_stage: "verify" } };
   }
   if (checkpoint === "verify_supervisor_judgment") {
+    if (input.checkpoint_mode === "yield") {
+      return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
+    }
     const assessment = await agent.assessProof(context);
     const blocker = requirePayload("proof_assessment", assessment, state, result);
-    if (blocker) return { blocker };
+    if (blocker) {
+      if (blocker.code === "main_agent_proof_review_required") {
+        recordEvent(state, {
+          kind: "checkpoint.packet.requested",
+          checkpoint,
+          stage: "verify",
+          summary: "Main-agent proof review is being converted to a portable checkpoint packet.",
+          details: { blocker }
+        });
+        return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
+      }
+      return { blocker };
+    }
     const payload = assessment.payload;
     recordEvent(state, {
       kind: "agent.proof_assessment.completed",
@@ -4842,14 +5116,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 {
@@ -5702,6 +5986,8 @@ function parseJson(value) {
   assessPlayabilityEvidence,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket,
   buildVisualProofSession,
   checkpointResponseIdentity,
   checkpointSummaryFromState,

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 export { EvidenceArtifact, EvidenceReference, ImplementationAdapter, ImplementationAdapterInput, ImplementationAdapterResult, IntegrationContext, JsonObject, JsonPrimitive, JsonValue, JudgeAdapter, NotificationAdapter, PreflightAdapter, PreflightAdapterInput, PreflightAdapterResult, ProofAdapter, ProofAdapterInput, ProofAdapterResult, RiddleProofArtifactRole, RiddleProofAssessment, RiddleProofBlocker, RiddleProofCheckpointArtifact, RiddleProofCheckpointPacket, RiddleProofCheckpointResponse, RiddleProofCheckpointRole, RiddleProofCheckpointRoutingHint, RiddleProofCheckpointSummary, RiddleProofCheckpointVisibility, RiddleProofDecision, RiddleProofEvent, RiddleProofEvidenceBundle, RiddleProofPrLifecycleState, RiddleProofPrLifecycleStatus, RiddleProofProofContract, RiddleProofRunParams, RiddleProofRunResult, RiddleProofRunState, RiddleProofRunStatusSnapshot, RiddleProofStage, RiddleProofStatePaths, RiddleProofStatus, RiddleProofTerminalMetadata, RiddleProofVerificationMode, RiddleProofVisualSession, RiddleProofVisualSessionFingerprintBasis, SetupAdapter, SetupAdapterInput, SetupAdapterResult, ShipAdapter } from './types.cjs';
 export { TerminalMetadataInput, applyTerminalMetadata, compactRecord, createRunResult, isSuccessfulStatus, isTerminalStatus, nonEmptyString, normalizeTerminalMetadata, recordValue } from './result.cjs';
 export { CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, RunEventInput, appendRunEvent, appendStageHeartbeat, applyPrLifecycleState, createRunState, createRunStatusSnapshot, normalizeIntegrationContext, normalizePrLifecycleState, normalizeRunParams, setRunStatus } from './state.cjs';
-export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, checkpointResponseIdentity, checkpointSummaryFromState, isDuplicateCheckpointResponse, normalizeCheckpointResponse, proofContractFromAuthorCheckpointResponse, statePathsForRunState } from './checkpoint.cjs';
+export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, buildCheckpointPacketForEngineResult, buildProofAssessmentCheckpointPacket, checkpointResponseIdentity, checkpointSummaryFromState, isDuplicateCheckpointResponse, normalizeCheckpointResponse, proofContractFromAuthorCheckpointResponse, statePathsForRunState } from './checkpoint.cjs';
 export { RiddleProofRunnerAdapters, RunRiddleProofInput, runRiddleProof } from './runner.cjs';
 export { RiddleProofAgentAdapter, RiddleProofAgentPayload, RiddleProofCheckpointMode, RiddleProofEngine, RiddleProofEngineHarnessConfig, RiddleProofEngineHarnessContext, RiddleProofEngineResult, RiddleProofShipMode, RiddleProofWorkflowParams, RunRiddleProofEngineHarnessInput, createDisabledRiddleProofAgentAdapter, readRiddleProofRunStatus, runRiddleProofEngineHarness } from './engine-harness.cjs';
 export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.cjs';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { EvidenceArtifact, EvidenceReference, ImplementationAdapter, ImplementationAdapterInput, ImplementationAdapterResult, IntegrationContext, JsonObject, JsonPrimitive, JsonValue, JudgeAdapter, NotificationAdapter, PreflightAdapter, PreflightAdapterInput, PreflightAdapterResult, ProofAdapter, ProofAdapterInput, ProofAdapterResult, RiddleProofArtifactRole, RiddleProofAssessment, RiddleProofBlocker, RiddleProofCheckpointArtifact, RiddleProofCheckpointPacket, RiddleProofCheckpointResponse, RiddleProofCheckpointRole, RiddleProofCheckpointRoutingHint, RiddleProofCheckpointSummary, RiddleProofCheckpointVisibility, RiddleProofDecision, RiddleProofEvent, RiddleProofEvidenceBundle, RiddleProofPrLifecycleState, RiddleProofPrLifecycleStatus, RiddleProofProofContract, RiddleProofRunParams, RiddleProofRunResult, RiddleProofRunState, RiddleProofRunStatusSnapshot, RiddleProofStage, RiddleProofStatePaths, RiddleProofStatus, RiddleProofTerminalMetadata, RiddleProofVerificationMode, RiddleProofVisualSession, RiddleProofVisualSessionFingerprintBasis, SetupAdapter, SetupAdapterInput, SetupAdapterResult, ShipAdapter } from './types.js';
 export { TerminalMetadataInput, applyTerminalMetadata, compactRecord, createRunResult, isSuccessfulStatus, isTerminalStatus, nonEmptyString, normalizeTerminalMetadata, recordValue } from './result.js';
 export { CreateRunStateInput, RIDDLE_PROOF_RUN_STATE_VERSION, RunEventInput, appendRunEvent, appendStageHeartbeat, applyPrLifecycleState, createRunState, createRunStatusSnapshot, normalizeIntegrationContext, normalizePrLifecycleState, normalizeRunParams, setRunStatus } from './state.js';
-export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, checkpointResponseIdentity, checkpointSummaryFromState, isDuplicateCheckpointResponse, normalizeCheckpointResponse, proofContractFromAuthorCheckpointResponse, statePathsForRunState } from './checkpoint.js';
+export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, buildCheckpointPacketForEngineResult, buildProofAssessmentCheckpointPacket, checkpointResponseIdentity, checkpointSummaryFromState, isDuplicateCheckpointResponse, normalizeCheckpointResponse, proofContractFromAuthorCheckpointResponse, statePathsForRunState } from './checkpoint.js';
 export { RiddleProofRunnerAdapters, RunRiddleProofInput, runRiddleProof } from './runner.js';
 export { RiddleProofAgentAdapter, RiddleProofAgentPayload, RiddleProofCheckpointMode, RiddleProofEngine, RiddleProofEngineHarnessConfig, RiddleProofEngineHarnessContext, RiddleProofEngineResult, RiddleProofShipMode, RiddleProofWorkflowParams, RunRiddleProofEngineHarnessInput, createDisabledRiddleProofAgentAdapter, readRiddleProofRunStatus, runRiddleProofEngineHarness } from './engine-harness.js';
 export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.js';

package/dist/index.js

@@ -25,19 +25,21 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-VSLU6XNI.js";
+} from "./chunk-CHRYLX6N.js";
 import {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket,
   checkpointResponseIdentity,
   checkpointSummaryFromState,
   isDuplicateCheckpointResponse,
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "./chunk-RI25RGQP.js";
+} from "./chunk-LXE5YUYY.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
@@ -67,7 +69,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,
@@ -88,6 +90,8 @@ export {
   assessPlayabilityEvidence,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket,
   buildVisualProofSession,
   checkpointResponseIdentity,
   checkpointSummaryFromState,

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";