@riddledc/riddle-proof 0.5.44 → 0.5.46

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

@@ -1,13 +1,8 @@
 import {
-  authorPacketPayloadFromCheckpointResponse,
-  buildAuthorCheckpointPacket,
-  checkpointResponseIdentity,
-  checkpointSummaryFromState,
-  isDuplicateCheckpointResponse,
-  normalizeCheckpointResponse,
-  proofContractFromAuthorCheckpointResponse,
-  statePathsForRunState
-} from "./chunk-RI25RGQP.js";
+  visualDeltaForState,
+  visualDeltaRequiredForState,
+  visualDeltaShipGateReason
+} from "./chunk-4ASMX4R6.js";
 import {
   appendRunEvent,
   appendStageHeartbeat,
@@ -15,7 +10,20 @@ import {
   createRunStatusSnapshot,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-7S7O3NKF.js";
+} from "./chunk-JTNMEH57.js";
+import {
+  createRiddleProofRunCard
+} from "./chunk-PLSGW2GI.js";
+import {
+  authorPacketPayloadFromCheckpointResponse,
+  buildCheckpointPacketForEngineResult,
+  checkpointResponseIdentity,
+  checkpointSummaryFromState,
+  isDuplicateCheckpointResponse,
+  normalizeCheckpointResponse,
+  proofContractFromAuthorCheckpointResponse,
+  statePathsForRunState
+} from "./chunk-R6SCWJCI.js";
 import {
   applyTerminalMetadata,
   compactRecord,
@@ -23,12 +31,7 @@ import {
   nonEmptyString,
   normalizeTerminalMetadata,
   recordValue
-} from "./chunk-W7VTDN4T.js";
-import {
-  visualDeltaForState,
-  visualDeltaRequiredForState,
-  visualDeltaShipGateReason
-} from "./chunk-4ASMX4R6.js";
+} from "./chunk-DUFDZJOF.js";
 
 // src/engine-harness.ts
 import { execFileSync } from "child_process";
@@ -117,6 +120,10 @@ function shouldPreserveFinalizedRunState(filePath, incoming) {
 function persist(state) {
   state.state_paths = statePathsForRunState(state);
   state.checkpoint_summary = checkpointSummaryFromState(state);
+  state.run_card = createRiddleProofRunCard(state, {
+    fullRiddleState: readJson(state.request.engine_state_path),
+    state_paths: state.state_paths
+  });
   if (!state.state_path) return;
   if (shouldPreserveFinalizedRunState(state.state_path, state)) return;
   writeJson(state.state_path, state);
@@ -308,6 +315,74 @@ 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 reconAssessmentPayloadFromCheckpointResponse(response) {
+  if (![
+    "ready_for_author",
+    "retry_recon",
+    "recon_stuck",
+    "needs_recon"
+  ].includes(response.decision)) {
+    return null;
+  }
+  const payload = recordValue(response.payload) || {};
+  const decision = response.decision === "needs_recon" ? "retry_recon" : response.decision;
+  const continueStage = response.continue_with_stage || nonEmptyString(payload.continue_with_stage) || (decision === "ready_for_author" ? "author" : "recon");
+  return compactRecord({
+    ...payload,
+    decision,
+    summary: response.summary,
+    continue_with_stage: continueStage,
+    escalation_target: nonEmptyString(payload.escalation_target) || (decision === "recon_stuck" ? "human" : "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 implementationNotesFromCheckpointResponse(response) {
+  const payload = recordValue(response.payload) || {};
+  const notes = nonEmptyString(payload.implementation_notes) || nonEmptyString(payload.implementationNotes) || nonEmptyString(payload.summary) || response.summary;
+  const changedFiles = Array.isArray(payload.changed_files) ? payload.changed_files.filter((item) => typeof item === "string") : [];
+  const testsRun = Array.isArray(payload.tests_run) ? payload.tests_run.filter((item) => typeof item === "string") : [];
+  return [
+    notes,
+    changedFiles.length ? `changed_files=${changedFiles.join(", ")}` : "",
+    testsRun.length ? `tests_run=${testsRun.join(", ")}` : ""
+  ].filter(Boolean).join("\n");
+}
 function proofAssessmentVisualBlocker(state, payload) {
   if (!proofAssessmentRequestsShip(payload)) return null;
   const source = nonEmptyString(payload.source) || "supervising_agent";
@@ -446,7 +521,7 @@ function blockerResult(state, result, blocker) {
   });
 }
 function checkpointAwaitingResult(state, result, visibility) {
-  const packet = buildAuthorCheckpointPacket({
+  const packet = buildCheckpointPacketForEngineResult({
     request: state.request,
     runState: state,
     engineResult: result,
@@ -609,10 +684,93 @@ function checkpointResponseContinuation(state, value) {
     appendCheckpointResponse(state, response);
     return { next: { ...base, author_packet_json: jsonParam(payload) } };
   }
+  if (packet.kind === "assess_recon" || packet.stage === "recon") {
+    const assessment = reconAssessmentPayloadFromCheckpointResponse(response);
+    if (assessment) {
+      appendCheckpointResponse(state, response);
+      return { next: { ...base, recon_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 recon with decision=${response.decision}.`,
+          details: { stage: packet.stage, response }
+        }
+      };
+    }
+  }
+  if (packet.kind === "implement_change" || packet.stage === "implement") {
+    if (response.decision === "implementation_complete") {
+      const workdir = nonEmptyString(packet.state_excerpt?.after_worktree) || state.worktree_path;
+      if (workdir) state.worktree_path = workdir;
+      if (!hasGitDiff(workdir)) {
+        return {
+          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 {
+        next: {
+          ...base,
+          advance_stage: "implement",
+          implementation_notes: implementationNotesFromCheckpointResponse(response)
+        }
+      };
+    }
+    if (response.decision === "needs_author") {
+      appendCheckpointResponse(state, response);
+      return { next: { ...base, advance_stage: "author" } };
+    }
+    if (response.decision === "needs_recon") {
+      appendCheckpointResponse(state, response);
+      return { next: { ...base, advance_stage: "recon" } };
+    }
+    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 implementation with decision=${response.decision}.`,
+          details: { stage: packet.stage, response }
+        }
+      };
+    }
+  }
   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: {
@@ -854,6 +1012,9 @@ async function routeCheckpoint(request, state, result, agent, input) {
     };
   }
   if (checkpoint === "recon_supervisor_judgment") {
+    if (input.checkpoint_mode === "yield") {
+      return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
+    }
     const assessment = await agent.assessRecon(context);
     const blocker = requirePayload("recon_assessment", assessment, state, result);
     if (blocker) return { blocker };
@@ -889,15 +1050,37 @@ async function routeCheckpoint(request, state, result, agent, input) {
     };
   }
   if (checkpoint === "implement_changes_missing" || checkpoint === "implement_required" || checkpoint === "verify_agent_retry" && continueStage === "implement") {
+    if (input.checkpoint_mode === "yield") {
+      const fullState = context.fullRiddleState || {};
+      state.worktree_path = workdirFromState(fullState) || state.worktree_path;
+      state.branch = nonEmptyString(fullState.branch) || state.branch;
+      persist(state);
+      return { terminal: checkpointAwaitingResult(state, result, input.checkpoint_visibility) };
+    }
     return handleImplementation(request, state, result, agent);
   }
   if (checkpoint === "implement_review") {
     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",