@riddledc/riddle-proof 0.5.13 → 0.5.15

package/package.json

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

package/runtime/lib/recon.py

@@ -244,7 +244,7 @@ def score_route_candidate(path, tokens):
 def choose_target_path(explicit_path, prod_url, route_hints, tokens=None, explicit_source=''):
     explicit = (explicit_path or '').strip()
     explicit_source = (explicit_source or '').strip()
-    is_meaningful_explicit = bool(explicit) and (explicit != '/' or explicit_source in ('user', 'tool_param', 'supervising_agent'))
+    is_meaningful_explicit = bool(explicit) and (explicit != '/' or bool(explicit_source))
     if is_meaningful_explicit:
         return explicit if explicit.startswith('/') else '/' + explicit
     candidates = route_candidates(route_hints, prod_url)
@@ -719,7 +719,7 @@ initial_target_path = choose_target_path(s.get('server_path', ''), s.get('prod_u
 selected_route = next((item for item in route_options if item.get('path') == initial_target_path), None)
 initial_hypothesis = {
     'target_path': initial_target_path,
-    'path_source': 'state.server_path' if (s.get('server_path') or '').strip() and (s.get('server_path') != '/' or server_path_source) else ((selected_route or {}).get('reason') or 'fallback root'),
+    'path_source': ('state.server_path:' + server_path_source) if (s.get('server_path') or '').strip() and (s.get('server_path') != '/' or server_path_source) else ((selected_route or {}).get('reason') or 'fallback root'),
     'reference': requested_reference,
     'mode': s.get('mode', 'server'),
     'wait_for_selector': (s.get('wait_for_selector') or '').strip(),

package/runtime/lib/verify.py

@@ -7,7 +7,7 @@ while good captures produce a structured evidence packet that the supervising ag
 must assess before the wrapper routes back into author/implement/recon work or ship.
 """
 
-import json, os, sys
+import json, os, sys, time
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from util import (
     append_capture_diagnostic,
@@ -83,6 +83,53 @@ def auto_screenshot_for_mode(verification_mode):
     return normalized_verification_mode(verification_mode) not in STRUCTURED_FIRST_MODES
 
 
+def record_verify_phase(phase, status='running', summary=''):
+    global s
+    ts = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
+    try:
+        current = load_state()
+    except Exception:
+        current = dict(s)
+    runtime_step = current.get('current_runtime_step') if isinstance(current.get('current_runtime_step'), dict) else {}
+    if not runtime_step:
+        runtime_step = {
+            'step': 'verify',
+            'action': 'run',
+            'status': 'running',
+            'started_at': ts,
+            'workflow_file': 'riddle-proof-verify.lobster',
+        }
+    runtime_step['step'] = 'verify'
+    runtime_step['action'] = 'run'
+    runtime_step['status'] = 'running'
+    runtime_step['workflow_file'] = 'riddle-proof-verify.lobster'
+    runtime_step['phase'] = phase
+    runtime_step['phase_status'] = status
+    if status == 'running':
+        runtime_step['phase_started_at'] = ts
+        runtime_step.pop('phase_finished_at', None)
+    else:
+        runtime_step['phase_finished_at'] = ts
+    if summary:
+        runtime_step['summary'] = summary
+    current['current_runtime_step'] = runtime_step
+    events = current.get('runtime_events') if isinstance(current.get('runtime_events'), list) else []
+    events.append({
+        'ts': ts,
+        'kind': 'workflow.phase.' + ('started' if status == 'running' else 'finished'),
+        'step': 'verify',
+        'phase': phase,
+        'summary': summary or (phase + ' ' + status),
+        'details': {'status': status},
+    })
+    current['runtime_events'] = events[-100:]
+    current['runtime_updated_at'] = ts
+    save_state(current)
+    for key in ('current_runtime_step', 'runtime_events', 'runtime_updated_at'):
+        if key in current:
+            s[key] = current[key]
+
+
 def payload_has_capture_artifacts(payload):
     if not isinstance(payload, dict):
         return False
@@ -108,6 +155,7 @@ def capture_payload_error(payload):
 
 def abort_capture_failure(state, results, expected_path, message, raw_payload):
     summary = 'After capture failed before usable proof artifacts were produced: ' + str(message).strip()
+    record_verify_phase('capture', 'failed', summary)
     observation = {
         'valid': False,
         'reason': summary,
@@ -979,16 +1027,20 @@ if existing_prod:
     print('Prod baseline: ' + existing_prod)
 
 # AFTER (always from after worktree)
+record_verify_phase('build', 'running', 'Building after worktree for verify capture.')
 print('Cleaning after .next cache...')
 sp.run('rm -rf .next', shell=True, cwd=after_dir, capture_output=True)
 
 print('Building after worktree...')
 br = sp.run(build_cmd, shell=True, cwd=after_dir, capture_output=True, text=True, timeout=600)
 if br.returncode != 0:
+    record_verify_phase('build', 'failed', 'After build failed: ' + br.stderr[:300])
     raise SystemExit('After build failed: ' + br.stderr[:500])
+record_verify_phase('build', 'completed', 'After worktree build completed.')
 
 after_payload = {}
 static_reason = should_use_static_preview(after_dir, s) if mode == 'server' else ''
+record_verify_phase('capture', 'running', 'Capturing after-proof evidence.')
 if mode == 'server' and not static_reason:
     build_dir, server_command, server_exclude = prepare_server_preview(after_dir, s)
 
@@ -1051,8 +1103,10 @@ else:
 after_observation = evaluate_capture_quality(after_payload, expected_path, verification_mode)
 results['after']['observation'] = after_observation
 results['after']['supporting_artifacts'] = collect_supporting_artifacts(after_payload)
+record_verify_phase('capture', 'completed', 'After-proof capture completed.')
 
 # Structured proof summary
+record_verify_phase('assessment', 'running', 'Assessing verify evidence bundle.')
 s['verify_results'] = results
 s['stage'] = 'verify'
 assertions = s.get('parsed_assertions')
@@ -1211,6 +1265,7 @@ s['evidence_notes'] = [
 ]
 
 save_state(s)
+record_verify_phase('assessment', 'completed', 'Verify evidence assessment completed.')
 
 assessment_status = 'awaiting_supervising_agent' if s.get('verify_status') == 'evidence_captured' else 'capture_incomplete'
 

package/runtime/tests/recon_verify_smoke.py

@@ -207,6 +207,30 @@ class FakeRiddle:
                         'largeVisibleElements': [{'tag': 'button', 'text': 'Reset Game'}],
                     }),
                 }
+            if (
+                'preview.example.com' in script
+                and '/pricing' not in script
+                and '/games/tic-tac-toe' not in script
+                and '/wrong' not in script
+            ):
+                return {
+                    'ok': True,
+                    'screenshots': [{'url': 'https://cdn.example.com/home-before.png'}],
+                    'outputs': [{'name': 'before.png', 'url': 'https://cdn.example.com/home-before.png'}],
+                    'console': state_console({
+                        'bodyTextLength': 180,
+                        'visibleTextSample': 'Riddle Proof homepage hero Start Free',
+                        'interactiveElements': 4,
+                        'visibleInteractiveElements': 4,
+                        'pathname': '/',
+                        'title': 'Riddle',
+                        'buttons': ['Start Free'],
+                        'headings': ['Riddle Proof'],
+                        'links': [],
+                        'canvasCount': 0,
+                        'largeVisibleElements': [{'tag': 'button', 'text': 'Start Free'}],
+                    }),
+                }
             raise AssertionError(f'unexpected riddle_script payload: {script}')
         raise AssertionError(f'unexpected invoke_retry tool: {tool}')
 
@@ -581,6 +605,53 @@ def run_recon_prefers_route_literals_over_import_paths():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_recon_prefers_hint_root_over_single_route_literal():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-hint-root-'))
+    state_path = tempdir / 'state.json'
+    try:
+        route_snippet = "export const routes = [{ path: '/docs/riddle-proof/markdown', element: <Docs /> }];\n"
+        state = base_state(tempdir, reference='before')
+        make_project(tempdir / 'before', route_snippet)
+        make_project(tempdir / 'after', route_snippet)
+        state.update({
+            'server_path': '/',
+            'server_path_source': 'hint_cache',
+            'capture_hint': {
+                'source': 'hint_cache',
+                'applied_fields': ['server_path'],
+                'selected': {'server_path': '/'},
+            },
+            'change_request': 'Make a tiny harmless homepage copy tweak',
+            'success_criteria': 'The homepage hero copy reflects the tiny tweak.',
+        })
+        write_state(state_path, state)
+        os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+
+        fake = FakeRiddle()
+        load_util_with_fake(fake)
+        load_module('recon_hint_root_preference', RECON_PATH)
+        after_recon = json.loads(state_path.read_text())
+
+        current_plan = after_recon['recon_results']['current_plan']
+        candidate_paths = [item['path'] for item in current_plan['route_candidates']]
+        assert current_plan['target_path'] == '/', current_plan
+        assert current_plan['path_source'] == 'state.server_path:hint_cache', current_plan
+        assert '/docs/riddle-proof/markdown' in candidate_paths, candidate_paths
+        details = after_recon['recon_results']['attempt_history'][-1]['observations']['before']['details']
+        assert details['observed_path'] == '/'
+        assert 'Start Free' in details['visible_text_sample'], details
+        assert details['buttons'] == ['Start Free'], details
+
+        return {
+            'ok': True,
+            'target_path': current_plan['target_path'],
+            'path_source': current_plan['path_source'],
+            'candidate_paths': candidate_paths,
+        }
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_author_applies_supervisor_packet():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-supervisor-apply-'))
     state_path = tempdir / 'state.json'
@@ -697,6 +768,13 @@ def run_verify_requests_supervisor_assessment():
         assert after_details['observed_path_raw'] == '/s/pv-after/pricing', after_details
         assert 'Buy Now' in after_details['visible_text_sample'], after_details
         assert after_details['buttons'] == ['Buy Now'], after_details
+        runtime_events = after_verify.get('runtime_events') or []
+        assert any(event.get('kind') == 'workflow.phase.started' and event.get('step') == 'verify' and event.get('phase') == 'build' for event in runtime_events)
+        assert any(event.get('kind') == 'workflow.phase.finished' and event.get('step') == 'verify' and event.get('phase') == 'build' for event in runtime_events)
+        assert any(event.get('kind') == 'workflow.phase.started' and event.get('step') == 'verify' and event.get('phase') == 'capture' for event in runtime_events)
+        assert any(event.get('kind') == 'workflow.phase.finished' and event.get('step') == 'verify' and event.get('phase') == 'capture' for event in runtime_events)
+        assert any(event.get('kind') == 'workflow.phase.started' and event.get('step') == 'verify' and event.get('phase') == 'assessment' for event in runtime_events)
+        assert any(event.get('kind') == 'workflow.phase.finished' and event.get('step') == 'verify' and event.get('phase') == 'assessment' for event in runtime_events)
 
         return {
             'ok': True,
@@ -1182,6 +1260,7 @@ if __name__ == '__main__':
         'verify_quality_ignores_proof_telemetry_console_text': run_verify_quality_ignores_proof_telemetry_console_text(),
         'recon_then_author_request': run_recon_then_author_request(),
         'recon_route_literal_preference': run_recon_prefers_route_literals_over_import_paths(),
+        'recon_hint_root_preference': run_recon_prefers_hint_root_over_single_route_literal(),
         'author_applies_supervisor_packet': run_author_applies_supervisor_packet(),
         'verify_requests_supervisor_assessment': run_verify_requests_supervisor_assessment(),
         'verify_structured_evidence_without_screenshot': run_verify_structured_evidence_without_screenshot(),