@riddledc/riddle-proof 0.8.3 → 0.8.4

package/dist/runner.js

@@ -1,10 +1,10 @@
 import {
   runRiddleProof
-} from "./chunk-ZX45XGDJ.js";
-import "./chunk-TNCDVE5O.js";
-import "./chunk-U4FUFBSH.js";
+} from "./chunk-UIJ7X63P.js";
+import "./chunk-YZUVEJ5B.js";
+import "./chunk-FMOYUYH2.js";
 import "./chunk-RV6LK7HU.js";
-import "./chunk-SKIAZTQ7.js";
+import "./chunk-4FOHZ7JG.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";
 export {

package/dist/spec/checkpoint.cjs

@@ -121,7 +121,7 @@ function responseSchemaForAuthorPacket() {
       summary: { type: "string" },
       payload: {
         type: "object",
-        description: "For decision=author_packet, provide the proof packet itself or {author_packet:{...}} with proof_plan and capture_script."
+        description: "For decision=author_packet, provide the proof packet itself or {author_packet:{...}} with proof_plan, capture_script, and refined_inputs.expected_terminal_path when the proof changes route, query, or hash."
       },
       reasons: { type: "array", items: { type: "string" } },
       continue_with_stage: { type: "string", enum: ["author", "recon"] },
@@ -428,9 +428,11 @@ function buildAuthorCheckpointPacket(input) {
       repo: input.request.repo || fullState.repo,
       branch: input.request.branch || fullState.branch,
       verification_mode: input.request.verification_mode || fullState.verification_mode,
+      success_criteria: fullState.success_criteria,
       reference: input.request.reference || fullState.reference,
       server_path: fullState.server_path,
       wait_for_selector: fullState.wait_for_selector,
+      route_expectation: jsonCloneRecord(fullState.route_expectation),
       author_summary: fullState.author_summary,
       author_request: jsonCloneRecord(authorRequest),
       recon_baseline_understanding: jsonCloneRecord(fullState.recon_baseline_understanding),

package/dist/spec/checkpoint.js

@@ -13,7 +13,7 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "../chunk-SKIAZTQ7.js";
+} from "../chunk-4FOHZ7JG.js";
 import "../chunk-VY4Y5U57.js";
 import "../chunk-MLKGABMK.js";
 export {

package/dist/spec/index.cjs

@@ -344,7 +344,7 @@ function responseSchemaForAuthorPacket() {
       summary: { type: "string" },
       payload: {
         type: "object",
-        description: "For decision=author_packet, provide the proof packet itself or {author_packet:{...}} with proof_plan and capture_script."
+        description: "For decision=author_packet, provide the proof packet itself or {author_packet:{...}} with proof_plan, capture_script, and refined_inputs.expected_terminal_path when the proof changes route, query, or hash."
       },
       reasons: { type: "array", items: { type: "string" } },
       continue_with_stage: { type: "string", enum: ["author", "recon"] },
@@ -651,9 +651,11 @@ function buildAuthorCheckpointPacket(input) {
       repo: input.request.repo || fullState.repo,
       branch: input.request.branch || fullState.branch,
       verification_mode: input.request.verification_mode || fullState.verification_mode,
+      success_criteria: fullState.success_criteria,
       reference: input.request.reference || fullState.reference,
       server_path: fullState.server_path,
       wait_for_selector: fullState.wait_for_selector,
+      route_expectation: jsonCloneRecord(fullState.route_expectation),
       author_summary: fullState.author_summary,
       author_request: jsonCloneRecord(authorRequest),
       recon_baseline_understanding: jsonCloneRecord(fullState.recon_baseline_understanding),

package/dist/spec/index.js

@@ -10,11 +10,11 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "../chunk-TNCDVE5O.js";
+} from "../chunk-YZUVEJ5B.js";
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
-} from "../chunk-U4FUFBSH.js";
+} from "../chunk-FMOYUYH2.js";
 import {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
@@ -30,7 +30,7 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "../chunk-SKIAZTQ7.js";
+} from "../chunk-4FOHZ7JG.js";
 import {
   applyTerminalMetadata,
   compactRecord,

package/dist/spec/run-card.js

@@ -1,8 +1,8 @@
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
-} from "../chunk-U4FUFBSH.js";
-import "../chunk-SKIAZTQ7.js";
+} from "../chunk-FMOYUYH2.js";
+import "../chunk-4FOHZ7JG.js";
 import "../chunk-VY4Y5U57.js";
 import "../chunk-MLKGABMK.js";
 export {

package/dist/spec/state.js

@@ -9,9 +9,9 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "../chunk-TNCDVE5O.js";
-import "../chunk-U4FUFBSH.js";
-import "../chunk-SKIAZTQ7.js";
+} from "../chunk-YZUVEJ5B.js";
+import "../chunk-FMOYUYH2.js";
+import "../chunk-4FOHZ7JG.js";
 import "../chunk-VY4Y5U57.js";
 import "../chunk-MLKGABMK.js";
 export {

package/dist/state.js

@@ -9,9 +9,9 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-TNCDVE5O.js";
-import "./chunk-U4FUFBSH.js";
-import "./chunk-SKIAZTQ7.js";
+} from "./chunk-YZUVEJ5B.js";
+import "./chunk-FMOYUYH2.js";
+import "./chunk-4FOHZ7JG.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riddledc/riddle-proof",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",

package/runtime/lib/util.py

@@ -710,6 +710,60 @@ def invoke(tool, args, timeout=180):
         return {'ok': False, 'error': r.stdout[:300], 'stderr': r.stderr[:300]}
 
 
+def compact_error_text(value, depth=0):
+    if depth > 4 or value is None:
+        return ''
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (int, float, bool)):
+        return str(value)
+    if isinstance(value, list):
+        return '\n'.join(compact_error_text(item, depth + 1) for item in value[:12])
+    if isinstance(value, dict):
+        parts = []
+        priority_keys = (
+            'error', 'message', 'script_error', 'stderr', 'stdout', 'raw',
+            'details', 'result', 'capture', 'proof', '_proof_json',
+        )
+        for key in priority_keys:
+            if key in value:
+                text = compact_error_text(value.get(key), depth + 1)
+                if text:
+                    parts.append(text)
+        if not parts:
+            for item in list(value.values())[:12]:
+                text = compact_error_text(item, depth + 1)
+                if text:
+                    parts.append(text)
+        return '\n'.join(parts)
+    return ''
+
+
+def non_retryable_riddle_script_error(result):
+    text = compact_error_text(result).lower()
+    if not text:
+        return False
+    playwright_timeout = (
+        'timeout' in text
+        and (
+            'locator.' in text
+            or 'page.waitforurl' in text
+            or 'page.waitforselector' in text
+            or 'waiting for selector' in text
+            or 'waiting for navigation' in text
+            or 'getbyrole' in text
+            or 'getbytext' in text
+            or 'scrollintoviewifneeded' in text
+        )
+    )
+    deterministic_playwright_error = (
+        'strict mode violation' in text
+        or 'selector_not_found' in text
+        or 'index_out_of_range' in text
+    )
+    return playwright_timeout or deterministic_playwright_error
+
+
 def invoke_retry(tool, args, retries=3, timeout=180):
     """Call an OpenClaw tool with automatic retries on failure."""
     last_result = None
@@ -720,6 +774,9 @@ def invoke_retry(tool, args, retries=3, timeout=180):
         if result.get('ok') or 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):
+            print('invoke_retry(riddle_script) stopping early for deterministic Playwright script error')
+            return result
         if attempt < retries:
             import time
             time.sleep(5)

package/runtime/lib/verify.py

@@ -1845,16 +1845,17 @@ def normalize_observed_path(value):
     raw = str(value or '').strip()
     if not raw:
         return ''
-    parsed = urlparse(raw.split('#', 1)[0])
+    parsed = urlparse(raw)
     path = parsed.path or ''
     query = parsed.query or ''
+    fragment = parsed.fragment or ''
     if not path.startswith('/'):
         path = '/' + path.lstrip('/')
     parts = path.split('/')
     if len(parts) >= 4 and parts[1] == 's':
         path = '/' + '/'.join(parts[3:])
     path = path.rstrip('/') or '/'
-    return path + (('?' + query) if query else '')
+    return path + (('?' + query) if query else '') + (('#' + fragment) if fragment else '')
 
 
 def observed_location_from_page_state(page_state):
@@ -1862,10 +1863,13 @@ def observed_location_from_page_state(page_state):
         return ''
     pathname = str(page_state.get('pathname') or '').strip()
     search = str(page_state.get('search') or '').strip()
+    hash_value = str(page_state.get('hash') or page_state.get('fragment') or '').strip()
     if search and not search.startswith('?'):
         search = '?' + search
+    if hash_value and not hash_value.startswith('#'):
+        hash_value = '#' + hash_value
     if pathname:
-        return pathname + search
+        return pathname + search + hash_value
     return str(page_state.get('href') or '').strip()
 
 
@@ -1889,9 +1893,29 @@ def route_matches_expected(expected_path, observed_path):
         if pair not in remaining:
             return False
         remaining.remove(pair)
+    if expected_parsed.fragment and observed_parsed.fragment != expected_parsed.fragment:
+        return False
     return True
 
 
+def route_parts(value):
+    normalized = normalize_observed_path(value)
+    if not normalized:
+        return {
+            'href': '',
+            'pathname': '',
+            'query': '',
+            'hash': '',
+        }
+    parsed = urlparse(normalized)
+    return {
+        'href': normalized,
+        'pathname': parsed.path.rstrip('/') or '/',
+        'query': parsed.query or '',
+        'hash': ('#' + parsed.fragment) if parsed.fragment else '',
+    }
+
+
 EXPLICIT_TERMINAL_PATH_KEYS = (
     'expected_terminal_path', 'expectedTerminalPath',
     'expected_terminal_route', 'expectedTerminalRoute',
@@ -1980,6 +2004,16 @@ def terminal_path_from_record(record, depth=0):
     return ''
 
 
+def terminal_path_from_text(value):
+    if not isinstance(value, str):
+        return ''
+    for match in re.findall(r"""['"`](/[^'"`\s]+[?#][^'"`\s]*)['"`]""", value):
+        candidate = path_candidate(match)
+        if candidate:
+            return candidate
+    return ''
+
+
 def interaction_assertions_pass(value):
     for record in proof_evidence_records(value):
         if any(record.get(key) is False for key in (
@@ -2039,29 +2073,58 @@ def interaction_terminal_path_from_state(state):
         candidate = terminal_path_from_record(state.get(key))
         if candidate:
             return candidate, key
+    for key in (
+        'expected_terminal_path',
+        'expected_after_path',
+        'capture_script',
+        'proof_plan',
+        'success_criteria',
+        'change_request',
+    ):
+        candidate = path_candidate(state.get(key)) or terminal_path_from_text(state.get(key))
+        if candidate:
+            return candidate, key
     return '', ''
 
 
 def expected_path_for_verify(state, start_path, proof_evidence):
     mode = normalized_verification_mode(state.get('verification_mode'))
     normalized_start = normalize_observed_path(start_path) or '/'
+    start_parts = route_parts(normalized_start)
     if mode not in INTERACTION_MODES:
         return normalized_start, {
             'mode': mode,
             'source': 'recon_start_path',
             'start_path': normalized_start,
             'expected_path': normalized_start,
+            'start_pathname': start_parts['pathname'],
+            'start_query': start_parts['query'],
+            'start_hash': start_parts['hash'],
+            'expected_pathname': start_parts['pathname'],
+            'expected_query': start_parts['query'],
+            'expected_hash': start_parts['hash'],
         }
     candidate, source = interaction_terminal_path_from_state(state)
     if not candidate:
         candidate, source = interaction_terminal_path_from_evidence(proof_evidence)
     expected = candidate or normalized_start
+    expected_parts = route_parts(expected)
     return expected, {
         'mode': mode,
         'source': source or 'recon_start_path',
         'start_path': normalized_start,
         'expected_path': expected,
         'terminal_path': expected if expected != normalized_start else '',
+        'start_pathname': start_parts['pathname'],
+        'start_query': start_parts['query'],
+        'start_hash': start_parts['hash'],
+        'expected_href': expected_parts['href'],
+        'expected_pathname': expected_parts['pathname'],
+        'expected_query': expected_parts['query'],
+        'expected_hash': expected_parts['hash'],
+        'terminal_pathname': expected_parts['pathname'] if expected != normalized_start else '',
+        'terminal_query': expected_parts['query'] if expected != normalized_start else '',
+        'terminal_hash': expected_parts['hash'] if expected != normalized_start else '',
     }
 
 
@@ -2391,6 +2454,19 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
             'reasons': reasons,
         }
 
+    details = after_observation.get('details') if isinstance(after_observation.get('details'), dict) else {}
+    route_mismatch = None
+    reason_text = str(after_observation.get('reason') or '')
+    if 'wrong route' in reason_text:
+        expected = details.get('expected_path') or ''
+        observed = details.get('observed_path_raw') or details.get('observed_path') or ''
+        if expected or observed:
+            route_mismatch = {
+                'field': 'route',
+                'expected_path': expected,
+                'observed_after_path': observed,
+            }
+
     if proof_evidence_blocker:
         reasons.append(proof_evidence_blocker)
         decision = 'missing_proof_evidence'
@@ -2399,19 +2475,36 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
             reasons.append('The capture reached usable page context, but the proof evidence explicitly failed its own required audio gate.')
         else:
             reasons.append('The capture reached usable page context, but the proof script did not emit the structured evidence required for this verification mode.')
+        if route_mismatch:
+            reasons.append(
+                'Route mismatch also present: expected after capture path ' +
+                (route_mismatch.get('expected_path') or '(unknown)') +
+                ', observed ' +
+                (route_mismatch.get('observed_after_path') or '(unknown)') +
+                '.'
+            )
         reasons.append('Return to author so the capture script can expose passing proof evidence before verify asks for a supervising-agent judgment.')
+        summary = proof_evidence_blocker
+        if route_mismatch:
+            summary += (
+                ' Route mismatch: expected ' +
+                (route_mismatch.get('expected_path') or '(unknown)') +
+                ', got ' +
+                (route_mismatch.get('observed_after_path') or '(unknown)') +
+                '.'
+            )
         return {
             'decision': decision,
-            'summary': proof_evidence_blocker,
+            'summary': summary,
             'recommended_stage': 'author',
             'continue_with_stage': 'author',
             'reasons': reasons,
+            'mismatch': route_mismatch,
         }
 
     reason = after_observation.get('reason') or 'after capture is not usable yet'
     reasons.append('The after evidence is not usable yet: ' + reason)
     recommended_stage = 'recon' if 'wrong route' in reason else 'author'
-    details = after_observation.get('details') if isinstance(after_observation.get('details'), dict) else {}
     error_messages = [
         str(item).strip()
         for item in (details.get('capture_error_messages') or [])
@@ -2528,6 +2621,9 @@ def build_semantic_context(state, results, after_observation, expected_path):
     after_semantic = semantic_observation('after', after_observation)
     expected_start_path = state.get('expected_start_path') or expected_path
     route_expectation = state.get('route_expectation') if isinstance(state.get('route_expectation'), dict) else {}
+    expected_parts = route_parts(expected_path)
+    start_parts = route_parts(expected_start_path)
+    after_parts = route_parts(after_semantic.get('observed_path_raw') or after_semantic.get('observed_path') or '')
     return {
         'expected_path': expected_path,
         'expected_start_path': expected_start_path,
@@ -2540,10 +2636,20 @@ def build_semantic_context(state, results, after_observation, expected_path):
             'expected_after_path': expected_path,
             'expected_start_path': expected_start_path,
             'expected_terminal_path': route_expectation.get('terminal_path') or '',
+            'expected_pathname': expected_parts['pathname'],
+            'expected_query': expected_parts['query'],
+            'expected_hash': expected_parts['hash'],
+            'expected_start_pathname': start_parts['pathname'],
+            'expected_start_query': start_parts['query'],
+            'expected_start_hash': start_parts['hash'],
+            'expected_terminal_query': route_expectation.get('terminal_query') or route_expectation.get('expected_query') or '',
+            'expected_terminal_hash': route_expectation.get('terminal_hash') or route_expectation.get('expected_hash') or '',
             'expectation_source': route_expectation.get('source') or '',
             'before_observed_path': before_semantic.get('observed_path') or before.get('path') or '',
             'prod_observed_path': prod_semantic.get('observed_path') or prod.get('path') or '',
             'after_observed_path': after_semantic.get('observed_path') or '',
+            'after_observed_query': after_parts['query'],
+            'after_observed_hash': after_parts['hash'],
         },
         'before': before_semantic,
         'prod': prod_semantic,
@@ -3051,6 +3157,15 @@ if expected_start_path and expected_start_path != expected_path:
     summary_lines.append('Expected terminal proof path: ' + expected_path)
 else:
     summary_lines.append('Expected proof path from recon: ' + expected_path)
+route_expected_query = (s.get('route_expectation') or {}).get('expected_query') or ''
+route_expected_hash = (s.get('route_expectation') or {}).get('expected_hash') or ''
+if route_expected_query or route_expected_hash:
+    summary_lines.append(
+        'Expected terminal query/hash: ' +
+        ('?' + route_expected_query if route_expected_query else '(none)') +
+        ' ' +
+        (route_expected_hash if route_expected_hash else '(none)')
+    )
 summary_lines.append('After observation: ' + after_observation['reason'])
 supporting = results['after'].get('supporting_artifacts') or {}
 if supporting.get('has_structured_payload'):
@@ -3064,6 +3179,14 @@ if supporting.get('has_structured_payload'):
     summary_lines.append('Structured after evidence: ' + ('; '.join(basis) if basis else 'present'))
 observed_path = (after_observation.get('details') or {}).get('observed_path') or expected_path
 summary_lines.append('Observed after path: ' + observed_path)
+observed_parts = route_parts((after_observation.get('details') or {}).get('observed_path_raw') or observed_path)
+if observed_parts.get('query') or observed_parts.get('hash') or route_expected_query or route_expected_hash:
+    summary_lines.append(
+        'Observed after query/hash: ' +
+        ('?' + observed_parts.get('query') if observed_parts.get('query') else '(none)') +
+        ' ' +
+        (observed_parts.get('hash') if observed_parts.get('hash') else '(none)')
+    )
 details = after_observation.get('details') or {}
 if details.get('headings'):
     summary_lines.append('Visible headings: ' + '; '.join(str(item) for item in details.get('headings', [])[:6]))

package/runtime/tests/recon_verify_smoke.py

@@ -249,6 +249,47 @@ class FakeRiddle:
                         'largeVisibleElements': [{'tag': 'button', 'text': 'Buy Now'}],
                     }),
                 }
+            if 'clickedSkipHashNavigation' in script:
+                page_state = {
+                    'bodyTextLength': 180,
+                    'visibleTextSample': 'Riddle Proof homepage main content',
+                    'interactiveElements': 4,
+                    'visibleInteractiveElements': 4,
+                    'pathname': '/',
+                    'search': '',
+                    'hash': '#main-content',
+                    'title': 'Riddle',
+                    'buttons': ['Start Free'],
+                    'headings': ['Riddle Proof'],
+                    'links': [{'text': 'Skip to main content', 'href': '#main-content'}],
+                    'canvasCount': 0,
+                    'largeVisibleElements': [{'tag': 'main', 'text': 'Riddle Proof'}],
+                }
+                proof_evidence = {
+                    'before': {'href': 'https://riddledc.com/'},
+                    'action': 'clicked Skip to main content',
+                    'after': {'href': 'https://riddledc.com/#main-content'},
+                    'assertions': {
+                        'startedOnHome': True,
+                        'hashPreserved': True,
+                        'mainContentFocused': True,
+                    },
+                }
+                return {
+                    'ok': True,
+                    'screenshots': [{'url': 'https://cdn.example.com/hash-after.png'}],
+                    'outputs': [{'name': 'after-hash.png', 'url': 'https://cdn.example.com/hash-after.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 'clickedProofNavigation' in script:
                 page_state = {
                     'bodyTextLength': 180,
@@ -1376,6 +1417,34 @@ def run_project_build_retries_after_clean_failure():
         shutil.rmtree(tempdir)
 
 
+def run_invoke_retry_stops_on_playwright_locator_timeout():
+    util = load_module('util_retry_timeout', UTIL_PATH)
+    calls = []
+    original_invoke = util.invoke
+    original_sleep = util.time.sleep
+
+    def fake_invoke(tool, args, timeout=180):
+        calls.append({'tool': tool, 'args': args, 'timeout': timeout})
+        return {
+            'ok': False,
+            'error': 'locator.scrollIntoViewIfNeeded: Timeout 30000ms exceeded',
+        }
+
+    try:
+        util.invoke = fake_invoke
+        util.time.sleep = lambda _seconds: None
+        result = util.invoke_retry('riddle_script', {'script': 'await page.locator("a").click();'}, retries=3, timeout=60)
+        assert result['ok'] is False
+        assert len(calls) == 1, calls
+        calls.clear()
+        generic = util.invoke_retry('riddle_preview', {'directory': '/tmp/nope'}, retries=3, timeout=60)
+        assert generic['ok'] is False
+        assert len(calls) == 3, calls
+    finally:
+        util.invoke = original_invoke
+        util.time.sleep = original_sleep
+
+
 def run_implement_records_detection_when_changes_missing():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-implement-missing-'))
     state_path = tempdir / 'state.json'
@@ -2381,6 +2450,51 @@ def run_verify_interaction_reverse_terminal_route_from_proof_evidence():
         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'
+    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 the skip link, and verify the terminal /#main-content route.',
+            'capture_script': "clickedSkipHashNavigation(); await saveScreenshot('after-hash');",
+            '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_hash_terminal_route', VERIFY_PATH)
+        after_verify = json.loads(state_path.read_text())
+
+        assert after_verify['verify_status'] == 'evidence_captured'
+        assert after_verify['route_expectation']['expected_path'] == '/#main-content'
+        assert after_verify['route_expectation']['expected_hash'] == '#main-content'
+        route = after_verify['proof_assessment_request']['semantic_context']['route']
+        assert route['expected_after_path'] == '/#main-content'
+        assert route['expected_terminal_hash'] == '#main-content'
+        assert route['after_observed_path'] == '/#main-content'
+        assert route['after_observed_hash'] == '#main-content'
+        assert 'wrong route' not in after_verify['verify_results']['after']['observation']['reason']
+        return {
+            'ok': True,
+            'expected_path': after_verify['route_expectation']['expected_path'],
+            'after_observed_hash': route['after_observed_hash'],
+        }
+    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'
@@ -2778,6 +2892,7 @@ if __name__ == '__main__':
         'capture_diagnostics_redaction': run_capture_diagnostics_redact_sensitive_values(),
         'apply_auth_context': run_apply_auth_context_passes_supported_auth_payloads(),
         'run_project_build_retries_after_clean_failure': run_project_build_retries_after_clean_failure(),
+        'invoke_retry_stops_on_playwright_locator_timeout': run_invoke_retry_stops_on_playwright_locator_timeout(),
         'implement_records_detection_when_changes_missing': run_implement_records_detection_when_changes_missing(),
         'implement_ignores_tool_noise_when_detecting_changes': run_implement_ignores_tool_noise_when_detecting_changes(),
         'verify_quality_ignores_proof_telemetry_console_text': run_verify_quality_ignores_proof_telemetry_console_text(),
@@ -2798,6 +2913,7 @@ if __name__ == '__main__':
         '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_reverse_terminal_route_from_proof_evidence': run_verify_interaction_reverse_terminal_route_from_proof_evidence(),
+        'verify_interaction_hash_terminal_route_from_proof_evidence': run_verify_interaction_hash_terminal_route_from_proof_evidence(),
         '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(),