@riddledc/riddle-proof 0.5.38 → 0.5.40

package/dist/{chunk-OASB3CYU.js → chunk-7S7O3NKF.js}

@@ -3,7 +3,7 @@ import {
   isTerminalStatus,
   nonEmptyString,
   recordValue
-} from "./chunk-J2MERROF.js";
+} from "./chunk-W7VTDN4T.js";
 
 // src/state.ts
 var RIDDLE_PROOF_RUN_STATE_VERSION = "riddle-proof.run-state.v1";
@@ -127,6 +127,11 @@ function createRunState(input) {
     request: normalizeRunParams(input.request),
     iterations: input.iterations ?? 0,
     last_checkpoint: input.last_checkpoint ?? null,
+    checkpoint_packet: input.checkpoint_packet,
+    checkpoint_summary: input.checkpoint_summary,
+    state_paths: input.state_paths,
+    proof_contract: input.proof_contract,
+    checkpoint_history: input.checkpoint_history,
     events: input.events ? [...input.events] : []
   });
 }
@@ -200,6 +205,10 @@ function createRunStatusSnapshot(state, at = timestamp()) {
     elapsed_ms: elapsedMs(state.created_at, at),
     stage_elapsed_ms: elapsedMs(state.stage_started_at, at),
     blocker: state.blocker,
+    checkpoint_packet: state.checkpoint_packet,
+    checkpoint_summary: state.checkpoint_summary,
+    state_paths: state.state_paths,
+    proof_contract: state.proof_contract,
     latest_event: latestEvent
   });
 }

package/dist/{chunk-GN7HSZ6G.js → chunk-COFOLRUW.js}

@@ -1,3 +1,12 @@
+import {
+  authorPacketPayloadFromCheckpointResponse,
+  buildAuthorCheckpointPacket,
+  checkpointSummaryFromState,
+  isDuplicateCheckpointResponse,
+  normalizeCheckpointResponse,
+  proofContractFromAuthorCheckpointResponse,
+  statePathsForRunState
+} from "./chunk-5LVCGDSD.js";
 import {
   appendRunEvent,
   appendStageHeartbeat,
@@ -5,7 +14,7 @@ import {
   createRunStatusSnapshot,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-OASB3CYU.js";
+} from "./chunk-7S7O3NKF.js";
 import {
   applyTerminalMetadata,
   compactRecord,
@@ -13,7 +22,7 @@ import {
   nonEmptyString,
   normalizeTerminalMetadata,
   recordValue
-} from "./chunk-J2MERROF.js";
+} from "./chunk-W7VTDN4T.js";
 import {
   visualDeltaShipGateReason
 } from "./chunk-4YCWZVBN.js";
@@ -103,6 +112,8 @@ function shouldPreserveFinalizedRunState(filePath, incoming) {
   return !(existing.status === "ready_to_ship" && incoming.status === "shipped");
 }
 function persist(state) {
+  state.state_paths = statePathsForRunState(state);
+  state.checkpoint_summary = checkpointSummaryFromState(state);
   if (!state.state_path) return;
   if (shouldPreserveFinalizedRunState(state.state_path, state)) return;
   writeJson(state.state_path, state);
@@ -359,6 +370,10 @@ function engineFailureBlocker(result, checkpoint) {
   };
 }
 function terminalResult(state, status, result, summary, raw = {}) {
+  if (result) {
+    const terminalStage = stageFromCheckpoint(result);
+    if (terminalStage !== "setup") state.current_stage = terminalStage;
+  }
   setRunStatus(state, status);
   if (isProtectedFinalStatus(status)) state.finalized = true;
   const metadata = normalizeTerminalMetadata({
@@ -381,10 +396,12 @@ function terminalResult(state, status, result, summary, raw = {}) {
 }
 function blockerResult(state, result, blocker) {
   state.blocker = blocker;
+  const blockerStage = nonEmptyString(recordValue(blocker.details)?.stage);
+  const stage = blockerStage || stageFromCheckpoint(result || { checkpoint: blocker.checkpoint || void 0 });
   recordEvent(state, {
     kind: "run.blocked",
     checkpoint: blocker.checkpoint || result?.checkpoint || null,
-    stage: stageFromCheckpoint(result || {}),
+    stage,
     summary: blocker.message,
     details: {
       code: blocker.code,
@@ -403,6 +420,169 @@ function blockerResult(state, result, blocker) {
     }
   });
 }
+function checkpointAwaitingResult(state, result, visibility) {
+  const packet = buildAuthorCheckpointPacket({
+    request: state.request,
+    runState: state,
+    engineResult: result,
+    fullRiddleState: fullRiddleState(result, state),
+    visibility
+  });
+  const at = timestamp();
+  state.checkpoint_packet = packet;
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, packet }
+  ].slice(-25);
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.packet.created",
+    checkpoint: packet.checkpoint,
+    stage: packet.stage,
+    summary: packet.summary,
+    details: compactRecord({
+      kind: packet.kind,
+      routing_hint: packet.routing_hint,
+      resume_token: packet.resume_token
+    })
+  });
+  setRunStatus(state, "awaiting_checkpoint", at);
+  persist(state);
+  return createRunResult({
+    state,
+    status: "awaiting_checkpoint",
+    last_summary: packet.summary,
+    raw: {
+      engine_state_path: result.state_path || state.request.engine_state_path || null,
+      last_result: result,
+      checkpoint_packet: packet
+    }
+  });
+}
+function appendCheckpointResponse(state, response, input = {}) {
+  const at = timestamp();
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, response }
+  ].slice(-25);
+  if (input.clear_packet !== false) {
+    state.checkpoint_packet = void 0;
+  }
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.response.accepted",
+    checkpoint: response.checkpoint,
+    stage: state.current_stage || "author",
+    summary: input.summary || response.summary,
+    details: compactRecord({
+      decision: response.decision,
+      resume_token: response.resume_token,
+      source: response.source
+    })
+  });
+  setRunStatus(state, "running", at);
+  persist(state);
+}
+function checkpointResponseContinuation(state, value) {
+  if (!value) return {};
+  const packet = state.checkpoint_packet;
+  const response = normalizeCheckpointResponse(value);
+  if (!response) {
+    return {
+      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 (!packet) {
+    if (isDuplicateCheckpointResponse(state, response)) {
+      return {
+        blocker: {
+          code: "checkpoint_response_duplicate",
+          checkpoint: response.checkpoint,
+          message: "Checkpoint response was already accepted and there is no pending checkpoint packet to resume.",
+          details: {
+            response,
+            checkpoint_summary: checkpointSummaryFromState(state)
+          }
+        }
+      };
+    }
+    return {
+      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 {
+      blocker: {
+        code: "checkpoint_response_mismatch",
+        checkpoint: packet.checkpoint,
+        message: "Checkpoint response does not match the pending checkpoint packet.",
+        details: {
+          stage: packet.stage,
+          expected: { run_id: packet.run_id, checkpoint: packet.checkpoint },
+          actual: { run_id: response.run_id, checkpoint: response.checkpoint }
+        }
+      }
+    };
+  }
+  if (packet.resume_token && response.resume_token !== packet.resume_token) {
+    return {
+      blocker: {
+        code: "checkpoint_response_resume_token_mismatch",
+        checkpoint: packet.checkpoint,
+        message: "Checkpoint response resume_token does not match the pending checkpoint packet.",
+        details: {
+          stage: packet.stage,
+          expected_resume_token: packet.resume_token,
+          actual_resume_token: response.resume_token || null
+        }
+      }
+    };
+  }
+  const base = {
+    action: "run",
+    state_path: state.request.engine_state_path || packet.state_path || "",
+    continue_from_checkpoint: true
+  };
+  if (response.decision === "author_packet") {
+    const payload = authorPacketPayloadFromCheckpointResponse(response);
+    if (!payload) {
+      return {
+        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);
+    return { next: { ...base, author_packet_json: jsonParam(payload) } };
+  }
+  if (response.decision === "needs_recon") {
+    appendCheckpointResponse(state, response);
+    return { next: { ...base, advance_stage: "recon" } };
+  }
+  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 }
+    }
+  };
+}
 function disabledAdapterPayload(action, context) {
   return {
     ok: false,
@@ -651,6 +831,9 @@ async function routeCheckpoint(request, state, result, agent, input) {
   const continueStage = checkpointContinueStage(result);
   const checkpointContinuesToAuthor = continueStage === "author";
   if (checkpoint === "author_supervisor_judgment" || checkpoint === "verify_capture_retry" || checkpoint === "verify_agent_retry" && checkpointContinuesToAuthor) {
+    if (input.checkpoint_mode === "yield") {
+      return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
+    }
     const packet = await agent.authorProofPacket(context);
     const blocker = requirePayload("author_packet", packet, state, result);
     if (blocker) return { blocker };
@@ -752,6 +935,10 @@ async function runRiddleProofEngineHarness(input) {
   const state = loadRunState(input);
   state.request = normalizeRunParams({ ...state.request, ...input.request });
   state.request.engine_state_path = nonEmptyString(input.resume_params?.state_path) || nonEmptyString(state.request.engine_state_path) || createEngineStatePath(state, input.config);
+  const checkpointContinuation = checkpointResponseContinuation(state, input.checkpoint_response);
+  if (checkpointContinuation.blocker) {
+    return blockerResult(state, null, checkpointContinuation.blocker);
+  }
   const request = state.request;
   const agent = input.agent || createDisabledRiddleProofAgentAdapter();
   const maxIterations = Math.max(
@@ -773,6 +960,8 @@ async function runRiddleProofEngineHarness(input) {
       engine_state_path: request.engine_state_path || null,
       max_iterations: maxIterations,
       ship_mode: effectiveShipMode(request, input.config),
+      checkpoint_mode: input.checkpoint_mode || "auto",
+      checkpoint_visibility: input.checkpoint_visibility || null,
       leave_draft: request.leave_draft || false
     }
   });
@@ -787,7 +976,7 @@ async function runRiddleProofEngineHarness(input) {
       message
     });
   }
-  let nextParams = input.resume_params || initialRunParams(request, input, state);
+  let nextParams = input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state);
   let lastResult = null;
   const stageIterations = {};
   for (let index = 0; index < maxIterations; index += 1) {

package/dist/{chunk-MQ2BHHLX.js → chunk-MRSYJMF4.js}

@@ -3,10 +3,10 @@ import {
   appendStageHeartbeat,
   createRunState,
   setRunStatus
-} from "./chunk-OASB3CYU.js";
+} from "./chunk-7S7O3NKF.js";
 import {
   createRunResult
-} from "./chunk-J2MERROF.js";
+} from "./chunk-W7VTDN4T.js";
 
 // src/runner.ts
 function errorDetails(error) {

package/dist/{chunk-J2MERROF.js → chunk-W7VTDN4T.js}

@@ -202,6 +202,10 @@ function createRunResult(input) {
     merge_recommendation: state.merge_recommendation,
     finalized: state.finalized,
     blocker: state.blocker,
+    checkpoint_packet: state.checkpoint_packet,
+    checkpoint_summary: state.checkpoint_summary,
+    state_paths: state.state_paths,
+    proof_contract: state.proof_contract,
     proof_session: state.proof_session,
     evidence_bundle: input.evidence_bundle,
     raw: input.raw