@riddledc/riddle-proof 0.8.10 → 0.8.12

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-Ci9uFxMc.cjs';
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-Bd1T43Dy.cjs';
+import './proof-run-core-CrpYH-qH.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-C6vYAZd8.cjs';

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

@@ -1,2 +1,2 @@
-import './proof-run-core-Ci9uFxMc.js';
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-CXyhB-io.js';
+import './proof-run-core-CrpYH-qH.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-h9C1lC0w.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.10",
+  "version": "0.8.12",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",

package/runtime/lib/verify.py

@@ -2061,7 +2061,24 @@ EXPLICIT_TERMINAL_PATH_KEYS = (
     'final_url', 'finalUrl',
     'final_route', 'finalRoute',
 )
-LOCATION_PATH_KEYS = ('path', 'pathname', 'route', 'url', 'href')
+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',
@@ -2158,18 +2175,29 @@ def text_path_candidate(value):
     return path_candidate(raw)
 
 
+def text_route_candidate(value):
+    candidate = text_path_candidate(value)
+    if not candidate:
+        return ''
+    parsed = urlparse(candidate)
+    first_segment = next((part for part in (parsed.path or '').split('/') if part), '')
+    if first_segment and first_segment[:1].isupper():
+        return ''
+    return candidate
+
+
 def terminal_path_from_text(value):
     if not isinstance(value, str):
         return ''
     for match in re.findall(r"""['"`](/[^'"`\s]+[?#][^'"`\s]*)['"`]""", value):
-        candidate = text_path_candidate(match)
+        candidate = text_route_candidate(match)
         if candidate:
             return candidate
     context_pattern = re.compile(
-        r"""(?is)\b(?:expected\s+(?:terminal|after|final)|terminal|after|final)\b[^/\r\n]{0,120}['"`]?(/[^'"`\s,;)]*)"""
+        r"""(?is)\b(?:expected\s+(?:terminal|after|final)(?:\s+(?:route|path|url))?|terminal(?:\s+(?:route|path|url))?|after(?:\s+(?:route|path|url))?|final(?:\s+(?:route|path|url))?)\s*(?:should\s+(?:be|equal|match)|must\s+(?:be|equal|match)|is|as|to|=|:)?\s*['"`]?(/[^'"`\s,;)]*)"""
     )
     for match in context_pattern.findall(value):
-        candidate = text_path_candidate(match)
+        candidate = text_route_candidate(match)
         if candidate:
             return candidate
     return ''
@@ -2372,6 +2400,25 @@ 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)
@@ -2389,6 +2436,13 @@ def interaction_terminal_path_from_evidence(proof_evidence):
 
 
 def interaction_terminal_path_from_state(state):
+    for key in (
+        'expected_terminal_path',
+        'expected_after_path',
+    ):
+        candidate = path_candidate(state.get(key))
+        if candidate:
+            return candidate, key
     for key in (
         'interaction_contract',
         'proof_contract',
@@ -2401,19 +2455,32 @@ def interaction_terminal_path_from_state(state):
         if candidate:
             return candidate, key
     for key in (
-        'expected_terminal_path',
-        'expected_after_path',
         'capture_script',
         'proof_plan',
-        'success_criteria',
-        'change_request',
     ):
-        candidate = path_candidate(state.get(key)) or terminal_path_from_text(state.get(key))
+        candidate = terminal_path_from_text(state.get(key))
         if candidate:
             return candidate, key
     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
+    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 '/'
@@ -2431,9 +2498,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, {
@@ -2824,10 +2896,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:
@@ -2838,7 +2917,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 += (
@@ -2854,8 +2936,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,
         }
@@ -3631,12 +3715,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'),
@@ -3648,6 +3737,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
@@ -3656,6 +3746,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
 )
 
@@ -3712,7 +3803,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 {}
@@ -3721,6 +3817,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
@@ -3728,6 +3825,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'] = {}
@@ -3742,8 +3842,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.',
@@ -3753,7 +3853,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']