@riddledc/riddle-proof 0.8.13 → 0.8.15

package/dist/advanced/engine-harness.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") {
@@ -5150,6 +5220,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,
@@ -5720,6 +5824,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/advanced/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "../chunk-RTLA6CPP.js";
+} from "../chunk-RW4OUHN4.js";
 import "../chunk-YZUVEJ5B.js";
 import "../chunk-FMOYUYH2.js";
 import "../chunk-7GZY5PLT.js";

package/dist/advanced/index.cjs

@@ -1170,6 +1170,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 || "");
 }
@@ -1200,6 +1206,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(
@@ -2226,6 +2271,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));
@@ -2238,40 +2284,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") {
@@ -5687,6 +5757,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,
@@ -6257,6 +6361,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/advanced/index.js

@@ -1,12 +1,12 @@
 import {
   proof_run_engine_exports
-} from "../chunk-JBY2SU5U.js";
+} from "../chunk-WJZYRUNV.js";
 import {
   runner_exports
 } from "../chunk-NGX4SUQN.js";
 import {
   engine_harness_exports
-} from "../chunk-RTLA6CPP.js";
+} from "../chunk-RW4OUHN4.js";
 import "../chunk-YZUVEJ5B.js";
 import "../chunk-FMOYUYH2.js";
 import {

package/dist/advanced/proof-run-engine.cjs

@@ -1138,6 +1138,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 || "");
 }
@@ -1168,6 +1174,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") {

package/dist/advanced/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/dist/{chunk-SZUC4MDN.js → chunk-KTIDPXE2.js}

@@ -22,7 +22,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-RTLA6CPP.js";
+} from "./chunk-RW4OUHN4.js";
 import {
   createCheckpointResponseTemplate
 } from "./chunk-4FOHZ7JG.js";