@riddledc/riddle-proof 0.7.224 → 0.7.226

package/dist/checkpoint.cjs

@@ -463,6 +463,24 @@ function visualDeltaFromState(fullState) {
   const proofAssessmentRequest = recordValue(fullState.proof_assessment_request);
   return recordValue(proofAssessmentRequest?.visual_delta) || null;
 }
+function normalizedText(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function noImplementationModeForCheckpoint(request, fullState) {
+  const requestRecord = recordValue(request) || {};
+  const mode = normalizedText(
+    requestRecord.mode || requestRecord.workflow_mode || fullState.mode || fullState.workflow_mode
+  );
+  const implementationMode = normalizedText(requestRecord.implementation_mode || fullState.implementation_mode);
+  const requireDiff = requestRecord.require_diff ?? fullState.require_diff;
+  const allowCodeChanges = requestRecord.allow_code_changes ?? fullState.allow_code_changes;
+  return mode === "audit" || mode === "profile" || implementationMode === "none" || requireDiff === false || allowCodeChanges === false;
+}
+function visualDeltaNotApplicableForNoImplementation(visualDelta) {
+  if (String(visualDelta?.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta?.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function verificationModeRequiresVisualDelta(value) {
   const mode = String(value || "proof").trim().toLowerCase();
   return [
@@ -500,7 +518,9 @@ function buildProofAssessmentCheckpointPacket(input) {
   const requiredSignals = recordValue(recordValue(artifactContract)?.required);
   const visualDelta = visualDeltaFromState(fullState);
   const verificationMode = nonEmptyString(bundle?.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(input.request.verification_mode) || "proof";
-  const visualDeltaRequired = requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
+  const noImplementationMode = noImplementationModeForCheckpoint(input.request, fullState);
+  const noImplementationVisualDelta = visualDeltaNotApplicableForNoImplementation(visualDelta);
+  const visualDeltaRequired = !noImplementationMode && !noImplementationVisualDelta && requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
   const evidenceIssueCode = visualDeltaIssueCode(visualDelta, visualDeltaRequired);
   const summary = nonEmptyString(input.engineResult.summary) || nonEmptyString(fullState.verify_summary) || "Verify captured evidence and needs a supervising proof assessment.";
   const recoveryHint = evidenceIssueCode ? "Required visual_delta evidence is incomplete. Keep this same run in verify/evidence recovery with decision=revise_capture and continue_with_stage=verify unless the evidence proves an implementation or recon problem." : "Assess whether the current artifacts prove the requested change, then choose the next stage.";
@@ -533,7 +553,7 @@ function buildProofAssessmentCheckpointPacket(input) {
       prod_cdn: fullState.prod_cdn || null,
       after_cdn: fullState.after_cdn || null,
       visual_delta_required: visualDeltaRequired,
-      visual_delta_ready: visualDelta?.status === "measured" && visualDelta?.passed === true,
+      visual_delta_ready: !visualDeltaRequired || visualDelta?.status === "measured" && visualDelta?.passed === true,
       visual_delta: jsonCloneRecord(visualDelta),
       evidence_issue_code: evidenceIssueCode,
       proof_assessment_request: jsonCloneRecord(proofAssessmentRequest),

package/dist/checkpoint.js

@@ -13,7 +13,7 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "./chunk-ABQQLRTS.js";
+} from "./chunk-2CFVREFI.js";
 import "./chunk-VY4Y5U57.js";
 export {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,

package/dist/{chunk-ABQQLRTS.js → chunk-2CFVREFI.js}

@@ -409,6 +409,24 @@ function visualDeltaFromState(fullState) {
   const proofAssessmentRequest = recordValue(fullState.proof_assessment_request);
   return recordValue(proofAssessmentRequest?.visual_delta) || null;
 }
+function normalizedText(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function noImplementationModeForCheckpoint(request, fullState) {
+  const requestRecord = recordValue(request) || {};
+  const mode = normalizedText(
+    requestRecord.mode || requestRecord.workflow_mode || fullState.mode || fullState.workflow_mode
+  );
+  const implementationMode = normalizedText(requestRecord.implementation_mode || fullState.implementation_mode);
+  const requireDiff = requestRecord.require_diff ?? fullState.require_diff;
+  const allowCodeChanges = requestRecord.allow_code_changes ?? fullState.allow_code_changes;
+  return mode === "audit" || mode === "profile" || implementationMode === "none" || requireDiff === false || allowCodeChanges === false;
+}
+function visualDeltaNotApplicableForNoImplementation(visualDelta) {
+  if (String(visualDelta?.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta?.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function verificationModeRequiresVisualDelta(value) {
   const mode = String(value || "proof").trim().toLowerCase();
   return [
@@ -446,7 +464,9 @@ function buildProofAssessmentCheckpointPacket(input) {
   const requiredSignals = recordValue(recordValue(artifactContract)?.required);
   const visualDelta = visualDeltaFromState(fullState);
   const verificationMode = nonEmptyString(bundle?.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(input.request.verification_mode) || "proof";
-  const visualDeltaRequired = requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
+  const noImplementationMode = noImplementationModeForCheckpoint(input.request, fullState);
+  const noImplementationVisualDelta = visualDeltaNotApplicableForNoImplementation(visualDelta);
+  const visualDeltaRequired = !noImplementationMode && !noImplementationVisualDelta && requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
   const evidenceIssueCode = visualDeltaIssueCode(visualDelta, visualDeltaRequired);
   const summary = nonEmptyString(input.engineResult.summary) || nonEmptyString(fullState.verify_summary) || "Verify captured evidence and needs a supervising proof assessment.";
   const recoveryHint = evidenceIssueCode ? "Required visual_delta evidence is incomplete. Keep this same run in verify/evidence recovery with decision=revise_capture and continue_with_stage=verify unless the evidence proves an implementation or recon problem." : "Assess whether the current artifacts prove the requested change, then choose the next stage.";
@@ -479,7 +499,7 @@ function buildProofAssessmentCheckpointPacket(input) {
       prod_cdn: fullState.prod_cdn || null,
       after_cdn: fullState.after_cdn || null,
       visual_delta_required: visualDeltaRequired,
-      visual_delta_ready: visualDelta?.status === "measured" && visualDelta?.passed === true,
+      visual_delta_ready: !visualDeltaRequired || visualDelta?.status === "measured" && visualDelta?.passed === true,
       visual_delta: jsonCloneRecord(visualDelta),
       evidence_issue_code: evidenceIssueCode,
       proof_assessment_request: jsonCloneRecord(proofAssessmentRequest),

package/dist/{chunk-WWYZBWKZ.js → chunk-GBVEQQIM.js}

@@ -377,6 +377,7 @@ function normalizedVerificationMode(state = {}) {
   return String(state?.verification_mode || "proof").trim().toLowerCase() || "proof";
 }
 function visualDeltaRequiredForState(state = {}) {
+  if (noImplementationModeFor(state) || visualDeltaNotApplicableForNoImplementation(state)) return false;
   const bundle = objectValue(state?.evidence_bundle);
   const contract = objectValue(bundle.artifact_contract);
   const required = objectValue(contract.required);
@@ -391,6 +392,12 @@ function visualDeltaForState(state = {}) {
   const request = objectValue(state?.proof_assessment_request);
   return objectValue(request.visual_delta);
 }
+function visualDeltaNotApplicableForNoImplementation(state = {}) {
+  const visualDelta = visualDeltaForState(state);
+  if (String(visualDelta.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function visualDeltaShipGateReason(state = {}) {
   if (!visualDeltaRequiredForState(state)) return null;
   const visualDelta = visualDeltaForState(state);

package/dist/{chunk-UYB7ABWU.js → chunk-OHJQRDST.js}

@@ -1,6 +1,6 @@
 import {
   createRiddleProofRunCard
-} from "./chunk-ZHEFYLII.js";
+} from "./chunk-Y2KTBACQ.js";
 import {
   compactRecord,
   isTerminalStatus,

package/dist/{chunk-VJLHXZAA.js → chunk-QUAZAMOM.js}

@@ -5,16 +5,16 @@ import {
   createRunStatusSnapshot,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-UYB7ABWU.js";
+} from "./chunk-OHJQRDST.js";
 import {
   createRiddleProofRunCard
-} from "./chunk-ZHEFYLII.js";
+} from "./chunk-Y2KTBACQ.js";
 import {
   noImplementationModeFor,
   visualDeltaForState,
   visualDeltaRequiredForState,
   visualDeltaShipGateReason
-} from "./chunk-WWYZBWKZ.js";
+} from "./chunk-GBVEQQIM.js";
 import {
   authorPacketPayloadFromCheckpointResponse,
   buildCheckpointPacketForEngineResult,
@@ -24,7 +24,7 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "./chunk-ABQQLRTS.js";
+} from "./chunk-2CFVREFI.js";
 import {
   applyTerminalMetadata,
   compactRecord,
@@ -235,6 +235,16 @@ function baseContinuation(result) {
     continue_from_checkpoint: true
   };
 }
+function carryRequestControlFlags(params, request) {
+  if (!noImplementationModeFor(request)) return params;
+  return compactRecord({
+    ...params,
+    mode: request.mode,
+    implementation_mode: request.implementation_mode || "none",
+    require_diff: request.require_diff ?? false,
+    allow_code_changes: request.allow_code_changes ?? false
+  });
+}
 function initialRunParams(request, input, state) {
   return compactRecord({
     action: "run",
@@ -1389,7 +1399,10 @@ async function runRiddleProofEngineHarness(input) {
       message
     });
   }
-  let nextParams = input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state);
+  let nextParams = carryRequestControlFlags(
+    input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state),
+    request
+  );
   let lastResult = null;
   const stageIterations = {};
   for (let index = 0; index < maxIterations; index += 1) {
@@ -1502,7 +1515,7 @@ async function runRiddleProofEngineHarness(input) {
         message: "The harness route returned no next step."
       });
     }
-    nextParams = routed.next;
+    nextParams = carryRequestControlFlags(routed.next, request);
   }
   return blockerResult(state, lastResult, {
     code: "max_iterations_reached",

package/dist/{chunk-MA6ZR5XY.js → chunk-TGHTM66Z.js}

@@ -3,10 +3,10 @@ import {
   appendStageHeartbeat,
   createRunState,
   setRunStatus
-} from "./chunk-UYB7ABWU.js";
+} from "./chunk-OHJQRDST.js";
 import {
   noImplementationModeFor
-} from "./chunk-WWYZBWKZ.js";
+} from "./chunk-GBVEQQIM.js";
 import {
   createRunResult
 } from "./chunk-VY4Y5U57.js";

package/dist/{chunk-ZHEFYLII.js → chunk-Y2KTBACQ.js}

@@ -1,6 +1,6 @@
 import {
   statePathsForRunState
-} from "./chunk-ABQQLRTS.js";
+} from "./chunk-2CFVREFI.js";
 import {
   compactRecord,
   isTerminalStatus,

package/dist/cli.cjs

@@ -385,6 +385,7 @@ function normalizedVerificationMode(state = {}) {
   return String(state?.verification_mode || "proof").trim().toLowerCase() || "proof";
 }
 function visualDeltaRequiredForState(state = {}) {
+  if (noImplementationModeFor(state) || visualDeltaNotApplicableForNoImplementation2(state)) return false;
   const bundle = objectValue(state?.evidence_bundle);
   const contract = objectValue(bundle.artifact_contract);
   const required = objectValue(contract.required);
@@ -399,6 +400,12 @@ function visualDeltaForState(state = {}) {
   const request = objectValue(state?.proof_assessment_request);
   return objectValue(request.visual_delta);
 }
+function visualDeltaNotApplicableForNoImplementation2(state = {}) {
+  const visualDelta = visualDeltaForState(state);
+  if (String(visualDelta.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function visualDeltaShipGateReason(state = {}) {
   if (!visualDeltaRequiredForState(state)) return null;
   const visualDelta = visualDeltaForState(state);
@@ -1654,6 +1661,10 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     const timer = beginRuntimeStep(config.statePath, action, step, stepWorkflowFile);
     let output;
     try {
+      if (step === "setup") {
+        (0, import_node_fs2.mkdirSync)(import_node_path2.default.dirname(config.argsPath), { recursive: true });
+        (0, import_node_fs2.writeFileSync)(config.argsPath, JSON.stringify(args, null, 2));
+      }
       output = JSON.parse(
         (0, import_node_child_process.execFileSync)(lobsterCommand, [...lobsterPrefix, "run", "--file", stepWorkflowFile, "--args-json", JSON.stringify(args)], {
           encoding: "utf-8",
@@ -3530,6 +3541,24 @@ function visualDeltaFromState(fullState) {
   const proofAssessmentRequest = recordValue(fullState.proof_assessment_request);
   return recordValue(proofAssessmentRequest?.visual_delta) || null;
 }
+function normalizedText(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function noImplementationModeForCheckpoint(request, fullState) {
+  const requestRecord = recordValue(request) || {};
+  const mode = normalizedText(
+    requestRecord.mode || requestRecord.workflow_mode || fullState.mode || fullState.workflow_mode
+  );
+  const implementationMode = normalizedText(requestRecord.implementation_mode || fullState.implementation_mode);
+  const requireDiff = requestRecord.require_diff ?? fullState.require_diff;
+  const allowCodeChanges = requestRecord.allow_code_changes ?? fullState.allow_code_changes;
+  return mode === "audit" || mode === "profile" || implementationMode === "none" || requireDiff === false || allowCodeChanges === false;
+}
+function visualDeltaNotApplicableForNoImplementation(visualDelta) {
+  if (String(visualDelta?.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta?.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function verificationModeRequiresVisualDelta(value) {
   const mode = String(value || "proof").trim().toLowerCase();
   return [
@@ -3567,7 +3596,9 @@ function buildProofAssessmentCheckpointPacket(input) {
   const requiredSignals = recordValue(recordValue(artifactContract)?.required);
   const visualDelta = visualDeltaFromState(fullState);
   const verificationMode = nonEmptyString(bundle?.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(input.request.verification_mode) || "proof";
-  const visualDeltaRequired = requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
+  const noImplementationMode = noImplementationModeForCheckpoint(input.request, fullState);
+  const noImplementationVisualDelta = visualDeltaNotApplicableForNoImplementation(visualDelta);
+  const visualDeltaRequired = !noImplementationMode && !noImplementationVisualDelta && requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
   const evidenceIssueCode2 = visualDeltaIssueCode(visualDelta, visualDeltaRequired);
   const summary = nonEmptyString(input.engineResult.summary) || nonEmptyString(fullState.verify_summary) || "Verify captured evidence and needs a supervising proof assessment.";
   const recoveryHint = evidenceIssueCode2 ? "Required visual_delta evidence is incomplete. Keep this same run in verify/evidence recovery with decision=revise_capture and continue_with_stage=verify unless the evidence proves an implementation or recon problem." : "Assess whether the current artifacts prove the requested change, then choose the next stage.";
@@ -3600,7 +3631,7 @@ function buildProofAssessmentCheckpointPacket(input) {
       prod_cdn: fullState.prod_cdn || null,
       after_cdn: fullState.after_cdn || null,
       visual_delta_required: visualDeltaRequired,
-      visual_delta_ready: visualDelta?.status === "measured" && visualDelta?.passed === true,
+      visual_delta_ready: !visualDeltaRequired || visualDelta?.status === "measured" && visualDelta?.passed === true,
       visual_delta: jsonCloneRecord(visualDelta),
       evidence_issue_code: evidenceIssueCode2,
       proof_assessment_request: jsonCloneRecord(proofAssessmentRequest),
@@ -4438,6 +4469,16 @@ function baseContinuation(result) {
     continue_from_checkpoint: true
   };
 }
+function carryRequestControlFlags(params, request) {
+  if (!noImplementationModeFor(request)) return params;
+  return compactRecord({
+    ...params,
+    mode: request.mode,
+    implementation_mode: request.implementation_mode || "none",
+    require_diff: request.require_diff ?? false,
+    allow_code_changes: request.allow_code_changes ?? false
+  });
+}
 function initialRunParams(request, input, state) {
   return compactRecord({
     action: "run",
@@ -5592,7 +5633,10 @@ async function runRiddleProofEngineHarness(input) {
       message
     });
   }
-  let nextParams = input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state);
+  let nextParams = carryRequestControlFlags(
+    input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state),
+    request
+  );
   let lastResult = null;
   const stageIterations = {};
   for (let index = 0; index < maxIterations; index += 1) {
@@ -5705,7 +5749,7 @@ async function runRiddleProofEngineHarness(input) {
         message: "The harness route returned no next step."
       });
     }
-    nextParams = routed.next;
+    nextParams = carryRequestControlFlags(routed.next, request);
   }
   return blockerResult(state, lastResult, {
     code: "max_iterations_reached",

package/dist/cli.js

@@ -23,13 +23,13 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-VJLHXZAA.js";
-import "./chunk-UYB7ABWU.js";
-import "./chunk-ZHEFYLII.js";
-import "./chunk-WWYZBWKZ.js";
+} from "./chunk-QUAZAMOM.js";
+import "./chunk-OHJQRDST.js";
+import "./chunk-Y2KTBACQ.js";
+import "./chunk-GBVEQQIM.js";
 import {
   createCheckpointResponseTemplate
-} from "./chunk-ABQQLRTS.js";
+} from "./chunk-2CFVREFI.js";
 import "./chunk-JFQXAJH2.js";
 import {
   createCodexExecAgentAdapter,

package/dist/engine-harness.cjs

@@ -385,6 +385,7 @@ function normalizedVerificationMode(state = {}) {
   return String(state?.verification_mode || "proof").trim().toLowerCase() || "proof";
 }
 function visualDeltaRequiredForState(state = {}) {
+  if (noImplementationModeFor(state) || visualDeltaNotApplicableForNoImplementation2(state)) return false;
   const bundle = objectValue(state?.evidence_bundle);
   const contract = objectValue(bundle.artifact_contract);
   const required = objectValue(contract.required);
@@ -399,6 +400,12 @@ function visualDeltaForState(state = {}) {
   const request = objectValue(state?.proof_assessment_request);
   return objectValue(request.visual_delta);
 }
+function visualDeltaNotApplicableForNoImplementation2(state = {}) {
+  const visualDelta = visualDeltaForState(state);
+  if (String(visualDelta.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function visualDeltaShipGateReason(state = {}) {
   if (!visualDeltaRequiredForState(state)) return null;
   const visualDelta = visualDeltaForState(state);
@@ -1654,6 +1661,10 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     const timer = beginRuntimeStep(config.statePath, action, step, stepWorkflowFile);
     let output;
     try {
+      if (step === "setup") {
+        (0, import_node_fs2.mkdirSync)(import_node_path2.default.dirname(config.argsPath), { recursive: true });
+        (0, import_node_fs2.writeFileSync)(config.argsPath, JSON.stringify(args, null, 2));
+      }
       output = JSON.parse(
         (0, import_node_child_process.execFileSync)(lobsterCommand, [...lobsterPrefix, "run", "--file", stepWorkflowFile, "--args-json", JSON.stringify(args)], {
           encoding: "utf-8",
@@ -3533,6 +3544,24 @@ function visualDeltaFromState(fullState) {
   const proofAssessmentRequest = recordValue(fullState.proof_assessment_request);
   return recordValue(proofAssessmentRequest?.visual_delta) || null;
 }
+function normalizedText(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function noImplementationModeForCheckpoint(request, fullState) {
+  const requestRecord = recordValue(request) || {};
+  const mode = normalizedText(
+    requestRecord.mode || requestRecord.workflow_mode || fullState.mode || fullState.workflow_mode
+  );
+  const implementationMode = normalizedText(requestRecord.implementation_mode || fullState.implementation_mode);
+  const requireDiff = requestRecord.require_diff ?? fullState.require_diff;
+  const allowCodeChanges = requestRecord.allow_code_changes ?? fullState.allow_code_changes;
+  return mode === "audit" || mode === "profile" || implementationMode === "none" || requireDiff === false || allowCodeChanges === false;
+}
+function visualDeltaNotApplicableForNoImplementation(visualDelta) {
+  if (String(visualDelta?.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta?.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function verificationModeRequiresVisualDelta(value) {
   const mode = String(value || "proof").trim().toLowerCase();
   return [
@@ -3570,7 +3599,9 @@ function buildProofAssessmentCheckpointPacket(input) {
   const requiredSignals = recordValue(recordValue(artifactContract)?.required);
   const visualDelta = visualDeltaFromState(fullState);
   const verificationMode = nonEmptyString(bundle?.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(input.request.verification_mode) || "proof";
-  const visualDeltaRequired = requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
+  const noImplementationMode = noImplementationModeForCheckpoint(input.request, fullState);
+  const noImplementationVisualDelta = visualDeltaNotApplicableForNoImplementation(visualDelta);
+  const visualDeltaRequired = !noImplementationMode && !noImplementationVisualDelta && requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
   const evidenceIssueCode2 = visualDeltaIssueCode(visualDelta, visualDeltaRequired);
   const summary = nonEmptyString(input.engineResult.summary) || nonEmptyString(fullState.verify_summary) || "Verify captured evidence and needs a supervising proof assessment.";
   const recoveryHint = evidenceIssueCode2 ? "Required visual_delta evidence is incomplete. Keep this same run in verify/evidence recovery with decision=revise_capture and continue_with_stage=verify unless the evidence proves an implementation or recon problem." : "Assess whether the current artifacts prove the requested change, then choose the next stage.";
@@ -3603,7 +3634,7 @@ function buildProofAssessmentCheckpointPacket(input) {
       prod_cdn: fullState.prod_cdn || null,
       after_cdn: fullState.after_cdn || null,
       visual_delta_required: visualDeltaRequired,
-      visual_delta_ready: visualDelta?.status === "measured" && visualDelta?.passed === true,
+      visual_delta_ready: !visualDeltaRequired || visualDelta?.status === "measured" && visualDelta?.passed === true,
       visual_delta: jsonCloneRecord(visualDelta),
       evidence_issue_code: evidenceIssueCode2,
       proof_assessment_request: jsonCloneRecord(proofAssessmentRequest),
@@ -4367,6 +4398,16 @@ function baseContinuation(result) {
     continue_from_checkpoint: true
   };
 }
+function carryRequestControlFlags(params, request) {
+  if (!noImplementationModeFor(request)) return params;
+  return compactRecord({
+    ...params,
+    mode: request.mode,
+    implementation_mode: request.implementation_mode || "none",
+    require_diff: request.require_diff ?? false,
+    allow_code_changes: request.allow_code_changes ?? false
+  });
+}
 function initialRunParams(request, input, state) {
   return compactRecord({
     action: "run",
@@ -5521,7 +5562,10 @@ async function runRiddleProofEngineHarness(input) {
       message
     });
   }
-  let nextParams = input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state);
+  let nextParams = carryRequestControlFlags(
+    input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state),
+    request
+  );
   let lastResult = null;
   const stageIterations = {};
   for (let index = 0; index < maxIterations; index += 1) {
@@ -5634,7 +5678,7 @@ async function runRiddleProofEngineHarness(input) {
         message: "The harness route returned no next step."
       });
     }
-    nextParams = routed.next;
+    nextParams = carryRequestControlFlags(routed.next, request);
   }
   return blockerResult(state, lastResult, {
     code: "max_iterations_reached",

package/dist/engine-harness.js

@@ -2,11 +2,11 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-VJLHXZAA.js";
-import "./chunk-UYB7ABWU.js";
-import "./chunk-ZHEFYLII.js";
-import "./chunk-WWYZBWKZ.js";
-import "./chunk-ABQQLRTS.js";
+} from "./chunk-QUAZAMOM.js";
+import "./chunk-OHJQRDST.js";
+import "./chunk-Y2KTBACQ.js";
+import "./chunk-GBVEQQIM.js";
+import "./chunk-2CFVREFI.js";
 import "./chunk-VY4Y5U57.js";
 export {
   createDisabledRiddleProofAgentAdapter,

package/dist/index.cjs

@@ -385,6 +385,7 @@ function normalizedVerificationMode(state = {}) {
   return String(state?.verification_mode || "proof").trim().toLowerCase() || "proof";
 }
 function visualDeltaRequiredForState(state = {}) {
+  if (noImplementationModeFor(state) || visualDeltaNotApplicableForNoImplementation2(state)) return false;
   const bundle = objectValue(state?.evidence_bundle);
   const contract = objectValue(bundle.artifact_contract);
   const required = objectValue(contract.required);
@@ -399,6 +400,12 @@ function visualDeltaForState(state = {}) {
   const request = objectValue(state?.proof_assessment_request);
   return objectValue(request.visual_delta);
 }
+function visualDeltaNotApplicableForNoImplementation2(state = {}) {
+  const visualDelta = visualDeltaForState(state);
+  if (String(visualDelta.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function visualDeltaShipGateReason(state = {}) {
   if (!visualDeltaRequiredForState(state)) return null;
   const visualDelta = visualDeltaForState(state);
@@ -1654,6 +1661,10 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     const timer = beginRuntimeStep(config.statePath, action, step, stepWorkflowFile);
     let output;
     try {
+      if (step === "setup") {
+        (0, import_node_fs2.mkdirSync)(import_node_path2.default.dirname(config.argsPath), { recursive: true });
+        (0, import_node_fs2.writeFileSync)(config.argsPath, JSON.stringify(args, null, 2));
+      }
       output = JSON.parse(
         (0, import_node_child_process.execFileSync)(lobsterCommand, [...lobsterPrefix, "run", "--file", stepWorkflowFile, "--args-json", JSON.stringify(args)], {
           encoding: "utf-8",
@@ -3647,6 +3658,24 @@ function visualDeltaFromState(fullState) {
   const proofAssessmentRequest = recordValue(fullState.proof_assessment_request);
   return recordValue(proofAssessmentRequest?.visual_delta) || null;
 }
+function normalizedText(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function noImplementationModeForCheckpoint(request, fullState) {
+  const requestRecord = recordValue(request) || {};
+  const mode = normalizedText(
+    requestRecord.mode || requestRecord.workflow_mode || fullState.mode || fullState.workflow_mode
+  );
+  const implementationMode = normalizedText(requestRecord.implementation_mode || fullState.implementation_mode);
+  const requireDiff = requestRecord.require_diff ?? fullState.require_diff;
+  const allowCodeChanges = requestRecord.allow_code_changes ?? fullState.allow_code_changes;
+  return mode === "audit" || mode === "profile" || implementationMode === "none" || requireDiff === false || allowCodeChanges === false;
+}
+function visualDeltaNotApplicableForNoImplementation(visualDelta) {
+  if (String(visualDelta?.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta?.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function verificationModeRequiresVisualDelta(value) {
   const mode = String(value || "proof").trim().toLowerCase();
   return [
@@ -3684,7 +3713,9 @@ function buildProofAssessmentCheckpointPacket(input) {
   const requiredSignals = recordValue(recordValue(artifactContract)?.required);
   const visualDelta = visualDeltaFromState(fullState);
   const verificationMode = nonEmptyString(bundle?.verification_mode) || nonEmptyString(fullState.verification_mode) || nonEmptyString(input.request.verification_mode) || "proof";
-  const visualDeltaRequired = requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
+  const noImplementationMode = noImplementationModeForCheckpoint(input.request, fullState);
+  const noImplementationVisualDelta = visualDeltaNotApplicableForNoImplementation(visualDelta);
+  const visualDeltaRequired = !noImplementationMode && !noImplementationVisualDelta && requiredSignals?.visual_delta !== false && (requiredSignals?.visual_delta === true || verificationModeRequiresVisualDelta(verificationMode));
   const evidenceIssueCode2 = visualDeltaIssueCode(visualDelta, visualDeltaRequired);
   const summary = nonEmptyString(input.engineResult.summary) || nonEmptyString(fullState.verify_summary) || "Verify captured evidence and needs a supervising proof assessment.";
   const recoveryHint = evidenceIssueCode2 ? "Required visual_delta evidence is incomplete. Keep this same run in verify/evidence recovery with decision=revise_capture and continue_with_stage=verify unless the evidence proves an implementation or recon problem." : "Assess whether the current artifacts prove the requested change, then choose the next stage.";
@@ -3717,7 +3748,7 @@ function buildProofAssessmentCheckpointPacket(input) {
       prod_cdn: fullState.prod_cdn || null,
       after_cdn: fullState.after_cdn || null,
       visual_delta_required: visualDeltaRequired,
-      visual_delta_ready: visualDelta?.status === "measured" && visualDelta?.passed === true,
+      visual_delta_ready: !visualDeltaRequired || visualDelta?.status === "measured" && visualDelta?.passed === true,
       visual_delta: jsonCloneRecord(visualDelta),
       evidence_issue_code: evidenceIssueCode2,
       proof_assessment_request: jsonCloneRecord(proofAssessmentRequest),
@@ -5101,6 +5132,16 @@ function baseContinuation(result) {
     continue_from_checkpoint: true
   };
 }
+function carryRequestControlFlags(params, request) {
+  if (!noImplementationModeFor(request)) return params;
+  return compactRecord({
+    ...params,
+    mode: request.mode,
+    implementation_mode: request.implementation_mode || "none",
+    require_diff: request.require_diff ?? false,
+    allow_code_changes: request.allow_code_changes ?? false
+  });
+}
 function initialRunParams(request, input, state) {
   return compactRecord({
     action: "run",
@@ -6255,7 +6296,10 @@ async function runRiddleProofEngineHarness(input) {
       message
     });
   }
-  let nextParams = input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state);
+  let nextParams = carryRequestControlFlags(
+    input.resume_params || checkpointContinuation.next || initialRunParams(request, input, state),
+    request
+  );
   let lastResult = null;
   const stageIterations = {};
   for (let index = 0; index < maxIterations; index += 1) {
@@ -6368,7 +6412,7 @@ async function runRiddleProofEngineHarness(input) {
         message: "The harness route returned no next step."
       });
     }
-    nextParams = routed.next;
+    nextParams = carryRequestControlFlags(routed.next, request);
   }
   return blockerResult(state, lastResult, {
     code: "max_iterations_reached",

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   runRiddleProof
-} from "./chunk-MA6ZR5XY.js";
+} from "./chunk-TGHTM66Z.js";
 import "./chunk-6F4PWJZI.js";
 import {
   RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION,
@@ -95,7 +95,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-VJLHXZAA.js";
+} from "./chunk-QUAZAMOM.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
@@ -107,12 +107,12 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-UYB7ABWU.js";
+} from "./chunk-OHJQRDST.js";
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
-} from "./chunk-ZHEFYLII.js";
-import "./chunk-WWYZBWKZ.js";
+} from "./chunk-Y2KTBACQ.js";
+import "./chunk-GBVEQQIM.js";
 import {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
@@ -128,7 +128,7 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "./chunk-ABQQLRTS.js";
+} from "./chunk-2CFVREFI.js";
 import "./chunk-JFQXAJH2.js";
 import {
   createCodexExecAgentAdapter,

package/dist/openclaw.js

@@ -1,9 +1,9 @@
 import {
   normalizeIntegrationContext,
   normalizeRunParams
-} from "./chunk-UYB7ABWU.js";
-import "./chunk-ZHEFYLII.js";
-import "./chunk-ABQQLRTS.js";
+} from "./chunk-OHJQRDST.js";
+import "./chunk-Y2KTBACQ.js";
+import "./chunk-2CFVREFI.js";
 import {
   compactRecord
 } from "./chunk-VY4Y5U57.js";

package/dist/proof-run-core.cjs

@@ -438,6 +438,7 @@ function normalizedVerificationMode(state = {}) {
   return String(state?.verification_mode || "proof").trim().toLowerCase() || "proof";
 }
 function visualDeltaRequiredForState(state = {}) {
+  if (noImplementationModeFor(state) || visualDeltaNotApplicableForNoImplementation(state)) return false;
   const bundle = objectValue(state?.evidence_bundle);
   const contract = objectValue(bundle.artifact_contract);
   const required = objectValue(contract.required);
@@ -452,6 +453,12 @@ function visualDeltaForState(state = {}) {
   const request = objectValue(state?.proof_assessment_request);
   return objectValue(request.visual_delta);
 }
+function visualDeltaNotApplicableForNoImplementation(state = {}) {
+  const visualDelta = visualDeltaForState(state);
+  if (String(visualDelta.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function visualDeltaShipGateReason(state = {}) {
   if (!visualDeltaRequiredForState(state)) return null;
   const visualDelta = visualDeltaForState(state);

package/dist/proof-run-core.js

@@ -26,7 +26,7 @@ import {
   visualDeltaShipGateReason,
   workflowFile,
   writeState
-} from "./chunk-WWYZBWKZ.js";
+} from "./chunk-GBVEQQIM.js";
 export {
   BUNDLED_RIDDLE_PROOF_DIR,
   CHECKPOINT_CONTRACT_VERSION,

package/dist/proof-run-engine.cjs

@@ -418,6 +418,7 @@ function normalizedVerificationMode(state = {}) {
   return String(state?.verification_mode || "proof").trim().toLowerCase() || "proof";
 }
 function visualDeltaRequiredForState(state = {}) {
+  if (noImplementationModeFor(state) || visualDeltaNotApplicableForNoImplementation(state)) return false;
   const bundle = objectValue(state?.evidence_bundle);
   const contract = objectValue(bundle.artifact_contract);
   const required = objectValue(contract.required);
@@ -432,6 +433,12 @@ function visualDeltaForState(state = {}) {
   const request = objectValue(state?.proof_assessment_request);
   return objectValue(request.visual_delta);
 }
+function visualDeltaNotApplicableForNoImplementation(state = {}) {
+  const visualDelta = visualDeltaForState(state);
+  if (String(visualDelta.status || "").trim() !== "not_applicable") return false;
+  const reason = String(visualDelta.reason || "").toLowerCase();
+  return reason.includes("audit/no-diff") || reason.includes("does not require a before/after implementation delta");
+}
 function visualDeltaShipGateReason(state = {}) {
   if (!visualDeltaRequiredForState(state)) return null;
   const visualDelta = visualDeltaForState(state);
@@ -1652,6 +1659,10 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     const timer = beginRuntimeStep(config.statePath, action, step, stepWorkflowFile);
     let output;
     try {
+      if (step === "setup") {
+        (0, import_node_fs2.mkdirSync)(import_node_path2.default.dirname(config.argsPath), { recursive: true });
+        (0, import_node_fs2.writeFileSync)(config.argsPath, JSON.stringify(args, null, 2));
+      }
       output = JSON.parse(
         (0, import_node_child_process.execFileSync)(lobsterCommand, [...lobsterPrefix, "run", "--file", stepWorkflowFile, "--args-json", JSON.stringify(args)], {
           encoding: "utf-8",

package/dist/proof-run-engine.js

@@ -15,11 +15,11 @@ import {
   validateShipGate,
   workflowFile,
   writeState
-} from "./chunk-WWYZBWKZ.js";
+} from "./chunk-GBVEQQIM.js";
 
 // src/proof-run-engine.ts
 import { execFileSync } from "child_process";
-import { existsSync, mkdirSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
 import path from "path";
 function snapshotFor(statePath) {
   return summarizeState(readState(statePath));
@@ -647,6 +647,10 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     const timer = beginRuntimeStep(config.statePath, action, step, stepWorkflowFile);
     let output;
     try {
+      if (step === "setup") {
+        mkdirSync(path.dirname(config.argsPath), { recursive: true });
+        writeFileSync(config.argsPath, JSON.stringify(args, null, 2));
+      }
       output = JSON.parse(
         execFileSync(lobsterCommand, [...lobsterPrefix, "run", "--file", stepWorkflowFile, "--args-json", JSON.stringify(args)], {
           encoding: "utf-8",

package/dist/run-card.js

@@ -1,8 +1,8 @@
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
-} from "./chunk-ZHEFYLII.js";
-import "./chunk-ABQQLRTS.js";
+} from "./chunk-Y2KTBACQ.js";
+import "./chunk-2CFVREFI.js";
 import "./chunk-VY4Y5U57.js";
 export {
   RIDDLE_PROOF_RUN_CARD_VERSION,

package/dist/runner.js

@@ -1,10 +1,10 @@
 import {
   runRiddleProof
-} from "./chunk-MA6ZR5XY.js";
-import "./chunk-UYB7ABWU.js";
-import "./chunk-ZHEFYLII.js";
-import "./chunk-WWYZBWKZ.js";
-import "./chunk-ABQQLRTS.js";
+} from "./chunk-TGHTM66Z.js";
+import "./chunk-OHJQRDST.js";
+import "./chunk-Y2KTBACQ.js";
+import "./chunk-GBVEQQIM.js";
+import "./chunk-2CFVREFI.js";
 import "./chunk-VY4Y5U57.js";
 export {
   runRiddleProof

package/dist/state.js

@@ -9,9 +9,9 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-UYB7ABWU.js";
-import "./chunk-ZHEFYLII.js";
-import "./chunk-ABQQLRTS.js";
+} from "./chunk-OHJQRDST.js";
+import "./chunk-Y2KTBACQ.js";
+import "./chunk-2CFVREFI.js";
 import "./chunk-VY4Y5U57.js";
 export {
   RIDDLE_PROOF_RUN_STATE_VERSION,

package/package.json

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

package/runtime/lib/verify.py

@@ -557,6 +557,50 @@ def extract_proof_evidence(payload):
     return evidence
 
 
+def proof_evidence_records(value):
+    if isinstance(value, dict):
+        return [value]
+    if isinstance(value, list):
+        records = []
+        for item in value:
+            records.extend(proof_evidence_records(item))
+        return records
+    return []
+
+
+def static_audit_evidence_support(value):
+    for record in proof_evidence_records(value):
+        explicit_static = (
+            record.get('interactionNotRequired') is True
+            or record.get('interactionExpected') is False
+            or record.get('zeroInteractiveElementsExpected') is True
+            or record.get('staticPageExpected') is True
+        )
+        ready = record.get('proofReady') is True or record.get('staticAuditReady') is True
+        failed = any(record.get(key) is False for key in (
+            'proofReady',
+            'staticAuditReady',
+            'routeMatches',
+            'titleMatches',
+            'headingMatches',
+            'markerMatches',
+            'normalizedCopyVisible',
+            'noConsoleErrors',
+            'noPageErrors',
+        ))
+        if explicit_static and ready and not failed:
+            return {
+                'ready': True,
+                'interaction_not_required': True,
+                'source': str(record.get('version') or record.get('mode') or 'proof_evidence'),
+            }
+    return {
+        'ready': False,
+        'interaction_not_required': False,
+        'source': '',
+    }
+
+
 PLAYABILITY_EVIDENCE_VERSION = 'riddle-proof.playability.v1'
 PLAYABILITY_ASSESSMENT_VERSION = 'riddle-proof.playability.assessment.v1'
 PLAYABILITY_CONTAINER_KEYS = (
@@ -2012,6 +2056,8 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
     payload = enrich_capture_payload(payload)
     mode = normalized_verification_mode(verification_mode)
     supporting = collect_supporting_artifacts(payload)
+    proof_evidence = extract_proof_evidence(payload)
+    static_audit_support = static_audit_evidence_support(proof_evidence)
     structured_ready = bool(supporting.get('has_structured_payload'))
     playability_ready = mode in PLAYABILITY_MODES and bool(supporting.get('playability_ready'))
     screenshot_required = screenshot_required_for_mode(mode)
@@ -2023,6 +2069,8 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
         'structured_evidence_present': structured_ready,
         'proof_evidence_present': bool(supporting.get('proof_evidence_present')),
         'playability_ready': playability_ready,
+        'static_audit_ready': bool(static_audit_support.get('ready')),
+        'static_audit_support_source': static_audit_support.get('source', ''),
         'canvas_capture_ready': False,
         'large_canvas_area': 0,
         'min_canvas_area': MIN_CANVAS_AREA,
@@ -2110,13 +2158,15 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
 
     should_enforce_visual_readiness = screenshot_required or (details['has_screenshot'] and not structured_ready)
     canvas_ready = bool(details.get('canvas_capture_ready'))
-    body_text_ready = details['body_text_length'] >= MIN_BODY_TEXT_LENGTH or canvas_ready or playability_ready
-    interactive_ready = details['interactive_elements'] >= MIN_INTERACTIVE_ELEMENTS or canvas_ready or playability_ready
-    semantic_ready = (not has_enriched_page_state(page_state)) or details['semantic_anchor_count'] >= 1 or canvas_ready or playability_ready
+    static_audit_ready = bool(static_audit_support.get('ready'))
+    body_text_ready = details['body_text_length'] >= MIN_BODY_TEXT_LENGTH or canvas_ready or playability_ready or static_audit_ready
+    interactive_ready = details['interactive_elements'] >= MIN_INTERACTIVE_ELEMENTS or canvas_ready or playability_ready or static_audit_ready
+    semantic_ready = (not has_enriched_page_state(page_state)) or details['semantic_anchor_count'] >= 1 or canvas_ready or playability_ready or static_audit_ready
     details['body_text_ready'] = body_text_ready
     details['interactive_ready'] = interactive_ready
     details['semantic_ready'] = semantic_ready
     details['canvas_or_playability_override'] = bool(should_enforce_visual_readiness and (canvas_ready or playability_ready))
+    details['static_audit_readiness_override'] = bool(should_enforce_visual_readiness and static_audit_ready)
 
     if should_enforce_visual_readiness and not body_text_ready:
         reasons.append(f'blank/near-blank page (text length: {details["body_text_length"]})')

package/runtime/pipelines/riddle-proof-setup.lobster

@@ -17,7 +17,7 @@ args:
     default: ""
   capture_script:
     default: ""
-    description: "Optional during setup. Add it before recon/verify once the proof target is clear."
+    description: "Optional Playwright JavaScript for proof capture. Add it before recon/verify once the proof target is clear; put natural-language instructions in change_request, context, success_criteria, or proof_plan."
   success_criteria:
     default: ""
     description: "Plain-English definition of what counts as fixed"
@@ -101,48 +101,52 @@ steps:
     command: |
       python3 << 'PYEOF'
       import json, os
-      raw_server_path = """${server_path}""".strip()
-      args = {
-          'mode': """${mode}""".strip() or 'server',
-          'reference': """${reference}""".strip() or 'both',
-          'repo': """${repo}""".strip(),
-          'branch': """${branch}""".strip(),
-          'change_request': """${change_request}""".strip(),
-          'commit_message': """${commit_message}""".strip(),
-          'prod_url': """${prod_url}""".strip(),
-          'capture_script': """${capture_script}""".strip(),
-          'success_criteria': """${success_criteria}""".strip(),
-          'assertions_json': """${assertions_json}""".strip(),
-          'verification_mode': """${verification_mode}""".strip() or 'proof',
-          'context': """${context}""".strip(),
-          'reviewer': """${reviewer}""".strip() or 'davisdiehl',
-          'base_branch': """${base_branch}""".strip() or 'main',
-          'before_ref': """${before_ref}""".strip(),
-          'allow_static_preview_fallback': """${allow_static_preview_fallback}""".strip(),
-          'implementation_mode': """${implementation_mode}""".strip(),
-          'require_diff': """${require_diff}""".strip(),
-          'allow_code_changes': """${allow_code_changes}""".strip(),
-          'build_command': """${build_command}""".strip() or 'npm run build',
-          'build_output': """${build_output}""".strip() or 'build',
-          'server_image': """${server_image}""".strip() or 'node:20-slim',
-          'server_command': """${server_command}""".strip() or 'npm start',
-          'server_port': """${server_port}""".strip() or '3000',
-          'server_path': raw_server_path,
-          'server_path_source': 'user' if raw_server_path else '',
-          'use_auth': """${use_auth}""".strip(),
-          'auth_localStorage_json': """${auth_localStorage_json}""".strip(),
-          'auth_cookies_json': """${auth_cookies_json}""".strip(),
-          'auth_headers_json': """${auth_headers_json}""".strip(),
-          'color_scheme': """${color_scheme}""".strip(),
-          'wait_for_selector': """${wait_for_selector}""".strip(),
-          'discord_channel': """${discord_channel}""".strip(),
-          'discord_thread_id': """${discord_thread_id}""".strip(),
-          'discord_message_id': """${discord_message_id}""".strip(),
-          'discord_source_url': """${discord_source_url}""".strip(),
-      }
       args_file = os.environ.get('RIDDLE_PROOF_ARGS_FILE', '/tmp/riddle-proof-args.json')
-      with open(args_file, 'w') as f:
-          json.dump(args, f, indent=2)
+      if os.environ.get('RIDDLE_PROOF_ARGS_FILE') and os.path.exists(args_file):
+          with open(args_file) as f:
+              json.load(f)
+      else:
+          raw_server_path = '''${server_path}'''.strip()
+          args = {
+              'mode': '''${mode}'''.strip() or 'server',
+              'reference': '''${reference}'''.strip() or 'both',
+              'repo': '''${repo}'''.strip(),
+              'branch': '''${branch}'''.strip(),
+              'change_request': '''${change_request}'''.strip(),
+              'commit_message': '''${commit_message}'''.strip(),
+              'prod_url': '''${prod_url}'''.strip(),
+              'capture_script': '''${capture_script}'''.strip(),
+              'success_criteria': '''${success_criteria}'''.strip(),
+              'assertions_json': '''${assertions_json}'''.strip(),
+              'verification_mode': '''${verification_mode}'''.strip() or 'proof',
+              'context': '''${context}'''.strip(),
+              'reviewer': '''${reviewer}'''.strip() or 'davisdiehl',
+              'base_branch': '''${base_branch}'''.strip() or 'main',
+              'before_ref': '''${before_ref}'''.strip(),
+              'allow_static_preview_fallback': '''${allow_static_preview_fallback}'''.strip(),
+              'implementation_mode': '''${implementation_mode}'''.strip(),
+              'require_diff': '''${require_diff}'''.strip(),
+              'allow_code_changes': '''${allow_code_changes}'''.strip(),
+              'build_command': '''${build_command}'''.strip() or 'npm run build',
+              'build_output': '''${build_output}'''.strip() or 'build',
+              'server_image': '''${server_image}'''.strip() or 'node:20-slim',
+              'server_command': '''${server_command}'''.strip() or 'npm start',
+              'server_port': '''${server_port}'''.strip() or '3000',
+              'server_path': raw_server_path,
+              'server_path_source': 'user' if raw_server_path else '',
+              'use_auth': '''${use_auth}'''.strip(),
+              'auth_localStorage_json': '''${auth_localStorage_json}'''.strip(),
+              'auth_cookies_json': '''${auth_cookies_json}'''.strip(),
+              'auth_headers_json': '''${auth_headers_json}'''.strip(),
+              'color_scheme': '''${color_scheme}'''.strip(),
+              'wait_for_selector': '''${wait_for_selector}'''.strip(),
+              'discord_channel': '''${discord_channel}'''.strip(),
+              'discord_thread_id': '''${discord_thread_id}'''.strip(),
+              'discord_message_id': '''${discord_message_id}'''.strip(),
+              'discord_source_url': '''${discord_source_url}'''.strip(),
+          }
+          with open(args_file, 'w') as f:
+              json.dump(args, f, indent=2)
       PYEOF
       RP="${RIDDLE_PROOF_DIR:-/root/.openclaw/extensions/openclaw-riddle-proof/node_modules/@riddledc/riddle-proof/runtime}"
       python3 "${RP}/lib/preflight.py"

package/runtime/tests/recon_verify_smoke.py

@@ -562,6 +562,47 @@ def run_verify_quality_ignores_proof_telemetry_console_text():
     assert missing_query_quality['valid'] is False
     assert 'wrong route' in missing_query_quality['reason']
 
+    static_audit_payload = {
+        'bodyTextLength': 61,
+        'visibleTextSample': 'Riddle static preview smoke Static preview marker is visible.',
+        'interactiveElements': 0,
+        'visibleInteractiveElements': 0,
+        'pathname': '/s/ps_b7b5f0dc/',
+        'title': 'Riddle Preview Smoke',
+        'headings': ['Riddle static preview smoke'],
+        'buttons': [],
+        'links': [],
+        'canvasCount': 0,
+        'largeVisibleElements': [{'tag': 'h1', 'text': 'Riddle static preview smoke', 'area': 17208}],
+    }
+    static_audit_evidence = {
+        'version': 'riddle-proof.static-smoke.v4',
+        'proofReady': True,
+        'staticAuditReady': True,
+        'interactionExpected': False,
+        'interactionNotRequired': True,
+        'zeroInteractiveElementsExpected': True,
+        'routeMatches': True,
+        'titleMatches': True,
+        'headingMatches': True,
+        'markerMatches': True,
+        'normalizedCopyVisible': True,
+        'noConsoleErrors': True,
+        'noPageErrors': True,
+    }
+    static_audit_quality = namespace['evaluate_capture_quality']({
+        'ok': True,
+        'screenshots': [{'name': 'after-proof.png', 'url': 'https://cdn.example.com/static-after.png'}],
+        'outputs': [{'name': 'after-proof.png', 'url': 'https://cdn.example.com/static-after.png'}],
+        'console': [
+            'RIDDLE_PROOF_STATE:' + json.dumps(static_audit_payload),
+            'RIDDLE_PROOF_EVIDENCE:' + json.dumps(static_audit_evidence),
+        ],
+    }, '/s/ps_b7b5f0dc/', 'visual')
+    assert static_audit_quality['valid'] is True, static_audit_quality
+    assert static_audit_quality['details']['interactive_ready'] is True
+    assert static_audit_quality['details']['static_audit_readiness_override'] is True
+
     strong_delta = namespace['extract_visual_delta']({
         'ok': True,
         'result': {