@riddledc/riddle-proof 0.5.33 → 0.5.34

package/runtime/lib/util.py

@@ -20,6 +20,8 @@ CAPTURE_DIAGNOSTIC_VERSION = 'riddle-proof.capture-diagnostic.v1'
 DEBUG_STRING_LIMIT = 2000
 CAPTURE_HINT_CACHE_VERSION = 'riddle-proof.capture-hints.v1'
 CAPTURE_HINT_CACHE_LIMIT = 12
+PROOF_SESSION_VERSION = 'riddle-proof.visual-session.v1'
+PROOF_SESSION_FINGERPRINT_VERSION = 'riddle-proof.visual-session.fingerprint.v1'
 SENSITIVE_KEY_FRAGMENTS = (
     'authorization',
     'apikey',
@@ -306,6 +308,241 @@ def compact_debug_value(value, limit=DEBUG_STRING_LIMIT):
     return value
 
 
+def stable_json(value):
+    return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False)
+
+
+def sha256_text(value):
+    text = str(value or '').strip()
+    if not text:
+        return ''
+    return hashlib.sha256(text.encode('utf-8')).hexdigest()
+
+
+def parse_optional_json(value, field_name):
+    if value in (None, ''):
+        return None
+    if isinstance(value, (dict, list)):
+        return value
+    if not isinstance(value, str):
+        raise SystemExit(field_name + ' must be JSON.')
+    text = value.strip()
+    if not text:
+        return None
+    try:
+        return json.loads(text)
+    except Exception as exc:
+        raise SystemExit(field_name + ' is not valid JSON: ' + str(exc))
+
+
+def load_proof_session_source(value):
+    source = str(value or '').strip()
+    if not source:
+        return None
+    try:
+        if source.startswith('{'):
+            session = json.loads(source)
+        elif source.startswith(('http://', 'https://')):
+            with urlopen(source, timeout=20) as response:
+                session = json.loads(response.read(512 * 1024).decode('utf-8'))
+        else:
+            with open(os.path.abspath(os.path.expanduser(source))) as f:
+                session = json.load(f)
+    except Exception as exc:
+        raise SystemExit('resume_session could not be loaded: ' + str(exc))
+
+    if not isinstance(session, dict):
+        raise SystemExit('resume_session must be a JSON object.')
+    if session.get('version') != PROOF_SESSION_VERSION:
+        raise SystemExit('resume_session has unsupported version: ' + str(session.get('version') or ''))
+    if not session.get('session_id'):
+        raise SystemExit('resume_session is missing session_id.')
+    if not session.get('fingerprint'):
+        raise SystemExit('resume_session is missing fingerprint.')
+    return session
+
+
+def apply_proof_session_defaults(state, session):
+    if not isinstance(session, dict):
+        return []
+    applied = []
+    route = session.get('route') if isinstance(session.get('route'), dict) else {}
+    capture = session.get('capture') if isinstance(session.get('capture'), dict) else {}
+    target_image = session.get('target_image') if isinstance(session.get('target_image'), dict) else {}
+
+    defaults = [
+        ('server_path', route.get('path'), 'proof_session'),
+        ('wait_for_selector', capture.get('wait_for_selector'), 'proof_session'),
+        ('proof_plan', capture.get('proof_plan'), 'proof_session'),
+        ('capture_script', capture.get('capture_script'), 'proof_session'),
+        ('reference', session.get('reference'), 'proof_session'),
+        ('verification_mode', session.get('verification_mode'), 'proof_session'),
+        ('target_image_url', target_image.get('url'), 'proof_session'),
+        ('target_image_hash', target_image.get('hash'), 'proof_session'),
+    ]
+    for key, value, source in defaults:
+        text = str(value or '').strip()
+        if text and not str(state.get(key) or '').strip():
+            state[key] = text
+            applied.append(key)
+            if key == 'server_path':
+                state['server_path_source'] = source
+
+    if state.get('viewport_matrix_json') in (None, '') and session.get('viewport_matrix') is not None:
+        state['viewport_matrix_json'] = json.dumps(session.get('viewport_matrix'))
+        applied.append('viewport_matrix_json')
+    if state.get('deterministic_setup_json') in (None, '') and session.get('deterministic_setup') is not None:
+        state['deterministic_setup_json'] = json.dumps(session.get('deterministic_setup'))
+        applied.append('deterministic_setup_json')
+    if state.get('assertions_json') in (None, '') and session.get('assertions') is not None:
+        state['assertions_json'] = json.dumps(session.get('assertions'))
+        applied.append('assertions_json')
+    return applied
+
+
+def visual_session_fingerprint_basis(state, route=''):
+    route_value = str(route or state.get('server_path') or '').strip()
+    basis = {
+        'version': PROOF_SESSION_FINGERPRINT_VERSION,
+        'repo': str(state.get('repo') or '').strip() or None,
+        'route': route_value or None,
+        'wait_for_selector': str(state.get('wait_for_selector') or '').strip() or None,
+        'reference': str(state.get('requested_reference') or state.get('reference') or '').strip() or None,
+        'verification_mode': str(state.get('verification_mode') or '').strip().lower() or None,
+        'target_image_url': str(state.get('target_image_url') or '').strip() or None,
+        'target_image_hash': str(state.get('target_image_hash') or '').strip() or None,
+        'viewport_matrix': state.get('viewport_matrix'),
+        'deterministic_setup': state.get('deterministic_setup'),
+        'assertions': state.get('parsed_assertions'),
+        'capture_script_hash': sha256_text(state.get('capture_script')),
+    }
+    return {key: value for key, value in basis.items() if value is not None}
+
+
+def visual_session_fingerprint_from_basis(basis):
+    return hashlib.sha256(stable_json(basis).encode('utf-8')).hexdigest()
+
+
+def visual_session_fingerprint(state, route=''):
+    return visual_session_fingerprint_from_basis(visual_session_fingerprint_basis(state, route=route))
+
+
+def proof_session_mismatches(state, session, route=''):
+    if not isinstance(session, dict):
+        return []
+    expected = session.get('fingerprint_basis') if isinstance(session.get('fingerprint_basis'), dict) else {}
+    actual = visual_session_fingerprint_basis(state, route=route)
+    keys = sorted(set(expected.keys()) | set(actual.keys()))
+    mismatches = []
+    for key in keys:
+        if stable_json(expected.get(key)) != stable_json(actual.get(key)):
+            mismatches.append({
+                'key': key,
+                'expected': expected.get(key),
+                'actual': actual.get(key),
+            })
+    return mismatches
+
+
+def validate_proof_session_resume(state, route=''):
+    session = state.get('parent_proof_session')
+    if not isinstance(session, dict):
+        return {'status': 'not_requested'}
+    mismatches = proof_session_mismatches(state, session, route=route)
+    if mismatches:
+        state['proof_session_resume'] = {
+            'status': 'fingerprint_mismatch',
+            'parent_session_id': session.get('session_id'),
+            'parent_fingerprint': session.get('fingerprint'),
+            'mismatches': mismatches,
+        }
+        raise SystemExit(
+            'resume_session fingerprint mismatch: ' +
+            ', '.join(item['key'] for item in mismatches[:8])
+        )
+    state['proof_session_resume'] = {
+        'status': 'accepted',
+        'parent_session_id': session.get('session_id'),
+        'parent_fingerprint': session.get('fingerprint'),
+        'fingerprint': visual_session_fingerprint(state, route=route),
+    }
+    return state['proof_session_resume']
+
+
+def capture_proof_session_seed(state, route=''):
+    parent = state.get('parent_proof_session') if isinstance(state.get('parent_proof_session'), dict) else {}
+    basis = visual_session_fingerprint_basis(state, route=route)
+    return {
+        'version': PROOF_SESSION_VERSION,
+        'session_kind': 'capture-seed',
+        'run_id': str(state.get('run_id') or '').strip(),
+        'parent_session_id': parent.get('session_id') or None,
+        'parent_fingerprint': parent.get('fingerprint') or None,
+        'fingerprint': visual_session_fingerprint_from_basis(basis),
+        'fingerprint_basis': basis,
+        'repo': str(state.get('repo') or '').strip(),
+        'route': {'path': str(route or state.get('server_path') or '').strip()},
+        'reference': str(state.get('requested_reference') or state.get('reference') or '').strip(),
+        'verification_mode': str(state.get('verification_mode') or '').strip(),
+        'target_image': {
+            'url': str(state.get('target_image_url') or '').strip(),
+            'hash': str(state.get('target_image_hash') or '').strip(),
+        },
+        'viewport_matrix': state.get('viewport_matrix'),
+        'deterministic_setup': state.get('deterministic_setup'),
+        'capture': {
+            'proof_plan': str(state.get('proof_plan') or '').strip(),
+            'capture_script': str(state.get('capture_script') or '').strip(),
+            'wait_for_selector': str(state.get('wait_for_selector') or '').strip(),
+        },
+        'assertions': state.get('parsed_assertions'),
+    }
+
+
+def proof_session_output_url(payload):
+    item = capture_output_item(payload, 'proof-session.json') or capture_output_item(payload, 'proof-session')
+    return (item or {}).get('url', '') if item else ''
+
+
+def build_visual_proof_session(state, route='', observed_after_path='', artifacts=None, evidence=None, status=''):
+    parent = state.get('parent_proof_session') if isinstance(state.get('parent_proof_session'), dict) else {}
+    basis = visual_session_fingerprint_basis(state, route=route)
+    session_id = 'rps_' + time.strftime('%Y%m%dT%H%M%SZ', time.gmtime()) + '_' + hashlib.sha1(os.urandom(16)).hexdigest()[:8]
+    return {
+        'version': PROOF_SESSION_VERSION,
+        'session_id': session_id,
+        'run_id': str(state.get('run_id') or '').strip(),
+        'parent_session_id': parent.get('session_id') or None,
+        'parent_fingerprint': parent.get('fingerprint') or None,
+        'created_at': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
+        'fingerprint': visual_session_fingerprint_from_basis(basis),
+        'fingerprint_basis': basis,
+        'repo': str(state.get('repo') or '').strip(),
+        'branch': str(state.get('branch') or state.get('target_branch') or '').strip(),
+        'route': {
+            'path': str(route or state.get('server_path') or '').strip(),
+            'observed_after_path': str(observed_after_path or '').strip(),
+        },
+        'reference': str(state.get('requested_reference') or state.get('reference') or '').strip(),
+        'verification_mode': str(state.get('verification_mode') or '').strip(),
+        'target_image': {
+            'url': str(state.get('target_image_url') or '').strip(),
+            'hash': str(state.get('target_image_hash') or '').strip(),
+        },
+        'viewport_matrix': state.get('viewport_matrix'),
+        'deterministic_setup': state.get('deterministic_setup'),
+        'capture': {
+            'proof_plan': str(state.get('proof_plan') or '').strip(),
+            'capture_script': str(state.get('capture_script') or '').strip(),
+            'wait_for_selector': str(state.get('wait_for_selector') or '').strip(),
+        },
+        'assertions': state.get('parsed_assertions'),
+        'artifacts': artifacts or {},
+        'evidence': evidence or {},
+        'status': status,
+    }
+
+
 def redact_for_diagnostics(value):
     if isinstance(value, dict):
         redacted = {}

package/runtime/lib/verify.py

@@ -13,6 +13,8 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from util import (
     append_capture_diagnostic,
     apply_auth_context,
+    build_visual_proof_session,
+    capture_proof_session_seed,
     capture_static_preview,
     enrich_capture_payload,
     has_auth_context,
@@ -24,6 +26,7 @@ from util import (
     run_project_build,
     save_state,
     should_use_static_preview,
+    proof_session_output_url,
     summarize_capture_artifacts,
 )
 import subprocess as sp
@@ -215,7 +218,7 @@ def abort_capture_failure(state, results, expected_path, message, raw_payload):
     raise SystemExit(summary)
 
 
-def build_probe_capture_script(base_script='', verification_mode='proof'):
+def build_probe_capture_script(base_script='', verification_mode='proof', proof_session_seed=None):
     pieces = []
     script = (base_script or '').strip()
     pieces.append('let __riddleProofCaptureScriptError = null;')
@@ -280,6 +283,12 @@ def build_probe_capture_script(base_script='', verification_mode='proof'):
     ])
     if auto_screenshot_for_mode(verification_mode) and not capture_script_saves_screenshot(script):
         pieces.append("await saveScreenshot('after-proof');")
+    if isinstance(proof_session_seed, dict):
+        pieces.append(
+            'try { if (typeof saveJson === "function") await saveJson("proof-session", ' +
+            json.dumps(proof_session_seed) +
+            '); } catch {}'
+        )
     pieces.append('if (__riddleProofCaptureScriptError) throw __riddleProofCaptureScriptError;')
     pieces.append('return { pageState, proofEvidence: __riddleProofEvidenceValue };')
     return ' '.join(pieces)
@@ -1056,6 +1065,36 @@ def build_evidence_bundle(state, results, after_payload, after_observation, requ
         semantic_context,
         [],
     )
+    observed_after_path = ((semantic_context.get('route') or {}).get('after_observed_path')) or ''
+    proof_session_artifact_url = proof_session_output_url(after_payload)
+    outputs = []
+    for item in after_payload.get('outputs') or []:
+        if not isinstance(item, dict):
+            continue
+        outputs.append({
+            'name': str(item.get('name') or ''),
+            'url': str(item.get('url') or ''),
+            'type': str(item.get('type') or item.get('kind') or ''),
+        })
+    proof_session = build_visual_proof_session(
+        state,
+        route=expected_path,
+        observed_after_path=observed_after_path,
+        artifacts={
+            'before': state.get('before_cdn') or '',
+            'prod': state.get('prod_cdn') or '',
+            'after': state.get('after_cdn') or '',
+            'session': proof_session_artifact_url,
+            'outputs': outputs,
+        },
+        evidence={
+            'visual_delta': visual_delta,
+            'semantic_context': semantic_context,
+            'artifact_contract': artifact_contract,
+            'artifact_usage': artifact_usage,
+        },
+        status='evidence_captured' if after_observation.get('valid') else 'capture_incomplete',
+    )
     return {
         'verification_mode': normalized_verification_mode(state.get('verification_mode')),
         'reference': state.get('requested_reference') or state.get('reference', 'both'),
@@ -1078,6 +1117,7 @@ def build_evidence_bundle(state, results, after_payload, after_observation, requ
         'proof_evidence_sample': compact_value(proof_evidence) if proof_evidence is not None else '',
         'success_criteria': (state.get('success_criteria') or '').strip(),
         'assertions': state.get('parsed_assertions') or None,
+        'proof_session': proof_session,
     }
 
 
@@ -1193,7 +1233,8 @@ expected_path = (
     or '/'
 )
 verification_mode = normalized_verification_mode(s.get('verification_mode'))
-probe_capture_script = build_probe_capture_script(capture_script, verification_mode)
+proof_session_seed = capture_proof_session_seed(s, expected_path)
+probe_capture_script = build_probe_capture_script(capture_script, verification_mode, proof_session_seed)
 results = {
     'baseline': {
         'reference': reference,
@@ -1402,6 +1443,18 @@ if reference in ('prod', 'both') and prod_url:
 
 evidence_bundle = build_evidence_bundle(s, results, after_payload, after_observation, required_baseline_present, expected_path)
 s['evidence_bundle'] = evidence_bundle
+s['proof_session'] = evidence_bundle.get('proof_session') or {}
+s['proof_session_fingerprint'] = (s.get('proof_session') or {}).get('fingerprint') or ''
+s['proof_session_artifact_url'] = ((s.get('proof_session') or {}).get('artifacts') or {}).get('session') or ''
+if s.get('proof_session'):
+    summary_lines.append(
+        'Proof session: ' +
+        str((s.get('proof_session') or {}).get('session_id') or '') +
+        ' ' +
+        str((s.get('proof_session') or {}).get('fingerprint') or '')[:12]
+    )
+if s.get('proof_session_artifact_url'):
+    summary_lines.append('Proof session artifact: ' + s['proof_session_artifact_url'])
 visual_delta = ((evidence_bundle.get('after') or {}).get('visual_delta') or {})
 if visual_delta.get('status') != 'not_applicable':
     summary_lines.append('Visual delta gate: ' + compact_value(visual_delta, limit=700))

package/runtime/tests/recon_verify_smoke.py

@@ -204,10 +204,13 @@ class FakeRiddle:
                     ],
                 }
             if 'after-proof' in script:
+                outputs = [{'name': 'after.png', 'url': 'https://cdn.example.com/after.png'}]
+                if 'proof-session' in script:
+                    outputs.append({'name': 'proof-session.json', 'url': 'https://cdn.example.com/proof-session.json'})
                 return {
                     'ok': True,
                     'screenshots': [{'url': 'https://cdn.example.com/after.png'}],
-                    'outputs': [{'name': 'after.png', 'url': 'https://cdn.example.com/after.png'}],
+                    'outputs': outputs,
                     'console': state_console({
                         'bodyTextLength': 180,
                         'visibleTextSample': 'Pricing CTA Buy Now',
@@ -637,6 +640,105 @@ def run_preflight_records_prod_reference_skip_reason():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_preflight_resumes_visual_proof_session():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-preflight-session-'))
+    args_path = tempdir / 'args.json'
+    state_path = tempdir / 'state.json'
+    repo_dir = tempdir / 'repo'
+    try:
+        make_project(repo_dir, "export const routes = [{ path: '/pricing', element: <Pricing /> }];\n")
+        util = load_module('util_proof_session_builder', UTIL_PATH)
+        parent_session = util.build_visual_proof_session({
+            'repo': 'example/repo',
+            'server_path': '/pricing',
+            'reference': 'before',
+            'verification_mode': 'visual',
+            'target_image_url': 'https://cdn.example.com/spec.png',
+            'target_image_hash': 'sha256:spec',
+            'viewport_matrix': [
+                {'name': 'mobile', 'width': 390, 'height': 844},
+                {'name': 'desktop', 'width': 1280, 'height': 900},
+            ],
+            'deterministic_setup': {'seed': 'pricing-visual-v1'},
+            'parsed_assertions': [{'kind': 'text', 'contains': 'Buy Now'}],
+            'proof_plan': 'Capture pricing route and compare CTA visual state.',
+            'capture_script': "await page.waitForSelector('[data-testid=pricing-cta]'); await saveScreenshot('after-proof');",
+            'wait_for_selector': '[data-testid=pricing-cta]',
+        }, route='/pricing', observed_after_path='/pricing', status='evidence_captured')
+
+        args_path.write_text(json.dumps({
+            'repo': 'example/repo',
+            'repo_dir': str(repo_dir),
+            'mode': 'static',
+            'change_request': 'Continue the pricing visual iteration',
+            'commit_message': 'Continue the pricing visual iteration',
+            'build_command': BUILD_SCRIPT,
+            'build_output': 'build',
+            'allow_static_preview_fallback': True,
+            'resume_session': json.dumps(parent_session),
+        }, indent=2))
+        with temporary_env(
+            RIDDLE_PROOF_ARGS_FILE=str(args_path),
+            RIDDLE_PROOF_STATE_FILE=str(state_path),
+        ):
+            sys.modules.pop('util', None)
+            load_module('preflight_resume_session', PREFLIGHT_PATH)
+        after_preflight = json.loads(state_path.read_text())
+        assert after_preflight['proof_session_resume']['status'] == 'accepted'
+        assert after_preflight['proof_session_resume']['applied_fields']
+        assert after_preflight['parent_proof_session']['session_id'] == parent_session['session_id']
+        assert after_preflight['server_path'] == '/pricing'
+        assert after_preflight['server_path_source'] == 'proof_session'
+        assert after_preflight['reference'] == 'before'
+        assert after_preflight['verification_mode'] == 'visual'
+        assert after_preflight['target_image_url'] == 'https://cdn.example.com/spec.png'
+        assert after_preflight['target_image_hash'] == 'sha256:spec'
+        assert after_preflight['viewport_matrix'][0]['name'] == 'mobile'
+        assert after_preflight['deterministic_setup']['seed'] == 'pricing-visual-v1'
+        assert after_preflight['parsed_assertions'][0]['contains'] == 'Buy Now'
+        assert after_preflight['proof_plan_status'] == 'ready'
+        assert after_preflight['author_status'] == 'ready'
+
+        mismatch_args_path = tempdir / 'mismatch-args.json'
+        mismatch_state_path = tempdir / 'mismatch-state.json'
+        mismatch_args_path.write_text(json.dumps({
+            'repo': 'example/repo',
+            'repo_dir': str(repo_dir),
+            'mode': 'static',
+            'reference': 'before',
+            'verification_mode': 'visual',
+            'change_request': 'Continue the pricing visual iteration',
+            'commit_message': 'Continue the pricing visual iteration',
+            'build_command': BUILD_SCRIPT,
+            'build_output': 'build',
+            'allow_static_preview_fallback': True,
+            'server_path': '/wrong',
+            'resume_session': json.dumps(parent_session),
+        }, indent=2))
+        with temporary_env(
+            RIDDLE_PROOF_ARGS_FILE=str(mismatch_args_path),
+            RIDDLE_PROOF_STATE_FILE=str(mismatch_state_path),
+        ):
+            try:
+                sys.modules.pop('util', None)
+                load_module('preflight_resume_session_mismatch', PREFLIGHT_PATH)
+            except SystemExit as exc:
+                assert 'fingerprint mismatch' in str(exc), exc
+            else:
+                raise AssertionError('route mismatch should reject resumed proof session')
+        mismatch_state = json.loads(mismatch_state_path.read_text())
+        assert mismatch_state['proof_session_resume']['status'] == 'fingerprint_mismatch'
+        assert any(item['key'] == 'route' for item in mismatch_state['proof_session_resume']['mismatches'])
+
+        return {
+            'ok': True,
+            'parent_session_id': parent_session['session_id'],
+            'fingerprint': after_preflight['proof_session_resume']['fingerprint'],
+        }
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def base_state(tempdir: Path, *, reference='before', prod_url=''):
     before_dir = tempdir / 'before'
     after_dir = tempdir / 'after'
@@ -1157,6 +1259,7 @@ def run_verify_requests_supervisor_assessment():
     try:
         state = base_state(tempdir, reference='both', prod_url='https://prod.example.com/pricing')
         state.update({
+            'repo': 'example/repo',
             'recon_status': 'ready_for_proof_plan',
             'author_status': 'ready',
             'proof_plan_status': 'ready',
@@ -1223,6 +1326,21 @@ 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
+        proof_session = after_verify['proof_session']
+        assert proof_session['version'] == 'riddle-proof.visual-session.v1'
+        assert proof_session['repo'] == 'example/repo'
+        assert proof_session['route']['path'] == '/pricing'
+        assert proof_session['route']['observed_after_path'] == '/pricing'
+        assert proof_session['artifacts']['before'] == 'https://cdn.example.com/before.png'
+        assert proof_session['artifacts']['prod'] == 'https://cdn.example.com/prod.png'
+        assert proof_session['artifacts']['after'] == 'https://cdn.example.com/after.png'
+        assert proof_session['artifacts']['session'] == 'https://cdn.example.com/proof-session.json'
+        assert proof_session['capture']['wait_for_selector'] == '[data-testid=pricing-cta]'
+        assert proof_session['fingerprint_basis']['route'] == '/pricing'
+        assert after_verify['proof_session_fingerprint'] == proof_session['fingerprint']
+        assert after_verify['proof_session_artifact_url'] == 'https://cdn.example.com/proof-session.json'
+        assert after_verify['evidence_bundle']['proof_session']['fingerprint'] == proof_session['fingerprint']
+        assert after_verify['proof_assessment_request']['evidence_bundle']['proof_session']['fingerprint'] == proof_session['fingerprint']
         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)
@@ -1866,6 +1984,7 @@ def run_ship_resolves_real_pr_branch():
 if __name__ == '__main__':
     payload = {
         'preflight_reference_skip_reason': run_preflight_records_prod_reference_skip_reason(),
+        'preflight_resume_visual_proof_session': run_preflight_resumes_visual_proof_session(),
         '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(),