@riddledc/riddle-proof 0.8.13 → 0.8.15

package/dist/index.cjs

@@ -1139,6 +1139,12 @@ function snapshotFor(statePath) {
 function authorReady(state) {
   return state?.author_status === "ready" || state?.proof_plan_status === "ready";
 }
+function hasAuthoredProofPlan2(state = {}) {
+  return Boolean((state?.proof_plan || "").trim()) && Boolean((state?.capture_script || "").trim());
+}
+function hasExplicitCaptureScript(state = {}) {
+  return Boolean((state?.capture_script || "").trim());
+}
 function implementationReady(state) {
   return ["changes_detected", "completed"].includes(state?.implementation_status || "");
 }
@@ -1169,6 +1175,45 @@ function latestReconHasRequiredBaselines(state) {
   const baselines = latestReconCapturedBaselines(state);
   return requiredReconBaselineLabels(state).every((label) => Boolean((baselines?.[label]?.url || "").trim()));
 }
+function canAutoAcceptExplicitCaptureRecon(params, state) {
+  const labels = requiredReconBaselineLabels(state);
+  return Boolean(
+    !implementationRequired(params, state) && hasExplicitCaptureScript(state) && ["needs_agent_decision", "needs_supervisor_judgment"].includes(state?.recon_status || "") && labels.length > 0 && latestReconHasRequiredBaselines(state)
+  );
+}
+function applyExplicitCaptureReconAcceptance(state) {
+  const baselines = promoteLatestReconBaselines(state);
+  const labels = requiredReconBaselineLabels(state);
+  const selected = latestReconAttempt(state) || {};
+  state.recon_status = "ready_for_proof_plan";
+  state.recon_results = state.recon_results || {};
+  state.recon_results.status = "ready_for_proof_plan";
+  state.recon_results.baselines = baselines;
+  state.recon_assessment_request = {};
+  state.recon_decision_request = {};
+  state.recon_assessment = {
+    decision: "ready_for_author",
+    continue_with_stage: "author",
+    source: "runner_auto_accept",
+    summary: "Runner accepted recon automatically because this audit/no-diff run already supplied an explicit capture script, and the required baseline capture exists.",
+    baseline_labels: labels
+  };
+  state.recon_assessment_source = "runner_auto_accept";
+  state.recon_baseline_understanding = state.recon_baseline_understanding || {
+    reference: state?.reference || state?.requested_reference || "before",
+    target_route: selected?.plan?.target_path || state?.server_path || "/",
+    proof_focus: state?.proof_plan || state?.change_request || "",
+    stop_condition: "Verify must judge the authored capture evidence against the explicit proof packet."
+  };
+  if (hasAuthoredProofPlan2(state)) {
+    state.author_status = "ready";
+    state.proof_plan_status = "ready";
+  } else {
+    state.author_status = "needs_authoring";
+    state.proof_plan_status = "needs_authoring";
+  }
+  return { baselines, labels };
+}
 function hasReconBaselineUnderstanding(state) {
   const understanding = state?.recon_assessment?.baseline_understanding || state?.recon_baseline_understanding || {};
   return Boolean(
@@ -2195,6 +2240,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         state = readState(config.statePath);
       }
     }
+    let reconAutoAcceptedExplicitCapture = false;
     if (!state?.recon_results || state?.stage === "setup" || state?.stage === "preflight" || ["needs_agent_decision", "needs_supervisor_judgment"].includes(state?.recon_status || "") || requestedStage === "recon") {
       const reconRes = runOne("recon");
       executed.push(executedStep(reconRes));
@@ -2207,40 +2253,64 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
       }
       state = readState(config.statePath);
       if (["needs_agent_decision", "needs_supervisor_judgment"].includes(state?.recon_status || "")) {
-        const reconAssessmentRequest = state?.recon_assessment_request || state?.recon_decision_request || null;
-        const summary = "Recon gathered route hints, candidate paths, baseline captures, and observations. The supervising agent should now judge whether the latest baseline is trustworthy, whether recon should retry/reframe, and whether recon is done.";
-        const reconDetails = {
-          executed,
-          latestAttempt: latestReconAttempt(state),
-          latestCapturedBaselines: latestReconCapturedBaselines(state),
-          reconAssessmentRequest
-        };
-        recordAttempt("recon", "checkpoint", summary, {
+        if (canAutoAcceptExplicitCaptureRecon(params, state)) {
+          const promoted = updateState(config.statePath, (currentState) => {
+            applyExplicitCaptureReconAcceptance(currentState);
+          });
+          state = promoted;
+          reconAutoAcceptedExplicitCapture = true;
+          effectiveAdvanceStage = stageAfterAuthor(state, params);
+          requestedStage = normalizeStageRequest(state, effectiveAdvanceStage);
+          updateState(config.statePath, (currentState) => {
+            currentState.last_requested_advance_stage = effectiveAdvanceStage;
+          });
+          recordAttempt("recon", "completed", "Recon baseline was captured and auto-accepted for an explicit audit/no-diff proof packet.", {
+            autoApproved: true,
+            checkpoint: "recon_auto_accept_explicit_capture",
+            details: {
+              executed,
+              promotedBaselines: latestReconCapturedBaselines(state),
+              baselineLabels: requiredReconBaselineLabels(state)
+            }
+          });
+        } else {
+          const reconAssessmentRequest = state?.recon_assessment_request || state?.recon_decision_request || null;
+          const summary = "Recon gathered route hints, candidate paths, baseline captures, and observations. The supervising agent should now judge whether the latest baseline is trustworthy, whether recon should retry/reframe, and whether recon is done.";
+          const reconDetails = {
+            executed,
+            latestAttempt: latestReconAttempt(state),
+            latestCapturedBaselines: latestReconCapturedBaselines(state),
+            reconAssessmentRequest
+          };
+          recordAttempt("recon", "checkpoint", summary, {
+            autoApproved: reconRes.autoApproved || false,
+            checkpoint: "recon_supervisor_judgment",
+            details: reconDetails
+          });
+          return checkpoint(
+            "recon",
+            "recon_supervisor_judgment",
+            summary,
+            {
+              nextActions: ["inspect_recon_packet", "supply_recon_assessment_json", "continue_internal_loop_with_checkpoint"],
+              advanceOptions: ["recon", "author"],
+              recommendedAdvanceStage: "recon",
+              continueWithStage: "recon",
+              blocking: false,
+              details: reconDetails,
+              reconAssessmentRequest,
+              reconDecisionRequest: state?.recon_decision_request || null,
+              executed
+            }
+          );
+        }
+      }
+      if (!reconAutoAcceptedExplicitCapture) {
+        recordAttempt("recon", "completed", "Recon completed and promoted an approved baseline context.", {
           autoApproved: reconRes.autoApproved || false,
-          checkpoint: "recon_supervisor_judgment",
-          details: reconDetails
+          details: { executed }
         });
-        return checkpoint(
-          "recon",
-          "recon_supervisor_judgment",
-          summary,
-          {
-            nextActions: ["inspect_recon_packet", "supply_recon_assessment_json", "continue_internal_loop_with_checkpoint"],
-            advanceOptions: ["recon", "author"],
-            recommendedAdvanceStage: "recon",
-            continueWithStage: "recon",
-            blocking: false,
-            details: reconDetails,
-            reconAssessmentRequest,
-            reconDecisionRequest: state?.recon_decision_request || null,
-            executed
-          }
-        );
       }
-      recordAttempt("recon", "completed", "Recon completed and promoted an approved baseline context.", {
-        autoApproved: reconRes.autoApproved || false,
-        details: { executed }
-      });
     }
     state = readState(config.statePath);
     if (!authorReady(state) || effectiveAdvanceStage === "author") {
@@ -5882,6 +5952,40 @@ function checkpointResponseContinuation(state, value) {
     }
   };
 }
+function finalizedCheckpointResponseWithoutPacketResult(state, value) {
+  if (!value || state.checkpoint_packet || !state.finalized || !isProtectedFinalStatus(state.status)) return null;
+  const response = normalizeCheckpointResponse(value);
+  if (!response) return null;
+  if (isDuplicateCheckpointResponse(state, response)) return null;
+  const at = timestamp3();
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, response }
+  ].slice(-25);
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.response.ignored",
+    checkpoint: response.checkpoint,
+    stage: state.current_stage || "verify",
+    summary: "Late checkpoint response ignored because the run is already finalized.",
+    details: compactRecord({
+      status: state.status,
+      decision: response.decision,
+      resume_token: response.resume_token,
+      source: response.source
+    })
+  });
+  persist(state);
+  return createRunResult({
+    state,
+    status: state.status,
+    last_summary: "Late checkpoint response ignored because the run is already finalized.",
+    raw: {
+      ignored_checkpoint_response: true,
+      response
+    }
+  });
+}
 function disabledAdapterPayload(action, context) {
   return {
     ok: false,
@@ -6452,6 +6556,8 @@ 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 finalizedCheckpointResponse = finalizedCheckpointResponseWithoutPacketResult(state, input.checkpoint_response);
+  if (finalizedCheckpointResponse) return finalizedCheckpointResponse;
   const checkpointContinuation = checkpointResponseContinuation(state, input.checkpoint_response);
   if (checkpointContinuation.blocker) {
     return blockerResult(state, null, checkpointContinuation.blocker);

package/dist/index.js

@@ -95,7 +95,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-RTLA6CPP.js";
+} from "./chunk-RW4OUHN4.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,

package/dist/proof-run-engine.cjs

@@ -1136,6 +1136,12 @@ function snapshotFor(statePath) {
 function authorReady(state) {
   return state?.author_status === "ready" || state?.proof_plan_status === "ready";
 }
+function hasAuthoredProofPlan2(state = {}) {
+  return Boolean((state?.proof_plan || "").trim()) && Boolean((state?.capture_script || "").trim());
+}
+function hasExplicitCaptureScript(state = {}) {
+  return Boolean((state?.capture_script || "").trim());
+}
 function implementationReady(state) {
   return ["changes_detected", "completed"].includes(state?.implementation_status || "");
 }
@@ -1166,6 +1172,45 @@ function latestReconHasRequiredBaselines(state) {
   const baselines = latestReconCapturedBaselines(state);
   return requiredReconBaselineLabels(state).every((label) => Boolean((baselines?.[label]?.url || "").trim()));
 }
+function canAutoAcceptExplicitCaptureRecon(params, state) {
+  const labels = requiredReconBaselineLabels(state);
+  return Boolean(
+    !implementationRequired(params, state) && hasExplicitCaptureScript(state) && ["needs_agent_decision", "needs_supervisor_judgment"].includes(state?.recon_status || "") && labels.length > 0 && latestReconHasRequiredBaselines(state)
+  );
+}
+function applyExplicitCaptureReconAcceptance(state) {
+  const baselines = promoteLatestReconBaselines(state);
+  const labels = requiredReconBaselineLabels(state);
+  const selected = latestReconAttempt(state) || {};
+  state.recon_status = "ready_for_proof_plan";
+  state.recon_results = state.recon_results || {};
+  state.recon_results.status = "ready_for_proof_plan";
+  state.recon_results.baselines = baselines;
+  state.recon_assessment_request = {};
+  state.recon_decision_request = {};
+  state.recon_assessment = {
+    decision: "ready_for_author",
+    continue_with_stage: "author",
+    source: "runner_auto_accept",
+    summary: "Runner accepted recon automatically because this audit/no-diff run already supplied an explicit capture script, and the required baseline capture exists.",
+    baseline_labels: labels
+  };
+  state.recon_assessment_source = "runner_auto_accept";
+  state.recon_baseline_understanding = state.recon_baseline_understanding || {
+    reference: state?.reference || state?.requested_reference || "before",
+    target_route: selected?.plan?.target_path || state?.server_path || "/",
+    proof_focus: state?.proof_plan || state?.change_request || "",
+    stop_condition: "Verify must judge the authored capture evidence against the explicit proof packet."
+  };
+  if (hasAuthoredProofPlan2(state)) {
+    state.author_status = "ready";
+    state.proof_plan_status = "ready";
+  } else {
+    state.author_status = "needs_authoring";
+    state.proof_plan_status = "needs_authoring";
+  }
+  return { baselines, labels };
+}
 function hasReconBaselineUnderstanding(state) {
   const understanding = state?.recon_assessment?.baseline_understanding || state?.recon_baseline_understanding || {};
   return Boolean(
@@ -2193,6 +2238,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         state = readState(config.statePath);
       }
     }
+    let reconAutoAcceptedExplicitCapture = false;
     if (!state?.recon_results || state?.stage === "setup" || state?.stage === "preflight" || ["needs_agent_decision", "needs_supervisor_judgment"].includes(state?.recon_status || "") || requestedStage === "recon") {
       const reconRes = runOne("recon");
       executed.push(executedStep(reconRes));
@@ -2205,40 +2251,64 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
       }
       state = readState(config.statePath);
       if (["needs_agent_decision", "needs_supervisor_judgment"].includes(state?.recon_status || "")) {
-        const reconAssessmentRequest = state?.recon_assessment_request || state?.recon_decision_request || null;
-        const summary = "Recon gathered route hints, candidate paths, baseline captures, and observations. The supervising agent should now judge whether the latest baseline is trustworthy, whether recon should retry/reframe, and whether recon is done.";
-        const reconDetails = {
-          executed,
-          latestAttempt: latestReconAttempt(state),
-          latestCapturedBaselines: latestReconCapturedBaselines(state),
-          reconAssessmentRequest
-        };
-        recordAttempt("recon", "checkpoint", summary, {
+        if (canAutoAcceptExplicitCaptureRecon(params, state)) {
+          const promoted = updateState(config.statePath, (currentState) => {
+            applyExplicitCaptureReconAcceptance(currentState);
+          });
+          state = promoted;
+          reconAutoAcceptedExplicitCapture = true;
+          effectiveAdvanceStage = stageAfterAuthor(state, params);
+          requestedStage = normalizeStageRequest(state, effectiveAdvanceStage);
+          updateState(config.statePath, (currentState) => {
+            currentState.last_requested_advance_stage = effectiveAdvanceStage;
+          });
+          recordAttempt("recon", "completed", "Recon baseline was captured and auto-accepted for an explicit audit/no-diff proof packet.", {
+            autoApproved: true,
+            checkpoint: "recon_auto_accept_explicit_capture",
+            details: {
+              executed,
+              promotedBaselines: latestReconCapturedBaselines(state),
+              baselineLabels: requiredReconBaselineLabels(state)
+            }
+          });
+        } else {
+          const reconAssessmentRequest = state?.recon_assessment_request || state?.recon_decision_request || null;
+          const summary = "Recon gathered route hints, candidate paths, baseline captures, and observations. The supervising agent should now judge whether the latest baseline is trustworthy, whether recon should retry/reframe, and whether recon is done.";
+          const reconDetails = {
+            executed,
+            latestAttempt: latestReconAttempt(state),
+            latestCapturedBaselines: latestReconCapturedBaselines(state),
+            reconAssessmentRequest
+          };
+          recordAttempt("recon", "checkpoint", summary, {
+            autoApproved: reconRes.autoApproved || false,
+            checkpoint: "recon_supervisor_judgment",
+            details: reconDetails
+          });
+          return checkpoint(
+            "recon",
+            "recon_supervisor_judgment",
+            summary,
+            {
+              nextActions: ["inspect_recon_packet", "supply_recon_assessment_json", "continue_internal_loop_with_checkpoint"],
+              advanceOptions: ["recon", "author"],
+              recommendedAdvanceStage: "recon",
+              continueWithStage: "recon",
+              blocking: false,
+              details: reconDetails,
+              reconAssessmentRequest,
+              reconDecisionRequest: state?.recon_decision_request || null,
+              executed
+            }
+          );
+        }
+      }
+      if (!reconAutoAcceptedExplicitCapture) {
+        recordAttempt("recon", "completed", "Recon completed and promoted an approved baseline context.", {
           autoApproved: reconRes.autoApproved || false,
-          checkpoint: "recon_supervisor_judgment",
-          details: reconDetails
+          details: { executed }
         });
-        return checkpoint(
-          "recon",
-          "recon_supervisor_judgment",
-          summary,
-          {
-            nextActions: ["inspect_recon_packet", "supply_recon_assessment_json", "continue_internal_loop_with_checkpoint"],
-            advanceOptions: ["recon", "author"],
-            recommendedAdvanceStage: "recon",
-            continueWithStage: "recon",
-            blocking: false,
-            details: reconDetails,
-            reconAssessmentRequest,
-            reconDecisionRequest: state?.recon_decision_request || null,
-            executed
-          }
-        );
       }
-      recordAttempt("recon", "completed", "Recon completed and promoted an approved baseline context.", {
-        autoApproved: reconRes.autoApproved || false,
-        details: { executed }
-      });
     }
     state = readState(config.statePath);
     if (!authorReady(state) || effectiveAdvanceStage === "author") {

package/dist/proof-run-engine.js

@@ -1,7 +1,7 @@
 import {
   createRiddleProofEngine,
   executeWorkflow
-} from "./chunk-JBY2SU5U.js";
+} from "./chunk-WJZYRUNV.js";
 import "./chunk-7GZY5PLT.js";
 import "./chunk-MLKGABMK.js";
 export {

package/package.json

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

package/runtime/lib/verify.py

@@ -3900,6 +3900,16 @@ has_judgable_failed_interaction_evidence = (
     and not proof_evidence_blocker
     and not visual_delta_recovery
 )
+route_expectation = s.get('route_expectation') if isinstance(s.get('route_expectation'), dict) else {}
+authored_terminal_route_mismatch = (
+    verification_mode in INTERACTION_MODES
+    and 'wrong route' in str(after_observation.get('reason') or '')
+    and bool(route_expectation.get('terminal_path'))
+    and str(route_expectation.get('source') or '') != 'recon_start_path'
+)
+if authored_terminal_route_mismatch:
+    has_judgable_failed_interaction_evidence = False
+    summary_lines.append('Structured interaction route gate: authored terminal route mismatch is a terminal capture blocker.')
 has_good_evidence = (
     required_baseline_present
     and (after_observation.get('valid') or has_judgable_failed_interaction_evidence)

package/runtime/tests/recon_verify_smoke.py

@@ -365,13 +365,18 @@ class FakeRiddle:
                         'hash': '',
                     },
                     'assertions': {
-                        'expectedUrlPreserved': True,
                         'expectedUrlReachedBeforeDrop': True,
+                        'expectedUrlStillPresentAtTerminal': False,
+                        'queryDropped': True,
+                        'hashDropped': True,
                         'routeExpectationSourceIsCaptureScriptExpectedUrl': True,
-                        'terminalIntentionallyDroppedQueryHash': True,
-                        'terminalUrlMismatchIsIntentional': True,
+                        'shouldTerminalizeAsFailedInteractionCapture': True,
                         'terminalMainVisible': True,
                     },
+                    'checks': {
+                        'routeMatches': False,
+                        'specificMismatchDetected': True,
+                    },
                     'errors': [],
                 }
                 return {

package/runtime/tests/trust_boundary_regression.py

@@ -109,6 +109,7 @@ CASES = [
 GENERIC_FAILURE_MARKERS = (
     'codex_invalid_json',
     'codex_no_final_response',
+    'codex_timeout',
     'max_iterations_reached',
     'stage_iteration_limit_reached',
     'unhandled_checkpoint',