@riddledc/riddle-proof 0.8.3 → 0.8.5

package/dist/proof-run-engine.cjs

@@ -1925,9 +1925,9 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     state = readState(config.statePath);
     const continuedStage = params.continue_from_checkpoint ? checkpointContinueStage(state) : null;
     if (params.continue_from_checkpoint && !params.advance_stage && !continuedStage) {
-      const recommended = recommendedAdvanceStage(state);
+      const recommended2 = recommendedAdvanceStage(state);
       return checkpoint(
-        state?.active_checkpoint_stage || recommended || "recon",
+        state?.active_checkpoint_stage || recommended2 || "recon",
         "continue_unavailable",
         "This run call asked to continue from a checkpoint, but the current state has no resumable checkpoint. Inspect status or set advance_stage explicitly.",
         {
@@ -1939,9 +1939,9 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
           details: {
             executed,
             activeCheckpoint: state?.active_checkpoint || null,
-            suggestedAdvanceStage: recommended || null
+            suggestedAdvanceStage: recommended2 || null
           },
-          suggestedAdvanceStage: recommended || null,
+          suggestedAdvanceStage: recommended2 || null,
           executed
         }
       );
@@ -2205,7 +2205,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
       }
       const noImplementationMode = !implementationRequired(params, state);
       const authorNextStage = stageAfterAuthor(state, params);
-      const explicitAuthorDebug = params.advance_stage === "author";
+      const explicitAuthorDebug = params.advance_stage === "author" && !params.continue_from_checkpoint;
       recordAttempt("author", "completed", "Author applied the supervising agent's proof packet to recon observations.", {
         autoApproved: authorRes.autoApproved || false,
         checkpoint: explicitAuthorDebug ? "author_review" : "author_auto_continue",
@@ -2254,16 +2254,16 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
       state = readState(config.statePath);
     }
     if (!effectiveAdvanceStage) {
-      const recommended = recommendedAdvanceStage(state);
+      const recommended2 = recommendedAdvanceStage(state);
       const noImplementationMode = !implementationRequired(params, state);
       return checkpoint(
-        recommended || (noImplementationMode ? "verify" : "implement"),
+        recommended2 || (noImplementationMode ? "verify" : "implement"),
         "awaiting_stage_advance",
         "Proof authoring is ready. The wrapper will not guess the next stage from here, explicitly choose whether to revisit recon/author, validate implementation, capture verify evidence, or ship.",
         {
           nextActions: ["inspect_state", "set_advance_stage", "resume_run"],
           advanceOptions: noImplementationMode ? ["recon", "author", "verify", "ship"] : ["recon", "author", "implement", "verify", "ship"],
-          recommendedAdvanceStage: recommended,
+          recommendedAdvanceStage: recommended2,
           details: { executed },
           executed
         }
@@ -2463,7 +2463,7 @@ ${implementRes.stderr || ""}`;
           state = readState(config.statePath);
         }
         const checkpointName = "verify_capture_retry";
-        const summary = "Verify ran, but the proof packet still needs internal capture-plan work before it should ship.";
+        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,
           checkpoint: checkpointName,
@@ -2819,6 +2819,26 @@ ${implementRes.stderr || ""}`;
         }
       );
     }
+    state = readState(config.statePath);
+    const recommended = recommendedAdvanceStage(state);
+    const fallbackStage = recommended || (implementationRequired(params, state) ? "implement" : "verify");
+    return checkpoint(
+      fallbackStage,
+      "awaiting_stage_advance",
+      "The requested run continuation finished its immediate work but did not resolve to verify or ship. Choose the next workflow stage explicitly.",
+      {
+        nextActions: ["inspect_state", "set_advance_stage", "resume_run"],
+        advanceOptions: implementationRequired(params, state) ? ["recon", "author", "implement", "verify", "ship"] : ["recon", "author", "verify"],
+        recommendedAdvanceStage: fallbackStage,
+        continueWithStage: fallbackStage,
+        blocking: false,
+        details: {
+          executed,
+          requestedAdvanceStage: effectiveAdvanceStage
+        },
+        executed
+      }
+    );
   }
   if (action === "ship") {
     const state = readState(config.statePath);

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-Rkd_hXB-.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-B7DCPzpK.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-DxWW1VX1.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-BomAcXhA.js';

package/dist/proof-run-engine.js

@@ -1,7 +1,7 @@
 import {
   createRiddleProofEngine,
   executeWorkflow
-} from "./chunk-TZ3YMCDM.js";
+} from "./chunk-GMZ57RRY.js";
 import "./chunk-RV6LK7HU.js";
 import "./chunk-MLKGABMK.js";
 export {

package/dist/run-card.js

@@ -1,8 +1,8 @@
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
-} from "./chunk-U4FUFBSH.js";
-import "./chunk-SKIAZTQ7.js";
+} from "./chunk-FMOYUYH2.js";
+import "./chunk-4FOHZ7JG.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";
 export {

package/dist/runner.js

@@ -1,10 +1,10 @@
 import {
   runRiddleProof
-} from "./chunk-ZX45XGDJ.js";
-import "./chunk-TNCDVE5O.js";
-import "./chunk-U4FUFBSH.js";
+} from "./chunk-UIJ7X63P.js";
+import "./chunk-YZUVEJ5B.js";
+import "./chunk-FMOYUYH2.js";
 import "./chunk-RV6LK7HU.js";
-import "./chunk-SKIAZTQ7.js";
+import "./chunk-4FOHZ7JG.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";
 export {

package/dist/spec/checkpoint.cjs

@@ -121,7 +121,7 @@ function responseSchemaForAuthorPacket() {
       summary: { type: "string" },
       payload: {
         type: "object",
-        description: "For decision=author_packet, provide the proof packet itself or {author_packet:{...}} with proof_plan and capture_script."
+        description: "For decision=author_packet, provide the proof packet itself or {author_packet:{...}} with proof_plan, capture_script, and refined_inputs.expected_terminal_path when the proof changes route, query, or hash."
       },
       reasons: { type: "array", items: { type: "string" } },
       continue_with_stage: { type: "string", enum: ["author", "recon"] },
@@ -428,9 +428,11 @@ function buildAuthorCheckpointPacket(input) {
       repo: input.request.repo || fullState.repo,
       branch: input.request.branch || fullState.branch,
       verification_mode: input.request.verification_mode || fullState.verification_mode,
+      success_criteria: fullState.success_criteria,
       reference: input.request.reference || fullState.reference,
       server_path: fullState.server_path,
       wait_for_selector: fullState.wait_for_selector,
+      route_expectation: jsonCloneRecord(fullState.route_expectation),
       author_summary: fullState.author_summary,
       author_request: jsonCloneRecord(authorRequest),
       recon_baseline_understanding: jsonCloneRecord(fullState.recon_baseline_understanding),

package/dist/spec/checkpoint.js

@@ -13,7 +13,7 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "../chunk-SKIAZTQ7.js";
+} from "../chunk-4FOHZ7JG.js";
 import "../chunk-VY4Y5U57.js";
 import "../chunk-MLKGABMK.js";
 export {

package/dist/spec/index.cjs

@@ -344,7 +344,7 @@ function responseSchemaForAuthorPacket() {
       summary: { type: "string" },
       payload: {
         type: "object",
-        description: "For decision=author_packet, provide the proof packet itself or {author_packet:{...}} with proof_plan and capture_script."
+        description: "For decision=author_packet, provide the proof packet itself or {author_packet:{...}} with proof_plan, capture_script, and refined_inputs.expected_terminal_path when the proof changes route, query, or hash."
       },
       reasons: { type: "array", items: { type: "string" } },
       continue_with_stage: { type: "string", enum: ["author", "recon"] },
@@ -651,9 +651,11 @@ function buildAuthorCheckpointPacket(input) {
       repo: input.request.repo || fullState.repo,
       branch: input.request.branch || fullState.branch,
       verification_mode: input.request.verification_mode || fullState.verification_mode,
+      success_criteria: fullState.success_criteria,
       reference: input.request.reference || fullState.reference,
       server_path: fullState.server_path,
       wait_for_selector: fullState.wait_for_selector,
+      route_expectation: jsonCloneRecord(fullState.route_expectation),
       author_summary: fullState.author_summary,
       author_request: jsonCloneRecord(authorRequest),
       recon_baseline_understanding: jsonCloneRecord(fullState.recon_baseline_understanding),

package/dist/spec/index.js

@@ -10,11 +10,11 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "../chunk-TNCDVE5O.js";
+} from "../chunk-YZUVEJ5B.js";
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
-} from "../chunk-U4FUFBSH.js";
+} from "../chunk-FMOYUYH2.js";
 import {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
@@ -30,7 +30,7 @@ import {
   normalizeCheckpointResponse,
   proofContractFromAuthorCheckpointResponse,
   statePathsForRunState
-} from "../chunk-SKIAZTQ7.js";
+} from "../chunk-4FOHZ7JG.js";
 import {
   applyTerminalMetadata,
   compactRecord,

package/dist/spec/run-card.js

@@ -1,8 +1,8 @@
 import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
-} from "../chunk-U4FUFBSH.js";
-import "../chunk-SKIAZTQ7.js";
+} from "../chunk-FMOYUYH2.js";
+import "../chunk-4FOHZ7JG.js";
 import "../chunk-VY4Y5U57.js";
 import "../chunk-MLKGABMK.js";
 export {

package/dist/spec/state.js

@@ -9,9 +9,9 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "../chunk-TNCDVE5O.js";
-import "../chunk-U4FUFBSH.js";
-import "../chunk-SKIAZTQ7.js";
+} from "../chunk-YZUVEJ5B.js";
+import "../chunk-FMOYUYH2.js";
+import "../chunk-4FOHZ7JG.js";
 import "../chunk-VY4Y5U57.js";
 import "../chunk-MLKGABMK.js";
 export {

package/dist/state.js

@@ -9,9 +9,9 @@ import {
   normalizePrLifecycleState,
   normalizeRunParams,
   setRunStatus
-} from "./chunk-TNCDVE5O.js";
-import "./chunk-U4FUFBSH.js";
-import "./chunk-SKIAZTQ7.js";
+} from "./chunk-YZUVEJ5B.js";
+import "./chunk-FMOYUYH2.js";
+import "./chunk-4FOHZ7JG.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";
 export {

package/package.json

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

package/runtime/lib/util.py

@@ -710,6 +710,60 @@ def invoke(tool, args, timeout=180):
         return {'ok': False, 'error': r.stdout[:300], 'stderr': r.stderr[:300]}
 
 
+def compact_error_text(value, depth=0):
+    if depth > 4 or value is None:
+        return ''
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (int, float, bool)):
+        return str(value)
+    if isinstance(value, list):
+        return '\n'.join(compact_error_text(item, depth + 1) for item in value[:12])
+    if isinstance(value, dict):
+        parts = []
+        priority_keys = (
+            'error', 'message', 'script_error', 'stderr', 'stdout', 'raw',
+            'details', 'result', 'capture', 'proof', '_proof_json',
+        )
+        for key in priority_keys:
+            if key in value:
+                text = compact_error_text(value.get(key), depth + 1)
+                if text:
+                    parts.append(text)
+        if not parts:
+            for item in list(value.values())[:12]:
+                text = compact_error_text(item, depth + 1)
+                if text:
+                    parts.append(text)
+        return '\n'.join(parts)
+    return ''
+
+
+def non_retryable_riddle_script_error(result):
+    text = compact_error_text(result).lower()
+    if not text:
+        return False
+    playwright_timeout = (
+        'timeout' in text
+        and (
+            'locator.' in text
+            or 'page.waitforurl' in text
+            or 'page.waitforselector' in text
+            or 'waiting for selector' in text
+            or 'waiting for navigation' in text
+            or 'getbyrole' in text
+            or 'getbytext' in text
+            or 'scrollintoviewifneeded' in text
+        )
+    )
+    deterministic_playwright_error = (
+        'strict mode violation' in text
+        or 'selector_not_found' in text
+        or 'index_out_of_range' in text
+    )
+    return playwright_timeout or deterministic_playwright_error
+
+
 def invoke_retry(tool, args, retries=3, timeout=180):
     """Call an OpenClaw tool with automatic retries on failure."""
     last_result = None
@@ -720,6 +774,9 @@ def invoke_retry(tool, args, retries=3, timeout=180):
         if result.get('ok') or result.get('outputs') or result.get('screenshots'):
             return result
         print(f'invoke_retry({tool}) attempt {attempt}/{retries} failed: {str(result.get("error", "no output"))[:200]}')
+        if tool == 'riddle_script' and non_retryable_riddle_script_error(result):
+            print('invoke_retry(riddle_script) stopping early for deterministic Playwright script error')
+            return result
         if attempt < retries:
             import time
             time.sleep(5)

package/runtime/lib/verify.py

@@ -1845,16 +1845,17 @@ def normalize_observed_path(value):
     raw = str(value or '').strip()
     if not raw:
         return ''
-    parsed = urlparse(raw.split('#', 1)[0])
+    parsed = urlparse(raw)
     path = parsed.path or ''
     query = parsed.query or ''
+    fragment = parsed.fragment or ''
     if not path.startswith('/'):
         path = '/' + path.lstrip('/')
     parts = path.split('/')
     if len(parts) >= 4 and parts[1] == 's':
         path = '/' + '/'.join(parts[3:])
     path = path.rstrip('/') or '/'
-    return path + (('?' + query) if query else '')
+    return path + (('?' + query) if query else '') + (('#' + fragment) if fragment else '')
 
 
 def observed_location_from_page_state(page_state):
@@ -1862,10 +1863,13 @@ def observed_location_from_page_state(page_state):
         return ''
     pathname = str(page_state.get('pathname') or '').strip()
     search = str(page_state.get('search') or '').strip()
+    hash_value = str(page_state.get('hash') or page_state.get('fragment') or '').strip()
     if search and not search.startswith('?'):
         search = '?' + search
+    if hash_value and not hash_value.startswith('#'):
+        hash_value = '#' + hash_value
     if pathname:
-        return pathname + search
+        return pathname + search + hash_value
     return str(page_state.get('href') or '').strip()
 
 
@@ -1889,9 +1893,29 @@ def route_matches_expected(expected_path, observed_path):
         if pair not in remaining:
             return False
         remaining.remove(pair)
+    if expected_parsed.fragment and observed_parsed.fragment != expected_parsed.fragment:
+        return False
     return True
 
 
+def route_parts(value):
+    normalized = normalize_observed_path(value)
+    if not normalized:
+        return {
+            'href': '',
+            'pathname': '',
+            'query': '',
+            'hash': '',
+        }
+    parsed = urlparse(normalized)
+    return {
+        'href': normalized,
+        'pathname': parsed.path.rstrip('/') or '/',
+        'query': parsed.query or '',
+        'hash': ('#' + parsed.fragment) if parsed.fragment else '',
+    }
+
+
 EXPLICIT_TERMINAL_PATH_KEYS = (
     'expected_terminal_path', 'expectedTerminalPath',
     'expected_terminal_route', 'expectedTerminalRoute',
@@ -1980,6 +2004,16 @@ def terminal_path_from_record(record, depth=0):
     return ''
 
 
+def terminal_path_from_text(value):
+    if not isinstance(value, str):
+        return ''
+    for match in re.findall(r"""['"`](/[^'"`\s]+[?#][^'"`\s]*)['"`]""", value):
+        candidate = path_candidate(match)
+        if candidate:
+            return candidate
+    return ''
+
+
 def interaction_assertions_pass(value):
     for record in proof_evidence_records(value):
         if any(record.get(key) is False for key in (
@@ -2039,29 +2073,58 @@ def interaction_terminal_path_from_state(state):
         candidate = terminal_path_from_record(state.get(key))
         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))
+        if candidate:
+            return candidate, key
     return '', ''
 
 
 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 '/'
+    start_parts = route_parts(normalized_start)
     if mode not in INTERACTION_MODES:
         return normalized_start, {
             'mode': mode,
             'source': 'recon_start_path',
             'start_path': normalized_start,
             'expected_path': normalized_start,
+            'start_pathname': start_parts['pathname'],
+            'start_query': start_parts['query'],
+            'start_hash': start_parts['hash'],
+            'expected_pathname': start_parts['pathname'],
+            'expected_query': start_parts['query'],
+            'expected_hash': start_parts['hash'],
         }
     candidate, source = interaction_terminal_path_from_state(state)
     if not candidate:
         candidate, source = interaction_terminal_path_from_evidence(proof_evidence)
     expected = candidate or normalized_start
+    expected_parts = route_parts(expected)
     return expected, {
         'mode': mode,
         'source': source or 'recon_start_path',
         'start_path': normalized_start,
         'expected_path': expected,
         'terminal_path': expected if expected != normalized_start else '',
+        'start_pathname': start_parts['pathname'],
+        'start_query': start_parts['query'],
+        'start_hash': start_parts['hash'],
+        'expected_href': expected_parts['href'],
+        'expected_pathname': expected_parts['pathname'],
+        'expected_query': expected_parts['query'],
+        'expected_hash': expected_parts['hash'],
+        'terminal_pathname': expected_parts['pathname'] if expected != normalized_start else '',
+        'terminal_query': expected_parts['query'] if expected != normalized_start else '',
+        'terminal_hash': expected_parts['hash'] if expected != normalized_start else '',
     }
 
 
@@ -2379,7 +2442,7 @@ def evaluate_capture_quality(payload, expected_path, verification_mode='proof'):
     }
 
 
-def build_capture_retry_decision(after_observation, required_baseline_present, proof_evidence_blocker=''):
+def build_capture_retry_decision(after_observation, required_baseline_present, proof_evidence_blocker='', route_expectation=None):
     reasons = []
     if not required_baseline_present:
         reasons.append('Recon baseline is missing, so verify should return to recon instead of guessing a new reference context.')
@@ -2391,6 +2454,25 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
             'reasons': reasons,
         }
 
+    details = after_observation.get('details') if isinstance(after_observation.get('details'), dict) else {}
+    route_expectation = route_expectation if isinstance(route_expectation, dict) else {}
+    route_mismatch = None
+    reason_text = str(after_observation.get('reason') or '')
+    if 'wrong route' in reason_text:
+        expected = details.get('expected_path') or ''
+        observed = details.get('observed_path_raw') or details.get('observed_path') or ''
+        if expected or observed:
+            route_mismatch = {
+                'field': 'route',
+                'expected_path': expected,
+                'observed_after_path': observed,
+            }
+    error_messages = [
+        str(item).strip()
+        for item in (details.get('capture_error_messages') or [])
+        if str(item).strip()
+    ]
+
     if proof_evidence_blocker:
         reasons.append(proof_evidence_blocker)
         decision = 'missing_proof_evidence'
@@ -2399,24 +2481,46 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
             reasons.append('The capture reached usable page context, but the proof evidence explicitly failed its own required audio gate.')
         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:
+            reasons.append(
+                'Route mismatch also present: expected after capture path ' +
+                (route_mismatch.get('expected_path') or '(unknown)') +
+                ', observed ' +
+                (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.')
+        summary = proof_evidence_blocker
+        if route_mismatch:
+            summary += (
+                ' Route mismatch: expected ' +
+                (route_mismatch.get('expected_path') or '(unknown)') +
+                ', got ' +
+                (route_mismatch.get('observed_after_path') or '(unknown)') +
+                '.'
+            )
+        if error_messages:
+            reasons.append('Capture script error: ' + error_messages[0][:500])
+            summary += ' Capture script error: ' + error_messages[0][:300]
         return {
             'decision': decision,
-            'summary': proof_evidence_blocker,
+            'summary': summary,
             'recommended_stage': 'author',
             'continue_with_stage': 'author',
             'reasons': reasons,
+            'mismatch': route_mismatch,
         }
 
     reason = after_observation.get('reason') or 'after capture is not usable yet'
     reasons.append('The after evidence is not usable yet: ' + reason)
-    recommended_stage = 'recon' if 'wrong route' in reason else 'author'
-    details = after_observation.get('details') if isinstance(after_observation.get('details'), dict) else {}
-    error_messages = [
-        str(item).strip()
-        for item in (details.get('capture_error_messages') or [])
-        if str(item).strip()
-    ]
+    route_expectation_source = str(route_expectation.get('source') or '')
+    authored_terminal_route = bool(
+        route_mismatch
+        and route_expectation.get('mode') in INTERACTION_MODES
+        and route_expectation.get('terminal_path')
+        and route_expectation_source != 'recon_start_path'
+    )
+    recommended_stage = 'recon' if 'wrong route' in reason and not authored_terminal_route else 'author'
     mismatch = None
     if recommended_stage == 'recon':
         expected = details.get('expected_path') or ''
@@ -2433,7 +2537,17 @@ def build_capture_retry_decision(after_observation, required_baseline_present, p
             summary = 'Verify capture route mismatch needs recon to refresh the reference path.'
         reasons.append('The capture appears to be on the wrong route or baseline context, so recon should refresh the reference path.')
     else:
-        if error_messages:
+        if route_mismatch:
+            expected = route_mismatch.get('expected_path') or ''
+            observed = route_mismatch.get('observed_after_path') or ''
+            mismatch = route_mismatch
+            reasons.append('Route mismatch: expected after capture path ' + (expected or '(unknown)') + ', observed ' + (observed or '(unknown)') + '.')
+            reasons.append('The terminal route came from the authored interaction proof packet, so the capture plan should be revised instead of refreshing recon.')
+            summary = 'Verify capture route mismatch after authored interaction: 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]
+        elif error_messages:
             reasons.append('Capture script error: ' + error_messages[0][:500])
             summary = 'Verify capture script failed: ' + error_messages[0][:300]
         else:
@@ -2528,6 +2642,9 @@ def build_semantic_context(state, results, after_observation, expected_path):
     after_semantic = semantic_observation('after', after_observation)
     expected_start_path = state.get('expected_start_path') or expected_path
     route_expectation = state.get('route_expectation') if isinstance(state.get('route_expectation'), dict) else {}
+    expected_parts = route_parts(expected_path)
+    start_parts = route_parts(expected_start_path)
+    after_parts = route_parts(after_semantic.get('observed_path_raw') or after_semantic.get('observed_path') or '')
     return {
         'expected_path': expected_path,
         'expected_start_path': expected_start_path,
@@ -2540,10 +2657,20 @@ def build_semantic_context(state, results, after_observation, expected_path):
             'expected_after_path': expected_path,
             'expected_start_path': expected_start_path,
             'expected_terminal_path': route_expectation.get('terminal_path') or '',
+            'expected_pathname': expected_parts['pathname'],
+            'expected_query': expected_parts['query'],
+            'expected_hash': expected_parts['hash'],
+            'expected_start_pathname': start_parts['pathname'],
+            'expected_start_query': start_parts['query'],
+            'expected_start_hash': start_parts['hash'],
+            'expected_terminal_query': route_expectation.get('terminal_query') or route_expectation.get('expected_query') or '',
+            'expected_terminal_hash': route_expectation.get('terminal_hash') or route_expectation.get('expected_hash') or '',
             'expectation_source': route_expectation.get('source') or '',
             'before_observed_path': before_semantic.get('observed_path') or before.get('path') or '',
             'prod_observed_path': prod_semantic.get('observed_path') or prod.get('path') or '',
             'after_observed_path': after_semantic.get('observed_path') or '',
+            'after_observed_query': after_parts['query'],
+            'after_observed_hash': after_parts['hash'],
         },
         'before': before_semantic,
         'prod': prod_semantic,
@@ -3051,6 +3178,15 @@ if expected_start_path and expected_start_path != expected_path:
     summary_lines.append('Expected terminal proof path: ' + expected_path)
 else:
     summary_lines.append('Expected proof path from recon: ' + expected_path)
+route_expected_query = (s.get('route_expectation') or {}).get('expected_query') or ''
+route_expected_hash = (s.get('route_expectation') or {}).get('expected_hash') or ''
+if route_expected_query or route_expected_hash:
+    summary_lines.append(
+        'Expected terminal query/hash: ' +
+        ('?' + route_expected_query if route_expected_query else '(none)') +
+        ' ' +
+        (route_expected_hash if route_expected_hash else '(none)')
+    )
 summary_lines.append('After observation: ' + after_observation['reason'])
 supporting = results['after'].get('supporting_artifacts') or {}
 if supporting.get('has_structured_payload'):
@@ -3064,6 +3200,14 @@ if supporting.get('has_structured_payload'):
     summary_lines.append('Structured after evidence: ' + ('; '.join(basis) if basis else 'present'))
 observed_path = (after_observation.get('details') or {}).get('observed_path') or expected_path
 summary_lines.append('Observed after path: ' + observed_path)
+observed_parts = route_parts((after_observation.get('details') or {}).get('observed_path_raw') or observed_path)
+if observed_parts.get('query') or observed_parts.get('hash') or route_expected_query or route_expected_hash:
+    summary_lines.append(
+        'Observed after query/hash: ' +
+        ('?' + observed_parts.get('query') if observed_parts.get('query') else '(none)') +
+        ' ' +
+        (observed_parts.get('hash') if observed_parts.get('hash') else '(none)')
+    )
 details = after_observation.get('details') or {}
 if details.get('headings'):
     summary_lines.append('Visible headings: ' + '; '.join(str(item) for item in details.get('headings', [])[:6]))
@@ -3175,7 +3319,7 @@ 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 = visual_delta_recovery or build_capture_retry_decision(after_observation, required_baseline_present, proof_evidence_blocker)
+    capture_retry = visual_delta_recovery or build_capture_retry_decision(after_observation, required_baseline_present, proof_evidence_blocker, s.get('route_expectation') or {})
     next_stage_options = ['author', 'verify', 'recon'] if no_implementation_mode else ['author', 'verify', 'implement', 'recon']
     s['verify_status'] = 'capture_incomplete'
     s['merge_recommendation'] = 'do-not-merge'