@riddledc/riddle-proof 0.8.11 → 0.8.13

package/runtime/tests/recon_verify_smoke.py

@@ -325,6 +325,70 @@ class FakeRiddle:
                         'proof.json': {'script_error': message},
                     },
                 }
+            if 'pricingQueryHashStructuredNegativeControl' in script:
+                page_state = {
+                    'bodyTextLength': 260,
+                    'visibleTextSample': 'Pricing One rate Browser Compute Example Costs',
+                    'interactiveElements': 8,
+                    'visibleInteractiveElements': 8,
+                    'pathname': '/pricing/',
+                    'search': '',
+                    'hash': '',
+                    'title': 'Pricing',
+                    'buttons': [],
+                    'headings': ['Pricing', 'Browser Compute'],
+                    'links': [{'text': 'Pricing', 'href': '/pricing/?rp_probe=1#pricing-probe'}],
+                    'canvasCount': 0,
+                    'largeVisibleElements': [{'tag': 'main', 'text': 'Pricing'}],
+                }
+                proof_evidence = {
+                    'version': 'riddle-proof.interaction.v1',
+                    'probe': 'query-hash-dropped-negative-control',
+                    'negativeControl': True,
+                    'routeExpectationSource': 'capture_script.expectedUrl',
+                    'expectedUrl': 'https://riddledc.com/pricing/?rp_probe=1#pricing-probe',
+                    'expectedHref': '/pricing/?rp_probe=1#pricing-probe',
+                    'intentionalObservedUrl': 'https://riddledc.com/pricing/',
+                    'start': {'href': 'https://riddledc.com/', 'pathname': '/', 'search': '', 'hash': ''},
+                    'action': {
+                        'type': 'rewrite-pricing-link-click-then-drop-query-hash',
+                        'afterClickHref': 'https://riddledc.com/pricing/?rp_probe=1#pricing-probe',
+                        'afterClickPathname': '/pricing/',
+                        'afterClickSearch': '?rp_probe=1',
+                        'afterClickHash': '#pricing-probe',
+                        'expectedNavigationReached': True,
+                    },
+                    'terminal': {
+                        'href': 'https://riddledc.com/pricing/',
+                        'pathname': '/pricing/',
+                        'search': '',
+                        'hash': '',
+                    },
+                    'assertions': {
+                        'expectedUrlPreserved': True,
+                        'expectedUrlReachedBeforeDrop': True,
+                        'routeExpectationSourceIsCaptureScriptExpectedUrl': True,
+                        'terminalIntentionallyDroppedQueryHash': True,
+                        'terminalUrlMismatchIsIntentional': True,
+                        'terminalMainVisible': True,
+                    },
+                    'errors': [],
+                }
+                return {
+                    'ok': True,
+                    'screenshots': [{'url': 'https://cdn.example.com/pricing-negative-control.png'}],
+                    'outputs': [{'name': 'after-pricing-negative-control.png', 'url': 'https://cdn.example.com/pricing-negative-control.png'}],
+                    'result': {'pageState': page_state, 'proofEvidence': proof_evidence},
+                    'console': [
+                        'RIDDLE_PROOF_STATE:' + json.dumps(page_state),
+                        'RIDDLE_PROOF_EVIDENCE:' + json.dumps(proof_evidence),
+                    ],
+                    'visual_diff': {
+                        'diffPercentage': 1.2,
+                        'differentPixels': 12000,
+                        'totalPixels': 972000,
+                    },
+                }
             if 'pricingQueryHashPassesWithPageStateHashGap' in script:
                 page_state = {
                     'bodyTextLength': 260,
@@ -345,7 +409,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 +549,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 +2667,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'
@@ -2751,9 +2902,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'] == {}
@@ -2778,6 +2931,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)
@@ -2844,6 +2998,136 @@ def run_verify_interaction_query_hash_pass_uses_proof_evidence_route():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_verify_interaction_explicit_expected_url_blocks_dropped_terminal_route():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-explicit-expected-url-mismatch-'))
+    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': 'Start at /, click Pricing, and intentionally prove the query/hash route mismatch.',
+            'capture_script': "pricingQueryHashStructuredNegativeControl();",
+            'supervisor_author_packet': {
+                'proof_plan': 'Use expectedUrl as the route expectation and return structured evidence for the dropped query/hash terminal URL.',
+                'capture_script': "pricingQueryHashStructuredNegativeControl();",
+                'refined_inputs': {
+                    'server_path': '/',
+                },
+            },
+            '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_explicit_expected_url_blocks_dropped_terminal_route', VERIFY_PATH)
+        after_verify = json.loads(state_path.read_text())
+
+        request = after_verify['verify_decision_request']
+        assert after_verify['verify_status'] == 'capture_incomplete'
+        assert after_verify['merge_recommendation'] == 'do-not-merge'
+        assert after_verify['route_expectation']['source'] == 'proof_evidence_contract'
+        assert after_verify['route_expectation']['expected_path'] == '/pricing?rp_probe=1#pricing-probe'
+        assert after_verify['route_expectation']['expected_query'] == 'rp_probe=1'
+        assert after_verify['route_expectation']['expected_hash'] == '#pricing-probe'
+        assert request['recommended_stage'] is None
+        assert request['continue_with_stage'] is None
+        capture_quality = request['capture_quality']
+        assert capture_quality['decision'] == 'failed_interaction_capture'
+        assert capture_quality['blocking'] is True
+        assert capture_quality['terminal_blocker'] is True
+        assert capture_quality['mismatch']['expected_path'] == '/pricing?rp_probe=1#pricing-probe'
+        assert capture_quality['mismatch']['observed_after_path'] in ('/pricing', '/pricing/')
+        assert 'Interaction proof terminal route mismatch' in capture_quality['summary']
+        assert after_verify['proof_assessment_request'] == {}
+        observation = request['latest_observation']
+        assert observation['valid'] is False
+        assert 'wrong route' in observation['reason']
+        supporting = after_verify['verify_results']['after']['supporting_artifacts']
+        assert supporting['proof_evidence_present'] is True
+        assert supporting['has_structured_payload'] is True
+        route = after_verify['evidence_bundle']['semantic_context']['route']
+        assert route['expected_terminal_query'] == 'rp_probe=1'
+        assert route['expected_terminal_hash'] == '#pricing-probe'
+        assert route['after_observed_path'] == '/pricing'
+        assert route['after_observed_query'] == ''
+        assert route['after_observed_hash'] == ''
+        return {
+            'ok': True,
+            'decision': capture_quality['decision'],
+            'summary': capture_quality['summary'],
+        }
+    finally:
+        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'
@@ -3262,11 +3546,14 @@ 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_explicit_expected_url_blocks_dropped_terminal_route': run_verify_interaction_explicit_expected_url_blocks_dropped_terminal_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,6 +25,12 @@ 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'],
@@ -49,6 +55,12 @@ CASES = [
         'function': 'run_verify_interaction_authored_query_hash_mismatch_blocks_with_evidence',
         'expected_terminal': 'specific_blocker',
     },
+    {
+        'name': 'query-hash-dropped-structured-negative-blocker',
+        'covers': ['query/hash/trailing-slash URLs', 'invalid browser evidence', 'proof-evidence-present'],
+        'function': 'run_verify_interaction_explicit_expected_url_blocks_dropped_terminal_route',
+        'expected_terminal': 'specific_blocker',
+    },
     {
         'name': 'same-page-hash-pass',
         'covers': ['same-page hashes'],
@@ -67,6 +79,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'],