@riddledc/riddle-proof 0.8.17 → 0.8.18

package/examples/regression-packs/oc-flow-regression.json

@@ -4,8 +4,8 @@
   "public_name": "Riddle Proof OC Flow Regression Pack",
   "description": "Reusable regression pack for the trust boundary between browser evidence, verifier judgment, retry policy, wrapper checkpoint handling, and terminal status.",
   "minimum_versions": {
-    "@riddledc/openclaw-riddle-proof": "0.4.144",
-    "@riddledc/riddle-proof": "0.8.16"
+    "@riddledc/openclaw-riddle-proof": "0.4.146",
+    "@riddledc/riddle-proof": "0.8.18"
   },
   "runtime_gate": {
     "tool": "riddle_proof_status",
@@ -26,6 +26,7 @@
     "required_cases": [
       "route-change-forward-pass",
       "route-change-retry-state-drift-ignored",
+      "route-change-proof-plan-placeholder-ignored",
       "route-change-reverse-pass",
       "route-change-reverse-nested-terminal-url-pass",
       "query-hash-trailing-slash-pass",

package/package.json

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

package/runtime/lib/verify.py

@@ -2319,11 +2319,22 @@ def text_path_candidate(value):
     return path_candidate(raw)
 
 
+PROSE_ROUTE_PLACEHOLDER_PATHS = {
+    '/href',
+    '/path',
+    '/pathname',
+    '/route',
+    '/url',
+}
+
+
 def text_route_candidate(value):
     candidate = text_path_candidate(value)
     if not candidate:
         return ''
     parsed = urlparse(candidate)
+    if (parsed.path or '').lower() in PROSE_ROUTE_PLACEHOLDER_PATHS and not parsed.query and not parsed.fragment:
+        return ''
     first_segment = next((part for part in (parsed.path or '').split('/') if part), '')
     if first_segment and first_segment[:1].isupper():
         return ''
@@ -2350,11 +2361,11 @@ def terminal_path_from_text(value):
 def interaction_assertions_pass(value):
     for record in proof_evidence_records(value):
         if any(record.get(key) is False for key in (
-            'passed', 'ok', 'proofReady', 'proof_ready', 'routeMatches', 'route_matches',
+            'passed', 'pass', 'ok', 'success', 'proofReady', 'proof_ready', 'routeMatches', 'route_matches',
         )):
             return False
         if any(record.get(key) is True for key in (
-            'passed', 'ok', 'proofReady', 'proof_ready', 'interactionPassed', 'interaction_passed',
+            'passed', 'pass', 'ok', 'success', 'proofReady', 'proof_ready', 'interactionPassed', 'interaction_passed',
         )):
             return True
         for key in ('assertions', 'checks', 'predicates', 'expectations'):
@@ -2369,7 +2380,7 @@ def interaction_assertions_pass(value):
                     if isinstance(item, bool):
                         bools.append(item)
                     elif isinstance(item, dict):
-                        for flag_key in ('passed', 'ok', 'valid'):
+                        for flag_key in ('passed', 'pass', 'ok', 'valid', 'success'):
                             if isinstance(item.get(flag_key), bool):
                                 bools.append(item.get(flag_key))
                                 break
@@ -2381,6 +2392,7 @@ def interaction_assertions_pass(value):
 INTERACTION_ASSERTION_CONTAINER_KEYS = ('assertions', 'checks', 'predicates', 'expectations')
 INTERACTION_FAILURE_FLAG_KEYS = (
     'passed',
+    'pass',
     'ok',
     'valid',
     'success',

package/runtime/tests/recon_verify_smoke.py

@@ -444,6 +444,62 @@ class FakeRiddle:
                         'totalPixels': 972000,
                     },
                 }
+            if 'clickedProofNavigationOcLiveShape' in script:
+                page_state = {
+                    'bodyTextLength': 4113,
+                    'visibleTextSample': 'RIDDLE PROOF Turn a URL into evidence an agent can cite.',
+                    'interactiveElements': 6,
+                    'visibleInteractiveElements': 6,
+                    'pathname': '/proof/',
+                    'href': 'https://riddledc.com/proof/',
+                    'title': 'Riddle Proof',
+                    'buttons': ['Proof'],
+                    'headings': ['Riddle Proof'],
+                    'links': [],
+                    'canvasCount': 0,
+                    'largeVisibleElements': [{'tag': 'h1', 'text': 'Riddle Proof'}],
+                }
+                proof_evidence = {
+                    'version': 'riddle-proof.interaction.v1',
+                    'expectedUrl': 'https://riddledc.com/proof/',
+                    'routeExpectationSource': 'capture_script.expectedUrl',
+                    'startRoute': {'url': 'https://riddledc.com/', 'pathname': '/'},
+                    'terminalRoute': {'url': 'https://riddledc.com/proof/', 'pathname': '/proof/'},
+                    'action': {'type': 'click', 'target': 'visible Proof navigation link', 'clicked': True},
+                    'startState': {'url': 'https://riddledc.com/', 'pathname': '/'},
+                    'terminalState': {'url': 'https://riddledc.com/proof/', 'pathname': '/proof/'},
+                    'assertions': [
+                        {
+                            'name': 'route expectation source is capture_script.expectedUrl',
+                            'pass': True,
+                            'routeExpectationSource': 'capture_script.expectedUrl',
+                            'expectedUrl': 'https://riddledc.com/proof/',
+                        },
+                        {'name': 'start URL is production home', 'pass': True, 'startPathname': '/'},
+                        {
+                            'name': 'terminal URL matched expected proof route',
+                            'pass': True,
+                            'terminalUrl': 'https://riddledc.com/proof/',
+                        },
+                        {'name': 'Proof page content visible', 'pass': True},
+                    ],
+                    'success': True,
+                }
+                return {
+                    'ok': True,
+                    'screenshots': [{'url': 'https://cdn.example.com/proof-after.png'}],
+                    'outputs': [{'name': 'after-proof.png', 'url': 'https://cdn.example.com/proof-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,
@@ -2787,6 +2843,51 @@ def run_verify_interaction_proof_evidence_overrides_stale_expected_path():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_verify_interaction_proof_plan_placeholder_uses_live_evidence():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-placeholder-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': '/',
+            'before_cdn': 'https://cdn.example.com/before-home.png',
+            'proof_plan': 'Start at /, click Proof, and verify the terminal pathname /pathname.',
+            'capture_script': "clickedProofNavigationOcLiveShape(); await saveScreenshot('after-proof');",
+            '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_placeholder_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 after_verify.get('expected_terminal_path') == '/proof'
+        assert '/pathname' not in json.dumps(after_verify['route_expectation'])
+        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'
@@ -3665,6 +3766,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_proof_evidence_overrides_stale_expected_path': run_verify_interaction_proof_evidence_overrides_stale_expected_path(),
+        'verify_interaction_proof_plan_placeholder_uses_live_evidence': run_verify_interaction_proof_plan_placeholder_uses_live_evidence(),
         'verify_interaction_reverse_terminal_route_from_proof_evidence': run_verify_interaction_reverse_terminal_route_from_proof_evidence(),
         'verify_interaction_reverse_terminal_expected_url_from_nested_terminal_evidence': run_verify_interaction_reverse_terminal_expected_url_from_nested_terminal_evidence(),
         'verify_interaction_prose_route_noise_uses_proof_evidence': run_verify_interaction_prose_route_noise_uses_proof_evidence(),

package/runtime/tests/trust_boundary_regression.py

@@ -31,6 +31,12 @@ CASES = [
         'function': 'run_verify_interaction_proof_evidence_overrides_stale_expected_path',
         'expected_terminal': 'pass',
     },
+    {
+        'name': 'route-change-proof-plan-placeholder-ignored',
+        'covers': ['route-changing interactions', 'proof-evidence-present'],
+        'function': 'run_verify_interaction_proof_plan_placeholder_uses_live_evidence',
+        'expected_terminal': 'pass',
+    },
     {
         'name': 'route-change-reverse-pass',
         'covers': ['route-changing interactions'],