@riddledc/riddle-proof 0.7.225 → 0.7.226

package/dist/{chunk-4DRRIJDX.js → chunk-QUAZAMOM.js}

@@ -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/cli.cjs

@@ -1661,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",
@@ -4465,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",
@@ -5619,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) {
@@ -5732,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,7 +23,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-4DRRIJDX.js";
+} from "./chunk-QUAZAMOM.js";
 import "./chunk-OHJQRDST.js";
 import "./chunk-Y2KTBACQ.js";
 import "./chunk-GBVEQQIM.js";

package/dist/engine-harness.cjs

@@ -1661,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",
@@ -4394,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",
@@ -5548,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) {
@@ -5661,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,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-4DRRIJDX.js";
+} from "./chunk-QUAZAMOM.js";
 import "./chunk-OHJQRDST.js";
 import "./chunk-Y2KTBACQ.js";
 import "./chunk-GBVEQQIM.js";

package/dist/index.cjs

@@ -1661,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",
@@ -5128,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",
@@ -6282,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) {
@@ -6395,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

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

package/dist/proof-run-engine.cjs

@@ -1659,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

@@ -19,7 +19,7 @@ import {
 
 // 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.7.225",
+  "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

@@ -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': {