@riddledc/riddle-proof 0.8.12 → 0.8.14

package/runtime/lib/verify.py

@@ -2029,7 +2029,7 @@ def interaction_proof_route_match(expected_path, proof_evidence):
         return None
     for record in proof_evidence_records_deep(proof_evidence):
         flag = explicit_route_match_flag(record)
-        candidate = terminal_path_from_record(record)
+        candidate = observed_terminal_path_from_record(record)
         if candidate and route_matches_expected(expected, candidate):
             return {
                 'matched': True,
@@ -2042,23 +2042,64 @@ def interaction_proof_route_match(expected_path, proof_evidence):
 
 
 EXPLICIT_TERMINAL_PATH_KEYS = (
+    'expected_url', 'expectedUrl',
+    'expected_href', 'expectedHref',
     'expected_terminal_path', 'expectedTerminalPath',
     'expected_terminal_url', 'expectedTerminalUrl',
+    'expected_terminal_href', 'expectedTerminalHref',
     'expected_terminal_route', 'expectedTerminalRoute',
+    'expected_route', 'expectedRoute',
     'terminal_path', 'terminalPath',
     'terminal_url', 'terminalUrl',
+    'terminal_href', 'terminalHref',
     'terminal_route', 'terminalRoute',
     'expected_after_path', 'expectedAfterPath',
     'expected_after_url', 'expectedAfterUrl',
+    'expected_after_href', 'expectedAfterHref',
     'expected_after_route', 'expectedAfterRoute',
     'after_path', 'afterPath',
     'after_url', 'afterUrl',
+    'after_href', 'afterHref',
     'after_route', 'afterRoute',
     'expected_final_path', 'expectedFinalPath',
     'expected_final_url', 'expectedFinalUrl',
+    'expected_final_href', 'expectedFinalHref',
     'expected_final_route', 'expectedFinalRoute',
     'final_path', 'finalPath',
     'final_url', 'finalUrl',
+    'final_href', 'finalHref',
+    'final_route', 'finalRoute',
+)
+EXPECTED_TERMINAL_PATH_KEYS = (
+    'expected_url', 'expectedUrl',
+    'expected_href', 'expectedHref',
+    'expected_path', 'expectedPath',
+    'expected_route', 'expectedRoute',
+    'expected_terminal_path', 'expectedTerminalPath',
+    'expected_terminal_url', 'expectedTerminalUrl',
+    'expected_terminal_href', 'expectedTerminalHref',
+    'expected_terminal_route', 'expectedTerminalRoute',
+    'expected_after_path', 'expectedAfterPath',
+    'expected_after_url', 'expectedAfterUrl',
+    'expected_after_href', 'expectedAfterHref',
+    'expected_after_route', 'expectedAfterRoute',
+    'expected_final_path', 'expectedFinalPath',
+    'expected_final_url', 'expectedFinalUrl',
+    'expected_final_href', 'expectedFinalHref',
+    'expected_final_route', 'expectedFinalRoute',
+)
+OBSERVED_TERMINAL_PATH_KEYS = (
+    'terminal_path', 'terminalPath',
+    'terminal_url', 'terminalUrl',
+    'terminal_href', 'terminalHref',
+    'terminal_route', 'terminalRoute',
+    'after_path', 'afterPath',
+    'after_url', 'afterUrl',
+    'after_href', 'afterHref',
+    'after_route', 'afterRoute',
+    'final_path', 'finalPath',
+    'final_url', 'finalUrl',
+    'final_href', 'finalHref',
     'final_route', 'finalRoute',
 )
 FULL_LOCATION_PATH_KEYS = (
@@ -2087,6 +2128,19 @@ AFTER_STATE_KEYS = (
     'final', 'final_state', 'finalState',
     'expected_final', 'expectedFinal',
 )
+EXPECTED_STATE_KEYS = (
+    'expected', 'expectation',
+    'route_expectation', 'routeExpectation',
+    'expected_after', 'expectedAfter',
+    'expected_terminal', 'expectedTerminal',
+    'expected_final', 'expectedFinal',
+)
+OBSERVED_STATE_KEYS = (
+    'observed', 'actual',
+    'after', 'after_state', 'afterState',
+    'terminal', 'terminal_state', 'terminalState',
+    'final', 'final_state', 'finalState',
+)
 EVIDENCE_CONTAINER_KEYS = (
     'proofEvidence', 'proof_evidence',
     'interactionEvidence', 'interaction_evidence',
@@ -2113,10 +2167,10 @@ def path_candidate(value):
     return ''
 
 
-def record_path_candidate(record, allow_location_keys=False):
+def record_path_candidate_for_keys(record, keys, allow_location_keys=False):
     if not isinstance(record, dict):
         return ''
-    keys = list(EXPLICIT_TERMINAL_PATH_KEYS)
+    keys = list(keys)
     if allow_location_keys:
         keys.extend(LOCATION_PATH_KEYS)
     for key in keys:
@@ -2126,6 +2180,10 @@ def record_path_candidate(record, allow_location_keys=False):
     return ''
 
 
+def record_path_candidate(record, allow_location_keys=False):
+    return record_path_candidate_for_keys(record, EXPLICIT_TERMINAL_PATH_KEYS, allow_location_keys)
+
+
 def terminal_path_from_record(record, depth=0):
     if not isinstance(record, dict) or depth > 4:
         return ''
@@ -2168,6 +2226,74 @@ def terminal_path_from_record(record, depth=0):
     return ''
 
 
+def expected_terminal_path_from_record(record, depth=0):
+    if not isinstance(record, dict) or depth > 4:
+        return ''
+    candidate = record_path_candidate_for_keys(record, EXPECTED_TERMINAL_PATH_KEYS)
+    if candidate:
+        return candidate
+    for key in EXPECTED_STATE_KEYS:
+        value = record.get(key)
+        if isinstance(value, dict):
+            candidate = (
+                record_path_candidate_for_keys(value, EXPECTED_TERMINAL_PATH_KEYS, allow_location_keys=True)
+                or expected_terminal_path_from_record(value, depth + 1)
+            )
+            if candidate:
+                return candidate
+        elif isinstance(value, list):
+            for item in value:
+                candidate = expected_terminal_path_from_record(item, depth + 1)
+                if candidate:
+                    return candidate
+    for key in EVIDENCE_CONTAINER_KEYS:
+        value = record.get(key)
+        if isinstance(value, dict):
+            candidate = expected_terminal_path_from_record(value, depth + 1)
+            if candidate:
+                return candidate
+        elif isinstance(value, list):
+            for item in value:
+                candidate = expected_terminal_path_from_record(item, depth + 1)
+                if candidate:
+                    return candidate
+    return ''
+
+
+def observed_terminal_path_from_record(record, depth=0):
+    if not isinstance(record, dict) or depth > 4:
+        return ''
+    candidate = record_path_candidate_for_keys(record, OBSERVED_TERMINAL_PATH_KEYS)
+    if candidate:
+        return candidate
+    for key in OBSERVED_STATE_KEYS:
+        value = record.get(key)
+        if isinstance(value, dict):
+            candidate = (
+                record_path_candidate_for_keys(value, OBSERVED_TERMINAL_PATH_KEYS, allow_location_keys=True)
+                or observed_terminal_path_from_record(value, depth + 1)
+            )
+            if candidate:
+                return candidate
+        elif isinstance(value, list):
+            for item in value:
+                candidate = observed_terminal_path_from_record(item, depth + 1)
+                if candidate:
+                    return candidate
+    for key in EVIDENCE_CONTAINER_KEYS:
+        value = record.get(key)
+        if isinstance(value, dict):
+            candidate = observed_terminal_path_from_record(value, depth + 1)
+            if candidate:
+                return candidate
+        elif isinstance(value, list):
+            for item in value:
+                candidate = observed_terminal_path_from_record(item, depth + 1)
+                if candidate:
+                    return candidate
+    return ''
+
+
 def text_path_candidate(value):
     if not isinstance(value, str):
         return ''
@@ -2421,17 +2547,20 @@ def interaction_capture_failure_evidence_summary(proof_evidence):
 
 def interaction_terminal_path_from_evidence(proof_evidence):
     for record in proof_evidence_records(proof_evidence):
-        candidate = terminal_path_from_record(record)
+        candidate = expected_terminal_path_from_record(record)
         if candidate:
             return candidate, 'proof_evidence_contract'
-    if interaction_assertions_pass(proof_evidence):
+    route_evidence_passed = interaction_assertions_pass(proof_evidence)
+    if not route_evidence_passed:
+        for record in proof_evidence_records_deep(proof_evidence):
+            if interaction_assertions_pass(record) or explicit_route_match_flag(record) is True:
+                route_evidence_passed = True
+                break
+    if route_evidence_passed:
         for record in proof_evidence_records(proof_evidence):
-            for key in AFTER_STATE_KEYS:
-                value = record.get(key)
-                if isinstance(value, dict):
-                    candidate = record_path_candidate(value, allow_location_keys=True)
-                    if candidate:
-                        return candidate, 'proof_evidence_after_state'
+            candidate = observed_terminal_path_from_record(record)
+            if candidate:
+                return candidate, 'proof_evidence_contract'
     return '', ''
 
 
@@ -2469,6 +2598,16 @@ def proof_evidence_should_override_state_terminal_path(state_candidate, evidence
         return False
     if not state_candidate:
         return True
+    state_parts = route_parts(state_candidate)
+    evidence_parts = route_parts(evidence_candidate)
+    if (
+        state_parts.get('pathname') == evidence_parts.get('pathname')
+        and (
+            (evidence_parts.get('query') and not state_parts.get('query'))
+            or (evidence_parts.get('hash') and not state_parts.get('hash'))
+        )
+    ):
+        return True
     if route_matches_expected(state_candidate, evidence_candidate):
         return False
     if interaction_assertions_pass(proof_evidence):
@@ -2953,6 +3092,25 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
         and route_expectation.get('terminal_path')
         and route_expectation_source != 'recon_start_path'
     )
+    if authored_terminal_route:
+        expected = route_mismatch.get('expected_path') or ''
+        observed = route_mismatch.get('observed_after_path') or ''
+        summary = 'Interaction proof terminal route mismatch: expected ' + (expected or '(unknown)') + ', got ' + (observed or '(unknown)') + '.'
+        if error_messages:
+            reasons.append('Capture script error: ' + error_messages[0][:500])
+            summary += ' Capture script error: ' + error_messages[0][:300]
+        reasons.append('Route mismatch: expected after capture path ' + (expected or '(unknown)') + ', observed ' + (observed or '(unknown)') + '.')
+        reasons.append('The terminal route came from authored interaction proof evidence, so the captured browser evidence is the terminal blocker instead of an author retry loop.')
+        return {
+            'decision': 'failed_interaction_capture',
+            'summary': summary,
+            'recommended_stage': None,
+            'continue_with_stage': None,
+            'blocking': True,
+            'terminal_blocker': True,
+            'reasons': reasons,
+            'mismatch': route_mismatch,
+        }
     recommended_stage = 'recon' if 'wrong route' in reason and not authored_terminal_route else 'author'
     mismatch = None
     if recommended_stage == 'recon':
@@ -3742,6 +3900,16 @@ has_judgable_failed_interaction_evidence = (
     and not proof_evidence_blocker
     and not visual_delta_recovery
 )
+route_expectation = s.get('route_expectation') if isinstance(s.get('route_expectation'), dict) else {}
+authored_terminal_route_mismatch = (
+    verification_mode in INTERACTION_MODES
+    and 'wrong route' in str(after_observation.get('reason') or '')
+    and bool(route_expectation.get('terminal_path'))
+    and str(route_expectation.get('source') or '') != 'recon_start_path'
+)
+if authored_terminal_route_mismatch:
+    has_judgable_failed_interaction_evidence = False
+    summary_lines.append('Structured interaction route gate: authored terminal route mismatch is a terminal capture blocker.')
 has_good_evidence = (
     required_baseline_present
     and (after_observation.get('valid') or has_judgable_failed_interaction_evidence)

package/runtime/tests/recon_verify_smoke.py

@@ -325,6 +325,75 @@ 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': {
+                        'expectedUrlReachedBeforeDrop': True,
+                        'expectedUrlStillPresentAtTerminal': False,
+                        'queryDropped': True,
+                        'hashDropped': True,
+                        'routeExpectationSourceIsCaptureScriptExpectedUrl': True,
+                        'shouldTerminalizeAsFailedInteractionCapture': True,
+                        'terminalMainVisible': True,
+                    },
+                    'checks': {
+                        'routeMatches': False,
+                        'specificMismatchDetected': 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,
@@ -2934,6 +3003,78 @@ 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'
@@ -3416,6 +3557,7 @@ if __name__ == '__main__':
         '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(),

package/runtime/tests/trust_boundary_regression.py

@@ -55,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'],