@riddledc/riddle-proof 0.8.13 → 0.8.14

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") {

package/dist/advanced/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "../chunk-RTLA6CPP.js";
+} from "../chunk-YFRPFV4U.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") {

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-YFRPFV4U.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-EGZT3EVL.js}

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