@riddledc/riddle-proof 0.5.41 → 0.5.42

package/dist/{chunk-4YCWZVBN.js → chunk-U4VNN2CT.js}

@@ -371,7 +371,8 @@ function visualDeltaShipGateReason(state = {}) {
   if (visualDelta.status === "measured" && visualDelta.passed === true) return null;
   const status = String(visualDelta.status || "missing");
   if (status === "unmeasured") {
-    return "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
+    const reason2 = String(visualDelta.reason || "").trim();
+    return reason2 ? `visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof: ${reason2}` : "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
   }
   if (status === "measured" && visualDelta.passed === false) {
     return "visual_delta.status=measured but visual_delta.passed=false blocks ready_to_ship for visual/UI proof";

package/dist/{chunk-ZBM67XGB.js → chunk-VSLU6XNI.js}

@@ -26,7 +26,7 @@ import {
 } from "./chunk-W7VTDN4T.js";
 import {
   visualDeltaShipGateReason
-} from "./chunk-4YCWZVBN.js";
+} from "./chunk-U4VNN2CT.js";
 
 // src/engine-harness.ts
 import { execFileSync } from "child_process";

package/dist/engine-harness.cjs

@@ -379,7 +379,8 @@ function visualDeltaShipGateReason(state = {}) {
   if (visualDelta.status === "measured" && visualDelta.passed === true) return null;
   const status = String(visualDelta.status || "missing");
   if (status === "unmeasured") {
-    return "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
+    const reason2 = String(visualDelta.reason || "").trim();
+    return reason2 ? `visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof: ${reason2}` : "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
   }
   if (status === "measured" && visualDelta.passed === false) {
     return "visual_delta.status=measured but visual_delta.passed=false blocks ready_to_ship for visual/UI proof";

package/dist/engine-harness.js

@@ -2,11 +2,11 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-ZBM67XGB.js";
+} from "./chunk-VSLU6XNI.js";
 import "./chunk-RI25RGQP.js";
 import "./chunk-7S7O3NKF.js";
 import "./chunk-W7VTDN4T.js";
-import "./chunk-4YCWZVBN.js";
+import "./chunk-U4VNN2CT.js";
 export {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,

package/dist/index.cjs

@@ -379,7 +379,8 @@ function visualDeltaShipGateReason(state = {}) {
   if (visualDelta.status === "measured" && visualDelta.passed === true) return null;
   const status = String(visualDelta.status || "missing");
   if (status === "unmeasured") {
-    return "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
+    const reason2 = String(visualDelta.reason || "").trim();
+    return reason2 ? `visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof: ${reason2}` : "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
   }
   if (status === "measured" && visualDelta.passed === false) {
     return "visual_delta.status=measured but visual_delta.passed=false blocks ready_to_ship for visual/UI proof";

package/dist/index.js

@@ -25,7 +25,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-ZBM67XGB.js";
+} from "./chunk-VSLU6XNI.js";
 import {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
@@ -67,7 +67,7 @@ import {
   extractPlayabilityEvidence,
   isRiddleProofPlayabilityMode
 } from "./chunk-NSWT3VSV.js";
-import "./chunk-4YCWZVBN.js";
+import "./chunk-U4VNN2CT.js";
 export {
   DEFAULT_DIAGNOSTIC_ARRAY_LIMIT,
   DEFAULT_DIAGNOSTIC_HISTORY_LIMIT,

package/dist/proof-run-core.cjs

@@ -430,7 +430,8 @@ function visualDeltaShipGateReason(state = {}) {
   if (visualDelta.status === "measured" && visualDelta.passed === true) return null;
   const status = String(visualDelta.status || "missing");
   if (status === "unmeasured") {
-    return "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
+    const reason2 = String(visualDelta.reason || "").trim();
+    return reason2 ? `visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof: ${reason2}` : "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
   }
   if (status === "measured" && visualDelta.passed === false) {
     return "visual_delta.status=measured but visual_delta.passed=false blocks ready_to_ship for visual/UI proof";

package/dist/proof-run-core.js

@@ -24,7 +24,7 @@ import {
   visualDeltaShipGateReason,
   workflowFile,
   writeState
-} from "./chunk-4YCWZVBN.js";
+} from "./chunk-U4VNN2CT.js";
 export {
   BUNDLED_RIDDLE_PROOF_DIR,
   CHECKPOINT_CONTRACT_VERSION,

package/dist/proof-run-engine.cjs

@@ -412,7 +412,8 @@ function visualDeltaShipGateReason(state = {}) {
   if (visualDelta.status === "measured" && visualDelta.passed === true) return null;
   const status = String(visualDelta.status || "missing");
   if (status === "unmeasured") {
-    return "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
+    const reason2 = String(visualDelta.reason || "").trim();
+    return reason2 ? `visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof: ${reason2}` : "visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof";
   }
   if (status === "measured" && visualDelta.passed === false) {
     return "visual_delta.status=measured but visual_delta.passed=false blocks ready_to_ship for visual/UI proof";

package/dist/proof-run-engine.js

@@ -14,7 +14,7 @@ import {
   validateShipGate,
   workflowFile,
   writeState
-} from "./chunk-4YCWZVBN.js";
+} from "./chunk-U4VNN2CT.js";
 
 // src/proof-run-engine.ts
 import { execFileSync } from "child_process";

package/package.json

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

package/runtime/lib/recon.py

@@ -33,6 +33,7 @@ import subprocess as sp
 MAX_RECON_ATTEMPTS = 4
 MIN_BODY_TEXT_LENGTH = 50
 MIN_INTERACTIVE_ELEMENTS = 1
+MIN_CANVAS_AREA = 50000
 HYDRATION_WAIT_MS = 1500
 PAGE_STATE_PREFIX = 'RIDDLE_PROOF_STATE:'
 PROOF_EVIDENCE_PREFIX = 'RIDDLE_PROOF_EVIDENCE:'
@@ -423,6 +424,45 @@ def has_enriched_page_state(page_state):
     )
 
 
+def numeric_value(value):
+    if isinstance(value, bool) or value is None:
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        text = value.strip().rstrip('%').replace(',', '')
+        if not text:
+            return None
+        try:
+            return float(text)
+        except Exception:
+            return None
+    return None
+
+
+def canvas_capture_signal(page_state):
+    if not isinstance(page_state, dict):
+        return {
+            'canvas_ready': False,
+            'canvas_count': 0,
+            'large_canvas_area': 0,
+        }
+    large_canvas_area = 0
+    for item in list_value(page_state.get('largeVisibleElements')):
+        if not isinstance(item, dict) or item.get('tag') != 'canvas':
+            continue
+        area = numeric_value(item.get('area')) or 0
+        if area > large_canvas_area:
+            large_canvas_area = area
+    canvas_count = int(numeric_value(page_state.get('canvasCount')) or 0)
+    return {
+        'canvas_ready': bool(canvas_count > 0 and large_canvas_area >= MIN_CANVAS_AREA),
+        'canvas_count': canvas_count,
+        'large_canvas_area': int(large_canvas_area),
+        'min_canvas_area': MIN_CANVAS_AREA,
+    }
+
+
 def normalize_observed_path(value):
     raw = str(value or '').strip()
     if not raw:
@@ -538,6 +578,9 @@ def evaluate_capture_quality(payload, expected_path):
         'buttons': [],
         'links': [],
         'canvas_count': 0,
+        'canvas_capture_ready': False,
+        'large_canvas_area': 0,
+        'min_canvas_area': MIN_CANVAS_AREA,
         'large_visible_elements': [],
         'semantic_anchor_count': 0,
         'capture_error_messages': [],
@@ -572,6 +615,12 @@ def evaluate_capture_quality(payload, expected_path):
             'large_visible_elements': list_value(page_state.get('largeVisibleElements'))[:10],
             'semantic_anchor_count': semantic_anchor_count(page_state),
         })
+        canvas_signal = canvas_capture_signal(page_state)
+        details.update({
+            'canvas_capture_ready': canvas_signal['canvas_ready'],
+            'large_canvas_area': canvas_signal['large_canvas_area'],
+            'min_canvas_area': canvas_signal['min_canvas_area'],
+        })
     else:
         details.update({
             'body_text_length': MIN_BODY_TEXT_LENGTH + 100,
@@ -596,11 +645,20 @@ def evaluate_capture_quality(payload, expected_path):
         details['capture_error_messages'].append(str(proof_json.get('script_error'))[:500])
 
     reasons = []
-    if details['body_text_length'] < MIN_BODY_TEXT_LENGTH:
+    canvas_ready = bool(details.get('canvas_capture_ready'))
+    body_text_ready = details['body_text_length'] >= MIN_BODY_TEXT_LENGTH or canvas_ready
+    interactive_ready = details['interactive_elements'] >= MIN_INTERACTIVE_ELEMENTS or canvas_ready
+    semantic_ready = (not has_enriched_page_state(page_state)) or details['semantic_anchor_count'] >= 1 or canvas_ready
+    details['body_text_ready'] = body_text_ready
+    details['interactive_ready'] = interactive_ready
+    details['semantic_ready'] = semantic_ready
+    details['canvas_capture_override'] = canvas_ready
+
+    if not body_text_ready:
         reasons.append(f'blank/near-blank page (text length: {details["body_text_length"]})')
-    if details['interactive_elements'] < MIN_INTERACTIVE_ELEMENTS:
+    if not interactive_ready:
         reasons.append(f'not interactive enough ({details["interactive_elements"]} interactive elements)')
-    if has_enriched_page_state(page_state) and details['semantic_anchor_count'] < 1:
+    if has_enriched_page_state(page_state) and not semantic_ready:
         reasons.append('no visible semantic UI anchors in page capture')
     if details['has_errors']:
         reasons.append('page has console/runtime errors')
@@ -610,11 +668,10 @@ def evaluate_capture_quality(payload, expected_path):
         raw_observed = details.get('observed_path_raw') or details.get('observed_path') or observed_path
         reasons.append(f'wrong route: expected {expected_path}, got {raw_observed}')
 
-    semantic_ready = (not has_enriched_page_state(page_state)) or details['semantic_anchor_count'] >= 1
     telemetry_ready = (
         details['has_screenshot']
-        and details['body_text_length'] >= MIN_BODY_TEXT_LENGTH
-        and details['interactive_elements'] >= MIN_INTERACTIVE_ELEMENTS
+        and body_text_ready
+        and interactive_ready
         and semantic_ready
         and not details['has_errors']
     )

package/runtime/lib/ship.py

@@ -352,7 +352,9 @@ def visual_delta_ship_blocker(state):
         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'
+        reason = str(visual_delta.get('reason') or '').strip()
+        detail = f': {reason}' if reason else ''
+        return 'visual_delta.status=unmeasured blocks ready_to_ship for visual/UI proof' + detail
     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()

package/runtime/lib/verify.py

@@ -33,6 +33,7 @@ import subprocess as sp
 
 MIN_BODY_TEXT_LENGTH = 50
 MIN_INTERACTIVE_ELEMENTS = 1
+MIN_CANVAS_AREA = 50000
 HYDRATION_WAIT_MS = 1500
 PAGE_STATE_PREFIX = 'RIDDLE_PROOF_STATE:'
 PROOF_EVIDENCE_PREFIX = 'RIDDLE_PROOF_EVIDENCE:'
@@ -800,6 +801,8 @@ def extract_visual_delta(payload):
     result = payload.get('result') if isinstance(payload, dict) else {}
     proof_json = payload.get('_proof_json') if isinstance(payload, dict) else {}
     proof_evidence = extract_proof_evidence(payload)
+    screenshot_url = extract_screenshot_url(payload)
+    artifact_summary = summarize_capture_artifacts(payload)
     candidates = [
         payload if isinstance(payload, dict) else {},
         result if isinstance(result, dict) else {},
@@ -837,6 +840,23 @@ def extract_visual_delta(payload):
         percent = (changed_pixels / total_pixels) * 100
 
     if percent is None and changed_pixels is None:
+        has_artifacts = bool(
+            screenshot_url
+            or artifact_summary.get('outputs')
+            or artifact_summary.get('screenshots')
+            or artifact_summary.get('artifact_json')
+        )
+        reason = 'No measured before/after visual delta was found in proof evidence.'
+        if screenshot_url:
+            reason = (
+                'After screenshot artifact is present, but no measured before/after visual delta metrics were emitted; '
+                'the comparator did not run or did not publish change_percent/changed_pixels.'
+            )
+        elif has_artifacts:
+            reason = (
+                'Capture artifacts are present, but no measured before/after visual delta metrics were emitted; '
+                'the comparator did not run or did not publish change_percent/changed_pixels.'
+            )
         return {
             'status': 'unmeasured',
             'passed': None,
@@ -845,7 +865,19 @@ def extract_visual_delta(payload):
             'total_pixels': int(total_pixels) if total_pixels else None,
             'min_change_percent': MIN_VISUAL_DELTA_PERCENT,
             'min_changed_pixels': MIN_VISUAL_CHANGED_PIXELS,
-            'reason': 'No measured before/after visual delta was found in proof evidence.',
+            'reason': reason,
+            'diagnostic': {
+                'after_screenshot_present': bool(screenshot_url),
+                'proof_evidence_present': proof_evidence is not None,
+                'artifact_output_count': len(artifact_summary.get('outputs') or []),
+                'artifact_screenshot_count': len(artifact_summary.get('screenshots') or []),
+                'artifact_json': list(artifact_summary.get('artifact_json') or []),
+                'expected_metric_keys': {
+                    'percent': sorted(VISUAL_DELTA_PERCENT_KEYS),
+                    'changed_pixels': sorted(VISUAL_CHANGED_PIXEL_KEYS),
+                    'total_pixels': sorted(VISUAL_TOTAL_PIXEL_KEYS),
+                },
+            },
         }
 
     percent_pass = percent is not None and percent >= MIN_VISUAL_DELTA_PERCENT
@@ -891,7 +923,8 @@ def visual_delta_blocker_for_mode(verification_mode, visual_delta):
         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.'
+        detail = f' Reason: {reason}' if reason else ''
+        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.' + detail
     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:
@@ -926,6 +959,29 @@ def has_enriched_page_state(page_state):
     )
 
 
+def canvas_capture_signal(page_state):
+    if not isinstance(page_state, dict):
+        return {
+            'canvas_ready': False,
+            'canvas_count': 0,
+            'large_canvas_area': 0,
+        }
+    large_canvas_area = 0
+    for item in list_value(page_state.get('largeVisibleElements')):
+        if not isinstance(item, dict) or item.get('tag') != 'canvas':
+            continue
+        area = metric_number(item.get('area')) or 0
+        if area > large_canvas_area:
+            large_canvas_area = area
+    canvas_count = int(metric_number(page_state.get('canvasCount')) or 0)
+    return {
+        'canvas_ready': bool(canvas_count > 0 and large_canvas_area >= MIN_CANVAS_AREA),
+        'canvas_count': canvas_count,
+        'large_canvas_area': int(large_canvas_area),
+        'min_canvas_area': MIN_CANVAS_AREA,
+    }
+
+
 def normalize_observed_path(value):
     raw = str(value or '').strip()
     if not raw:
@@ -1135,6 +1191,7 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
     mode = normalized_verification_mode(verification_mode)
     supporting = collect_supporting_artifacts(payload)
     structured_ready = bool(supporting.get('has_structured_payload'))
+    playability_ready = mode in PLAYABILITY_MODES and bool(supporting.get('playability_ready'))
     screenshot_required = screenshot_required_for_mode(mode)
     details = {
         'verification_mode': mode,
@@ -1143,6 +1200,10 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
         'screenshot_required': screenshot_required,
         'structured_evidence_present': structured_ready,
         'proof_evidence_present': bool(supporting.get('proof_evidence_present')),
+        'playability_ready': playability_ready,
+        'canvas_capture_ready': False,
+        'large_canvas_area': 0,
+        'min_canvas_area': MIN_CANVAS_AREA,
         'proof_evidence_sample': supporting.get('proof_evidence_sample', ''),
         'body_text_length': 0,
         'interactive_elements': 0,
@@ -1183,6 +1244,12 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
             'large_visible_elements': list_value(page_state.get('largeVisibleElements'))[:10],
             'semantic_anchor_count': semantic_anchor_count(page_state),
         })
+        canvas_signal = canvas_capture_signal(page_state)
+        details.update({
+            'canvas_capture_ready': canvas_signal['canvas_ready'],
+            'large_canvas_area': canvas_signal['large_canvas_area'],
+            'min_canvas_area': canvas_signal['min_canvas_area'],
+        })
     elif screenshot_url:
         details.update({
             'body_text_length': MIN_BODY_TEXT_LENGTH + 100,
@@ -1220,11 +1287,20 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
         reasons.append('no screenshot or structured proof evidence in capture')
 
     should_enforce_visual_readiness = screenshot_required or (details['has_screenshot'] and not structured_ready)
-    if should_enforce_visual_readiness and details['body_text_length'] < MIN_BODY_TEXT_LENGTH:
+    canvas_ready = bool(details.get('canvas_capture_ready'))
+    body_text_ready = details['body_text_length'] >= MIN_BODY_TEXT_LENGTH or canvas_ready or playability_ready
+    interactive_ready = details['interactive_elements'] >= MIN_INTERACTIVE_ELEMENTS or canvas_ready or playability_ready
+    semantic_ready = (not has_enriched_page_state(page_state)) or details['semantic_anchor_count'] >= 1 or canvas_ready or playability_ready
+    details['body_text_ready'] = body_text_ready
+    details['interactive_ready'] = interactive_ready
+    details['semantic_ready'] = semantic_ready
+    details['canvas_or_playability_override'] = bool(should_enforce_visual_readiness and (canvas_ready or playability_ready))
+
+    if should_enforce_visual_readiness and not body_text_ready:
         reasons.append(f'blank/near-blank page (text length: {details["body_text_length"]})')
-    if should_enforce_visual_readiness and details['interactive_elements'] < MIN_INTERACTIVE_ELEMENTS:
+    if should_enforce_visual_readiness and not interactive_ready:
         reasons.append(f'not interactive enough ({details["interactive_elements"]} interactive elements)')
-    if should_enforce_visual_readiness and has_enriched_page_state(page_state) and details['semantic_anchor_count'] < 1:
+    if should_enforce_visual_readiness and has_enriched_page_state(page_state) and not semantic_ready:
         reasons.append('no visible semantic UI anchors in page capture')
     if details['has_errors']:
         reasons.append('page has console/runtime errors')
@@ -1234,15 +1310,14 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
         raw_observed = details.get('observed_path_raw') or details.get('observed_path') or observed_path
         reasons.append(f'wrong route: expected {expected_path}, got {raw_observed}')
 
-    semantic_ready = (not has_enriched_page_state(page_state)) or details['semantic_anchor_count'] >= 1
     visual_ready = (
         details['has_screenshot']
-        and details['body_text_length'] >= MIN_BODY_TEXT_LENGTH
-        and details['interactive_elements'] >= MIN_INTERACTIVE_ELEMENTS
+        and body_text_ready
+        and interactive_ready
         and semantic_ready
         and not details['has_errors']
     )
-    telemetry_ready = (visual_ready or structured_ready) and not details['has_errors']
+    telemetry_ready = (visual_ready or structured_ready or playability_ready) and not details['has_errors']
 
     return {
         'valid': len(reasons) == 0 and telemetry_ready,

package/runtime/tests/recon_verify_smoke.py

@@ -566,8 +566,106 @@ def run_verify_quality_ignores_proof_telemetry_console_text():
     })
     assert unmeasured_delta['status'] == 'unmeasured'
     assert unmeasured_delta['passed'] is None
+    assert unmeasured_delta['diagnostic']['after_screenshot_present'] is True
+    assert 'After screenshot artifact is present' in unmeasured_delta['reason']
+
+    canvas_payload = {
+        'bodyTextLength': 7,
+        'visibleTextSample': 'Luge',
+        'interactiveElements': 1,
+        'visibleInteractiveElements': 1,
+        'pathname': '/games/luge-run',
+        'title': 'Luge Run',
+        'headings': [],
+        'buttons': [],
+        'links': [],
+        'canvasCount': 1,
+        'largeVisibleElements': [{'tag': 'canvas', 'text': '', 'area': 420000}],
+    }
+    canvas_quality = namespace['evaluate_capture_quality']({
+        'ok': True,
+        'screenshots': [{'name': 'after-proof.png', 'url': 'https://cdn.example.com/after-proof.png'}],
+        'outputs': [{'name': 'after-proof.png', 'url': 'https://cdn.example.com/after-proof.png'}],
+        'console': ['RIDDLE_PROOF_STATE:' + json.dumps(canvas_payload)],
+    }, '/games/luge-run', 'visual')
+    assert canvas_quality['valid'] is True, canvas_quality
+    assert canvas_quality['details']['canvas_capture_ready'] is True
+    assert canvas_quality['details']['body_text_ready'] is True
+    assert 'blank/near-blank' not in canvas_quality['reason']
+
+    playability_payload = {
+        **canvas_payload,
+        'interactiveElements': 0,
+        'visibleInteractiveElements': 0,
+        'largeVisibleElements': [],
+    }
+    playability_evidence = {
+        'input_events': [{'type': 'pointerdown'}],
+        'state_delta': {'changed': True, 'changed_keys': ['distance']},
+        'canvas_delta': {'changed_pixels': 18000},
+        'time_delta_ms': 1300,
+    }
+    playable_quality = namespace['evaluate_capture_quality']({
+        'ok': True,
+        'screenshots': [{'name': 'after-proof.png', 'url': 'https://cdn.example.com/after-proof.png'}],
+        'outputs': [{'name': 'after-proof.png', 'url': 'https://cdn.example.com/after-proof.png'}],
+        'console': [
+            'RIDDLE_PROOF_STATE:' + json.dumps(playability_payload),
+            'RIDDLE_PROOF_EVIDENCE:' + json.dumps({'playability': playability_evidence}),
+        ],
+    }, '/games/luge-run', 'playable')
+    assert playable_quality['valid'] is True, playable_quality
+    assert playable_quality['details']['playability_ready'] is True
+    assert playable_quality['details']['interactive_ready'] is True
 
-    return {'ok': True, 'telemetry_valid': quality['valid'], 'weak_delta_passed': weak_delta['passed']}
+    return {
+        'ok': True,
+        'telemetry_valid': quality['valid'],
+        'weak_delta_passed': weak_delta['passed'],
+        'canvas_valid': canvas_quality['valid'],
+        'playable_valid': playable_quality['valid'],
+    }
+
+
+def run_recon_quality_accepts_canvas_first_routes():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-recon-canvas-quality-'))
+    state_path = tempdir / 'state.json'
+    try:
+        write_state(state_path, {
+            'after_worktree': str(tempdir),
+            'before_worktree': str(tempdir),
+        })
+        with temporary_env(RIDDLE_PROOF_STATE_FILE=str(state_path)):
+            sys.modules.pop('util', None)
+            source = RECON_PATH.read_text()
+            helpers_source = source.split('\ndef clean_next_cache', 1)[0]
+            namespace = {'__file__': str(RECON_PATH)}
+            exec(compile(helpers_source, str(RECON_PATH), 'exec'), namespace)
+        canvas_payload = {
+            'bodyTextLength': 4,
+            'visibleTextSample': 'Game',
+            'interactiveElements': 1,
+            'visibleInteractiveElements': 1,
+            'pathname': '/games/luge-run',
+            'title': 'Luge Run',
+            'headings': [],
+            'buttons': [],
+            'links': [],
+            'canvasCount': 1,
+            'largeVisibleElements': [{'tag': 'canvas', 'text': '', 'area': 420000}],
+        }
+        quality = namespace['evaluate_capture_quality']({
+            'ok': True,
+            'screenshots': [{'name': 'before.png', 'url': 'https://cdn.example.com/before.png'}],
+            'outputs': [{'name': 'before.png', 'url': 'https://cdn.example.com/before.png'}],
+            'console': ['RIDDLE_PROOF_STATE:' + json.dumps(canvas_payload)],
+        }, '/games/luge-run')
+        assert quality['valid'] is True, quality
+        assert quality['details']['canvas_capture_ready'] is True
+        assert 'blank/near-blank' not in quality['reason']
+        return {'ok': True, 'valid': quality['valid']}
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
 
 
 def load_util_with_fake(fake: FakeRiddle):
@@ -1992,6 +2090,7 @@ if __name__ == '__main__':
         'implement_records_detection_when_changes_missing': run_implement_records_detection_when_changes_missing(),
         'implement_ignores_tool_noise_when_detecting_changes': run_implement_ignores_tool_noise_when_detecting_changes(),
         'verify_quality_ignores_proof_telemetry_console_text': run_verify_quality_ignores_proof_telemetry_console_text(),
+        'recon_quality_accepts_canvas_first_routes': run_recon_quality_accepts_canvas_first_routes(),
         'recon_then_author_request': run_recon_then_author_request(),
         'recon_preserves_query_route': run_recon_preserves_query_route(),
         'recon_route_literal_preference': run_recon_prefers_route_literals_over_import_paths(),