@riddledc/riddle-proof 0.8.55 → 0.8.57

package/dist/cli.cjs

@@ -3419,6 +3419,9 @@ var import_node_crypto3 = __toESM(require("crypto"), 1);
 function isTerminalStatus(status) {
   return status === "blocked" || status === "failed" || status === "ready_to_ship" || status === "shipped" || status === "completed";
 }
+function isProtectedFinalStatus(status) {
+  return status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
 function isSuccessfulStatus(status) {
   return status !== "blocked" && status !== "failed";
 }
@@ -3632,6 +3635,7 @@ function createRunResult(input) {
   const state = input.metadata ? applyTerminalMetadata(input.state, input.metadata) : input.state;
   state.status = status;
   state.ok = ok;
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   applyShipControlState(state, { status, raw: input.raw });
   return compactRecord({
     ok,
@@ -4379,6 +4383,8 @@ function checkpointSummaryFromState(state, engineStatePath2) {
   const packets = history.filter((entry) => entry.packet);
   const responses = acceptedCheckpointResponseEntries(state);
   const duplicateResponses = events.filter((event) => event.kind === "checkpoint.response.duplicate");
+  const rejectedResponses = events.filter((event) => event.kind === "checkpoint.response.rejected");
+  const ignoredResponses = events.filter((event) => event.kind === "checkpoint.response.ignored");
   const latestPacketEntry = [...history].reverse().find((entry) => entry.packet);
   const latestResponseEntry = [...responses].reverse().find((entry) => entry.response);
   const latestPacket = state.checkpoint_packet || latestPacketEntry?.packet;
@@ -4394,6 +4400,8 @@ function checkpointSummaryFromState(state, engineStatePath2) {
     packet_count: packets.length,
     response_count: responses.length,
     duplicate_response_count: duplicateResponses.length,
+    rejected_response_count: rejectedResponses.length,
+    ignored_response_count: ignoredResponses.length,
     latest_checkpoint: state.checkpoint_packet?.checkpoint || latestResponse?.checkpoint || state.last_checkpoint || null,
     latest_stage: state.checkpoint_packet?.stage || latestResponse?.continue_with_stage || state.current_stage || null,
     latest_kind: state.checkpoint_packet?.kind || latestPacket?.kind || null,
@@ -4892,6 +4900,7 @@ function createRunStatusSnapshot(state, at = timestamp2()) {
 function setRunStatus(state, status, at = timestamp2()) {
   state.status = status;
   state.ok = status !== "blocked" && status !== "failed";
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   state.updated_at = at;
   return state;
 }
@@ -4960,9 +4969,6 @@ function loadRunState(input) {
     state_path: statePath
   });
 }
-function isProtectedFinalStatus(status) {
-  return status === "ready_to_ship" || status === "shipped" || status === "completed";
-}
 function shouldPreserveFinalizedRunState(filePath, incoming) {
   const existing = readJson(filePath);
   if (!existing?.finalized || !isProtectedFinalStatus(existing.status)) return false;
@@ -5534,19 +5540,38 @@ function appendCheckpointResponse(state, response, input = {}) {
   setRunStatus(state, "running", at);
   persist(state);
 }
+function checkpointResponseRejectedBlocker(state, input) {
+  const packet = input.packet || null;
+  const response = input.response || null;
+  appendRunEvent(state, {
+    kind: "checkpoint.response.rejected",
+    checkpoint: response?.checkpoint || packet?.checkpoint || input.blocker.checkpoint || null,
+    stage: packet?.stage || state.current_stage || "author",
+    summary: input.blocker.message,
+    details: compactRecord({
+      code: input.blocker.code,
+      decision: response?.decision,
+      resume_token: response?.resume_token,
+      packet_id: response?.packet_id,
+      source: response?.source
+    })
+  });
+  return { blocker: input.blocker };
+}
 function checkpointResponseContinuation(state, value) {
   if (!value) return {};
   const packet = state.checkpoint_packet;
   const response = normalizeCheckpointResponse(value);
   if (!response) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
       blocker: {
         code: "checkpoint_response_invalid",
         checkpoint: packet?.checkpoint || state.last_checkpoint || null,
         message: "Checkpoint response was not a valid riddle-proof.checkpoint_response.v1 object.",
         details: { checkpoint_packet: packet || null, checkpoint_summary: checkpointSummaryFromState(state) }
       }
-    };
+    });
   }
   if (isDuplicateCheckpointResponse(state, response)) {
     const stage = packet?.stage || state.current_stage || "author";
@@ -5577,17 +5602,20 @@ function checkpointResponseContinuation(state, value) {
     };
   }
   if (!packet) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      response,
       blocker: {
         code: "checkpoint_response_without_packet",
         checkpoint: response.checkpoint,
         message: "A checkpoint response was supplied, but the run state has no pending checkpoint packet.",
         details: { response, checkpoint_summary: checkpointSummaryFromState(state) }
       }
-    };
+    });
   }
   if (response.run_id !== packet.run_id || response.checkpoint !== packet.checkpoint) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
+      response,
       blocker: {
         code: "checkpoint_response_mismatch",
         checkpoint: packet.checkpoint,
@@ -5598,10 +5626,12 @@ function checkpointResponseContinuation(state, value) {
           actual: { run_id: response.run_id, checkpoint: response.checkpoint }
         }
       }
-    };
+    });
   }
   if (packet.resume_token && response.resume_token !== packet.resume_token) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
+      response,
       blocker: {
         code: "checkpoint_response_resume_token_mismatch",
         checkpoint: packet.checkpoint,
@@ -5612,10 +5642,12 @@ function checkpointResponseContinuation(state, value) {
           actual_resume_token: response.resume_token || null
         }
       }
-    };
+    });
   }
   if (packet.packet_id && response.packet_id !== packet.packet_id) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
+      response,
       blocker: {
         code: "checkpoint_response_packet_id_mismatch",
         checkpoint: packet.checkpoint,
@@ -5628,10 +5660,12 @@ function checkpointResponseContinuation(state, value) {
           actual_resume_token: response.resume_token || null
         }
       }
-    };
+    });
   }
   if (!packet.allowed_decisions.includes(response.decision)) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
+      response,
       blocker: {
         code: "checkpoint_response_decision_not_allowed",
         checkpoint: packet.checkpoint,
@@ -5643,7 +5677,7 @@ function checkpointResponseContinuation(state, value) {
           response
         }
       }
-    };
+    });
   }
   const base = {
     action: "run",
@@ -5653,14 +5687,16 @@ function checkpointResponseContinuation(state, value) {
   if (response.decision === "author_packet") {
     const payload = authorPacketPayloadFromCheckpointResponse(response);
     if (!payload) {
-      return {
+      return checkpointResponseRejectedBlocker(state, {
+        packet,
+        response,
         blocker: {
           code: "checkpoint_author_packet_missing",
           checkpoint: packet.checkpoint,
           message: "Checkpoint response decision=author_packet did not include a proof_plan and capture_script payload.",
           details: { stage: packet.stage, response }
         }
-      };
+      });
     }
     state.proof_contract = proofContractFromAuthorCheckpointResponse(response, packet, payload);
     appendCheckpointResponse(state, response);
@@ -5689,14 +5725,16 @@ function checkpointResponseContinuation(state, value) {
       const workdir = nonEmptyString(packet.state_excerpt?.after_worktree) || state.worktree_path;
       if (workdir) state.worktree_path = workdir;
       if (!hasGitDiff(workdir)) {
-        return {
+        return checkpointResponseRejectedBlocker(state, {
+          packet,
+          response,
           blocker: {
             code: "implementation_diff_missing",
             checkpoint: packet.checkpoint,
             message: "Checkpoint response claimed implementation_complete, but the after worktree has no detectable git diff.",
             details: { stage: packet.stage, worktree_path: workdir || null, response }
           }
-        };
+        });
       }
       appendCheckpointResponse(state, response);
       return {
@@ -5745,7 +5783,13 @@ function checkpointResponseContinuation(state, value) {
         response,
         code: "checkpoint_response_source_not_trusted"
       });
-      if (sourceBlocker) return { blocker: sourceBlocker };
+      if (sourceBlocker) {
+        return checkpointResponseRejectedBlocker(state, {
+          packet,
+          response,
+          blocker: sourceBlocker
+        });
+      }
       appendCheckpointResponse(state, response);
       if (state.request.ship_mode !== "ship" && proofAssessmentRequestsShip(assessment)) {
         const result = {
@@ -17694,6 +17738,20 @@ function numberValue2(value) {
 function booleanValue2(value) {
   return typeof value === "boolean" ? value : void 0;
 }
+function firstStringValue(...values) {
+  for (const value of values) {
+    const text = stringValue3(value);
+    if (text) return text;
+  }
+  return void 0;
+}
+function firstBooleanValue(...values) {
+  for (const value of values) {
+    const bool = booleanValue2(value);
+    if (typeof bool === "boolean") return bool;
+  }
+  return void 0;
+}
 function artifactKind(name, url) {
   const target = `${name} ${url}`.toLowerCase();
   if (/\.(png|jpe?g|gif|webp|avif|svg)(\?|#|$)/.test(target)) return "image";
@@ -17770,20 +17828,55 @@ function selectPrimaryImage(artifacts) {
   const images = artifacts.filter((artifact) => artifact.kind === "image");
   return images.find((artifact) => /after|proof|screenshot/i.test(artifact.name)) || images[0];
 }
+function firstRecordValue(...values) {
+  for (const value of values) {
+    const record = asRecord(value);
+    if (Object.keys(record).length) return record;
+  }
+  return void 0;
+}
+function checkpointSummaryFrom(...values) {
+  const record = firstRecordValue(...values);
+  if (!record) return void 0;
+  const summary = {
+    pending: booleanValue2(record.pending),
+    response_count: numberValue2(record.response_count),
+    rejected_response_count: numberValue2(record.rejected_response_count),
+    ignored_response_count: numberValue2(record.ignored_response_count),
+    duplicate_response_count: numberValue2(record.duplicate_response_count),
+    latest_decision: stringValue3(record.latest_decision),
+    latest_packet_id: stringValue3(record.latest_packet_id),
+    latest_resume_token: stringValue3(record.latest_resume_token)
+  };
+  return Object.values(summary).some((value) => typeof value !== "undefined") ? summary : void 0;
+}
 function summarizeRiddleProofPrComment(input) {
   const runResponse = asRecord(input.runResponse);
   const result = asRecord(input.result);
   const proofResult = asRecord(runResponse.proofResult);
   const preview = asRecord(runResponse.preview);
+  const resultRunCard = asRecord(result.run_card);
+  const stopCondition = asRecord(resultRunCard.stop_condition);
+  const resultDetails = asRecord(result.details);
+  const resultRaw = asRecord(result.raw);
+  const rawDetails = asRecord(resultRaw.details);
   const artifacts = collectArtifacts(runResponse);
   const pages = pageSummaries(result);
   const checkSource = { ...result };
   delete checkSource.ok;
   const nestedChecks = summarizeExplicitChecks(checkSource);
   const ok = booleanValue2(result.ok) ?? booleanValue2(runResponse.ok) ?? null;
+  const checkpointSummary = checkpointSummaryFrom(
+    result.checkpoint_summary,
+    stopCondition.checkpoint_summary,
+    resultDetails.checkpoint_summary,
+    rawDetails.checkpoint_summary,
+    proofResult.checkpoint_summary
+  );
   return {
     ok,
     status: stringValue3(proofResult.status),
+    result_status: firstStringValue(result.status, stopCondition.status),
     job_id: stringValue3(proofResult.job_id),
     duration_ms: numberValue2(proofResult.duration_ms),
     proof_url: stringValue3(runResponse.proofUrl),
@@ -17791,6 +17884,12 @@ function summarizeRiddleProofPrComment(input) {
     preview_url: stringValue3(preview.preview_url) || stringValue3(preview.url),
     preview_publish_recovered: booleanValue2(preview.publish_recovered),
     preview_publish_error: stringValue3(preview.publish_error),
+    ship_held: firstBooleanValue(result.ship_held, stopCondition.ship_held, resultRaw.ship_held),
+    shipping_disabled: firstBooleanValue(result.shipping_disabled, stopCondition.shipping_disabled, resultRaw.shipping_disabled),
+    ship_authorized: firstBooleanValue(result.ship_authorized, stopCondition.ship_authorized, resultRaw.ship_authorized),
+    proof_decision: firstStringValue(result.proof_decision, stopCondition.proof_decision, resultRaw.proof_decision),
+    merge_recommendation: firstStringValue(result.merge_recommendation, stopCondition.merge_recommendation, resultRaw.merge_recommendation),
+    checkpoint_summary: checkpointSummary,
     passed_checks: nestedChecks.passed,
     failed_checks: nestedChecks.failed,
     pages,
@@ -17809,9 +17908,15 @@ function markdownLink(label, url) {
   return `[${label.replace(/\]/g, "\\]")}](${url})`;
 }
 function resultLabel(summary) {
-  if (summary.ok === true) return "passed";
+  if (summary.ok === true) {
+    if (summary.result_status === "shipped") return "shipped";
+    if (summary.result_status === "completed") return "completed";
+    if (summary.ship_held === true) return "proof passed; ship held";
+    if (summary.ship_authorized === true) return "passed; ship authorized";
+    return "passed";
+  }
   if (summary.ok === false) return "failed";
-  return summary.status || "recorded";
+  return summary.result_status || summary.status || "recorded";
 }
 function artifactRank(artifact) {
   const name = artifact.name.toLowerCase();
@@ -17823,6 +17928,25 @@ function artifactRank(artifact) {
   if (artifact.kind === "image") return 20;
   return 30;
 }
+function formatBool(value) {
+  return typeof value === "boolean" ? String(value) : "unknown";
+}
+function hasShipControl(summary) {
+  return typeof summary.ship_held === "boolean" || typeof summary.shipping_disabled === "boolean" || typeof summary.ship_authorized === "boolean";
+}
+function checkpointSummaryLine(summary) {
+  const accepted = summary.response_count ?? 0;
+  const rejected = summary.rejected_response_count ?? 0;
+  const ignored = summary.ignored_response_count ?? 0;
+  const parts = [`${accepted} accepted`, `${rejected} rejected`, `${ignored} ignored`];
+  if ((summary.duplicate_response_count ?? 0) > 0) parts.push(`${summary.duplicate_response_count} duplicate`);
+  const state = summary.pending === true ? "pending" : summary.pending === false ? "complete" : "";
+  return [
+    parts.join(" / "),
+    state,
+    summary.latest_decision ? `latest decision \`${summary.latest_decision}\`` : ""
+  ].filter(Boolean).join("; ");
+}
 function buildRiddleProofPrCommentMarkdown(input) {
   const summary = summarizeRiddleProofPrComment(input);
   const title = input.title?.trim() || "Riddle Proof Evidence";
@@ -17834,9 +17958,16 @@ function buildRiddleProofPrCommentMarkdown(input) {
   ];
   if (input.goal?.trim()) lines.push(`**Goal:** ${input.goal.trim()}`);
   if (input.successCriteria?.trim()) lines.push(`**Success criteria:** ${input.successCriteria.trim()}`);
+  if (summary.result_status) lines.push(`**Evidence status:** ${summary.result_status}`);
   if (summary.status) lines.push(`**Riddle job status:** ${summary.status}`);
   if (summary.job_id) lines.push(`**Riddle job:** \`${summary.job_id}\``);
   if (summary.duration_ms) lines.push(`**Duration:** ${formatDuration(summary.duration_ms)}`);
+  if (hasShipControl(summary)) {
+    lines.push(`**Ship control:** held=${formatBool(summary.ship_held)}, shipping_disabled=${formatBool(summary.shipping_disabled)}, authorized=${formatBool(summary.ship_authorized)}`);
+  }
+  if (summary.proof_decision) lines.push(`**Proof decision:** \`${summary.proof_decision}\``);
+  if (summary.merge_recommendation) lines.push(`**Merge recommendation:** ${summary.merge_recommendation}`);
+  if (summary.checkpoint_summary) lines.push(`**Checkpoints:** ${checkpointSummaryLine(summary.checkpoint_summary)}`);
   if (summary.proof_url) lines.push(`**Proof URL:** ${markdownLink(summary.proof_url, summary.proof_url)}`);
   if (summary.preview_id || summary.preview_url) {
     const previewLabel = summary.preview_id ? `\`${summary.preview_id}\`` : "preview";

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
-import "./chunk-MYMTAVGP.js";
+import "./chunk-LUFT7AGY.js";
 import "./chunk-DI2XNGEZ.js";
-import "./chunk-6KYXX4OE.js";
+import "./chunk-JR7GFTLS.js";
 import "./chunk-EX7TO4I5.js";
-import "./chunk-QGE3KBRL.js";
-import "./chunk-Q5GYD5RG.js";
-import "./chunk-NYRMPWJB.js";
+import "./chunk-GHBNDHG7.js";
+import "./chunk-UZIX7M7D.js";
+import "./chunk-KNPCWWF3.js";
 import "./chunk-EKZXU6MU.js";
-import "./chunk-QUK3SG24.js";
+import "./chunk-MOTQNIZX.js";
 import "./chunk-JFQXAJH2.js";
-import "./chunk-SONWF3FQ.js";
-import "./chunk-W44XEGYW.js";
+import "./chunk-RS4HJLJQ.js";
+import "./chunk-CUBYSWZT.js";
 import "./chunk-MLKGABMK.js";

package/dist/codex-exec-agent.js

@@ -2,8 +2,8 @@ import {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   runCodexExecAgentDoctor
-} from "./chunk-SONWF3FQ.js";
-import "./chunk-W44XEGYW.js";
+} from "./chunk-RS4HJLJQ.js";
+import "./chunk-CUBYSWZT.js";
 import "./chunk-MLKGABMK.js";
 export {
   createCodexExecAgentAdapter,

package/dist/engine-harness.cjs

@@ -3421,6 +3421,9 @@ var import_node_crypto3 = __toESM(require("crypto"), 1);
 function isTerminalStatus(status) {
   return status === "blocked" || status === "failed" || status === "ready_to_ship" || status === "shipped" || status === "completed";
 }
+function isProtectedFinalStatus(status) {
+  return status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
 function isSuccessfulStatus(status) {
   return status !== "blocked" && status !== "failed";
 }
@@ -3634,6 +3637,7 @@ function createRunResult(input) {
   const state = input.metadata ? applyTerminalMetadata(input.state, input.metadata) : input.state;
   state.status = status;
   state.ok = ok;
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   applyShipControlState(state, { status, raw: input.raw });
   return compactRecord({
     ok,
@@ -4291,6 +4295,8 @@ function checkpointSummaryFromState(state, engineStatePath2) {
   const packets = history.filter((entry) => entry.packet);
   const responses = acceptedCheckpointResponseEntries(state);
   const duplicateResponses = events.filter((event) => event.kind === "checkpoint.response.duplicate");
+  const rejectedResponses = events.filter((event) => event.kind === "checkpoint.response.rejected");
+  const ignoredResponses = events.filter((event) => event.kind === "checkpoint.response.ignored");
   const latestPacketEntry = [...history].reverse().find((entry) => entry.packet);
   const latestResponseEntry = [...responses].reverse().find((entry) => entry.response);
   const latestPacket = state.checkpoint_packet || latestPacketEntry?.packet;
@@ -4306,6 +4312,8 @@ function checkpointSummaryFromState(state, engineStatePath2) {
     packet_count: packets.length,
     response_count: responses.length,
     duplicate_response_count: duplicateResponses.length,
+    rejected_response_count: rejectedResponses.length,
+    ignored_response_count: ignoredResponses.length,
     latest_checkpoint: state.checkpoint_packet?.checkpoint || latestResponse?.checkpoint || state.last_checkpoint || null,
     latest_stage: state.checkpoint_packet?.stage || latestResponse?.continue_with_stage || state.current_stage || null,
     latest_kind: state.checkpoint_packet?.kind || latestPacket?.kind || null,
@@ -4804,6 +4812,7 @@ function createRunStatusSnapshot(state, at = timestamp2()) {
 function setRunStatus(state, status, at = timestamp2()) {
   state.status = status;
   state.ok = status !== "blocked" && status !== "failed";
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   state.updated_at = at;
   return state;
 }
@@ -4872,9 +4881,6 @@ function loadRunState(input) {
     state_path: statePath
   });
 }
-function isProtectedFinalStatus(status) {
-  return status === "ready_to_ship" || status === "shipped" || status === "completed";
-}
 function shouldPreserveFinalizedRunState(filePath, incoming) {
   const existing = readJson(filePath);
   if (!existing?.finalized || !isProtectedFinalStatus(existing.status)) return false;
@@ -5446,19 +5452,38 @@ function appendCheckpointResponse(state, response, input = {}) {
   setRunStatus(state, "running", at);
   persist(state);
 }
+function checkpointResponseRejectedBlocker(state, input) {
+  const packet = input.packet || null;
+  const response = input.response || null;
+  appendRunEvent(state, {
+    kind: "checkpoint.response.rejected",
+    checkpoint: response?.checkpoint || packet?.checkpoint || input.blocker.checkpoint || null,
+    stage: packet?.stage || state.current_stage || "author",
+    summary: input.blocker.message,
+    details: compactRecord({
+      code: input.blocker.code,
+      decision: response?.decision,
+      resume_token: response?.resume_token,
+      packet_id: response?.packet_id,
+      source: response?.source
+    })
+  });
+  return { blocker: input.blocker };
+}
 function checkpointResponseContinuation(state, value) {
   if (!value) return {};
   const packet = state.checkpoint_packet;
   const response = normalizeCheckpointResponse(value);
   if (!response) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
       blocker: {
         code: "checkpoint_response_invalid",
         checkpoint: packet?.checkpoint || state.last_checkpoint || null,
         message: "Checkpoint response was not a valid riddle-proof.checkpoint_response.v1 object.",
         details: { checkpoint_packet: packet || null, checkpoint_summary: checkpointSummaryFromState(state) }
       }
-    };
+    });
   }
   if (isDuplicateCheckpointResponse(state, response)) {
     const stage = packet?.stage || state.current_stage || "author";
@@ -5489,17 +5514,20 @@ function checkpointResponseContinuation(state, value) {
     };
   }
   if (!packet) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      response,
       blocker: {
         code: "checkpoint_response_without_packet",
         checkpoint: response.checkpoint,
         message: "A checkpoint response was supplied, but the run state has no pending checkpoint packet.",
         details: { response, checkpoint_summary: checkpointSummaryFromState(state) }
       }
-    };
+    });
   }
   if (response.run_id !== packet.run_id || response.checkpoint !== packet.checkpoint) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
+      response,
       blocker: {
         code: "checkpoint_response_mismatch",
         checkpoint: packet.checkpoint,
@@ -5510,10 +5538,12 @@ function checkpointResponseContinuation(state, value) {
           actual: { run_id: response.run_id, checkpoint: response.checkpoint }
         }
       }
-    };
+    });
   }
   if (packet.resume_token && response.resume_token !== packet.resume_token) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
+      response,
       blocker: {
         code: "checkpoint_response_resume_token_mismatch",
         checkpoint: packet.checkpoint,
@@ -5524,10 +5554,12 @@ function checkpointResponseContinuation(state, value) {
           actual_resume_token: response.resume_token || null
         }
       }
-    };
+    });
   }
   if (packet.packet_id && response.packet_id !== packet.packet_id) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
+      response,
       blocker: {
         code: "checkpoint_response_packet_id_mismatch",
         checkpoint: packet.checkpoint,
@@ -5540,10 +5572,12 @@ function checkpointResponseContinuation(state, value) {
           actual_resume_token: response.resume_token || null
         }
       }
-    };
+    });
   }
   if (!packet.allowed_decisions.includes(response.decision)) {
-    return {
+    return checkpointResponseRejectedBlocker(state, {
+      packet,
+      response,
       blocker: {
         code: "checkpoint_response_decision_not_allowed",
         checkpoint: packet.checkpoint,
@@ -5555,7 +5589,7 @@ function checkpointResponseContinuation(state, value) {
           response
         }
       }
-    };
+    });
   }
   const base = {
     action: "run",
@@ -5565,14 +5599,16 @@ function checkpointResponseContinuation(state, value) {
   if (response.decision === "author_packet") {
     const payload = authorPacketPayloadFromCheckpointResponse(response);
     if (!payload) {
-      return {
+      return checkpointResponseRejectedBlocker(state, {
+        packet,
+        response,
         blocker: {
           code: "checkpoint_author_packet_missing",
           checkpoint: packet.checkpoint,
           message: "Checkpoint response decision=author_packet did not include a proof_plan and capture_script payload.",
           details: { stage: packet.stage, response }
         }
-      };
+      });
     }
     state.proof_contract = proofContractFromAuthorCheckpointResponse(response, packet, payload);
     appendCheckpointResponse(state, response);
@@ -5601,14 +5637,16 @@ function checkpointResponseContinuation(state, value) {
       const workdir = nonEmptyString(packet.state_excerpt?.after_worktree) || state.worktree_path;
       if (workdir) state.worktree_path = workdir;
       if (!hasGitDiff(workdir)) {
-        return {
+        return checkpointResponseRejectedBlocker(state, {
+          packet,
+          response,
           blocker: {
             code: "implementation_diff_missing",
             checkpoint: packet.checkpoint,
             message: "Checkpoint response claimed implementation_complete, but the after worktree has no detectable git diff.",
             details: { stage: packet.stage, worktree_path: workdir || null, response }
           }
-        };
+        });
       }
       appendCheckpointResponse(state, response);
       return {
@@ -5657,7 +5695,13 @@ function checkpointResponseContinuation(state, value) {
         response,
         code: "checkpoint_response_source_not_trusted"
       });
-      if (sourceBlocker) return { blocker: sourceBlocker };
+      if (sourceBlocker) {
+        return checkpointResponseRejectedBlocker(state, {
+          packet,
+          response,
+          blocker: sourceBlocker
+        });
+      }
       appendCheckpointResponse(state, response);
       if (state.request.ship_mode !== "ship" && proofAssessmentRequestsShip(assessment)) {
         const result = {

package/dist/engine-harness.js

@@ -2,12 +2,12 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-QGE3KBRL.js";
-import "./chunk-Q5GYD5RG.js";
-import "./chunk-NYRMPWJB.js";
+} from "./chunk-GHBNDHG7.js";
+import "./chunk-UZIX7M7D.js";
+import "./chunk-KNPCWWF3.js";
 import "./chunk-EKZXU6MU.js";
-import "./chunk-QUK3SG24.js";
-import "./chunk-W44XEGYW.js";
+import "./chunk-MOTQNIZX.js";
+import "./chunk-CUBYSWZT.js";
 import "./chunk-MLKGABMK.js";
 export {
   createDisabledRiddleProofAgentAdapter,