@riddledc/riddle-proof 0.5.14 → 0.5.16

package/package.json

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

package/runtime/lib/util.py

@@ -566,6 +566,41 @@ def git(cmd, cwd):
     return sp.run(cmd, shell=True, cwd=cwd, capture_output=True, text=True)
 
 
+def run_project_build(project_dir, build_cmd, timeout=600, clean_cache_dir='.next'):
+    """Build once with existing cache, then retry clean if the cached build fails."""
+    attempts = []
+    for clean_first in (False, True):
+        if clean_first and clean_cache_dir:
+            cache_path = os.path.join(project_dir, clean_cache_dir)
+            if os.path.exists(cache_path):
+                sp.run(
+                    'rm -rf ' + shell_quote(clean_cache_dir),
+                    shell=True,
+                    cwd=project_dir,
+                    capture_output=True,
+                    text=True,
+                )
+        result = sp.run(build_cmd, shell=True, cwd=project_dir, capture_output=True, text=True, timeout=timeout)
+        attempts.append({
+            'clean_first': clean_first,
+            'returncode': int(result.returncode),
+            'stderr': (result.stderr or '')[:500],
+        })
+        if result.returncode == 0:
+            return {
+                'result': result,
+                'clean_retry_used': clean_first,
+                'attempts': attempts,
+            }
+        if not clean_cache_dir or clean_first:
+            break
+    return {
+        'result': result,
+        'clean_retry_used': False,
+        'attempts': attempts,
+    }
+
+
 def load_package_json(project_dir):
     package_json = os.path.join(project_dir, 'package.json')
     if not os.path.exists(package_json):

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,
@@ -20,6 +20,7 @@ from util import (
     load_state,
     prepare_server_preview,
     record_successful_capture_hint,
+    run_project_build,
     save_state,
     should_use_static_preview,
     summarize_capture_artifacts,
@@ -83,6 +84,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 +156,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 +1028,23 @@ if existing_prod:
     print('Prod baseline: ' + existing_prod)
 
 # AFTER (always from after worktree)
-print('Cleaning after .next cache...')
-sp.run('rm -rf .next', shell=True, cwd=after_dir, capture_output=True)
-
+record_verify_phase('build', 'running', 'Building after worktree for verify capture.')
 print('Building after worktree...')
-br = sp.run(build_cmd, shell=True, cwd=after_dir, capture_output=True, text=True, timeout=600)
+build_attempt = run_project_build(after_dir, build_cmd, timeout=600, clean_cache_dir='.next')
+br = build_attempt.get('result')
+if build_attempt.get('clean_retry_used'):
+    print('Verify build recovered after cleaning .next cache.')
 if br.returncode != 0:
+    record_verify_phase('build', 'failed', 'After build failed: ' + br.stderr[:300])
     raise SystemExit('After build failed: ' + br.stderr[:500])
+if build_attempt.get('attempts'):
+    s['verify_build_attempts'] = build_attempt['attempts']
+    s['verify_build_clean_retry_used'] = bool(build_attempt.get('clean_retry_used'))
+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 +1107,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 +1269,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

@@ -508,6 +508,38 @@ def base_state(tempdir: Path, *, reference='before', prod_url=''):
     }
 
 
+def run_project_build_retries_after_clean_failure():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-build-retry-'))
+    cache_dir = tempdir / '.next'
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    util = load_module('util_build_retry', UTIL_PATH)
+    original_run = util.sp.run
+    calls = []
+
+    def fake_run(cmd, *args, **kwargs):
+        calls.append(cmd)
+        if cmd == 'npm run build':
+            build_attempts = calls.count('npm run build')
+            if build_attempts == 1:
+                return sp.CompletedProcess(cmd, 1, '', 'stale cache')
+            return sp.CompletedProcess(cmd, 0, 'ok', '')
+        if cmd == 'rm -rf .next':
+            shutil.rmtree(cache_dir, ignore_errors=True)
+            return sp.CompletedProcess(cmd, 0, '', '')
+        raise AssertionError(f'unexpected command: {cmd}')
+
+    try:
+        util.sp.run = fake_run
+        result = util.run_project_build(str(tempdir), 'npm run build', timeout=30, clean_cache_dir='.next')
+        assert result['clean_retry_used'] is True
+        assert result['result'].returncode == 0
+        assert calls == ['npm run build', 'rm -rf .next', 'npm run build']
+        assert not cache_dir.exists()
+    finally:
+        util.sp.run = original_run
+        shutil.rmtree(tempdir)
+
+
 def run_recon_then_author_request():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-supervisor-request-'))
     state_path = tempdir / 'state.json'
@@ -768,6 +800,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,
@@ -1250,6 +1289,7 @@ if __name__ == '__main__':
         'capture_artifact_enrichment': run_capture_artifact_enrichment(),
         '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(),
         '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(),