@riddledc/riddle-proof 0.7.0 → 0.7.2

package/dist/index.cjs

@@ -31,6 +31,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/proof-run-core.ts
+function normalizedMode(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function previewModeFromWorkflowMode(value) {
+  const mode = normalizedMode(value);
+  return mode === "server" || mode === "static" ? mode : void 0;
+}
+function noImplementationModeInput(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function noImplementationModeFor(params, state) {
+  const input = noImplementationModeInput(params);
+  const stateInput = noImplementationModeInput(state);
+  const mode = normalizedMode(input.mode ?? input.workflow_mode ?? stateInput.mode ?? stateInput.workflow_mode);
+  const implementationMode = normalizedMode(input.implementation_mode ?? stateInput.implementation_mode);
+  const requireDiff = input.require_diff ?? stateInput.require_diff;
+  const allowCodeChanges = input.allow_code_changes ?? stateInput.allow_code_changes;
+  return mode === "audit" || mode === "profile" || implementationMode === "none" || requireDiff === false || allowCodeChanges === false;
+}
 function currentDistDir() {
   const meta = typeof import_meta === "object" ? import_meta : {};
   if (typeof meta.url === "string" && meta.url) {
@@ -114,7 +133,7 @@ function buildSetupArgs(params, config) {
     allow_static_preview_fallback: params.allow_static_preview_fallback ? "true" : "",
     context: params.context || "",
     reviewer: params.reviewer || config.defaultReviewer,
-    mode: params.mode || "",
+    mode: previewModeFromWorkflowMode(params.mode) || "",
     build_command: params.build_command || "npm run build",
     build_output: params.build_output || "build",
     server_image: params.server_image || "node:20-slim",
@@ -539,7 +558,8 @@ function mergeStateFromParams(statePath, params) {
     "auth_cookies_json",
     "auth_headers_json",
     "proof_plan",
-    "implementation_notes"
+    "implementation_notes",
+    "implementation_mode"
   ];
   for (const field of stringFields) {
     if (params[field] !== void 0) {
@@ -554,7 +574,17 @@ function mergeStateFromParams(statePath, params) {
     if (issues.length) state.implementation_environment_issues = issues;
   }
   if (params.reference !== void 0) state.reference = params.reference;
-  if (params.mode !== void 0) state.mode = params.mode;
+  if (params.mode !== void 0) {
+    const previewMode = previewModeFromWorkflowMode(params.mode);
+    if (previewMode) {
+      state.mode = previewMode;
+    } else {
+      state.workflow_mode = normalizeOptionalString(params.mode);
+    }
+  }
+  if (params.implementation_mode !== void 0) state.implementation_mode = normalizeOptionalString(params.implementation_mode);
+  if (params.require_diff !== void 0) state.require_diff = params.require_diff;
+  if (params.allow_code_changes !== void 0) state.allow_code_changes = params.allow_code_changes;
   if (params.allow_static_preview_fallback !== void 0) {
     state.allow_static_preview_fallback = params.allow_static_preview_fallback;
   }
@@ -699,6 +729,11 @@ function summarizeState(state) {
     repo: state.repo || null,
     branch: state.branch || null,
     mode: state.mode || null,
+    workflow_mode: state.workflow_mode || null,
+    implementation_mode: state.implementation_mode || null,
+    require_diff: state.require_diff ?? null,
+    allow_code_changes: state.allow_code_changes ?? null,
+    no_implementation_mode: noImplementationModeFor(state),
     reference: state.reference || null,
     before_ref: state.before_ref || null,
     allow_static_preview_fallback: Boolean(state.allow_static_preview_fallback),
@@ -997,8 +1032,11 @@ function authorReady(state) {
 function implementationReady(state) {
   return ["changes_detected", "completed"].includes(state?.implementation_status || "");
 }
-function stageAfterAuthor(state) {
-  return implementationReady(state) ? "verify" : "implement";
+function implementationRequired(params, state) {
+  return !noImplementationModeFor(params, state);
+}
+function stageAfterAuthor(state, params) {
+  return implementationReady(state) || !implementationRequired(params, state) ? "verify" : "implement";
 }
 function latestReconAttempt(state) {
   const history = Array.isArray(state?.recon_results?.attempt_history) ? state.recon_results.attempt_history : [];
@@ -1208,7 +1246,7 @@ function recommendedAdvanceStage(state) {
   if (!state?.workspace_ready) return "setup";
   if (!state?.recon_results || ["needs_agent_decision", "needs_supervisor_judgment"].includes(state?.recon_status || "")) return "recon";
   if (!authorReady(state)) return "author";
-  if (!implementationReady(state)) return "implement";
+  if (!implementationReady(state) && !noImplementationModeFor(state)) return "implement";
   if (state?.verify_status === "capture_incomplete") return verifyAssessment(state).continueWithStage || verifyAssessment(state).recommendedStage || "author";
   if (state?.verify_status === "evidence_captured") return verifyAssessment(state).continueWithStage || verifyAssessment(state).recommendedStage;
   if (!(state?.after_cdn || "").trim()) return "verify";
@@ -1833,6 +1871,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         checkpoint: params.advance_stage === "setup" ? "setup_review" : null,
         autoApproved: setupRes.autoApproved || false
       });
+      mergeStateFromParams(config.statePath, params);
       state = readState(config.statePath);
       if (params.advance_stage === "setup") {
         return checkpoint(
@@ -2130,7 +2169,8 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
           }
         );
       }
-      const authorNextStage = stageAfterAuthor(state);
+      const noImplementationMode = !implementationRequired(params, state);
+      const authorNextStage = stageAfterAuthor(state, params);
       const explicitAuthorDebug = params.advance_stage === "author";
       recordAttempt("author", "completed", "Author applied the supervising agent's proof packet to recon observations.", {
         autoApproved: authorRes.autoApproved || false,
@@ -2148,7 +2188,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         return checkpoint(
           "author",
           "author_review",
-          authorNextStage === "verify" ? "Author applied the supervising agent's proof packet. Because implementation is already recorded, you can continue straight into verify." : "Author applied the supervising agent's proof packet. Inspect it if needed, then continue into implement.",
+          authorNextStage === "verify" ? noImplementationMode ? "Author applied the supervising agent's proof packet. Audit/no-diff mode disables implementation, so you can continue straight into verify." : "Author applied the supervising agent's proof packet. Because implementation is already recorded, you can continue straight into verify." : "Author applied the supervising agent's proof packet. Inspect it if needed, then continue into implement.",
           {
             nextActions: authorNextStage === "verify" ? ["inspect_proof_packet", "advance_run_to_verify", "rerun_author"] : ["inspect_proof_packet", "advance_run_to_implement", "rerun_author"],
             advanceOptions: authorNextStage === "verify" ? ["author", "verify", "recon"] : ["author", "implement", "recon"],
@@ -2181,13 +2221,14 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     }
     if (!effectiveAdvanceStage) {
       const recommended = recommendedAdvanceStage(state);
+      const noImplementationMode = !implementationRequired(params, state);
       return checkpoint(
-        recommended || "implement",
+        recommended || (noImplementationMode ? "verify" : "implement"),
         "awaiting_stage_advance",
         "Proof authoring is ready. The wrapper will not guess the next stage from here, explicitly choose whether to revisit recon/author, validate implementation, capture verify evidence, or ship.",
         {
           nextActions: ["inspect_state", "set_advance_stage", "resume_run"],
-          advanceOptions: ["recon", "author", "implement", "verify", "ship"],
+          advanceOptions: noImplementationMode ? ["recon", "author", "verify", "ship"] : ["recon", "author", "implement", "verify", "ship"],
           recommendedAdvanceStage: recommended,
           details: { executed },
           executed
@@ -2195,6 +2236,26 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
       );
     }
     if (effectiveAdvanceStage === "implement") {
+      if (!implementationRequired(params, state)) {
+        recordAttempt("implement", "checkpoint", "Implementation stage was skipped because audit/no-diff mode disables code changes.", {
+          checkpoint: "implement_disabled_for_audit",
+          details: { executed }
+        });
+        return checkpoint(
+          "verify",
+          "implement_disabled_for_audit",
+          "Audit/no-diff mode disables implementation. Continue to verify against the existing target; do not launch an implementation agent or require a git diff.",
+          {
+            nextActions: ["advance_run_to_verify", "inspect_author_packet", "rerun_recon_if_target_changed"],
+            advanceOptions: ["verify", "author", "recon"],
+            recommendedAdvanceStage: "verify",
+            continueWithStage: "verify",
+            blocking: false,
+            details: { executed },
+            executed
+          }
+        );
+      }
       const implementRes = runOne("implement");
       executed.push(executedStep(implementRes));
       if (implementRes.haltedForApproval) {
@@ -2285,7 +2346,8 @@ ${implementRes.stderr || ""}`;
     }
     if (effectiveAdvanceStage === "verify") {
       state = readState(config.statePath);
-      if (!["changes_detected", "completed"].includes(state?.implementation_status || "")) {
+      const needsImplementation = implementationRequired(params, state);
+      if (needsImplementation && !implementationReady(state)) {
         return checkpoint(
           "implement",
           "implement_required",
@@ -2302,6 +2364,18 @@ ${implementRes.stderr || ""}`;
           }
         );
       }
+      if (!needsImplementation && !implementationReady(state)) {
+        recordAttempt("implement", "completed", "Implementation stage is not required for this audit/no-diff run.", {
+          checkpoint: "implementation_not_required",
+          details: { executed }
+        });
+        state = updateState(config.statePath, (currentState) => {
+          currentState.implementation_status = "not_required";
+          currentState.implementation_mode = currentState.implementation_mode || "none";
+          if (currentState.require_diff === void 0) currentState.require_diff = false;
+          if (currentState.allow_code_changes === void 0) currentState.allow_code_changes = false;
+        });
+      }
       const hasIncomingProofAssessment = typeof params.proof_assessment_json === "string" && params.proof_assessment_json.trim().length > 0;
       const canReuseVerifyEvidence = (params.advance_stage !== "verify" || hasIncomingProofAssessment) && state?.verify_status === "evidence_captured" && Boolean((state?.after_cdn || "").trim()) && (state?.active_checkpoint === "verify_supervisor_judgment" || hasSupervisorProofAssessment(state));
       let verifyRes = { ok: true, step: "verify", reusedEvidence: canReuseVerifyEvidence };
@@ -2324,8 +2398,13 @@ ${implementRes.stderr || ""}`;
       const verifySummary = state?.verify_summary || state?.proof_summary || null;
       const proofAssessment = verifyAssessment(state);
       const convergenceSignals = nonConvergenceSignals(state, proofAssessment);
-      const verifyRecommendedStage = proofAssessment.recommendedStage || null;
-      const verifyContinueWithStage = shouldEscalateVerifyToHuman(state, proofAssessment) ? null : proofAssessment.continueWithStage || verifyRecommendedStage || null;
+      const rawVerifyRecommendedStage = proofAssessment.recommendedStage || null;
+      const verifyRecommendedStage = !needsImplementation && rawVerifyRecommendedStage === "implement" ? "verify" : rawVerifyRecommendedStage;
+      const rawVerifyContinueWithStage = shouldEscalateVerifyToHuman(state, proofAssessment) ? null : proofAssessment.continueWithStage || verifyRecommendedStage || null;
+      const verifyContinueWithStage = !needsImplementation && rawVerifyContinueWithStage === "implement" ? "verify" : rawVerifyContinueWithStage;
+      const verifyLoopAdvanceOptions = needsImplementation ? ["author", "verify", "implement", "recon"] : ["author", "verify", "recon"];
+      const verifyReviewAdvanceOptions = needsImplementation ? ["verify", "author", "implement", "recon", "ship"] : ["verify", "author", "recon"];
+      const verifyRetryAdvanceOptions = needsImplementation ? ["author", "implement", "ship", "verify", "recon"] : ["author", "verify", "recon"];
       const verifyDetails = {
         executed,
         verifyStatus,
@@ -2363,7 +2442,7 @@ ${implementRes.stderr || ""}`;
           {
             ok: true,
             nextActions: ["inspect_after_capture", "continue_internal_loop_with_checkpoint", "return_to_recon_if_baseline_is_wrong"],
-            advanceOptions: ["author", "verify", "implement", "recon"],
+            advanceOptions: verifyLoopAdvanceOptions,
             recommendedAdvanceStage: verifyRecommendedStage || "author",
             continueWithStage: verifyContinueWithStage || "author",
             blocking: false,
@@ -2391,7 +2470,7 @@ ${implementRes.stderr || ""}`;
           summary,
           {
             nextActions: ["inspect_evidence", "author_proof_assessment_json", "continue_internal_loop_with_checkpoint"],
-            advanceOptions: ["verify", "author", "implement", "recon", "ship"],
+            advanceOptions: verifyReviewAdvanceOptions,
             recommendedAdvanceStage: "verify",
             continueWithStage: "verify",
             blocking: false,
@@ -2421,7 +2500,7 @@ ${implementRes.stderr || ""}`;
           {
             ok: false,
             nextActions: ["inspect_retry_history", "summarize_internal_loop", "ask_human_for_direction"],
-            advanceOptions: ["author", "implement", "ship", "verify", "recon"],
+            advanceOptions: verifyRetryAdvanceOptions,
             recommendedAdvanceStage: null,
             continueWithStage: null,
             blocking: true,
@@ -2436,7 +2515,7 @@ ${implementRes.stderr || ""}`;
           }
         );
       }
-      const shouldAutoShip = verifyContinueWithStage === "ship" && (params.ship_after_verify || params.continue_from_checkpoint || params.advance_stage !== "verify");
+      const shouldAutoShip = verifyContinueWithStage === "ship" && needsImplementation && (params.ship_after_verify || params.continue_from_checkpoint || params.advance_stage !== "verify");
       if (shouldAutoShip) {
         const shipGate = validateShipGate(state);
         if (!shipGate.ok) {
@@ -2494,6 +2573,33 @@ ${implementRes.stderr || ""}`;
         };
       }
       if (proofAssessment.decision === "ready_to_ship") {
+        if (!needsImplementation) {
+          recordAttempt("verify", "completed", "Verify captured a proof packet for audit/no-diff mode; shipping remains disabled.", {
+            autoApproved: verifyRes.autoApproved || false,
+            checkpoint: "verify_audit_complete",
+            details: verifyDetails
+          });
+          return checkpoint(
+            "verify",
+            "verify_audit_complete",
+            "The supervising agent judged the audit proof sufficient. Audit/no-diff mode disables ship, PR creation, implementation agents, and git-diff requirements.",
+            {
+              nextActions: ["inspect_evidence", "report_audit_result", "rerun_verify_if_needed"],
+              advanceOptions: ["verify", "author", "recon"],
+              recommendedAdvanceStage: "verify",
+              continueWithStage: null,
+              blocking: false,
+              details: verifyDetails,
+              verifyStatus,
+              verifySummary,
+              afterCdn: state?.after_cdn || null,
+              mergeRecommendation: state?.merge_recommendation || null,
+              verifyDecisionRequest,
+              proofAssessment: proofAssessment.raw,
+              executed
+            }
+          );
+        }
         const shipGate = validateShipGate(state);
         if (!shipGate.ok) {
           recordAttempt("verify", "checkpoint", "Verify cannot mark ship ready because the hard ship gate is missing required evidence or approval.", {
@@ -2550,8 +2656,8 @@ ${implementRes.stderr || ""}`;
         unresolvedSummary,
         {
           ok: true,
-          nextActions: convergenceSignals.warning ? ["inspect_retry_history", "decide_whether_to_keep_iterating_or_escalate", "continue_internal_loop_with_checkpoint"] : ["inspect_proof_assessment", "continue_internal_loop_with_checkpoint", "return_to_implement_if_fix_failed"],
-          advanceOptions: ["author", "implement", "ship", "verify", "recon"],
+          nextActions: convergenceSignals.warning ? ["inspect_retry_history", "decide_whether_to_keep_iterating_or_escalate", "continue_internal_loop_with_checkpoint"] : needsImplementation ? ["inspect_proof_assessment", "continue_internal_loop_with_checkpoint", "return_to_implement_if_fix_failed"] : ["inspect_proof_assessment", "continue_internal_loop_with_checkpoint", "rerun_author_if_proof_contract_is_wrong"],
+          advanceOptions: verifyRetryAdvanceOptions,
           recommendedAdvanceStage: verifyRecommendedStage,
           continueWithStage: verifyContinueWithStage,
           blocking: false,
@@ -2568,6 +2674,23 @@ ${implementRes.stderr || ""}`;
     }
     if (effectiveAdvanceStage === "ship") {
       state = readState(config.statePath);
+      if (!implementationRequired(params, state)) {
+        return checkpoint(
+          "verify",
+          "ship_disabled_for_audit",
+          "Audit/no-diff mode disables ship and PR creation. Report the audit result from verify evidence instead.",
+          {
+            ok: false,
+            nextActions: ["inspect_verify_state", "report_audit_result"],
+            advanceOptions: ["verify", "author", "recon"],
+            recommendedAdvanceStage: "verify",
+            continueWithStage: "verify",
+            blocking: true,
+            details: { executed },
+            executed
+          }
+        );
+      }
       const shipAssessment = verifyAssessment(state);
       const shipGate = validateShipGate(state);
       if (state?.verify_status !== "evidence_captured") {
@@ -4104,6 +4227,9 @@ function normalizeRunParams(input) {
     context: input.context,
     reviewer: input.reviewer,
     mode: input.mode,
+    implementation_mode: input.implementation_mode,
+    require_diff: input.require_diff,
+    allow_code_changes: input.allow_code_changes,
     build_command: input.build_command,
     build_output: input.build_output,
     server_image: input.server_image,
@@ -4255,6 +4381,7 @@ function applyPrLifecycleState(state, input, at = timestamp2()) {
 }
 
 // src/runner.ts
+init_proof_run_core();
 function errorDetails(error) {
   if (error instanceof Error) {
     return {
@@ -4454,6 +4581,7 @@ async function runRiddleProof(input) {
     }
   }
   const changeRequest = state.request.change_request?.trim();
+  const noImplementationMode = noImplementationModeFor(state.request);
   if (!changeRequest) {
     return blockRun({
       state,
@@ -4461,14 +4589,14 @@ async function runRiddleProof(input) {
       blocker: adapterBlocker("change_request_required", "A change request is required before implementation.", "request_invalid")
     });
   }
-  if (!workdir) {
+  if (!noImplementationMode && !workdir) {
     return blockRun({
       state,
       stage: "setup",
       blocker: adapterBlocker("workdir_not_configured", "A workdir or setup adapter result is required before implementation.", "setup_required")
     });
   }
-  if (!adapters.implementation) {
+  if (!noImplementationMode && !adapters.implementation) {
     return blockRun({
       state,
       stage: "implement",
@@ -4494,57 +4622,68 @@ async function runRiddleProof(input) {
   let assessment;
   for (let attempt = 0; attempt < maxIterations; attempt += 1) {
     state.iterations += 1;
-    appendStageHeartbeat(state, {
-      stage: "implement",
-      summary: "Implementation stage is active.",
-      details: { iteration: state.iterations }
-    });
-    appendRunEvent(state, {
-      kind: "implementation.started",
-      checkpoint: "implementation_started",
-      stage: "implement",
-      summary: "Implementation adapter started.",
-      details: { iteration: state.iterations }
-    });
-    try {
-      implementation = await adapters.implementation.implement({
-        workdir,
-        change_request: changeRequest,
-        evidence_context: evidenceContext,
-        state
+    if (noImplementationMode) {
+      state.implementation_status = "not_required";
+      appendRunEvent(state, {
+        kind: "implementation.skipped",
+        checkpoint: "implementation_not_required",
+        stage: "implement",
+        summary: "Implementation stage skipped because audit/no-diff mode disables code changes.",
+        details: { iteration: state.iterations }
       });
-    } catch (error) {
-      return blockRun({
-        state,
+    } else {
+      appendStageHeartbeat(state, {
         stage: "implement",
-        blocker: adapterBlocker("implementation_exception", "The implementation adapter threw an exception.", "implementation_failed", errorDetails(error)),
-        evidence_bundle: evidenceBundle
+        summary: "Implementation stage is active.",
+        details: { iteration: state.iterations }
       });
-    }
-    if (!implementation.ok) {
-      return blockRun({
-        state,
+      appendRunEvent(state, {
+        kind: "implementation.started",
+        checkpoint: "implementation_started",
         stage: "implement",
-        blocker: adapterBlocker(
-          "implementation_failed",
-          "The implementation adapter did not complete successfully.",
-          "implementation_failed",
-          { blockers: implementation.blockers }
-        ),
-        evidence_bundle: evidenceBundle,
-        raw: { implementation }
+        summary: "Implementation adapter started.",
+        details: { iteration: state.iterations }
       });
-    }
-    appendRunEvent(state, {
-      kind: "implementation.completed",
-      checkpoint: "implementation_completed",
-      stage: "implement",
-      summary: "Implementation adapter completed.",
-      details: {
-        changed_files: implementation.changed_files,
-        tests_run: implementation.tests_run
+      try {
+        implementation = await adapters.implementation.implement({
+          workdir,
+          change_request: changeRequest,
+          evidence_context: evidenceContext,
+          state
+        });
+      } catch (error) {
+        return blockRun({
+          state,
+          stage: "implement",
+          blocker: adapterBlocker("implementation_exception", "The implementation adapter threw an exception.", "implementation_failed", errorDetails(error)),
+          evidence_bundle: evidenceBundle
+        });
       }
-    });
+      if (!implementation.ok) {
+        return blockRun({
+          state,
+          stage: "implement",
+          blocker: adapterBlocker(
+            "implementation_failed",
+            "The implementation adapter did not complete successfully.",
+            "implementation_failed",
+            { blockers: implementation.blockers }
+          ),
+          evidence_bundle: evidenceBundle,
+          raw: { implementation }
+        });
+      }
+      appendRunEvent(state, {
+        kind: "implementation.completed",
+        checkpoint: "implementation_completed",
+        stage: "implement",
+        summary: "Implementation adapter completed.",
+        details: {
+          changed_files: implementation.changed_files,
+          tests_run: implementation.tests_run
+        }
+      });
+    }
     appendStageHeartbeat(state, {
       stage: "prove",
       summary: "Proof capture stage is active.",
@@ -4920,7 +5059,7 @@ function stageFromWorkflowParams(params) {
   if (params.ship_after_verify) return "ship";
   if (params.proof_assessment_json) return "verify";
   if (params.implementation_notes) return "verify";
-  if (params.author_packet_json) return "implement";
+  if (params.author_packet_json) return noImplementationModeFor(params) ? "verify" : "implement";
   if (params.recon_assessment_json) return "author";
   return "setup";
 }
@@ -4950,6 +5089,9 @@ function initialRunParams(request, input, state) {
     context: request.context,
     reviewer: request.reviewer,
     mode: request.mode,
+    implementation_mode: request.implementation_mode,
+    require_diff: request.require_diff,
+    allow_code_changes: request.allow_code_changes,
     build_command: request.build_command,
     build_output: request.build_output,
     server_image: request.server_image,

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   runRiddleProof
-} from "./chunk-RXFKKYWA.js";
+} from "./chunk-HIKFPDRO.js";
 import "./chunk-6F4PWJZI.js";
 import {
   RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION,
@@ -84,7 +84,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-D3M2FAYQ.js";
+} from "./chunk-N5BVCRKI.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
@@ -96,12 +96,12 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-MO24D3PY.js";
+} from "./chunk-4DM3OTWH.js";
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
 } from "./chunk-3UHWI3FO.js";
-import "./chunk-RFJ5BQF6.js";
+import "./chunk-FPD2RF3Q.js";
 import {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,

package/dist/openclaw.cjs

@@ -77,6 +77,9 @@ function normalizeRunParams(input) {
     context: input.context,
     reviewer: input.reviewer,
     mode: input.mode,
+    implementation_mode: input.implementation_mode,
+    require_diff: input.require_diff,
+    allow_code_changes: input.allow_code_changes,
     build_command: input.build_command,
     build_output: input.build_output,
     server_image: input.server_image,
@@ -176,6 +179,9 @@ function toRiddleProofRunParams(params) {
     context: params.context,
     reviewer: params.reviewer,
     mode: params.mode,
+    implementation_mode: params.implementation_mode,
+    require_diff: params.require_diff,
+    allow_code_changes: params.allow_code_changes,
     build_command: params.build_command,
     build_output: params.build_output,
     server_image: params.server_image,

package/dist/openclaw.d.cts

@@ -22,6 +22,9 @@ interface OpenClawProofedChangeParams {
     context?: string;
     reviewer?: string;
     mode?: string;
+    implementation_mode?: "change" | "none" | (string & {});
+    require_diff?: boolean;
+    allow_code_changes?: boolean;
     build_command?: string;
     build_output?: string;
     server_image?: string;

package/dist/openclaw.d.ts

@@ -22,6 +22,9 @@ interface OpenClawProofedChangeParams {
     context?: string;
     reviewer?: string;
     mode?: string;
+    implementation_mode?: "change" | "none" | (string & {});
+    require_diff?: boolean;
+    allow_code_changes?: boolean;
     build_command?: string;
     build_output?: string;
     server_image?: string;

package/dist/openclaw.js

@@ -1,7 +1,7 @@
 import {
   normalizeIntegrationContext,
   normalizeRunParams
-} from "./chunk-MO24D3PY.js";
+} from "./chunk-4DM3OTWH.js";
 import "./chunk-3UHWI3FO.js";
 import "./chunk-33XO42CY.js";
 import {
@@ -83,6 +83,9 @@ function toRiddleProofRunParams(params) {
     context: params.context,
     reviewer: params.reviewer,
     mode: params.mode,
+    implementation_mode: params.implementation_mode,
+    require_diff: params.require_diff,
+    allow_code_changes: params.allow_code_changes,
     build_command: params.build_command,
     build_output: params.build_output,
     server_image: params.server_image,