@riddledc/riddle-proof 0.8.10 → 0.8.12

package/runtime/tests/recon_verify_smoke.py

@@ -345,7 +345,12 @@ class FakeRiddle:
                     'version': 'riddle-proof.interaction.v1',
                     'start': {'href': 'https://riddledc.com/'},
                     'action': {'type': 'click', 'target': 'Pricing'},
-                    'terminal': {'href': 'https://riddledc.com/pricing/?rp_probe=1#pricing-probe'},
+                    'terminal': {
+                        'pathname': '/pricing/',
+                        'search': '?rp_probe=1',
+                        'hash': '#pricing-probe',
+                        'href': 'https://riddledc.com/pricing/?rp_probe=1#pricing-probe',
+                    },
                     'afterUrl': 'https://riddledc.com/pricing/?rp_probe=1#pricing-probe',
                     'routeMatched': True,
                     'assertions': {
@@ -480,6 +485,36 @@ class FakeRiddle:
                         'proof.json': {'script_error': message},
                     },
                 }
+            if 'interactionThrownError' in script:
+                message = 'Error: intentional-riddle-proof-0811-thrown-error'
+                page_state = {
+                    'bodyTextLength': 180,
+                    'visibleTextSample': 'Riddle Proof homepage hero Start Free',
+                    'interactiveElements': 4,
+                    'visibleInteractiveElements': 4,
+                    'pathname': '/',
+                    'search': '',
+                    'hash': '',
+                    'title': 'Riddle',
+                    'buttons': ['Start Free'],
+                    'headings': ['Riddle Proof'],
+                    'links': [],
+                    'canvasCount': 0,
+                    'largeVisibleElements': [{'tag': 'h1', 'text': 'Riddle Proof'}],
+                }
+                return {
+                    'ok': True,
+                    'screenshots': [{'url': 'https://cdn.example.com/thrown-error.png'}],
+                    'outputs': [{'name': 'after-thrown-error.png', 'url': 'https://cdn.example.com/thrown-error.png'}],
+                    'result': {'pageState': page_state},
+                    'console': [
+                        'RIDDLE_PROOF_STATE:' + json.dumps(page_state),
+                        'Uncaught exception: ' + message,
+                    ],
+                    '_artifact_json': {
+                        'proof.json': {'script_error': message},
+                    },
+                }
             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}]
@@ -2568,6 +2603,58 @@ def run_verify_interaction_terminal_route_from_proof_evidence():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_verify_interaction_proof_evidence_overrides_stale_expected_path():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-stale-route-'))
+    state_path = tempdir / 'state.json'
+    try:
+        state = base_state(tempdir, reference='before')
+        state.update({
+            'recon_status': 'ready_for_proof_plan',
+            'author_status': 'ready',
+            'proof_plan_status': 'ready',
+            'implementation_status': 'changes_detected',
+            'verification_mode': 'interaction',
+            'server_path': '/',
+            'expected_terminal_path': '/state',
+            'before_cdn': 'https://cdn.example.com/before-home.png',
+            'proof_plan': 'Start at /, click Proof, and verify the terminal /proof/ route.',
+            'capture_script': "clickedProofNavigation(); await saveScreenshot('after-proof');",
+            'supervisor_author_packet': {
+                'proof_plan': 'Click Proof and prove the terminal route.',
+                'capture_script': "clickedProofNavigation(); await saveScreenshot('after-proof');",
+                'refined_inputs': {
+                    'server_path': '/',
+                    'expected_terminal_path': '/state',
+                },
+            },
+            'recon_results': {
+                'baselines': {'before': {'path': '/', 'url': 'https://cdn.example.com/before-home.png'}},
+            },
+        })
+        write_state(state_path, state)
+        os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+
+        fake = FakeRiddle()
+        load_util_with_fake(fake)
+        load_module('verify_interaction_stale_route_uses_evidence', VERIFY_PATH)
+        after_verify = json.loads(state_path.read_text())
+
+        assert after_verify['verify_status'] == 'evidence_captured'
+        assert after_verify['route_expectation']['source'] == 'proof_evidence_contract'
+        assert after_verify['route_expectation']['expected_path'] == '/proof'
+        route = after_verify['proof_assessment_request']['semantic_context']['route']
+        assert route['expected_after_path'] == '/proof'
+        assert route['after_observed_path'] == '/proof'
+        assert 'wrong route' not in after_verify['verify_results']['after']['observation']['reason']
+        return {
+            'ok': True,
+            'expected_path': after_verify['route_expectation']['expected_path'],
+            'source': after_verify['route_expectation']['source'],
+        }
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_verify_interaction_reverse_terminal_route_from_proof_evidence():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-reverse-'))
     state_path = tempdir / 'state.json'
@@ -2612,6 +2699,59 @@ def run_verify_interaction_reverse_terminal_route_from_proof_evidence():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_verify_interaction_prose_route_noise_uses_proof_evidence():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-prose-noise-'))
+    state_path = tempdir / 'state.json'
+    try:
+        state = base_state(tempdir, reference='before')
+        state.update({
+            'recon_status': 'ready_for_proof_plan',
+            'author_status': 'ready',
+            'proof_plan_status': 'ready',
+            'implementation_status': 'changes_detected',
+            'verification_mode': 'interaction',
+            'server_path': '/proof/',
+            'before_cdn': 'https://cdn.example.com/before-proof.png',
+            'proof_plan': 'Start on the proof page, click Home, and confirm the home page content is visible.',
+            'capture_script': "clickedHomeNavigation(); await saveScreenshot('after-home');",
+            'change_request': (
+                'Prior wrapper notes mentioned terminal drift to /Your and package '
+                '@riddledc/openclaw-riddle-proof, but those are prose diagnostics, not route expectations.'
+            ),
+            'success_criteria': (
+                'Use structured browser evidence for the terminal route; do not parse '
+                '/openclaw-riddle-proof from package text as the expected path.'
+            ),
+            'recon_results': {
+                'baselines': {'before': {'path': '/proof/', 'url': 'https://cdn.example.com/before-proof.png'}},
+            },
+        })
+        write_state(state_path, state)
+        os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+
+        fake = FakeRiddle()
+        load_util_with_fake(fake)
+        load_module('verify_interaction_prose_route_noise', VERIFY_PATH)
+        after_verify = json.loads(state_path.read_text())
+
+        assert after_verify['verify_status'] == 'evidence_captured'
+        assert after_verify['route_expectation']['source'] == 'proof_evidence_contract'
+        assert after_verify['route_expectation']['expected_path'] == '/'
+        route = after_verify['proof_assessment_request']['semantic_context']['route']
+        assert route['expected_after_path'] == '/'
+        assert route['after_observed_path'] == '/'
+        encoded = json.dumps(after_verify, sort_keys=True)
+        assert '"expected_path": "/Your"' not in encoded
+        assert '"expected_path": "/openclaw-riddle-proof"' not in encoded
+        return {
+            'ok': True,
+            'expected_path': after_verify['route_expectation']['expected_path'],
+            'source': after_verify['route_expectation']['source'],
+        }
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_verify_interaction_hash_terminal_route_from_proof_evidence():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-hash-'))
     state_path = tempdir / 'state.json'
@@ -2698,9 +2838,11 @@ def run_verify_interaction_authored_query_hash_mismatch_blocks_with_evidence():
         assert after_verify['route_expectation']['expected_query'] == 'rp_probe=1'
         assert after_verify['route_expectation']['expected_hash'] == '#pricing-probe'
         capture_quality = request['capture_quality']
-        assert capture_quality['decision'] in ('revise_capture', 'failed_proof_evidence', 'visual_delta_unmeasured')
-        assert request['recommended_stage'] in ('author', 'verify')
-        assert request['continue_with_stage'] in ('author', 'verify')
+        assert capture_quality['decision'] == 'failed_interaction_capture'
+        assert request['recommended_stage'] is None
+        assert request['continue_with_stage'] is None
+        assert capture_quality['blocking'] is True
+        assert capture_quality['terminal_blocker'] is True
         quality_text = json.dumps(capture_quality, sort_keys=True)
         assert 'page.waitForURL: Timeout 15000ms exceeded' in quality_text
         assert after_verify['proof_assessment_request'] == {}
@@ -2725,6 +2867,7 @@ def run_verify_interaction_authored_query_hash_mismatch_blocks_with_evidence():
             'ok': True,
             'summary': request['summary'],
             'recommended_stage': request['recommended_stage'],
+            'blocking': capture_quality['blocking'],
         }
     finally:
         shutil.rmtree(tempdir, ignore_errors=True)
@@ -2791,6 +2934,64 @@ def run_verify_interaction_query_hash_pass_uses_proof_evidence_route():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_verify_interaction_thrown_error_terminal_blocker():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-thrown-error-'))
+    state_path = tempdir / 'state.json'
+    try:
+        state = base_state(tempdir, reference='before')
+        state.update({
+            'recon_status': 'ready_for_proof_plan',
+            'author_status': 'ready',
+            'proof_plan_status': 'ready',
+            'implementation_status': 'changes_detected',
+            'verification_mode': 'interaction',
+            'server_path': '/',
+            'before_cdn': 'https://cdn.example.com/before-home.png',
+            'proof_plan': 'Run a diagnostic interaction script that intentionally throws.',
+            'capture_script': "interactionThrownError();",
+            'recon_results': {
+                'baselines': {'before': {'path': '/', 'url': 'https://cdn.example.com/before-home.png'}},
+            },
+        })
+        write_state(state_path, state)
+        os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+
+        fake = FakeRiddle()
+        load_util_with_fake(fake)
+        load_module('verify_interaction_thrown_error_terminal_blocker', VERIFY_PATH)
+        after_verify = json.loads(state_path.read_text())
+
+        assert after_verify['verify_status'] == 'capture_incomplete'
+        assert after_verify['merge_recommendation'] == 'do-not-merge'
+        assert after_verify['proof_assessment_request'] == {}
+        capture_quality = after_verify['verify_decision_request']['capture_quality']
+        assert capture_quality['decision'] == 'failed_interaction_capture'
+        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 'intentional-riddle-proof-0811-thrown-error' in capture_quality_text
+        assert after_verify['structured_interaction_capture_failure_summary']
+        evidence = after_verify['evidence_bundle']['proof_evidence']
+        if isinstance(evidence, list):
+            evidence = next(
+                record for record in evidence_records(evidence)
+                if record.get('version') == 'riddle-proof.interaction.capture-failure.v1'
+            )
+        assert evidence['version'] == 'riddle-proof.interaction.capture-failure.v1'
+        assert evidence['checks']['scriptCompleted'] is False
+        assert evidence['checks']['authoredEvidenceReturned'] is False
+        assert 'intentional-riddle-proof-0811-thrown-error' in evidence['capture_error']
+        return {
+            'ok': True,
+            'decision': capture_quality['decision'],
+            'blocking': capture_quality['blocking'],
+        }
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_verify_capture_retry_surfaces_script_timeout():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-capture-timeout-'))
     state_path = tempdir / 'state.json'
@@ -3209,10 +3410,13 @@ if __name__ == '__main__':
         'verify_capture_retry': run_verify_capture_retry(),
         'remote_audit_verify_uses_default_capture_script': run_remote_audit_verify_uses_default_capture_script(),
         'verify_interaction_terminal_route_from_proof_evidence': run_verify_interaction_terminal_route_from_proof_evidence(),
+        'verify_interaction_proof_evidence_overrides_stale_expected_path': run_verify_interaction_proof_evidence_overrides_stale_expected_path(),
         'verify_interaction_reverse_terminal_route_from_proof_evidence': run_verify_interaction_reverse_terminal_route_from_proof_evidence(),
+        'verify_interaction_prose_route_noise_uses_proof_evidence': run_verify_interaction_prose_route_noise_uses_proof_evidence(),
         'verify_interaction_hash_terminal_route_from_proof_evidence': run_verify_interaction_hash_terminal_route_from_proof_evidence(),
         'verify_interaction_authored_query_hash_mismatch_blocks_with_evidence': run_verify_interaction_authored_query_hash_mismatch_blocks_with_evidence(),
         'verify_interaction_query_hash_pass_uses_proof_evidence_route': run_verify_interaction_query_hash_pass_uses_proof_evidence_route(),
+        'verify_interaction_thrown_error_terminal_blocker': run_verify_interaction_thrown_error_terminal_blocker(),
         'verify_capture_retry_surfaces_script_timeout': run_verify_capture_retry_surfaces_script_timeout(),
         'missing_baseline_guard': run_verify_missing_baseline(),
         'ship_supervisor_gate': run_ship_missing_supervisor_gate(),

package/runtime/tests/trust_boundary_regression.py

@@ -25,12 +25,24 @@ CASES = [
         'function': 'run_verify_interaction_terminal_route_from_proof_evidence',
         'expected_terminal': 'pass',
     },
+    {
+        'name': 'route-change-retry-state-drift-ignored',
+        'covers': ['route-changing interactions', 'proof-evidence-present'],
+        'function': 'run_verify_interaction_proof_evidence_overrides_stale_expected_path',
+        'expected_terminal': 'pass',
+    },
     {
         'name': 'route-change-reverse-pass',
         'covers': ['route-changing interactions'],
         'function': 'run_verify_interaction_reverse_terminal_route_from_proof_evidence',
         'expected_terminal': 'pass',
     },
+    {
+        'name': 'route-prose-noise-ignored',
+        'covers': ['route-changing interactions', 'proof-evidence-present'],
+        'function': 'run_verify_interaction_prose_route_noise_uses_proof_evidence',
+        'expected_terminal': 'pass',
+    },
     {
         'name': 'query-hash-trailing-slash-pass',
         'covers': ['query/hash/trailing-slash URLs', 'proof-evidence-present'],
@@ -61,6 +73,12 @@ CASES = [
         'function': 'run_verify_preserves_proof_evidence_on_capture_script_error',
         'expected_terminal': 'specific_blocker',
     },
+    {
+        'name': 'interaction-thrown-error-specific-blocker',
+        'covers': ['thrown errors', 'invalid browser evidence'],
+        'function': 'run_verify_interaction_thrown_error_terminal_blocker',
+        'expected_terminal': 'specific_blocker',
+    },
     {
         'name': 'structured-proof-without-screenshot-pass',
         'covers': ['proof-evidence-present'],