@riddledc/riddle-proof 0.8.54 → 0.8.56

package/dist/advanced/index.cjs

@@ -3457,6 +3457,9 @@ __export(runner_exports, {
 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";
 }
@@ -3554,6 +3557,9 @@ function normalizeTerminalMetadata(input) {
     pr_state: prState,
     marked_ready: markedReady,
     left_draft: leftDraft,
+    ship_held: firstBoolean(riddleState.ship_held, result.ship_held, result.shipHeld, details.ship_held, details.shipHeld, shipReport.ship_held, shipReport.shipHeld),
+    shipping_disabled: firstBoolean(riddleState.shipping_disabled, result.shipping_disabled, result.shippingDisabled, details.shipping_disabled, details.shippingDisabled, shipReport.shipping_disabled, shipReport.shippingDisabled),
+    ship_authorized: firstBoolean(riddleState.ship_authorized, result.ship_authorized, result.shipAuthorized, details.ship_authorized, details.shipAuthorized, shipReport.ship_authorized, shipReport.shipAuthorized),
     ci_status: firstNonEmptyString(riddleState.ci_status, result.ci_status, result.ciStatus, details.ci_status, details.ciStatus, shipReport.ci_status),
     ship_commit: firstNonEmptyString(riddleState.ship_commit, result.ship_commit, result.shipCommit, details.ship_commit, details.shipCommit, shipReport.shipped_commit, shipReport.ship_commit),
     ship_remote_head: firstNonEmptyString(riddleState.ship_remote_head, result.ship_remote_head, result.shipRemoteHead, details.ship_remote_head, details.shipRemoteHead, shipReport.ship_remote_head),
@@ -3587,6 +3593,9 @@ function applyTerminalMetadata(state, metadata) {
   if (prBranch) state.pr_branch = prBranch;
   if (typeof metadata.marked_ready === "boolean") state.marked_ready = metadata.marked_ready;
   if (typeof metadata.left_draft === "boolean") state.left_draft = metadata.left_draft;
+  if (typeof metadata.ship_held === "boolean") state.ship_held = metadata.ship_held;
+  if (typeof metadata.shipping_disabled === "boolean") state.shipping_disabled = metadata.shipping_disabled;
+  if (typeof metadata.ship_authorized === "boolean") state.ship_authorized = metadata.ship_authorized;
   const ciStatus = nonEmptyString(metadata.ci_status);
   if (ciStatus) state.ci_status = ciStatus;
   const shipCommit = nonEmptyString(metadata.ship_commit);
@@ -3618,12 +3627,54 @@ function applyTerminalMetadata(state, metadata) {
   if (typeof metadata.finalized === "boolean") state.finalized = metadata.finalized;
   return state;
 }
+function shipControlStateFor(input) {
+  const state = input.state;
+  const status = input.status || state.status;
+  const raw = recordValue(input.raw) || {};
+  const shipReport = recordValue(state.ship_report) || {};
+  const prState = recordValue(state.pr_state) || {};
+  const shippingDisabled = firstBoolean(
+    raw.shipping_disabled,
+    raw.shippingDisabled,
+    state.shipping_disabled,
+    shipReport.shipping_disabled,
+    shipReport.shippingDisabled
+  ) ?? state.request?.ship_mode === "none";
+  const explicitAuthorized = firstBoolean(
+    raw.ship_authorized,
+    raw.shipAuthorized,
+    state.ship_authorized,
+    shipReport.ship_authorized,
+    shipReport.shipAuthorized
+  );
+  const authorizationEvidence = Boolean(
+    status === "shipped" || state.marked_ready === true || shipReport.marked_ready === true || prState.status === "merged" || state.merge_commit || state.merged_at
+  );
+  const inferredAuthorized = explicitAuthorized ?? authorizationEvidence;
+  const rawHeld = firstBoolean(raw.ship_held, raw.shipHeld);
+  const inferredHeld = status === "ready_to_ship" && shippingDisabled && !inferredAuthorized;
+  const shipHeld = rawHeld ?? (state.ship_held === true || inferredHeld);
+  return {
+    ship_held: shipHeld,
+    shipping_disabled: shippingDisabled,
+    ship_authorized: shipHeld ? false : inferredAuthorized
+  };
+}
+function applyShipControlState(state, input = {}) {
+  const control = shipControlStateFor({ state, status: input.status, raw: input.raw });
+  state.ship_held = control.ship_held;
+  state.shipping_disabled = control.shipping_disabled;
+  state.ship_authorized = control.ship_authorized;
+  return state;
+}
 function createRunResult(input) {
   const status = input.status || input.state.status;
   const ok = isSuccessfulStatus(status);
   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,
     status,
@@ -3641,6 +3692,9 @@ function createRunResult(input) {
     pr_state: state.pr_state,
     marked_ready: state.marked_ready,
     left_draft: state.left_draft,
+    ship_held: state.ship_held,
+    shipping_disabled: state.shipping_disabled,
+    ship_authorized: state.ship_authorized,
     ci_status: state.ci_status,
     ship_commit: state.ship_commit,
     ship_remote_head: state.ship_remote_head,
@@ -4277,6 +4331,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;
@@ -4292,6 +4348,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,
@@ -4530,6 +4588,7 @@ function createRiddleProofRunCard(state, input = {}) {
   const visualDelta = visualDeltaFrom({ fullRiddleState: fullState, runState: state });
   const artifacts = artifactsFrom({ fullRiddleState: fullState, runState: state });
   const viewportMatrix = viewportMatrixFrom({ fullRiddleState: fullState, runState: state });
+  const shipControl = shipControlStateFor({ state });
   return {
     version: RIDDLE_PROOF_RUN_CARD_VERSION,
     run_id: state.run_id || "unknown",
@@ -4583,6 +4642,9 @@ function createRiddleProofRunCard(state, input = {}) {
     stop_condition: compactRecord({
       status: state.status,
       terminal: isTerminalStatus(state.status),
+      ship_held: shipControl.ship_held,
+      shipping_disabled: shipControl.shipping_disabled,
+      ship_authorized: shipControl.ship_authorized,
       blocker_code: state.blocker?.code || null,
       blocker_message: state.blocker?.message || null,
       proof_decision: state.proof_decision,
@@ -4743,7 +4805,8 @@ function appendStageHeartbeat(state, input) {
 function createRunStatusSnapshot(state, at = timestamp2()) {
   const latestEvent = state.events[state.events.length - 1];
   const runId = state.run_id || "unknown";
-  const existingRunCardCurrent = state.run_card?.status === state.status && state.run_card.stop_condition?.status === state.status && state.run_card.stop_condition?.terminal === isTerminalStatus(state.status) && state.run_card.stop_condition?.monitor_should_continue === !isTerminalStatus(state.status);
+  const shipControl = shipControlStateFor({ state });
+  const existingRunCardCurrent = state.run_card?.status === state.status && state.run_card.stop_condition?.status === state.status && state.run_card.stop_condition?.terminal === isTerminalStatus(state.status) && state.run_card.stop_condition?.monitor_should_continue === !isTerminalStatus(state.status) && state.run_card.stop_condition?.ship_held === shipControl.ship_held && state.run_card.stop_condition?.shipping_disabled === shipControl.shipping_disabled && state.run_card.stop_condition?.ship_authorized === shipControl.ship_authorized;
   const runCard = existingRunCardCurrent ? state.run_card : createRiddleProofRunCard(state, { at });
   return compactRecord({
     run_id: runId,
@@ -4757,6 +4820,9 @@ function createRunStatusSnapshot(state, at = timestamp2()) {
     pr_url: state.pr_url ?? null,
     pr_branch: state.pr_branch ?? null,
     pr_state: state.pr_state,
+    ship_held: shipControl.ship_held,
+    shipping_disabled: shipControl.shipping_disabled,
+    ship_authorized: shipControl.ship_authorized,
     ci_status: state.ci_status,
     ship_commit: state.ship_commit,
     ship_remote_head: state.ship_remote_head,
@@ -4782,6 +4848,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;
 }
@@ -5223,7 +5290,7 @@ async function runRiddleProof(input) {
       status: "ready_to_ship",
       last_summary: assessment.summary,
       evidence_bundle: evidenceBundle,
-      raw: { implementation, assessment }
+      raw: { implementation, assessment, ship_held: true, shipping_disabled: true, ship_authorized: false }
     });
     return notifyIfConfigured({ state, result: result2, notification: adapters.notification });
   }
@@ -5355,9 +5422,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;
@@ -5548,7 +5612,7 @@ function shipHeldTerminal(state, result) {
     "ready_to_ship",
     result,
     result.summary || "Riddle Proof evidence is approved, but ship_mode=none is holding before PR/ship.",
-    { ship_held: true }
+    { ship_held: true, shipping_disabled: true, ship_authorized: false }
   );
 }
 function checkpointContinueStage2(result) {
@@ -5826,6 +5890,7 @@ function terminalResult(state, status, result, summary, raw = {}) {
     engineResult: result
   });
   applyTerminalMetadata(state, metadata);
+  applyShipControlState(state, { status, raw });
   persist(state);
   return createRunResult({
     state,
@@ -5928,19 +5993,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";
@@ -5971,17 +6055,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,
@@ -5992,10 +6079,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,
@@ -6006,10 +6095,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,
@@ -6022,10 +6113,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,
@@ -6037,7 +6130,7 @@ function checkpointResponseContinuation(state, value) {
           response
         }
       }
-    };
+    });
   }
   const base = {
     action: "run",
@@ -6047,14 +6140,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);
@@ -6083,14 +6178,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 {
@@ -6139,7 +6236,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 = {
@@ -6158,6 +6261,8 @@ function checkpointResponseContinuation(state, value) {
             response.summary || "Riddle Proof evidence is approved, but ship_mode=none is holding before PR/ship.",
             {
               ship_held: true,
+              shipping_disabled: true,
+              ship_authorized: false,
               proof_assessment: assessment
             }
           )
@@ -6751,6 +6856,8 @@ async function routeCheckpoint(request, state, result, agent, input) {
           assessment.summary || result.summary || "Riddle Proof evidence is approved, but ship_mode=none is holding before PR/ship.",
           {
             ship_held: true,
+            shipping_disabled: true,
+            ship_authorized: false,
             proof_assessment: payload
           }
         )

package/dist/advanced/index.d.cts

@@ -1,5 +1,5 @@
 export { b as runner } from '../runner-4LJ5z0D-.cjs';
 export { l as engineHarness } from '../engine-harness-LBfqbFSe.cjs';
 export { p as proofRunCore } from '../proof-run-core-7Dqm7RKM.cjs';
-export { p as proofRunEngine } from '../proof-run-engine-Baiv6l3A.cjs';
+export { p as proofRunEngine } from '../proof-run-engine-DpChFR5H.cjs';
 import '../types.cjs';

package/dist/advanced/index.d.ts

@@ -1,5 +1,5 @@
 export { b as runner } from '../runner-BdQpOkZD.js';
 export { l as engineHarness } from '../engine-harness-CMACHP6A.js';
 export { p as proofRunCore } from '../proof-run-core-7Dqm7RKM.js';
-export { p as proofRunEngine } from '../proof-run-engine-MiKZt9oY.js';
+export { p as proofRunEngine } from '../proof-run-engine-BqRoA3Do.js';
 import '../types.js';

package/dist/advanced/index.js

@@ -3,17 +3,17 @@ import {
 } from "../chunk-VYJD6XYF.js";
 import {
   runner_exports
-} from "../chunk-S5DX7Z6X.js";
+} from "../chunk-JLOZTVXU.js";
 import {
   engine_harness_exports
-} from "../chunk-IV4DVWPR.js";
-import "../chunk-WDIKPIMB.js";
-import "../chunk-JJ4IWRMJ.js";
+} from "../chunk-GHBNDHG7.js";
+import "../chunk-UZIX7M7D.js";
+import "../chunk-KNPCWWF3.js";
 import {
   proof_run_core_exports
 } from "../chunk-EKZXU6MU.js";
-import "../chunk-BLM5EIBA.js";
-import "../chunk-VY4Y5U57.js";
+import "../chunk-MOTQNIZX.js";
+import "../chunk-CUBYSWZT.js";
 import "../chunk-MLKGABMK.js";
 export {
   engine_harness_exports as engineHarness,

package/dist/advanced/proof-run-engine.d.cts

@@ -1,2 +1,2 @@
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-Baiv6l3A.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-DpChFR5H.cjs';
 import '../proof-run-core-7Dqm7RKM.cjs';

package/dist/advanced/proof-run-engine.d.ts

@@ -1,2 +1,2 @@
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-MiKZt9oY.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-BqRoA3Do.js';
 import '../proof-run-core-7Dqm7RKM.js';

package/dist/advanced/runner.cjs

@@ -35,6 +35,9 @@ __export(runner_exports, {
 module.exports = __toCommonJS(runner_exports);
 
 // src/result.ts
+function isProtectedFinalStatus(status) {
+  return status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
 function isSuccessfulStatus(status) {
   return status !== "blocked" && status !== "failed";
 }
@@ -47,6 +50,12 @@ function nonEmptyString(value) {
 function recordValue(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
+function firstBoolean(...values) {
+  for (const value of values) {
+    if (typeof value === "boolean") return value;
+  }
+  return void 0;
+}
 function applyTerminalMetadata(state, metadata) {
   if (metadata.pr_state) {
     state.pr_state = metadata.pr_state;
@@ -63,6 +72,9 @@ function applyTerminalMetadata(state, metadata) {
   if (prBranch) state.pr_branch = prBranch;
   if (typeof metadata.marked_ready === "boolean") state.marked_ready = metadata.marked_ready;
   if (typeof metadata.left_draft === "boolean") state.left_draft = metadata.left_draft;
+  if (typeof metadata.ship_held === "boolean") state.ship_held = metadata.ship_held;
+  if (typeof metadata.shipping_disabled === "boolean") state.shipping_disabled = metadata.shipping_disabled;
+  if (typeof metadata.ship_authorized === "boolean") state.ship_authorized = metadata.ship_authorized;
   const ciStatus = nonEmptyString(metadata.ci_status);
   if (ciStatus) state.ci_status = ciStatus;
   const shipCommit = nonEmptyString(metadata.ship_commit);
@@ -94,12 +106,54 @@ function applyTerminalMetadata(state, metadata) {
   if (typeof metadata.finalized === "boolean") state.finalized = metadata.finalized;
   return state;
 }
+function shipControlStateFor(input) {
+  const state = input.state;
+  const status = input.status || state.status;
+  const raw = recordValue(input.raw) || {};
+  const shipReport = recordValue(state.ship_report) || {};
+  const prState = recordValue(state.pr_state) || {};
+  const shippingDisabled = firstBoolean(
+    raw.shipping_disabled,
+    raw.shippingDisabled,
+    state.shipping_disabled,
+    shipReport.shipping_disabled,
+    shipReport.shippingDisabled
+  ) ?? state.request?.ship_mode === "none";
+  const explicitAuthorized = firstBoolean(
+    raw.ship_authorized,
+    raw.shipAuthorized,
+    state.ship_authorized,
+    shipReport.ship_authorized,
+    shipReport.shipAuthorized
+  );
+  const authorizationEvidence = Boolean(
+    status === "shipped" || state.marked_ready === true || shipReport.marked_ready === true || prState.status === "merged" || state.merge_commit || state.merged_at
+  );
+  const inferredAuthorized = explicitAuthorized ?? authorizationEvidence;
+  const rawHeld = firstBoolean(raw.ship_held, raw.shipHeld);
+  const inferredHeld = status === "ready_to_ship" && shippingDisabled && !inferredAuthorized;
+  const shipHeld = rawHeld ?? (state.ship_held === true || inferredHeld);
+  return {
+    ship_held: shipHeld,
+    shipping_disabled: shippingDisabled,
+    ship_authorized: shipHeld ? false : inferredAuthorized
+  };
+}
+function applyShipControlState(state, input = {}) {
+  const control = shipControlStateFor({ state, status: input.status, raw: input.raw });
+  state.ship_held = control.ship_held;
+  state.shipping_disabled = control.shipping_disabled;
+  state.ship_authorized = control.ship_authorized;
+  return state;
+}
 function createRunResult(input) {
   const status = input.status || input.state.status;
   const ok = isSuccessfulStatus(status);
   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,
     status,
@@ -117,6 +171,9 @@ function createRunResult(input) {
     pr_state: state.pr_state,
     marked_ready: state.marked_ready,
     left_draft: state.left_draft,
+    ship_held: state.ship_held,
+    shipping_disabled: state.shipping_disabled,
+    ship_authorized: state.ship_authorized,
     ci_status: state.ci_status,
     ship_commit: state.ship_commit,
     ship_remote_head: state.ship_remote_head,
@@ -295,6 +352,7 @@ function appendStageHeartbeat(state, input) {
 function setRunStatus(state, status, at = timestamp()) {
   state.status = status;
   state.ok = status !== "blocked" && status !== "failed";
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   state.updated_at = at;
   return state;
 }
@@ -770,7 +828,7 @@ async function runRiddleProof(input) {
       status: "ready_to_ship",
       last_summary: assessment.summary,
       evidence_bundle: evidenceBundle,
-      raw: { implementation, assessment }
+      raw: { implementation, assessment, ship_held: true, shipping_disabled: true, ship_authorized: false }
     });
     return notifyIfConfigured({ state, result: result2, notification: adapters.notification });
   }

package/dist/advanced/runner.js

@@ -1,11 +1,11 @@
 import {
   runRiddleProof
-} from "../chunk-S5DX7Z6X.js";
-import "../chunk-WDIKPIMB.js";
-import "../chunk-JJ4IWRMJ.js";
+} from "../chunk-JLOZTVXU.js";
+import "../chunk-UZIX7M7D.js";
+import "../chunk-KNPCWWF3.js";
 import "../chunk-EKZXU6MU.js";
-import "../chunk-BLM5EIBA.js";
-import "../chunk-VY4Y5U57.js";
+import "../chunk-MOTQNIZX.js";
+import "../chunk-CUBYSWZT.js";
 import "../chunk-MLKGABMK.js";
 export {
   runRiddleProof

package/dist/checkpoint.cjs

@@ -757,6 +757,8 @@ function checkpointSummaryFromState(state, engineStatePath) {
   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;
@@ -772,6 +774,8 @@ function checkpointSummaryFromState(state, engineStatePath) {
     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,

package/dist/checkpoint.js

@@ -14,8 +14,8 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "./chunk-BLM5EIBA.js";
-import "./chunk-VY4Y5U57.js";
+} from "./chunk-MOTQNIZX.js";
+import "./chunk-CUBYSWZT.js";
 import "./chunk-MLKGABMK.js";
 export {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,

package/dist/{chunk-ECLGGGAI.js → chunk-54DIEDR3.js}

@@ -28,14 +28,14 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-IV4DVWPR.js";
+} from "./chunk-GHBNDHG7.js";
 import {
   createCheckpointResponseTemplate
-} from "./chunk-BLM5EIBA.js";
+} from "./chunk-MOTQNIZX.js";
 import {
   createCodexExecAgentAdapter,
   runCodexExecAgentDoctor
-} from "./chunk-73EBR3YL.js";
+} from "./chunk-RS4HJLJQ.js";
 
 // src/cli.ts
 import { spawnSync } from "child_process";