@riddledc/riddle-proof 0.8.29 → 0.8.31

package/runtime/lib/util.py

@@ -621,37 +621,65 @@ def nested_non_riddle_enabled():
 def invoke_riddle_core(tool, args, timeout=180):
     """Call Riddle's shared core package directly, without nested OpenClaw tool invocation."""
     script = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'riddle_core_call.mjs')
+    result_file = tempfile.NamedTemporaryFile(prefix='riddle-proof-direct-', suffix='.json', delete=False).name
+    stderr_file = tempfile.NamedTemporaryFile(prefix='riddle-proof-direct-', suffix='.stderr', delete=False).name
+    env = dict(os.environ)
+    env['RIDDLE_PROOF_DIRECT_RESULT_FILE'] = result_file
+    stderr_text = ''
     try:
-        r = sp.run(
-            ['node', script, tool, json.dumps(args)],
-            capture_output=True, text=True, timeout=timeout
-        )
+        with open(stderr_file, 'w', encoding='utf-8') as stderr_handle:
+            r = sp.run(
+                ['node', script, tool, json.dumps(args)],
+                stdout=sp.DEVNULL, stderr=stderr_handle, text=True, timeout=timeout, env=env
+            )
     except sp.TimeoutExpired as e:
         print('direct_riddle(' + tool + ') TIMED OUT after ' + str(timeout) + 's')
-        if e.stdout:
-            print('  stdout: ' + e.stdout[:500])
-        if e.stderr:
-            print('  stderr: ' + e.stderr[:500])
+        try:
+            with open(stderr_file, 'r', encoding='utf-8') as f:
+                stderr_text = f.read()[:500]
+        except Exception:
+            stderr_text = ''
+        if stderr_text:
+            print('  stderr: ' + stderr_text)
         return {
             'ok': False,
             'timeout': True,
             'error': f'direct_riddle({tool}) timed out after {timeout}s',
-            'stdout': (e.stdout or '')[:500],
-            'stderr': (e.stderr or '')[:500],
+            'stderr': stderr_text[:500],
         }
+    finally:
+        if 'r' not in locals():
+            for temp_path in (result_file, stderr_file):
+                try:
+                    os.unlink(temp_path)
+                except Exception:
+                    pass
+    try:
+        with open(stderr_file, 'r', encoding='utf-8') as f:
+            stderr_text = f.read()
+    except Exception:
+        stderr_text = ''
 
     if r.returncode != 0:
         print('direct_riddle(' + tool + ') FAILED rc=' + str(r.returncode))
-        print('  stdout: ' + r.stdout[:500])
-        print('  stderr: ' + r.stderr[:500])
+        print('  stderr: ' + stderr_text[:500])
 
     try:
-        return json.loads(r.stdout)
-    except:
+        with open(result_file, 'r', encoding='utf-8') as f:
+            return json.loads(f.read())
+    except Exception:
         print('direct_riddle(' + tool + ') JSON parse failed')
-        print('  stdout: ' + r.stdout[:500])
-        print('  stderr: ' + r.stderr[:500])
-        return {'ok': False, 'error': r.stdout[:300], 'stderr': r.stderr[:300]}
+        print('  stderr: ' + stderr_text[:500])
+        return {'ok': False, 'error': 'direct_riddle result file missing or invalid', 'stderr': stderr_text[:300]}
+    finally:
+        try:
+            os.unlink(result_file)
+        except Exception:
+            pass
+        try:
+            os.unlink(stderr_file)
+        except Exception:
+            pass
 
 
 def invoke(tool, args, timeout=180):
@@ -771,7 +799,12 @@ def invoke_retry(tool, args, retries=3, timeout=180):
         result = invoke(tool, args, timeout=timeout)
         last_result = result
         # Check for success indicators
-        if result.get('ok') or result.get('outputs') or result.get('screenshots'):
+        if result.get('ok'):
+            return result
+        if tool == 'riddle_script' and (result.get('error') or result.get('script_error')):
+            print('invoke_retry(riddle_script) stopping early for deterministic script error')
+            return result
+        if result.get('outputs') or result.get('screenshots'):
             return result
         print(f'invoke_retry({tool}) attempt {attempt}/{retries} failed: {str(result.get("error", "no output"))[:200]}')
         if tool == 'riddle_script' and non_retryable_riddle_script_error(result):
@@ -911,6 +944,39 @@ def summarize_capture_artifact_item(item):
     return {key: value for key, value in summary.items() if value not in (None, '')}
 
 
+def capture_screenshot_url(payload, label=''):
+    if not isinstance(payload, dict):
+        return ''
+    enriched = enrich_capture_payload(payload)
+    candidates = []
+    for key in ('screenshots', 'outputs', 'artifacts'):
+        values = enriched.get(key) or []
+        if isinstance(values, list):
+            candidates.extend([item for item in values if isinstance(item, dict)])
+
+    requested = (label or '').strip()
+    expected_names = set()
+    if requested:
+        expected_names.update({
+            requested,
+            requested + '.png',
+            requested + '.jpg',
+            requested + '.jpeg',
+            requested + '.webp',
+        })
+    for item in candidates:
+        name = str(item.get('name') or '')
+        url = str(item.get('url') or '')
+        if url and expected_names and name in expected_names:
+            return url
+    for item in candidates:
+        url = str(item.get('url') or '')
+        name = str(item.get('name') or '')
+        if url and (not name or re.search(r'\.(png|jpe?g|webp|gif)$', name, re.I)):
+            return url
+    return ''
+
+
 def git(cmd, cwd):
     """Run a shell command in a repo directory."""
     return sp.run(cmd, shell=True, cwd=cwd, capture_output=True, text=True)
@@ -1152,7 +1218,7 @@ def build_capture_script(url, capture_script, label, wait_for_selector='', viewp
     effective_viewport_matrix = None if script_handles_viewport_matrix else viewport_matrix
     pieces = [
         *viewport_matrix_setup_js(effective_viewport_matrix),
-        'await page.goto(' + json.dumps(url) + ');',
+        'await page.goto(' + json.dumps(url) + ', { waitUntil: "domcontentloaded", timeout: 30000 });',
     ]
     selector = (wait_for_selector or '').strip()
     if selector:
@@ -1179,33 +1245,44 @@ def capture_static_preview(state, project_dir, label, capture_script, timeout=30
             'raw': {'ok': False, 'error': 'No static build output found. Tried configured build_output, dist, build, out.'},
         }
 
-    preview = invoke_retry('riddle_preview', {'directory': build_dir, 'label': label}, retries=3, timeout=timeout)
-    if not preview.get('ok'):
-        return {
-            'ok': False,
-            'preview_id': preview.get('id', ''),
-            'preview_url': preview.get('preview_url') or preview.get('previewUrl') or '',
-            'url': '',
-            'raw': preview,
-        }
-    preview_url = preview.get('preview_url') or preview.get('previewUrl') or ''
-    preview_id = preview.get('id', '')
-    capture_url = join_url_path(preview_url, target_path or state.get('server_path', ''))
-
-    script = build_capture_script(capture_url, capture_script, label, state.get('wait_for_selector', ''), state.get('viewport_matrix'))
-    args = {'script': script, 'timeout_sec': 60}
+    static_server_command = (
+        (state.get('static_server_command') or '').strip()
+        or os.environ.get('RIDDLE_PROOF_STATIC_SERVER_COMMAND', '').strip()
+        or 'python3 -m http.server "$PORT" --bind 127.0.0.1'
+    )
+    target = target_path or state.get('server_path', '') or '/'
+    args = {
+        'directory': build_dir,
+        'command': static_server_command,
+        'port': int(state.get('server_port') or 3000),
+        'wait_until': 'domcontentloaded',
+        'readiness_timeout': 60,
+        'timeout': max(60, min(int(timeout or 300), 300)),
+        'path': target,
+        'readiness_path': '/',
+        'script': capture_script,
+    }
+    if state.get('wait_for_selector'):
+        args['wait_for_selector'] = state.get('wait_for_selector')
+    if state.get('color_scheme'):
+        args['color_scheme'] = state.get('color_scheme')
     apply_auth_context(state, args)
-    shot = invoke_retry('riddle_script', args, retries=3, timeout=max(timeout, 120))
+    shot = invoke_retry('riddle_server_preview', args, retries=2, timeout=max(timeout, 120))
     screenshots = shot.get('screenshots') or []
-    url = screenshots[0].get('url', '') if screenshots else ''
+    url = screenshots[0].get('url', '') if screenshots else capture_screenshot_url(shot, label)
     return {
         'ok': bool(url),
-        'preview_id': preview_id,
-        'preview_url': preview_url,
-        'capture_url': capture_url,
+        'preview_id': '',
+        'preview_url': shot.get('preview_url') or '',
+        'capture_url': shot.get('target_url') or target,
         'url': url,
         'raw': {
-            'preview': preview,
+            'preview': {
+                'ok': shot.get('ok'),
+                'runner': shot.get('runner'),
+                'preview_url': shot.get('preview_url') or '',
+                'target_url': shot.get('target_url') or '',
+            },
             'capture': shot,
         },
     }

package/runtime/lib/verify.py

@@ -310,12 +310,13 @@ def payload_has_capture_artifacts(payload):
 def capture_payload_error(payload):
     if not isinstance(payload, dict):
         return ''
-    if payload.get('ok') is False and not payload_has_capture_artifacts(payload):
-        for key in ('error', 'stderr', 'stdout'):
+    if payload.get('ok') is False:
+        for key in ('error', 'script_error', 'stderr', 'stdout'):
             value = payload.get(key)
             if value:
                 return str(value).strip()
-        return 'capture tool returned ok=false without artifacts'
+        if not payload_has_capture_artifacts(payload):
+            return 'capture tool returned ok=false without artifacts'
     return ''
 
 
@@ -3222,7 +3223,7 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
     }
 
 
-def build_capture_retry_decision(after_observation, required_baseline_present, proof_evidence_blocker='', route_expectation=None):
+def build_capture_retry_decision(after_observation, required_baseline_present, proof_evidence_blocker='', route_expectation=None, verification_mode=''):
     reasons = []
     if not required_baseline_present:
         reasons.append('Recon baseline is missing, so verify should return to recon instead of guessing a new reference context.')
@@ -3361,6 +3362,17 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
         elif error_messages:
             reasons.append('Capture script error: ' + error_messages[0][:500])
             summary = 'Verify capture script failed: ' + error_messages[0][:300]
+            reasons.append('The capture script produced a concrete browser/runtime failure, so this run should block with that exact evidence instead of re-authoring in a loop.')
+            return {
+                'decision': 'failed_interaction_capture' if normalized_verification_mode(verification_mode) in INTERACTION_MODES else 'failed_capture',
+                'summary': summary,
+                'recommended_stage': None,
+                'continue_with_stage': None,
+                'blocking': True,
+                'terminal_blocker': True,
+                'reasons': reasons,
+                'mismatch': None,
+            }
         else:
             summary = 'Verify needs another internal capture iteration before the evidence can be judged.'
         reasons.append('The capture plan itself needs revision, so author should tighten the proof script or framing inputs.')
@@ -4248,6 +4260,7 @@ else:
         required_baseline_present,
         proof_evidence_blocker or structured_interaction_capture_failure_summary,
         s.get('route_expectation') or {},
+        s.get('verification_mode') or '',
     )
     if visual_delta_recovery:
         observation_reason = str(after_observation.get('reason') or '')

package/runtime/tests/recon_verify_smoke.py

@@ -89,6 +89,138 @@ class FakeRiddle:
                 'id': f'pv-{label}',
                 'preview_url': f'https://preview.example.com/{label}/',
             }
+        if tool == 'riddle_server_preview':
+            script = args.get('script', '')
+            target_path = args.get('path') or '/'
+            path_only, _, query = str(target_path).partition('?')
+            search = '?' + query if query else ''
+            delegated_markers = [
+                'after-proof',
+                'audioNoProof',
+                'audioFailedProof',
+                'throwAfterProofEvidence',
+                'attack_ms_after',
+                'window.__riddleProofEvidence',
+                'globalThis.__riddleProofEvidence',
+                'clickedSkipHashNavigation',
+                'pricingQueryHashDropsTerminal',
+                'pricingQueryHashStructuredNegativeControl',
+                'pricingQueryHashPassesWithPageStateHashGap',
+                'clickedProofNavigation',
+                'clickedHomeNavigation',
+                'skipLinkTimeout',
+                'interactionThrownAfterFailedEvidence',
+                'interactionThrownError',
+            ]
+            if any(marker in script for marker in delegated_markers):
+                return self.invoke_retry('riddle_script', {'script': script}, retries=retries, timeout=timeout)
+            if path_only == '/wrong' or '/wrong' in script:
+                return {
+                    'ok': True,
+                    'runner': 'local-server-preview',
+                    'target_url': 'http://127.0.0.1:3000/wrong',
+                    'screenshots': [{'url': 'https://cdn.example.com/wrong.png'}],
+                    'outputs': [{'name': 'wrong.png', 'url': 'https://cdn.example.com/wrong.png'}],
+                    'console': ['RIDDLE_PROOF_STATE:{"bodyTextLength":5,"interactiveElements":0,"pathname":"/wrong","title":"Wrong"}'],
+                }
+            if '/games/drum-sequencer' in path_only:
+                page_state = {
+                    'bodyTextLength': 240,
+                    'visibleTextSample': 'Neon Step Sequencer Monkberry Moon Delight Mix Board Play All',
+                    'interactiveElements': 8,
+                    'visibleInteractiveElements': 8,
+                    'pathname': '/games/drum-sequencer',
+                    'search': search,
+                    'title': 'Neon Step Sequencer',
+                    'buttons': ['Play All', 'Shuffle'],
+                    'headings': ['Neon Step Sequencer'],
+                    'links': [],
+                    'canvasCount': 1,
+                    'largeVisibleElements': [{'tag': 'canvas', 'text': ''}],
+                }
+                return {
+                    'ok': True,
+                    'runner': 'local-server-preview',
+                    'target_url': 'http://127.0.0.1:3000' + str(target_path),
+                    'screenshots': [{'url': 'https://cdn.example.com/sequencer-before.png'}],
+                    'outputs': [{'name': 'before.png', 'url': 'https://cdn.example.com/sequencer-before.png'}],
+                    'console': state_console(page_state),
+                }
+            if '/games/tic-tac-toe' in path_only:
+                return {
+                    'ok': True,
+                    'runner': 'local-server-preview',
+                    'target_url': 'http://127.0.0.1:3000' + str(target_path),
+                    'screenshots': [{'url': 'https://cdn.example.com/tictactoe-before.png'}],
+                    'outputs': [{'name': 'before.png', 'url': 'https://cdn.example.com/tictactoe-before.png'}],
+                    'console': state_console({
+                        'bodyTextLength': 220,
+                        'visibleTextSample': 'LilArcade Tic Tac Toe Player X Reset Game',
+                        'interactiveElements': 5,
+                        'visibleInteractiveElements': 5,
+                        'pathname': '/games/tic-tac-toe',
+                        'title': 'TicTacToe',
+                        'buttons': ['Reset Game'],
+                        'headings': ['Tic Tac Toe'],
+                        'links': [],
+                        'canvasCount': 0,
+                        'largeVisibleElements': [{'tag': 'button', 'text': 'Reset Game'}],
+                    }),
+                }
+            if 'after-proof' in script:
+                after_url = 'https://cdn.example.com/after-artifact' if 'noVisualDelta' in script else 'https://cdn.example.com/after.png'
+                outputs = [{'name': 'after.png', 'url': after_url}]
+                if 'proof-session' in script:
+                    outputs.append({'name': 'proof-session.json', 'url': 'https://cdn.example.com/proof-session.json'})
+                payload = {
+                    'ok': True,
+                    'runner': 'local-server-preview',
+                    'target_url': 'http://127.0.0.1:3000' + str(target_path),
+                    'screenshots': [{'url': after_url}],
+                    'outputs': outputs,
+                    'console': state_console({
+                        'bodyTextLength': 180,
+                        'visibleTextSample': 'Pricing CTA Buy Now',
+                        'interactiveElements': 4,
+                        'visibleInteractiveElements': 4,
+                        'pathname': path_only or '/pricing',
+                        'search': search,
+                        'title': 'After',
+                        'buttons': ['Buy Now'],
+                        'headings': ['Pricing'],
+                        'links': [],
+                        'canvasCount': 0,
+                        'largeVisibleElements': [{'tag': 'button', 'text': 'Buy Now'}],
+                    }),
+                }
+                if 'noVisualDelta' not in script:
+                    payload['visual_diff'] = {
+                        'diffPercentage': 1.2,
+                        'differentPixels': 12000,
+                        'totalPixels': 972000,
+                    }
+                return payload
+            return {
+                'ok': True,
+                'runner': 'local-server-preview',
+                'target_url': 'http://127.0.0.1:3000' + str(target_path),
+                'screenshots': [{'url': 'https://cdn.example.com/home-before.png'}],
+                'outputs': [{'name': 'before.png', 'url': 'https://cdn.example.com/home-before.png'}],
+                'console': state_console({
+                    'bodyTextLength': 180,
+                    'visibleTextSample': 'Riddle Proof homepage hero Start Free',
+                    'interactiveElements': 4,
+                    'visibleInteractiveElements': 4,
+                    'pathname': path_only or '/',
+                    'search': search,
+                    'title': 'Riddle',
+                    'buttons': ['Start Free'],
+                    'headings': ['Riddle Proof'],
+                    'links': [],
+                    'canvasCount': 0,
+                    'largeVisibleElements': [{'tag': 'button', 'text': 'Start Free'}],
+                }),
+            }
         if tool == 'riddle_script':
             script = args.get('script', '')
             if 'preview.example.com' in script and '/wrong' in script:
@@ -3709,11 +3841,15 @@ def run_verify_capture_retry_surfaces_script_timeout():
 
         assert after_verify['verify_status'] == 'capture_incomplete'
         capture_quality = after_verify['verify_decision_request']['capture_quality']
-        assert capture_quality['recommended_stage'] in ('author', 'verify')
+        assert capture_quality['recommended_stage'] is None
+        assert capture_quality['continue_with_stage'] is None
+        assert capture_quality['blocking'] is True
+        assert capture_quality['terminal_blocker'] is True
         capture_quality_text = json.dumps(capture_quality, sort_keys=True)
         assert 'locator.click: Timeout 30000ms exceeded' in capture_quality_text
         return {
             'ok': True,
+            'decision': capture_quality['decision'],
             'summary': capture_quality['summary'],
         }
     finally: