@riddledc/riddle-proof 0.8.11 → 0.8.13

package/dist/proof-run-engine.cjs

@@ -505,6 +505,25 @@ function visualDeltaShipGateReason(state = {}) {
   if (reason) return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof: ${reason}`;
   return `visual_delta.status=${status} blocks ready_to_ship for visual/UI proof`;
 }
+function proofAssessmentHardBlockersForState(state = {}) {
+  const request = objectValue(state?.proof_assessment_request);
+  const blockers = [];
+  const add = (value) => {
+    if (typeof value !== "string") return;
+    const trimmed = value.trim();
+    if (trimmed && !blockers.includes(trimmed)) blockers.push(trimmed);
+  };
+  if (Array.isArray(request.hard_blockers)) {
+    for (const blocker of request.hard_blockers) add(blocker);
+  }
+  add(state?.structured_interaction_capture_failure_summary);
+  add(state?.structured_interaction_failure_summary);
+  const mergeRecommendation = String(state?.merge_recommendation || "").trim();
+  if (mergeRecommendation === "do-not-merge" && blockers.length) {
+    add("merge_recommendation=do-not-merge because the proof bundle contains hard blockers.");
+  }
+  return blockers;
+}
 function visualDeltaEvidenceIssueCode(state = {}, blocker = "") {
   const visualDelta = visualDeltaForState(state || {});
   const status = String(visualDelta.status || "").trim();
@@ -539,6 +558,7 @@ function validateShipGate(state = {}) {
   const visualDelta = visualDeltaForState(state);
   const visualDeltaRequired = visualDeltaRequiredForState(state);
   const visualDeltaBlocker = visualDeltaShipGateReason(state);
+  const hardBlockers = proofAssessmentHardBlockersForState(state);
   const reasons = [];
   if (!["before", "prod", "both"].includes(reference)) {
     reasons.push(`reference must be before, prod, or both; got ${reference}`);
@@ -570,6 +590,9 @@ function validateShipGate(state = {}) {
   if (visualDeltaBlocker) {
     reasons.push(visualDeltaBlocker);
   }
+  for (const blocker of hardBlockers) {
+    reasons.push(`proof hard blocker prevents ready_to_ship: ${blocker}`);
+  }
   return {
     ok: reasons.length === 0,
     reasons,
@@ -586,7 +609,8 @@ function validateShipGate(state = {}) {
       proof_assessment_source: proofAssessment.source,
       visual_delta_required: visualDeltaRequired,
       visual_delta_status: typeof visualDelta.status === "string" ? visualDelta.status : null,
-      visual_delta_passed: typeof visualDelta.passed === "boolean" ? visualDelta.passed : null
+      visual_delta_passed: typeof visualDelta.passed === "boolean" ? visualDelta.passed : null,
+      hard_blockers: hardBlockers
     }
   };
 }
@@ -700,6 +724,10 @@ var CHECKPOINT_CONTRACT_SPECS = {
     }],
     required_state: ["verify_decision_request"]
   },
+  verify_capture_blocked: {
+    purpose: "Verify capture produced conclusive failed browser evidence and should stop instead of retrying proof authoring.",
+    required_state: ["verify_decision_request"]
+  },
   verify_supervisor_judgment: {
     purpose: "Supervising agent judges whether captured evidence proves the change is ready to ship.",
     accepted_inputs: [{
@@ -1284,14 +1312,18 @@ function verifyAssessment(state) {
     };
   }
   if (state?.verify_status === "capture_incomplete") {
+    const captureQuality = verifyDecision?.capture_quality || {};
+    const terminalBlocker = captureQuality?.terminal_blocker === true || captureQuality?.blocking === true;
+    const recommendedStage = terminalBlocker ? null : verifyDecision?.continue_with_stage || verifyDecision?.recommended_stage || "author";
+    const continueWithStage = terminalBlocker ? null : verifyDecision?.continue_with_stage || verifyDecision?.recommended_stage || "author";
     return {
-      decision: verifyDecision?.capture_quality?.decision || "revise_capture",
+      decision: captureQuality?.decision || "revise_capture",
       summary: verifyDecision?.summary || "Verify needs another internal capture iteration before the evidence can be judged.",
-      recommendedStage: verifyDecision?.continue_with_stage || verifyDecision?.recommended_stage || "author",
-      continueWithStage: verifyDecision?.continue_with_stage || verifyDecision?.recommended_stage || "author",
+      recommendedStage,
+      continueWithStage,
       escalationTarget: "agent",
-      reasons: Array.isArray(verifyDecision?.capture_quality?.reasons) ? verifyDecision.capture_quality.reasons : [],
-      raw: verifyDecision?.capture_quality || verifyDecision,
+      reasons: Array.isArray(captureQuality?.reasons) ? captureQuality.reasons : [],
+      raw: captureQuality || verifyDecision,
       source: "workflow_capture"
     };
   }
@@ -2511,7 +2543,9 @@ ${implementRes.stderr || ""}`;
         convergenceSignals
       };
       if (verifyStatus !== "evidence_captured") {
-        if ((verifyContinueWithStage || verifyRecommendedStage || "author") === "author") {
+        const captureQuality = verifyDecisionRequest?.capture_quality || {};
+        const captureTerminalBlocker = captureQuality?.terminal_blocker === true || captureQuality?.blocking === true;
+        if (!captureTerminalBlocker && (verifyContinueWithStage || verifyRecommendedStage || "author") === "author") {
           updateState(config.statePath, (currentState) => {
             currentState.author_status = "needs_authoring";
             currentState.proof_plan_status = "needs_authoring";
@@ -2519,7 +2553,7 @@ ${implementRes.stderr || ""}`;
           });
           state = readState(config.statePath);
         }
-        const checkpointName = "verify_capture_retry";
+        const checkpointName = captureTerminalBlocker ? "verify_capture_blocked" : "verify_capture_retry";
         const summary = stringValue(proofAssessment.summary) || "Verify ran, but the proof packet still needs internal capture-plan work before it should ship.";
         recordAttempt("verify", "checkpoint", summary, {
           autoApproved: verifyRes.autoApproved || false,
@@ -2532,11 +2566,11 @@ ${implementRes.stderr || ""}`;
           summary,
           {
             ok: true,
-            nextActions: ["inspect_after_capture", "continue_internal_loop_with_checkpoint", "return_to_recon_if_baseline_is_wrong"],
+            nextActions: captureTerminalBlocker ? ["inspect_after_capture", "report_specific_browser_evidence_blocker", "start_a_new_run_after_the_product_or_script_is_fixed"] : ["inspect_after_capture", "continue_internal_loop_with_checkpoint", "return_to_recon_if_baseline_is_wrong"],
             advanceOptions: verifyLoopAdvanceOptions,
-            recommendedAdvanceStage: verifyRecommendedStage || "author",
-            continueWithStage: verifyContinueWithStage || "author",
-            blocking: false,
+            recommendedAdvanceStage: captureTerminalBlocker ? null : verifyRecommendedStage || "author",
+            continueWithStage: captureTerminalBlocker ? null : verifyContinueWithStage || "author",
+            blocking: captureTerminalBlocker,
             details: verifyDetails,
             verifyStatus,
             verifySummary,

package/dist/proof-run-engine.d.cts

@@ -1,2 +1,2 @@
-import './proof-run-core-CE0jx7wL.cjs';
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-B7DCPzpK.cjs';
+import './proof-run-core-C8FDUhle.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-D80hVFMf.cjs';

package/dist/proof-run-engine.d.ts

@@ -1,2 +1,2 @@
-import './proof-run-core-CE0jx7wL.js';
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-BomAcXhA.js';
+import './proof-run-core-C8FDUhle.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-By7oLsF-.js';

package/dist/proof-run-engine.js

@@ -1,8 +1,8 @@
 import {
   createRiddleProofEngine,
   executeWorkflow
-} from "./chunk-46DDSZJR.js";
-import "./chunk-5N5QFI2S.js";
+} from "./chunk-JBY2SU5U.js";
+import "./chunk-7GZY5PLT.js";
 import "./chunk-MLKGABMK.js";
 export {
   createRiddleProofEngine,

package/dist/runner.js

@@ -1,9 +1,9 @@
 import {
   runRiddleProof
-} from "./chunk-5N6MQCLC.js";
+} from "./chunk-NGX4SUQN.js";
 import "./chunk-YZUVEJ5B.js";
 import "./chunk-FMOYUYH2.js";
-import "./chunk-5N5QFI2S.js";
+import "./chunk-7GZY5PLT.js";
 import "./chunk-4FOHZ7JG.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";

package/package.json

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

package/runtime/lib/verify.py

@@ -2029,7 +2029,7 @@ def interaction_proof_route_match(expected_path, proof_evidence):
         return None
     for record in proof_evidence_records_deep(proof_evidence):
         flag = explicit_route_match_flag(record)
-        candidate = terminal_path_from_record(record)
+        candidate = observed_terminal_path_from_record(record)
         if candidate and route_matches_expected(expected, candidate):
             return {
                 'matched': True,
@@ -2042,26 +2042,84 @@ def interaction_proof_route_match(expected_path, proof_evidence):
 
 
 EXPLICIT_TERMINAL_PATH_KEYS = (
+    'expected_url', 'expectedUrl',
+    'expected_href', 'expectedHref',
     'expected_terminal_path', 'expectedTerminalPath',
     'expected_terminal_url', 'expectedTerminalUrl',
+    'expected_terminal_href', 'expectedTerminalHref',
     'expected_terminal_route', 'expectedTerminalRoute',
+    'expected_route', 'expectedRoute',
     'terminal_path', 'terminalPath',
     'terminal_url', 'terminalUrl',
+    'terminal_href', 'terminalHref',
     'terminal_route', 'terminalRoute',
     'expected_after_path', 'expectedAfterPath',
     'expected_after_url', 'expectedAfterUrl',
+    'expected_after_href', 'expectedAfterHref',
     'expected_after_route', 'expectedAfterRoute',
     'after_path', 'afterPath',
     'after_url', 'afterUrl',
+    'after_href', 'afterHref',
     'after_route', 'afterRoute',
     'expected_final_path', 'expectedFinalPath',
     'expected_final_url', 'expectedFinalUrl',
+    'expected_final_href', 'expectedFinalHref',
     'expected_final_route', 'expectedFinalRoute',
     'final_path', 'finalPath',
     'final_url', 'finalUrl',
+    'final_href', 'finalHref',
     'final_route', 'finalRoute',
 )
-LOCATION_PATH_KEYS = ('path', 'pathname', 'route', 'url', 'href')
+EXPECTED_TERMINAL_PATH_KEYS = (
+    'expected_url', 'expectedUrl',
+    'expected_href', 'expectedHref',
+    'expected_path', 'expectedPath',
+    'expected_route', 'expectedRoute',
+    'expected_terminal_path', 'expectedTerminalPath',
+    'expected_terminal_url', 'expectedTerminalUrl',
+    'expected_terminal_href', 'expectedTerminalHref',
+    'expected_terminal_route', 'expectedTerminalRoute',
+    'expected_after_path', 'expectedAfterPath',
+    'expected_after_url', 'expectedAfterUrl',
+    'expected_after_href', 'expectedAfterHref',
+    'expected_after_route', 'expectedAfterRoute',
+    'expected_final_path', 'expectedFinalPath',
+    'expected_final_url', 'expectedFinalUrl',
+    'expected_final_href', 'expectedFinalHref',
+    'expected_final_route', 'expectedFinalRoute',
+)
+OBSERVED_TERMINAL_PATH_KEYS = (
+    'terminal_path', 'terminalPath',
+    'terminal_url', 'terminalUrl',
+    'terminal_href', 'terminalHref',
+    'terminal_route', 'terminalRoute',
+    'after_path', 'afterPath',
+    'after_url', 'afterUrl',
+    'after_href', 'afterHref',
+    'after_route', 'afterRoute',
+    'final_path', 'finalPath',
+    'final_url', 'finalUrl',
+    'final_href', 'finalHref',
+    'final_route', 'finalRoute',
+)
+FULL_LOCATION_PATH_KEYS = (
+    'url', 'href',
+    'hrefNormalized', 'href_normalized',
+    'terminalUrl', 'terminal_url',
+    'afterUrl', 'after_url',
+    'finalUrl', 'final_url',
+    'currentUrl', 'current_url',
+    'pathWithSearchAndHash', 'path_with_search_and_hash',
+    'fullPath', 'full_path',
+)
+PARTIAL_LOCATION_PATH_KEYS = (
+    'route',
+    'path',
+    'pathname',
+    'normalizedPath', 'normalized_path',
+    'rawPath', 'raw_path',
+)
+LOCATION_PATH_KEYS = FULL_LOCATION_PATH_KEYS + PARTIAL_LOCATION_PATH_KEYS
 AFTER_STATE_KEYS = (
     'after', 'after_state', 'afterState',
     'expected_after', 'expectedAfter',
@@ -2070,6 +2128,19 @@ AFTER_STATE_KEYS = (
     'final', 'final_state', 'finalState',
     'expected_final', 'expectedFinal',
 )
+EXPECTED_STATE_KEYS = (
+    'expected', 'expectation',
+    'route_expectation', 'routeExpectation',
+    'expected_after', 'expectedAfter',
+    'expected_terminal', 'expectedTerminal',
+    'expected_final', 'expectedFinal',
+)
+OBSERVED_STATE_KEYS = (
+    'observed', 'actual',
+    'after', 'after_state', 'afterState',
+    'terminal', 'terminal_state', 'terminalState',
+    'final', 'final_state', 'finalState',
+)
 EVIDENCE_CONTAINER_KEYS = (
     'proofEvidence', 'proof_evidence',
     'interactionEvidence', 'interaction_evidence',
@@ -2096,10 +2167,10 @@ def path_candidate(value):
     return ''
 
 
-def record_path_candidate(record, allow_location_keys=False):
+def record_path_candidate_for_keys(record, keys, allow_location_keys=False):
     if not isinstance(record, dict):
         return ''
-    keys = list(EXPLICIT_TERMINAL_PATH_KEYS)
+    keys = list(keys)
     if allow_location_keys:
         keys.extend(LOCATION_PATH_KEYS)
     for key in keys:
@@ -2109,6 +2180,10 @@ def record_path_candidate(record, allow_location_keys=False):
     return ''
 
 
+def record_path_candidate(record, allow_location_keys=False):
+    return record_path_candidate_for_keys(record, EXPLICIT_TERMINAL_PATH_KEYS, allow_location_keys)
+
+
 def terminal_path_from_record(record, depth=0):
     if not isinstance(record, dict) or depth > 4:
         return ''
@@ -2151,6 +2226,74 @@ def terminal_path_from_record(record, depth=0):
     return ''
 
 
+def expected_terminal_path_from_record(record, depth=0):
+    if not isinstance(record, dict) or depth > 4:
+        return ''
+    candidate = record_path_candidate_for_keys(record, EXPECTED_TERMINAL_PATH_KEYS)
+    if candidate:
+        return candidate
+    for key in EXPECTED_STATE_KEYS:
+        value = record.get(key)
+        if isinstance(value, dict):
+            candidate = (
+                record_path_candidate_for_keys(value, EXPECTED_TERMINAL_PATH_KEYS, allow_location_keys=True)
+                or expected_terminal_path_from_record(value, depth + 1)
+            )
+            if candidate:
+                return candidate
+        elif isinstance(value, list):
+            for item in value:
+                candidate = expected_terminal_path_from_record(item, depth + 1)
+                if candidate:
+                    return candidate
+    for key in EVIDENCE_CONTAINER_KEYS:
+        value = record.get(key)
+        if isinstance(value, dict):
+            candidate = expected_terminal_path_from_record(value, depth + 1)
+            if candidate:
+                return candidate
+        elif isinstance(value, list):
+            for item in value:
+                candidate = expected_terminal_path_from_record(item, depth + 1)
+                if candidate:
+                    return candidate
+    return ''
+
+
+def observed_terminal_path_from_record(record, depth=0):
+    if not isinstance(record, dict) or depth > 4:
+        return ''
+    candidate = record_path_candidate_for_keys(record, OBSERVED_TERMINAL_PATH_KEYS)
+    if candidate:
+        return candidate
+    for key in OBSERVED_STATE_KEYS:
+        value = record.get(key)
+        if isinstance(value, dict):
+            candidate = (
+                record_path_candidate_for_keys(value, OBSERVED_TERMINAL_PATH_KEYS, allow_location_keys=True)
+                or observed_terminal_path_from_record(value, depth + 1)
+            )
+            if candidate:
+                return candidate
+        elif isinstance(value, list):
+            for item in value:
+                candidate = observed_terminal_path_from_record(item, depth + 1)
+                if candidate:
+                    return candidate
+    for key in EVIDENCE_CONTAINER_KEYS:
+        value = record.get(key)
+        if isinstance(value, dict):
+            candidate = observed_terminal_path_from_record(value, depth + 1)
+            if candidate:
+                return candidate
+        elif isinstance(value, list):
+            for item in value:
+                candidate = observed_terminal_path_from_record(item, depth + 1)
+                if candidate:
+                    return candidate
+    return ''
+
+
 def text_path_candidate(value):
     if not isinstance(value, str):
         return ''
@@ -2383,19 +2526,41 @@ def failed_interaction_evidence_summary(proof_evidence):
     return summary
 
 
+def interaction_capture_failure_evidence_summary(proof_evidence):
+    for record in proof_evidence_records_deep(proof_evidence):
+        if not isinstance(record, dict):
+            continue
+        version = str(record.get('version') or '').strip()
+        source = str(record.get('source') or '').strip()
+        if version != 'riddle-proof.interaction.capture-failure.v1' and source != 'verify_capture_failure':
+            continue
+        summary = str(record.get('evidence_summary') or '').strip() or 'Interaction capture failed before usable authored proof evidence was emitted.'
+        failures = collect_interaction_failed_assertions(record)
+        if failures:
+            summary += ' Failed checks: ' + ', '.join(failures[:8]) + '.'
+        error = str(record.get('capture_error') or record.get('error') or '').strip()
+        if error:
+            summary += ' Capture script error: ' + error[:300]
+        return summary
+    return ''
+
+
 def interaction_terminal_path_from_evidence(proof_evidence):
     for record in proof_evidence_records(proof_evidence):
-        candidate = terminal_path_from_record(record)
+        candidate = expected_terminal_path_from_record(record)
         if candidate:
             return candidate, 'proof_evidence_contract'
-    if interaction_assertions_pass(proof_evidence):
+    route_evidence_passed = interaction_assertions_pass(proof_evidence)
+    if not route_evidence_passed:
+        for record in proof_evidence_records_deep(proof_evidence):
+            if interaction_assertions_pass(record) or explicit_route_match_flag(record) is True:
+                route_evidence_passed = True
+                break
+    if route_evidence_passed:
         for record in proof_evidence_records(proof_evidence):
-            for key in AFTER_STATE_KEYS:
-                value = record.get(key)
-                if isinstance(value, dict):
-                    candidate = record_path_candidate(value, allow_location_keys=True)
-                    if candidate:
-                        return candidate, 'proof_evidence_after_state'
+            candidate = observed_terminal_path_from_record(record)
+            if candidate:
+                return candidate, 'proof_evidence_contract'
     return '', ''
 
 
@@ -2428,6 +2593,33 @@ def interaction_terminal_path_from_state(state):
     return '', ''
 
 
+def proof_evidence_should_override_state_terminal_path(state_candidate, evidence_candidate, proof_evidence):
+    if not evidence_candidate:
+        return False
+    if not state_candidate:
+        return True
+    state_parts = route_parts(state_candidate)
+    evidence_parts = route_parts(evidence_candidate)
+    if (
+        state_parts.get('pathname') == evidence_parts.get('pathname')
+        and (
+            (evidence_parts.get('query') and not state_parts.get('query'))
+            or (evidence_parts.get('hash') and not state_parts.get('hash'))
+        )
+    ):
+        return True
+    if route_matches_expected(state_candidate, evidence_candidate):
+        return False
+    if interaction_assertions_pass(proof_evidence):
+        return True
+    for record in proof_evidence_records_deep(proof_evidence):
+        if interaction_assertions_pass(record):
+            return True
+        if explicit_route_match_flag(record) is True:
+            return True
+    return False
+
+
 def expected_path_for_verify(state, start_path, proof_evidence):
     mode = normalized_verification_mode(state.get('verification_mode'))
     normalized_start = normalize_observed_path(start_path) or '/'
@@ -2445,9 +2637,14 @@ def expected_path_for_verify(state, start_path, proof_evidence):
             'expected_query': start_parts['query'],
             'expected_hash': start_parts['hash'],
         }
-    candidate, source = interaction_terminal_path_from_state(state)
+    state_candidate, state_source = interaction_terminal_path_from_state(state)
+    evidence_candidate, evidence_source = interaction_terminal_path_from_evidence(proof_evidence)
+    if proof_evidence_should_override_state_terminal_path(state_candidate, evidence_candidate, proof_evidence):
+        candidate, source = evidence_candidate, evidence_source
+    else:
+        candidate, source = state_candidate, state_source
     if not candidate:
-        candidate, source = interaction_terminal_path_from_evidence(proof_evidence)
+        candidate, source = evidence_candidate, evidence_source
     expected = candidate or normalized_start
     expected_parts = route_parts(expected)
     return expected, {
@@ -2838,10 +3035,17 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
 
     if proof_evidence_blocker:
         reasons.append(proof_evidence_blocker)
-        decision = 'missing_proof_evidence'
+        interaction_capture_blocker = (
+            proof_evidence_blocker.startswith('Interaction capture ')
+            or 'Interaction capture failed before usable authored proof evidence was emitted' in proof_evidence_blocker
+            or 'Interaction capture reached a different terminal route' in proof_evidence_blocker
+        )
+        decision = 'failed_interaction_capture' if interaction_capture_blocker else 'missing_proof_evidence'
         if 'proof_evidence_present=false' in proof_evidence_blocker:
             decision = 'failed_proof_evidence'
             reasons.append('The capture reached usable page context, but the proof evidence explicitly failed its own required audio gate.')
+        elif interaction_capture_blocker:
+            reasons.append('The capture produced conclusive structured interaction-failure evidence, so this run should block with that specific browser evidence instead of re-authoring in a loop.')
         else:
             reasons.append('The capture reached usable page context, but the proof script did not emit the structured evidence required for this verification mode.')
         if route_mismatch:
@@ -2852,7 +3056,10 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
                 (route_mismatch.get('observed_after_path') or '(unknown)') +
                 '.'
             )
-        reasons.append('Return to author so the capture script can expose passing proof evidence before verify asks for a supervising-agent judgment.')
+        if interaction_capture_blocker:
+            reasons.append('Do not ask the authoring loop to infer a new route; the captured browser evidence is the terminal blocker.')
+        else:
+            reasons.append('Return to author so the capture script can expose passing proof evidence before verify asks for a supervising-agent judgment.')
         summary = proof_evidence_blocker
         if route_mismatch:
             summary += (
@@ -2868,8 +3075,10 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
         return {
             'decision': decision,
             'summary': summary,
-            'recommended_stage': 'author',
-            'continue_with_stage': 'author',
+            'recommended_stage': None if interaction_capture_blocker else 'author',
+            'continue_with_stage': None if interaction_capture_blocker else 'author',
+            'blocking': bool(interaction_capture_blocker),
+            'terminal_blocker': bool(interaction_capture_blocker),
             'reasons': reasons,
             'mismatch': route_mismatch,
         }
@@ -2883,6 +3092,25 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
         and route_expectation.get('terminal_path')
         and route_expectation_source != 'recon_start_path'
     )
+    if authored_terminal_route:
+        expected = route_mismatch.get('expected_path') or ''
+        observed = route_mismatch.get('observed_after_path') or ''
+        summary = 'Interaction proof terminal route mismatch: expected ' + (expected or '(unknown)') + ', got ' + (observed or '(unknown)') + '.'
+        if error_messages:
+            reasons.append('Capture script error: ' + error_messages[0][:500])
+            summary += ' Capture script error: ' + error_messages[0][:300]
+        reasons.append('Route mismatch: expected after capture path ' + (expected or '(unknown)') + ', observed ' + (observed or '(unknown)') + '.')
+        reasons.append('The terminal route came from authored interaction proof evidence, so the captured browser evidence is the terminal blocker instead of an author retry loop.')
+        return {
+            'decision': 'failed_interaction_capture',
+            'summary': summary,
+            'recommended_stage': None,
+            'continue_with_stage': None,
+            'blocking': True,
+            'terminal_blocker': True,
+            'reasons': reasons,
+            'mismatch': route_mismatch,
+        }
     recommended_stage = 'recon' if 'wrong route' in reason and not authored_terminal_route else 'author'
     mismatch = None
     if recommended_stage == 'recon':
@@ -3645,12 +3873,17 @@ if proof_evidence_required_for_mode(s.get('verification_mode')):
         summary_lines.append('Structured proof evidence gate: ' + proof_evidence_blocker)
 
 structured_interaction_failure_summary = ''
+structured_interaction_capture_failure_summary = ''
 proof_evidence = evidence_bundle.get('proof_evidence')
 if verification_mode in INTERACTION_MODES and proof_evidence is not None:
     structured_interaction_failure_summary = failed_interaction_evidence_summary(proof_evidence)
+    structured_interaction_capture_failure_summary = interaction_capture_failure_evidence_summary(proof_evidence)
     if structured_interaction_failure_summary:
         summary_lines.append('Structured interaction evidence gate: ' + structured_interaction_failure_summary)
+    if structured_interaction_capture_failure_summary:
+        summary_lines.append('Structured interaction capture blocker: ' + structured_interaction_capture_failure_summary)
 s['structured_interaction_failure_summary'] = structured_interaction_failure_summary
+s['structured_interaction_capture_failure_summary'] = structured_interaction_capture_failure_summary
 
 visual_delta_recovery = build_visual_delta_recovery_decision(
     s.get('verification_mode'),
@@ -3662,6 +3895,7 @@ if visual_delta_recovery:
 
 has_judgable_failed_interaction_evidence = (
     bool(structured_interaction_failure_summary)
+    and not structured_interaction_capture_failure_summary
     and required_baseline_present
     and not proof_evidence_blocker
     and not visual_delta_recovery
@@ -3670,6 +3904,7 @@ has_good_evidence = (
     required_baseline_present
     and (after_observation.get('valid') or has_judgable_failed_interaction_evidence)
     and not proof_evidence_blocker
+    and not structured_interaction_capture_failure_summary
     and not visual_delta_recovery
 )
 
@@ -3726,7 +3961,12 @@ if has_good_evidence:
         summary_lines.append('Proof assessment: awaiting supervising agent judgment')
     summary_lines.append('Proof next stage: supervising agent decides after reviewing the evidence packet')
 else:
-    capture_retry = build_capture_retry_decision(after_observation, required_baseline_present, proof_evidence_blocker, s.get('route_expectation') or {})
+    capture_retry = build_capture_retry_decision(
+        after_observation,
+        required_baseline_present,
+        proof_evidence_blocker or structured_interaction_capture_failure_summary,
+        s.get('route_expectation') or {},
+    )
     if visual_delta_recovery:
         observation_reason = str(after_observation.get('reason') or '')
         observation_details = after_observation.get('details') if isinstance(after_observation.get('details'), dict) else {}
@@ -3735,6 +3975,7 @@ else:
             or 'console/runtime errors' in observation_reason
             or (observation_details.get('capture_error_messages') or [])
             or proof_evidence_blocker
+            or structured_interaction_capture_failure_summary
         )
         if has_primary_capture_failure:
             capture_retry['visual_delta_recovery'] = visual_delta_recovery
@@ -3742,6 +3983,9 @@ else:
         else:
             capture_retry = visual_delta_recovery
     next_stage_options = ['author', 'verify', 'recon'] if no_implementation_mode else ['author', 'verify', 'implement', 'recon']
+    capture_terminal_blocker = bool(capture_retry.get('terminal_blocker') or capture_retry.get('blocking'))
+    recommended_stage = None if capture_terminal_blocker else (capture_retry.get('recommended_stage') or 'author')
+    continue_with_stage = None if capture_terminal_blocker else (capture_retry.get('continue_with_stage') or 'author')
     s['verify_status'] = 'capture_incomplete'
     s['merge_recommendation'] = 'do-not-merge'
     s['proof_assessment'] = {}
@@ -3756,8 +4000,8 @@ else:
         'latest_observation': after_observation,
         'capture_quality': capture_retry,
         'next_stage_options': next_stage_options,
-        'recommended_stage': capture_retry.get('recommended_stage') or 'author',
-        'continue_with_stage': capture_retry.get('continue_with_stage') or 'author',
+        'recommended_stage': recommended_stage,
+        'continue_with_stage': continue_with_stage,
         'fields_agent_may_update': ['capture_script', 'server_path', 'wait_for_selector', 'proof_plan'],
         'instructions': [
             'The after-proof evidence packet is incomplete, so use the recommended stage before proof review.',
@@ -3767,7 +4011,7 @@ else:
         ],
     }
     summary_lines.append('Proof assessment: not yet possible because the after capture is still incomplete')
-    summary_lines.append('Proof next stage: ' + str(capture_retry.get('recommended_stage') or 'author'))
+    summary_lines.append('Proof next stage: blocked' if capture_terminal_blocker else 'Proof next stage: ' + str(recommended_stage or 'author'))
 
 s['verify_summary'] = '\n'.join(summary_lines)
 s['proof_summary'] = s['verify_summary']