@riddledc/riddle-proof 0.5.44 → 0.5.45

package/dist/checkpoint.cjs

@@ -34,6 +34,8 @@ __export(checkpoint_exports, {
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION: () => RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   authorPacketPayloadFromCheckpointResponse: () => authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket: () => buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult: () => buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket: () => buildProofAssessmentCheckpointPacket,
   checkpointResponseIdentity: () => checkpointResponseIdentity,
   checkpointSummaryFromState: () => checkpointSummaryFromState,
   isDuplicateCheckpointResponse: () => isDuplicateCheckpointResponse,
@@ -131,6 +133,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}`;
@@ -214,6 +257,124 @@ function buildAuthorCheckpointPacket(input) {
     created_at: input.created_at || timestamp()
   };
 }
+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 || timestamp()
+  };
+}
+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;
@@ -334,6 +495,8 @@ function proofContractFromAuthorCheckpointResponse(response, packet, payload) {
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket,
   checkpointResponseIdentity,
   checkpointSummaryFromState,
   isDuplicateCheckpointResponse,

package/dist/checkpoint.d.cts

@@ -17,6 +17,34 @@ declare function buildAuthorCheckpointPacket(input: {
     visibility?: "liveblog" | "quiet" | "terminal_only" | "manual" | string;
     created_at?: string;
 }): RiddleProofCheckpointPacket;
+declare function buildProofAssessmentCheckpointPacket(input: {
+    request: RiddleProofRunParams;
+    runState: RiddleProofRunState;
+    engineResult: {
+        state_path?: string | null;
+        checkpoint?: string | null;
+        checkpointContract?: Record<string, unknown> | null;
+        decisionRequest?: Record<string, unknown> | null;
+        summary?: string;
+    };
+    fullRiddleState?: Record<string, unknown> | null;
+    visibility?: "liveblog" | "quiet" | "terminal_only" | "manual" | string;
+    created_at?: string;
+}): RiddleProofCheckpointPacket;
+declare function buildCheckpointPacketForEngineResult(input: {
+    request: RiddleProofRunParams;
+    runState: RiddleProofRunState;
+    engineResult: {
+        state_path?: string | null;
+        checkpoint?: string | null;
+        checkpointContract?: Record<string, unknown> | null;
+        decisionRequest?: Record<string, unknown> | null;
+        summary?: string;
+    };
+    fullRiddleState?: Record<string, unknown> | null;
+    visibility?: "liveblog" | "quiet" | "terminal_only" | "manual" | string;
+    created_at?: string;
+}): RiddleProofCheckpointPacket;
 declare function normalizeCheckpointResponse(value: unknown): RiddleProofCheckpointResponse | null;
 declare function checkpointSummaryFromState(state: RiddleProofRunState, engineStatePath?: string | null): RiddleProofCheckpointSummary;
 declare function isDuplicateCheckpointResponse(state: RiddleProofRunState, response: RiddleProofCheckpointResponse): boolean;
@@ -24,4 +52,4 @@ declare function checkpointResponseIdentity(response: RiddleProofCheckpointRespo
 declare function authorPacketPayloadFromCheckpointResponse(response: RiddleProofCheckpointResponse): Record<string, unknown> | null;
 declare function proofContractFromAuthorCheckpointResponse(response: RiddleProofCheckpointResponse, packet: RiddleProofCheckpointPacket, payload: Record<string, unknown>): RiddleProofProofContract;
 
-export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, checkpointResponseIdentity, checkpointSummaryFromState, isDuplicateCheckpointResponse, normalizeCheckpointResponse, proofContractFromAuthorCheckpointResponse, statePathsForRunState };
+export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, buildCheckpointPacketForEngineResult, buildProofAssessmentCheckpointPacket, checkpointResponseIdentity, checkpointSummaryFromState, isDuplicateCheckpointResponse, normalizeCheckpointResponse, proofContractFromAuthorCheckpointResponse, statePathsForRunState };

package/dist/checkpoint.d.ts

@@ -17,6 +17,34 @@ declare function buildAuthorCheckpointPacket(input: {
     visibility?: "liveblog" | "quiet" | "terminal_only" | "manual" | string;
     created_at?: string;
 }): RiddleProofCheckpointPacket;
+declare function buildProofAssessmentCheckpointPacket(input: {
+    request: RiddleProofRunParams;
+    runState: RiddleProofRunState;
+    engineResult: {
+        state_path?: string | null;
+        checkpoint?: string | null;
+        checkpointContract?: Record<string, unknown> | null;
+        decisionRequest?: Record<string, unknown> | null;
+        summary?: string;
+    };
+    fullRiddleState?: Record<string, unknown> | null;
+    visibility?: "liveblog" | "quiet" | "terminal_only" | "manual" | string;
+    created_at?: string;
+}): RiddleProofCheckpointPacket;
+declare function buildCheckpointPacketForEngineResult(input: {
+    request: RiddleProofRunParams;
+    runState: RiddleProofRunState;
+    engineResult: {
+        state_path?: string | null;
+        checkpoint?: string | null;
+        checkpointContract?: Record<string, unknown> | null;
+        decisionRequest?: Record<string, unknown> | null;
+        summary?: string;
+    };
+    fullRiddleState?: Record<string, unknown> | null;
+    visibility?: "liveblog" | "quiet" | "terminal_only" | "manual" | string;
+    created_at?: string;
+}): RiddleProofCheckpointPacket;
 declare function normalizeCheckpointResponse(value: unknown): RiddleProofCheckpointResponse | null;
 declare function checkpointSummaryFromState(state: RiddleProofRunState, engineStatePath?: string | null): RiddleProofCheckpointSummary;
 declare function isDuplicateCheckpointResponse(state: RiddleProofRunState, response: RiddleProofCheckpointResponse): boolean;
@@ -24,4 +52,4 @@ declare function checkpointResponseIdentity(response: RiddleProofCheckpointRespo
 declare function authorPacketPayloadFromCheckpointResponse(response: RiddleProofCheckpointResponse): Record<string, unknown> | null;
 declare function proofContractFromAuthorCheckpointResponse(response: RiddleProofCheckpointResponse, packet: RiddleProofCheckpointPacket, payload: Record<string, unknown>): RiddleProofProofContract;
 
-export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, checkpointResponseIdentity, checkpointSummaryFromState, isDuplicateCheckpointResponse, normalizeCheckpointResponse, proofContractFromAuthorCheckpointResponse, statePathsForRunState };
+export { RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION, RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION, authorPacketPayloadFromCheckpointResponse, buildAuthorCheckpointPacket, buildCheckpointPacketForEngineResult, buildProofAssessmentCheckpointPacket, checkpointResponseIdentity, checkpointSummaryFromState, isDuplicateCheckpointResponse, normalizeCheckpointResponse, proofContractFromAuthorCheckpointResponse, statePathsForRunState };

package/dist/checkpoint.js

@@ -3,19 +3,23 @@ import {
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket,
   checkpointResponseIdentity,
   checkpointSummaryFromState,
   isDuplicateCheckpointResponse,
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "./chunk-RI25RGQP.js";
+} from "./chunk-LXE5YUYY.js";
 import "./chunk-W7VTDN4T.js";
 export {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket,
   checkpointResponseIdentity,
   checkpointSummaryFromState,
   isDuplicateCheckpointResponse,

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

@@ -1,13 +1,13 @@
 import {
   authorPacketPayloadFromCheckpointResponse,
-  buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult,
   checkpointResponseIdentity,
   checkpointSummaryFromState,
   isDuplicateCheckpointResponse,
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "./chunk-RI25RGQP.js";
+} from "./chunk-LXE5YUYY.js";
 import {
   appendRunEvent,
   appendStageHeartbeat,
@@ -308,6 +308,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";
@@ -446,7 +479,7 @@ function blockerResult(state, result, blocker) {
   });
 }
 function checkpointAwaitingResult(state, result, visibility) {
-  const packet = buildAuthorCheckpointPacket({
+  const packet = buildCheckpointPacketForEngineResult({
     request: state.request,
     runState: state,
     engineResult: result,
@@ -611,8 +644,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: {
@@ -895,9 +950,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",

package/dist/{chunk-RI25RGQP.js → chunk-LXE5YUYY.js}

@@ -81,6 +81,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 = crypto.createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 24);
   return `rpchk_${hash}`;
@@ -164,6 +205,124 @@ function buildAuthorCheckpointPacket(input) {
     created_at: input.created_at || timestamp()
   };
 }
+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 || timestamp()
+  };
+}
+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;
@@ -284,6 +443,8 @@ export {
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   statePathsForRunState,
   buildAuthorCheckpointPacket,
+  buildProofAssessmentCheckpointPacket,
+  buildCheckpointPacketForEngineResult,
   normalizeCheckpointResponse,
   checkpointSummaryFromState,
   isDuplicateCheckpointResponse,

package/dist/engine-harness.cjs

@@ -3238,6 +3238,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}`;
@@ -3321,6 +3362,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;
@@ -3704,6 +3863,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";
@@ -3842,7 +4034,7 @@ function blockerResult(state, result, blocker) {
   });
 }
 function checkpointAwaitingResult(state, result, visibility) {
-  const packet = buildAuthorCheckpointPacket({
+  const packet = buildCheckpointPacketForEngineResult({
     request: state.request,
     runState: state,
     engineResult: result,
@@ -4007,8 +4199,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: {
@@ -4291,9 +4505,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",

package/dist/engine-harness.js

@@ -2,8 +2,8 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-MJD37CLH.js";
-import "./chunk-RI25RGQP.js";
+} from "./chunk-CHRYLX6N.js";
+import "./chunk-LXE5YUYY.js";
 import "./chunk-7S7O3NKF.js";
 import "./chunk-W7VTDN4T.js";
 import "./chunk-4ASMX4R6.js";

package/dist/index.cjs

@@ -2772,6 +2772,8 @@ __export(index_exports, {
   assessPlayabilityEvidence: () => assessPlayabilityEvidence,
   authorPacketPayloadFromCheckpointResponse: () => authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket: () => buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult: () => buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket: () => buildProofAssessmentCheckpointPacket,
   buildVisualProofSession: () => buildVisualProofSession,
   checkpointResponseIdentity: () => checkpointResponseIdentity,
   checkpointSummaryFromState: () => checkpointSummaryFromState,
@@ -3330,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}`;
@@ -3413,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;
@@ -4282,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";
@@ -4420,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,
@@ -4585,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: {
@@ -4869,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",
@@ -5755,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-MJD37CLH.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,
@@ -88,6 +90,8 @@ export {
   assessPlayabilityEvidence,
   authorPacketPayloadFromCheckpointResponse,
   buildAuthorCheckpointPacket,
+  buildCheckpointPacketForEngineResult,
+  buildProofAssessmentCheckpointPacket,
   buildVisualProofSession,
   checkpointResponseIdentity,
   checkpointSummaryFromState,

package/dist/types.d.cts

@@ -82,6 +82,7 @@ interface RiddleProofCheckpointPacket {
     artifacts?: RiddleProofCheckpointArtifact[];
     state_excerpt?: Record<string, unknown>;
     evidence_excerpt?: Record<string, unknown>;
+    artifact_contract?: Record<string, unknown>;
     allowed_decisions: string[];
     response_schema: Record<string, unknown>;
     routing_hint?: RiddleProofCheckpointRoutingHint;

package/dist/types.d.ts

@@ -82,6 +82,7 @@ interface RiddleProofCheckpointPacket {
     artifacts?: RiddleProofCheckpointArtifact[];
     state_excerpt?: Record<string, unknown>;
     evidence_excerpt?: Record<string, unknown>;
+    artifact_contract?: Record<string, unknown>;
     allowed_decisions: string[];
     response_schema: Record<string, unknown>;
     routing_hint?: RiddleProofCheckpointRoutingHint;

package/package.json

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