@riddledc/riddle-proof 0.5.32 → 0.5.34

package/runtime/lib/preflight.py

@@ -8,7 +8,16 @@ capture_script: optional at setup and recon; required before verify.
 
 import json, os, re, time, uuid, sys
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from util import STATE_FILE, ARGS_FILE, save_state, invoke, load_package_json
+from util import (
+    STATE_FILE,
+    ARGS_FILE,
+    apply_proof_session_defaults,
+    invoke,
+    load_package_json,
+    load_proof_session_source,
+    save_state,
+    validate_proof_session_resume,
+)
 
 def truthy(value):
     return str(value or '').strip().lower() in ('1', 'true', 'yes', 'y', 'on')
@@ -40,6 +49,19 @@ if not os.path.exists(args_file):
 with open(args_file) as f:
     s = json.load(f)
 
+resume_session_source = (s.get('resume_session') or '').strip()
+if resume_session_source:
+    parent_proof_session = load_proof_session_source(resume_session_source)
+    s['parent_proof_session'] = parent_proof_session
+    s['parent_proof_session_id'] = parent_proof_session.get('session_id')
+    s['proof_session_resume'] = {
+        'status': 'loaded',
+        'source': 'inline_json' if resume_session_source.startswith('{') else resume_session_source,
+        'parent_session_id': parent_proof_session.get('session_id'),
+        'parent_fingerprint': parent_proof_session.get('fingerprint'),
+        'applied_fields': apply_proof_session_defaults(s, parent_proof_session),
+    }
+
 mode = (s.get('mode') or '').strip().lower()
 reference = s.get('reference', 'both')
 requested_reference = reference
@@ -107,6 +129,8 @@ if raw_assertions:
     except Exception as e:
         raise SystemExit('assertions_json is not valid JSON: ' + str(e))
 s['parsed_assertions'] = parsed_assertions
+s['viewport_matrix'] = parse_json_arg('viewport_matrix_json', (dict, list), None)
+s['deterministic_setup'] = parse_json_arg('deterministic_setup_json', (dict, list), None)
 
 # Generate branch if not provided. The riddle-proof/* namespace is reserved for
 # temporary proof worktrees, so never let a user-supplied branch use it as the
@@ -173,6 +197,16 @@ s['stage'] = 'preflight'
 s['status'] = 'ready' if not missing else 'needs_input'
 s['missing'] = missing
 
+if s.get('parent_proof_session') and not missing:
+    try:
+        s['proof_session_resume'] = {
+            **(s.get('proof_session_resume') or {}),
+            **validate_proof_session_resume(s, route=s.get('server_path') or ''),
+        }
+    except SystemExit:
+        save_state(s)
+        raise
+
 # Auth context can be supplied directly for public-plugin use, while use_auth
 # remains a private/configured Cognito helper for Riddle-owned environments.
 explicit_local_storage = parse_json_arg('auth_localStorage_json', (dict,), {})
@@ -231,7 +265,7 @@ print('RIDDLE PROOF — PREFLIGHT (' + mode.upper() + ' / ' + reference.upper()
 print('=' * 50)
 display_keys = ['repo', 'branch', 'target_branch', 'ship_target_branch', 'base_branch', 'before_ref', 'change_request', 'commit_message',
                 'reference', 'verification_mode', 'success_criteria', 'prod_url', 'build_command',
-                'allow_static_preview_fallback']
+                'allow_static_preview_fallback', 'resume_session', 'target_image_url', 'target_image_hash']
 if mode == 'server':
     display_keys += ['server_image', 'server_command', 'server_port', 'server_path']
 if s.get('auth_localStorage'):
@@ -247,6 +281,12 @@ for k in display_keys:
     print(k + ': ' + v)
 if parsed_assertions is not None:
     print('assertions_json: parsed')
+if s.get('viewport_matrix') is not None:
+    print('viewport_matrix_json: parsed')
+if s.get('deterministic_setup') is not None:
+    print('deterministic_setup_json: parsed')
+if s.get('proof_session_resume'):
+    print('proof_session_resume: ' + str((s.get('proof_session_resume') or {}).get('status') or 'loaded'))
 if not (s.get('capture_script') or '').strip():
     print('NOTE: capture_script can be added later after recon and before verify.')
 if reference_note:

package/runtime/lib/ship.py

@@ -9,6 +9,10 @@ from util import load_state, save_state, invoke, git
 
 DISCORD_API = 'https://discord.com/api/v10'
 SHIP_NOISE_PATHS = ('.codex', '.oc-smoke')
+VISUAL_FIRST_MODES = {
+    'visual', 'render', 'interaction', 'ui', 'layout', 'screenshot',
+    'canvas', 'animation',
+}
 
 
 def read_json_file(path):
@@ -293,7 +297,11 @@ def record_ship_report(state, marked_ready=None):
 def proof_assessment_is_ready(state):
     assessment = state.get('proof_assessment') or {}
     source = str(assessment.get('source') or state.get('proof_assessment_source') or '').strip().lower()
-    return source in ('supervising_agent', 'supervisor') and assessment.get('decision') == 'ready_to_ship'
+    return (
+        source in ('supervising_agent', 'supervisor')
+        and assessment.get('decision') == 'ready_to_ship'
+        and not visual_delta_ship_blocker(state)
+    )
 
 
 def effective_merge_recommendation(state):
@@ -310,6 +318,49 @@ def after_evidence_bundle(state):
     return after if isinstance(after, dict) else {}
 
 
+def normalized_verification_mode(state):
+    bundle = state.get('evidence_bundle') or {}
+    if isinstance(bundle, dict) and str(bundle.get('verification_mode') or '').strip():
+        return str(bundle.get('verification_mode')).strip().lower()
+    return str(state.get('verification_mode') or 'proof').strip().lower() or 'proof'
+
+
+def visual_delta_required_for_ship(state):
+    bundle = state.get('evidence_bundle') or {}
+    contract = bundle.get('artifact_contract') if isinstance(bundle, dict) else {}
+    required = contract.get('required') if isinstance(contract, dict) else {}
+    if isinstance(required, dict) and required.get('visual_delta') is True:
+        return True
+    return normalized_verification_mode(state) in VISUAL_FIRST_MODES
+
+
+def visual_delta_for_state(state):
+    after = after_evidence_bundle(state)
+    visual_delta = after.get('visual_delta') if isinstance(after, dict) else None
+    if isinstance(visual_delta, dict):
+        return visual_delta
+    request = state.get('proof_assessment_request') or {}
+    visual_delta = request.get('visual_delta') if isinstance(request, dict) else None
+    return visual_delta if isinstance(visual_delta, dict) else {}
+
+
+def visual_delta_ship_blocker(state):
+    if not visual_delta_required_for_ship(state):
+        return ''
+    visual_delta = visual_delta_for_state(state)
+    if visual_delta.get('status') == 'measured' and visual_delta.get('passed') is True:
+        return ''
+    status = str(visual_delta.get('status') or 'missing')
+    if status == 'unmeasured':
+        return 'visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof'
+    if status == 'measured' and visual_delta.get('passed') is False:
+        return 'visual_delta.status=measured but visual_delta.passed=false blocks ready_to_ship for visual/UI proof'
+    reason = str(visual_delta.get('reason') or '').strip()
+    if reason:
+        return f'visual_delta.status={status} blocks ready_to_ship for visual/UI proof: {reason}'
+    return f'visual_delta.status={status} blocks ready_to_ship for visual/UI proof'
+
+
 def state_has_after_evidence(state):
     if (state.get('after_cdn') or '').strip():
         return True
@@ -581,6 +632,9 @@ if reference in ('prod', 'both'):
         raise SystemExit('prod_url is required when reference=' + reference + ' before ship.')
     if not prod_cdn:
         raise SystemExit('prod_cdn is required before ship. Run recon/verify again and preserve the approved prod baseline.')
+visual_delta_blocker = visual_delta_ship_blocker(s)
+if visual_delta_blocker:
+    raise SystemExit(visual_delta_blocker + '. Rerun verify with measured before/after visual delta or return a non-shipping proof assessment.')
 if proof_source not in ('supervising_agent', 'supervisor') or proof_assessment.get('decision') != 'ready_to_ship':
     raise SystemExit('Supervising-agent proof_assessment.decision=ready_to_ship is required before ship.')
 

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)
@@ -559,6 +568,34 @@ def visual_delta_applies(verification_mode):
     return screenshot_required_for_mode(verification_mode)
 
 
+def visual_delta_passes_ship_gate(visual_delta):
+    return (
+        isinstance(visual_delta, dict)
+        and visual_delta.get('status') == 'measured'
+        and visual_delta.get('passed') is True
+    )
+
+
+def visual_delta_blocker_for_mode(verification_mode, visual_delta):
+    if not visual_delta_applies(verification_mode):
+        return ''
+    if visual_delta_passes_ship_gate(visual_delta):
+        return ''
+    if not isinstance(visual_delta, dict):
+        status = 'missing'
+        reason = 'No visual_delta object was found in proof evidence.'
+    else:
+        status = str(visual_delta.get('status') or 'missing')
+        reason = str(visual_delta.get('reason') or '').strip()
+    if status == 'unmeasured':
+        return 'visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof; capture a measured before/after visual delta or choose needs_richer_proof.'
+    if status == 'measured' and isinstance(visual_delta, dict) and visual_delta.get('passed') is False:
+        return 'visual_delta.status=measured but visual_delta.passed=false blocks ready_to_ship for visual/UI proof; the measured change did not clear the threshold.'
+    if reason:
+        return f'visual_delta.status={status} blocks ready_to_ship for visual/UI proof: {reason}'
+    return f'visual_delta.status={status} blocks ready_to_ship for visual/UI proof.'
+
+
 def list_value(value):
     return value if isinstance(value, list) else []
 
@@ -684,11 +721,11 @@ def artifact_contract_for_mode(verification_mode):
             'route_semantics': True,
             'screenshot': screenshot_required_for_mode(mode),
             'proof_evidence': proof_evidence_required_for_mode(mode),
+            'visual_delta': visual_delta_applies(mode),
         },
         'preferred': {
             'page_state': True,
             'structured_payload': mode in STRUCTURED_FIRST_MODES or proof_evidence_required_for_mode(mode),
-            'visual_delta': visual_delta_applies(mode),
         },
         'optional': {
             'console_summary': True,
@@ -731,7 +768,7 @@ def artifact_signal_availability(state, after_observation, supporting, visual_de
         ),
         'structured_payload': bool(supporting.get('has_structured_payload')),
         'proof_evidence': bool(supporting.get('proof_evidence_present')),
-        'visual_delta': bool((visual_delta or {}).get('status') not in ('', None, 'not_applicable')),
+        'visual_delta': visual_delta_passes_ship_gate(visual_delta),
         'console_summary': bool(supporting.get('console_entries')),
         'json_artifacts': bool(supporting.get('data_outputs')),
         'image_outputs': bool(supporting.get('image_outputs')),
@@ -1028,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'),
@@ -1050,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,
     }
 
 
@@ -1097,6 +1165,8 @@ def build_supervisor_assessment_request(state, payload, after_observation, requi
         evidence_bundle['artifact_contract'] = artifact_contract
         evidence_bundle['artifact_production'] = artifact_production
         evidence_bundle['artifact_usage'] = artifact_usage
+    visual_delta_blocker = visual_delta_blocker_for_mode(verification_mode, visual_delta)
+    hard_blockers = [visual_delta_blocker] if visual_delta_blocker else []
 
     return {
         'status': 'needs_supervising_agent_assessment',
@@ -1112,14 +1182,15 @@ def build_supervisor_assessment_request(state, payload, after_observation, requi
         'artifact_contract': artifact_contract,
         'artifact_production': artifact_production,
         'artifact_usage': artifact_usage,
+        'hard_blockers': hard_blockers,
         'instructions': [
             'The supervising agent owns proof assessment. Inspect the recon baseline(s), after evidence, and any structured artifacts together.',
             'Decide whether the evidence is ready_to_ship or should continue internally through author, implement, or recon.',
+            'Hard blockers cannot be overridden by supervisor judgment; if hard_blockers is non-empty, do not choose ready_to_ship.',
             'Do not mark ready_to_ship if the before/prod baseline is blank, shell-only, generic, or not visibly tied to the requested feature.',
             'Use semantic_context.route plus headings/buttons/text anchors to ground route and content judgment before treating a screenshot as wrong-route.',
             'For visual/UI modes, use screenshots plus after_observation.details.visible_text_sample, headings, buttons, links, canvas_count, and large_visible_elements to explain what the proof actually shows.',
-            'For visual/UI polish, capture success is not proof. If visual_delta.status=measured and visual_delta.passed=false, choose needs_implementation or needs_richer_proof instead of ready_to_ship.',
-            'If visual_delta.status=unmeasured for visual/UI proof, only choose ready_to_ship when the screenshots and page-state details let you name a clearly legible before/after change; otherwise request richer proof or another implementation pass.',
+            'For visual/UI polish, capture success is not proof. If visual_delta.status is unmeasured, missing, not_applicable, or measured with passed=false, choose needs_implementation or needs_richer_proof instead of ready_to_ship.',
             'For data/audio/log/metrics/custom modes, judge the structured evidence bundle and proof_evidence_sample directly; screenshots are optional supporting context.',
             'The summary must name the concrete change, the target route/UI, what changed in after evidence, and why the stop condition is satisfied.',
             'Only set escalation_target=human when you conclude the workflow has hit a real wall or is not converging.',
@@ -1162,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,
@@ -1371,9 +1443,24 @@ 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))
+visual_delta_blocker = visual_delta_blocker_for_mode(s.get('verification_mode'), visual_delta)
+if visual_delta_blocker:
+    summary_lines.append('Visual delta hard gate: ' + visual_delta_blocker)
 
 proof_evidence_blocker = ''
 if proof_evidence_required_for_mode(s.get('verification_mode')):