@riddledc/riddle-proof 0.8.28 → 0.8.30

package/runtime/lib/setup.py

@@ -6,7 +6,7 @@ scratch storage by default:
   /var/tmp/riddle-proof/.riddle-proof-worktrees/riddle-proof-<run_id>-after
 """
 
-import json, subprocess as sp, os, sys, shutil, time, tempfile
+import json, subprocess as sp, os, sys, shutil, time, tempfile, re
 from urllib.parse import urlparse
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from util import load_state, save_state, git, shell_quote
@@ -223,6 +223,76 @@ def interaction_verification_mode():
     )
 
 
+def normalize_route_path(value):
+    raw = str(value or '').strip()
+    if not raw:
+        return ''
+    try:
+        parsed = urlparse(raw if raw.startswith(('http://', 'https://')) else raw)
+        path = parsed.path or '/'
+        if not path.startswith('/'):
+            path = '/' + path
+        if len(path) > 1:
+            path = path.rstrip('/')
+        query = ('?' + parsed.query) if parsed.query else ''
+        fragment = ('#' + parsed.fragment) if parsed.fragment else ''
+        return path + query + fragment
+    except Exception:
+        path = raw.split('#', 1)[0].split('?', 1)[0]
+        if not path.startswith('/'):
+            path = '/' + path
+        return path.rstrip('/') or '/'
+
+
+def trim_route_candidate(value):
+    return str(value or '').strip().rstrip('),.;]}')
+
+
+def expected_terminal_route_from_text(value):
+    text = str(value or '').strip()
+    if not text:
+        return ''
+    route_pattern = r'(https?://[^\s"\'<>`]+|/[^\s"\'<>`]+)'
+    patterns = [
+        r'\bexpected\s+(?:terminal\s+|final\s+|after\s+)?(?:url|route|path)\s*(?:is|=|:)\s*' + route_pattern,
+        r'\b(?:terminal|final|after)\s+(?:url|route|path)\s*(?:is|=|:)\s*' + route_pattern,
+        r'\b(?:ends|end|ending|lands|land|landing)\s+(?:at|on)\s*' + route_pattern,
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            route = normalize_route_path(trim_route_candidate(match.group(1)))
+            if route:
+                return route
+    return ''
+
+
+def requested_expected_terminal_route():
+    return (
+        expected_terminal_route_from_text(s.get('success_criteria')) or
+        expected_terminal_route_from_text(s.get('change_request')) or
+        expected_terminal_route_from_text(s.get('context')) or
+        expected_terminal_route_from_text(s.get('assertions_json'))
+    )
+
+
+def apply_interaction_route_contract(start_path):
+    if not interaction_verification_mode():
+        return
+    terminal_path = requested_expected_terminal_route()
+    if not terminal_path:
+        return
+    normalized_start = normalize_route_path(start_path) or '/'
+    s['requested_expected_terminal_path'] = terminal_path
+    s['expected_terminal_path'] = s.get('expected_terminal_path') or terminal_path
+    s['expected_start_path'] = s.get('expected_start_path') or normalized_start
+    contract = s.get('interaction_contract') if isinstance(s.get('interaction_contract'), dict) else {}
+    contract = dict(contract)
+    contract['start_path'] = contract.get('start_path') or normalized_start
+    contract['expected_terminal_path'] = contract.get('expected_terminal_path') or terminal_path
+    s['interaction_contract'] = contract
+
+
 def remote_audit_mode():
     return bool(s.get('remote_audit')) or (
         not repo
@@ -550,6 +620,7 @@ if remote_audit_mode():
     s['allow_code_changes'] = False
     s['server_path'] = s.get('server_path') or target_path
     s['server_path_source'] = s.get('server_path_source') or 'prod_url'
+    apply_interaction_route_contract(s['server_path'])
     s['recon_status'] = 'ready_for_proof_plan'
     s['recon_summary'] = 'Remote audit/no-diff run uses prod_url as the current target and skips repo worktrees.'
     s['recon_hypothesis'] = {

package/runtime/lib/verify.py

@@ -3222,7 +3222,7 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
     }
 
 
-def build_capture_retry_decision(after_observation, required_baseline_present, proof_evidence_blocker='', route_expectation=None):
+def build_capture_retry_decision(after_observation, required_baseline_present, proof_evidence_blocker='', route_expectation=None, verification_mode=''):
     reasons = []
     if not required_baseline_present:
         reasons.append('Recon baseline is missing, so verify should return to recon instead of guessing a new reference context.')
@@ -3361,6 +3361,17 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
         elif error_messages:
             reasons.append('Capture script error: ' + error_messages[0][:500])
             summary = 'Verify capture script failed: ' + error_messages[0][:300]
+            reasons.append('The capture script produced a concrete browser/runtime failure, so this run should block with that exact evidence instead of re-authoring in a loop.')
+            return {
+                'decision': 'failed_interaction_capture' if normalized_verification_mode(verification_mode) in INTERACTION_MODES else 'failed_capture',
+                'summary': summary,
+                'recommended_stage': None,
+                'continue_with_stage': None,
+                'blocking': True,
+                'terminal_blocker': True,
+                'reasons': reasons,
+                'mismatch': None,
+            }
         else:
             summary = 'Verify needs another internal capture iteration before the evidence can be judged.'
         reasons.append('The capture plan itself needs revision, so author should tighten the proof script or framing inputs.')
@@ -4248,6 +4259,7 @@ else:
         required_baseline_present,
         proof_evidence_blocker or structured_interaction_capture_failure_summary,
         s.get('route_expectation') or {},
+        s.get('verification_mode') or '',
     )
     if visual_delta_recovery:
         observation_reason = str(after_observation.get('reason') or '')

package/runtime/tests/recon_verify_smoke.py

@@ -1700,13 +1700,33 @@ def run_remote_interaction_audit_setup_requires_authoring():
         assert state['recon_status'] == 'ready_for_proof_plan'
         assert state['author_status'] == 'needs_authoring'
         assert state['proof_plan_status'] == 'needs_authoring'
+        assert state['requested_expected_terminal_path'] == '/proof'
+        assert state['expected_terminal_path'] == '/proof'
+        assert state['expected_start_path'] == '/'
+        assert state['interaction_contract']['start_path'] == '/'
+        assert state['interaction_contract']['expected_terminal_path'] == '/proof'
         assert state.get('capture_script', '') == ''
         assert state.get('capture_script_source', '') == ''
         assert 'requires an authored browser interaction capture' in state['author_summary']
+
+        with temporary_env(RIDDLE_PROOF_STATE_FILE=str(state_path)):
+            sys.modules.pop('util', None)
+            try:
+                load_module('author_remote_interaction_audit_request', AUTHOR_PATH)
+            except SystemExit as exc:
+                assert exc.code in (0, None), exc
+        after_author = json.loads(state_path.read_text())
+        assert after_author['author_status'] == 'needs_supervisor_judgment'
+        assert after_author['author_request']['fallback_defaults']['server_path'] == '/'
+        assert after_author['author_request']['fallback_defaults']['expected_start_path'] == '/'
+        assert after_author['author_request']['fallback_defaults']['expected_terminal_path'] == '/proof'
+        assert after_author['author_request']['fallback_defaults']['capture_script'] == ''
+        assert after_author['author_request']['interaction_contract']['expected_terminal_path'] == '/proof'
         return {
             'ok': True,
-            'author_status': state['author_status'],
-            'capture_script_source': state.get('capture_script_source', ''),
+            'author_status': after_author['author_status'],
+            'expected_terminal_path': after_author['expected_terminal_path'],
+            'capture_script_source': after_author.get('capture_script_source', ''),
         }
     finally:
         sys.modules.pop('util', None)
@@ -2062,6 +2082,8 @@ def run_recon_then_author_request():
         assert after_author['author_runtime_model_hint'] == 'openai-codex/gpt-5.4'
         assert after_author['author_request']['status'] == 'needs_supervisor_judgment'
         assert after_author['author_request']['fallback_defaults']['server_path'] == '/pricing'
+        assert after_author['author_request']['fallback_defaults']['expected_start_path'] == '/pricing'
+        assert after_author['author_request']['fallback_defaults']['expected_terminal_path'] == ''
         assert 'supervising agent owns proof authoring' in after_author['author_request']['instructions'][0].lower()
 
         return {
@@ -2400,6 +2422,8 @@ def run_author_keeps_interaction_start_route():
         assert after_author['expected_start_path'] == '/'
         assert after_author['expected_terminal_path'] == '/proof/'
         assert after_author['author_packet']['refined_inputs']['server_path'] == '/'
+        assert after_author['author_packet']['refined_inputs']['expected_start_path'] == '/'
+        assert after_author['author_packet']['refined_inputs']['expected_terminal_path'] == '/proof/'
         assert after_author['author_warnings']
         assert 'terminal interaction route' in after_author['author_warnings'][0]
         return {
@@ -3685,11 +3709,15 @@ def run_verify_capture_retry_surfaces_script_timeout():
 
         assert after_verify['verify_status'] == 'capture_incomplete'
         capture_quality = after_verify['verify_decision_request']['capture_quality']
-        assert capture_quality['recommended_stage'] in ('author', 'verify')
+        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 'locator.click: Timeout 30000ms exceeded' in capture_quality_text
         return {
             'ok': True,
+            'decision': capture_quality['decision'],
             'summary': capture_quality['summary'],
         }
     finally: