@riddledc/riddle-proof 0.8.14 → 0.8.16

package/dist/advanced/engine-harness.cjs

@@ -5220,6 +5220,40 @@ function checkpointResponseContinuation(state, value) {
     }
   };
 }
+function finalizedCheckpointResponseWithoutPacketResult(state, value) {
+  if (!value || state.checkpoint_packet || !isProtectedFinalStatus(state.status)) return null;
+  const response = normalizeCheckpointResponse(value);
+  if (!response) return null;
+  if (isDuplicateCheckpointResponse(state, response)) return null;
+  const at = timestamp3();
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, response }
+  ].slice(-25);
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.response.ignored",
+    checkpoint: response.checkpoint,
+    stage: state.current_stage || "verify",
+    summary: "Late checkpoint response ignored because the run is already finalized.",
+    details: compactRecord({
+      status: state.status,
+      decision: response.decision,
+      resume_token: response.resume_token,
+      source: response.source
+    })
+  });
+  persist(state);
+  return createRunResult({
+    state,
+    status: state.status,
+    last_summary: "Late checkpoint response ignored because the run is already finalized.",
+    raw: {
+      ignored_checkpoint_response: true,
+      response
+    }
+  });
+}
 function disabledAdapterPayload(action, context) {
   return {
     ok: false,
@@ -5790,6 +5824,8 @@ async function runRiddleProofEngineHarness(input) {
   const state = loadRunState(input);
   state.request = normalizeRunParams({ ...state.request, ...input.request });
   state.request.engine_state_path = nonEmptyString(input.resume_params?.state_path) || nonEmptyString(state.request.engine_state_path) || createEngineStatePath(state, input.config);
+  const finalizedCheckpointResponse = finalizedCheckpointResponseWithoutPacketResult(state, input.checkpoint_response);
+  if (finalizedCheckpointResponse) return finalizedCheckpointResponse;
   const checkpointContinuation = checkpointResponseContinuation(state, input.checkpoint_response);
   if (checkpointContinuation.blocker) {
     return blockerResult(state, null, checkpointContinuation.blocker);

package/dist/advanced/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "../chunk-YFRPFV4U.js";
+} from "../chunk-ZOZLORGR.js";
 import "../chunk-YZUVEJ5B.js";
 import "../chunk-FMOYUYH2.js";
 import "../chunk-7GZY5PLT.js";

package/dist/advanced/index.cjs

@@ -5757,6 +5757,40 @@ function checkpointResponseContinuation(state, value) {
     }
   };
 }
+function finalizedCheckpointResponseWithoutPacketResult(state, value) {
+  if (!value || state.checkpoint_packet || !isProtectedFinalStatus(state.status)) return null;
+  const response = normalizeCheckpointResponse(value);
+  if (!response) return null;
+  if (isDuplicateCheckpointResponse(state, response)) return null;
+  const at = timestamp3();
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, response }
+  ].slice(-25);
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.response.ignored",
+    checkpoint: response.checkpoint,
+    stage: state.current_stage || "verify",
+    summary: "Late checkpoint response ignored because the run is already finalized.",
+    details: compactRecord({
+      status: state.status,
+      decision: response.decision,
+      resume_token: response.resume_token,
+      source: response.source
+    })
+  });
+  persist(state);
+  return createRunResult({
+    state,
+    status: state.status,
+    last_summary: "Late checkpoint response ignored because the run is already finalized.",
+    raw: {
+      ignored_checkpoint_response: true,
+      response
+    }
+  });
+}
 function disabledAdapterPayload(action, context) {
   return {
     ok: false,
@@ -6327,6 +6361,8 @@ async function runRiddleProofEngineHarness(input) {
   const state = loadRunState(input);
   state.request = normalizeRunParams({ ...state.request, ...input.request });
   state.request.engine_state_path = nonEmptyString(input.resume_params?.state_path) || nonEmptyString(state.request.engine_state_path) || createEngineStatePath(state, input.config);
+  const finalizedCheckpointResponse = finalizedCheckpointResponseWithoutPacketResult(state, input.checkpoint_response);
+  if (finalizedCheckpointResponse) return finalizedCheckpointResponse;
   const checkpointContinuation = checkpointResponseContinuation(state, input.checkpoint_response);
   if (checkpointContinuation.blocker) {
     return blockerResult(state, null, checkpointContinuation.blocker);

package/dist/advanced/index.js

@@ -6,7 +6,7 @@ import {
 } from "../chunk-NGX4SUQN.js";
 import {
   engine_harness_exports
-} from "../chunk-YFRPFV4U.js";
+} from "../chunk-ZOZLORGR.js";
 import "../chunk-YZUVEJ5B.js";
 import "../chunk-FMOYUYH2.js";
 import {

package/dist/{chunk-EGZT3EVL.js → chunk-E7UTJ7KB.js}

@@ -22,7 +22,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-YFRPFV4U.js";
+} from "./chunk-ZOZLORGR.js";
 import {
   createCheckpointResponseTemplate
 } from "./chunk-4FOHZ7JG.js";

package/dist/{chunk-YFRPFV4U.js → chunk-ZOZLORGR.js}

@@ -861,6 +861,40 @@ function checkpointResponseContinuation(state, value) {
     }
   };
 }
+function finalizedCheckpointResponseWithoutPacketResult(state, value) {
+  if (!value || state.checkpoint_packet || !isProtectedFinalStatus(state.status)) return null;
+  const response = normalizeCheckpointResponse(value);
+  if (!response) return null;
+  if (isDuplicateCheckpointResponse(state, response)) return null;
+  const at = timestamp();
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, response }
+  ].slice(-25);
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.response.ignored",
+    checkpoint: response.checkpoint,
+    stage: state.current_stage || "verify",
+    summary: "Late checkpoint response ignored because the run is already finalized.",
+    details: compactRecord({
+      status: state.status,
+      decision: response.decision,
+      resume_token: response.resume_token,
+      source: response.source
+    })
+  });
+  persist(state);
+  return createRunResult({
+    state,
+    status: state.status,
+    last_summary: "Late checkpoint response ignored because the run is already finalized.",
+    raw: {
+      ignored_checkpoint_response: true,
+      response
+    }
+  });
+}
 function disabledAdapterPayload(action, context) {
   return {
     ok: false,
@@ -1431,6 +1465,8 @@ async function runRiddleProofEngineHarness(input) {
   const state = loadRunState(input);
   state.request = normalizeRunParams({ ...state.request, ...input.request });
   state.request.engine_state_path = nonEmptyString(input.resume_params?.state_path) || nonEmptyString(state.request.engine_state_path) || createEngineStatePath(state, input.config);
+  const finalizedCheckpointResponse = finalizedCheckpointResponseWithoutPacketResult(state, input.checkpoint_response);
+  if (finalizedCheckpointResponse) return finalizedCheckpointResponse;
   const checkpointContinuation = checkpointResponseContinuation(state, input.checkpoint_response);
   if (checkpointContinuation.blocker) {
     return blockerResult(state, null, checkpointContinuation.blocker);

package/dist/cli/index.js

@@ -1,7 +1,7 @@
-import "../chunk-EGZT3EVL.js";
+import "../chunk-E7UTJ7KB.js";
 import "../chunk-PEWAIEER.js";
 import "../chunk-TWTEUS7R.js";
-import "../chunk-YFRPFV4U.js";
+import "../chunk-ZOZLORGR.js";
 import "../chunk-YZUVEJ5B.js";
 import "../chunk-FMOYUYH2.js";
 import "../chunk-7GZY5PLT.js";

package/dist/cli.cjs

@@ -5289,6 +5289,40 @@ function checkpointResponseContinuation(state, value) {
     }
   };
 }
+function finalizedCheckpointResponseWithoutPacketResult(state, value) {
+  if (!value || state.checkpoint_packet || !isProtectedFinalStatus(state.status)) return null;
+  const response = normalizeCheckpointResponse(value);
+  if (!response) return null;
+  if (isDuplicateCheckpointResponse(state, response)) return null;
+  const at = timestamp3();
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, response }
+  ].slice(-25);
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.response.ignored",
+    checkpoint: response.checkpoint,
+    stage: state.current_stage || "verify",
+    summary: "Late checkpoint response ignored because the run is already finalized.",
+    details: compactRecord({
+      status: state.status,
+      decision: response.decision,
+      resume_token: response.resume_token,
+      source: response.source
+    })
+  });
+  persist(state);
+  return createRunResult({
+    state,
+    status: state.status,
+    last_summary: "Late checkpoint response ignored because the run is already finalized.",
+    raw: {
+      ignored_checkpoint_response: true,
+      response
+    }
+  });
+}
 function disabledAdapterPayload(action, context) {
   return {
     ok: false,
@@ -5859,6 +5893,8 @@ async function runRiddleProofEngineHarness(input) {
   const state = loadRunState(input);
   state.request = normalizeRunParams({ ...state.request, ...input.request });
   state.request.engine_state_path = nonEmptyString(input.resume_params?.state_path) || nonEmptyString(state.request.engine_state_path) || createEngineStatePath(state, input.config);
+  const finalizedCheckpointResponse = finalizedCheckpointResponseWithoutPacketResult(state, input.checkpoint_response);
+  if (finalizedCheckpointResponse) return finalizedCheckpointResponse;
   const checkpointContinuation = checkpointResponseContinuation(state, input.checkpoint_response);
   if (checkpointContinuation.blocker) {
     return blockerResult(state, null, checkpointContinuation.blocker);

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import "./chunk-EGZT3EVL.js";
+import "./chunk-E7UTJ7KB.js";
 import "./chunk-PEWAIEER.js";
 import "./chunk-TWTEUS7R.js";
-import "./chunk-YFRPFV4U.js";
+import "./chunk-ZOZLORGR.js";
 import "./chunk-YZUVEJ5B.js";
 import "./chunk-FMOYUYH2.js";
 import "./chunk-7GZY5PLT.js";

package/dist/engine-harness.cjs

@@ -5218,6 +5218,40 @@ function checkpointResponseContinuation(state, value) {
     }
   };
 }
+function finalizedCheckpointResponseWithoutPacketResult(state, value) {
+  if (!value || state.checkpoint_packet || !isProtectedFinalStatus(state.status)) return null;
+  const response = normalizeCheckpointResponse(value);
+  if (!response) return null;
+  if (isDuplicateCheckpointResponse(state, response)) return null;
+  const at = timestamp3();
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, response }
+  ].slice(-25);
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.response.ignored",
+    checkpoint: response.checkpoint,
+    stage: state.current_stage || "verify",
+    summary: "Late checkpoint response ignored because the run is already finalized.",
+    details: compactRecord({
+      status: state.status,
+      decision: response.decision,
+      resume_token: response.resume_token,
+      source: response.source
+    })
+  });
+  persist(state);
+  return createRunResult({
+    state,
+    status: state.status,
+    last_summary: "Late checkpoint response ignored because the run is already finalized.",
+    raw: {
+      ignored_checkpoint_response: true,
+      response
+    }
+  });
+}
 function disabledAdapterPayload(action, context) {
   return {
     ok: false,
@@ -5788,6 +5822,8 @@ async function runRiddleProofEngineHarness(input) {
   const state = loadRunState(input);
   state.request = normalizeRunParams({ ...state.request, ...input.request });
   state.request.engine_state_path = nonEmptyString(input.resume_params?.state_path) || nonEmptyString(state.request.engine_state_path) || createEngineStatePath(state, input.config);
+  const finalizedCheckpointResponse = finalizedCheckpointResponseWithoutPacketResult(state, input.checkpoint_response);
+  if (finalizedCheckpointResponse) return finalizedCheckpointResponse;
   const checkpointContinuation = checkpointResponseContinuation(state, input.checkpoint_response);
   if (checkpointContinuation.blocker) {
     return blockerResult(state, null, checkpointContinuation.blocker);

package/dist/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-YFRPFV4U.js";
+} from "./chunk-ZOZLORGR.js";
 import "./chunk-YZUVEJ5B.js";
 import "./chunk-FMOYUYH2.js";
 import "./chunk-7GZY5PLT.js";

package/dist/index.cjs

@@ -5952,6 +5952,40 @@ function checkpointResponseContinuation(state, value) {
     }
   };
 }
+function finalizedCheckpointResponseWithoutPacketResult(state, value) {
+  if (!value || state.checkpoint_packet || !isProtectedFinalStatus(state.status)) return null;
+  const response = normalizeCheckpointResponse(value);
+  if (!response) return null;
+  if (isDuplicateCheckpointResponse(state, response)) return null;
+  const at = timestamp3();
+  state.checkpoint_history = [
+    ...state.checkpoint_history || [],
+    { ts: at, response }
+  ].slice(-25);
+  appendRunEvent(state, {
+    ts: at,
+    kind: "checkpoint.response.ignored",
+    checkpoint: response.checkpoint,
+    stage: state.current_stage || "verify",
+    summary: "Late checkpoint response ignored because the run is already finalized.",
+    details: compactRecord({
+      status: state.status,
+      decision: response.decision,
+      resume_token: response.resume_token,
+      source: response.source
+    })
+  });
+  persist(state);
+  return createRunResult({
+    state,
+    status: state.status,
+    last_summary: "Late checkpoint response ignored because the run is already finalized.",
+    raw: {
+      ignored_checkpoint_response: true,
+      response
+    }
+  });
+}
 function disabledAdapterPayload(action, context) {
   return {
     ok: false,
@@ -6522,6 +6556,8 @@ async function runRiddleProofEngineHarness(input) {
   const state = loadRunState(input);
   state.request = normalizeRunParams({ ...state.request, ...input.request });
   state.request.engine_state_path = nonEmptyString(input.resume_params?.state_path) || nonEmptyString(state.request.engine_state_path) || createEngineStatePath(state, input.config);
+  const finalizedCheckpointResponse = finalizedCheckpointResponseWithoutPacketResult(state, input.checkpoint_response);
+  if (finalizedCheckpointResponse) return finalizedCheckpointResponse;
   const checkpointContinuation = checkpointResponseContinuation(state, input.checkpoint_response);
   if (checkpointContinuation.blocker) {
     return blockerResult(state, null, checkpointContinuation.blocker);

package/dist/index.js

@@ -95,7 +95,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-YFRPFV4U.js";
+} from "./chunk-ZOZLORGR.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,

package/package.json

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

package/runtime/lib/verify.py

@@ -2109,6 +2109,8 @@ FULL_LOCATION_PATH_KEYS = (
     'afterUrl', 'after_url',
     'finalUrl', 'final_url',
     'currentUrl', 'current_url',
+    'observedUrl', 'observed_url',
+    'actualUrl', 'actual_url',
     'pathWithSearchAndHash', 'path_with_search_and_hash',
     'fullPath', 'full_path',
 )
@@ -2116,6 +2118,8 @@ PARTIAL_LOCATION_PATH_KEYS = (
     'route',
     'path',
     'pathname',
+    'observedPath', 'observed_path',
+    'actualPath', 'actual_path',
     'normalizedPath', 'normalized_path',
     'rawPath', 'raw_path',
 )
@@ -2246,6 +2250,20 @@ def expected_terminal_path_from_record(record, depth=0):
                 candidate = expected_terminal_path_from_record(item, depth + 1)
                 if candidate:
                     return candidate
+    for key in AFTER_STATE_KEYS:
+        value = record.get(key)
+        if isinstance(value, dict):
+            candidate = (
+                record_path_candidate_for_keys(value, EXPECTED_TERMINAL_PATH_KEYS)
+                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):

package/runtime/tests/recon_verify_smoke.py

@@ -488,6 +488,69 @@ class FakeRiddle:
                         'totalPixels': 972000,
                     },
                 }
+            if 'clickedHomeNavigationOcTerminalShape' in script:
+                page_state = {
+                    'bodyTextLength': 180,
+                    'visibleTextSample': 'Riddle Proof homepage hero Start Free',
+                    'interactiveElements': 4,
+                    'visibleInteractiveElements': 4,
+                    'pathname': '/',
+                    'href': 'https://riddledc.com/',
+                    'title': 'Riddle',
+                    'buttons': ['Start Free'],
+                    'headings': ['Riddle Proof'],
+                    'links': [],
+                    'canvasCount': 0,
+                    'largeVisibleElements': [{'tag': 'h1', 'text': 'Riddle Proof'}],
+                }
+                proof_evidence = {
+                    'version': 'riddle-proof.interaction.v1',
+                    'start': {
+                        'expectedUrl': 'https://riddledc.com/proof/',
+                        'expectedPath': '/proof/',
+                        'observedUrl': 'https://riddledc.com/proof/',
+                        'observedPath': '/proof/',
+                    },
+                    'action': {
+                        'type': 'click',
+                        'target': 'visible Riddle/Home nav link to root',
+                        'chosenText': 'Riddle',
+                        'chosenHref': '/',
+                        'clicked': True,
+                    },
+                    'terminal': {
+                        'expectedUrl': 'https://riddledc.com/',
+                        'expectedPath': '/',
+                        'routeExpectationSource': 'capture_script.expectedUrl',
+                        'observedUrl': 'https://riddledc.com/',
+                        'observedPath': '/',
+                        'pageReady': True,
+                    },
+                    'assertions': {
+                        'startedOnProofRoute': True,
+                        'clickedRootNavLink': True,
+                        'terminalUrlMatchedExpected': True,
+                        'terminalRouteMatchedRoot': True,
+                        'terminalMainVisible': True,
+                        'routeExpectationSourceMatched': True,
+                    },
+                    'errors': [],
+                }
+                return {
+                    'ok': True,
+                    'screenshots': [{'url': 'https://cdn.example.com/home-after.png'}],
+                    'outputs': [{'name': 'after-home.png', 'url': 'https://cdn.example.com/home-after.png'}],
+                    'result': {'pageState': page_state, 'proofEvidence': proof_evidence},
+                    'console': [
+                        'RIDDLE_PROOF_STATE:' + json.dumps(page_state),
+                        'RIDDLE_PROOF_EVIDENCE:' + json.dumps(proof_evidence),
+                    ],
+                    'visual_diff': {
+                        'diffPercentage': 1.2,
+                        'differentPixels': 12000,
+                        'totalPixels': 972000,
+                    },
+                }
             if 'clickedHomeNavigation' in script:
                 page_state = {
                     'bodyTextLength': 180,
@@ -2768,6 +2831,56 @@ def run_verify_interaction_reverse_terminal_route_from_proof_evidence():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_verify_interaction_reverse_terminal_expected_url_from_nested_terminal_evidence():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-reverse-oc-shape-'))
+    state_path = tempdir / 'state.json'
+    try:
+        state = base_state(tempdir, reference='prod')
+        state.update({
+            'recon_status': 'ready_for_proof_plan',
+            'author_status': 'ready',
+            'proof_plan_status': 'ready',
+            'implementation_status': 'not_required',
+            'verification_mode': 'interaction',
+            'implementation_mode': 'none',
+            'require_diff': False,
+            'allow_code_changes': False,
+            'server_path': '/proof/',
+            'prod_url': 'https://riddledc.com/proof/',
+            'prod_cdn': 'https://cdn.example.com/prod-proof.png',
+            'proof_plan': 'Start on the proof page, click the visible Riddle/Home root nav link, and trust the structured evidence for the terminal route.',
+            'capture_script': "clickedHomeNavigationOcTerminalShape(); await saveScreenshot('after-home');",
+            'recon_results': {
+                'baselines': {'prod': {'path': '/proof/', 'url': 'https://cdn.example.com/prod-proof.png'}},
+            },
+        })
+        write_state(state_path, state)
+        os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+
+        fake = FakeRiddle()
+        load_util_with_fake(fake)
+        load_module('verify_interaction_reverse_terminal_nested_expected_url', VERIFY_PATH)
+        after_verify = json.loads(state_path.read_text())
+
+        assert after_verify['verify_status'] == 'evidence_captured'
+        assert after_verify['route_expectation']['source'] == 'proof_evidence_contract'
+        assert after_verify['route_expectation']['start_path'] == '/proof'
+        assert after_verify['route_expectation']['expected_path'] == '/'
+        route = after_verify['proof_assessment_request']['semantic_context']['route']
+        assert route['expected_start_path'] == '/proof'
+        assert route['expected_after_path'] == '/'
+        assert route['after_observed_path'] == '/'
+        assert 'wrong route' not in after_verify['verify_results']['after']['observation']['reason']
+        return {
+            'ok': True,
+            'expected_path': after_verify['route_expectation']['expected_path'],
+            'after_observed_path': route['after_observed_path'],
+            'source': after_verify['route_expectation']['source'],
+        }
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_verify_interaction_prose_route_noise_uses_proof_evidence():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-prose-noise-'))
     state_path = tempdir / 'state.json'
@@ -3553,6 +3666,7 @@ if __name__ == '__main__':
         'verify_interaction_terminal_route_from_proof_evidence': run_verify_interaction_terminal_route_from_proof_evidence(),
         'verify_interaction_proof_evidence_overrides_stale_expected_path': run_verify_interaction_proof_evidence_overrides_stale_expected_path(),
         'verify_interaction_reverse_terminal_route_from_proof_evidence': run_verify_interaction_reverse_terminal_route_from_proof_evidence(),
+        'verify_interaction_reverse_terminal_expected_url_from_nested_terminal_evidence': run_verify_interaction_reverse_terminal_expected_url_from_nested_terminal_evidence(),
         'verify_interaction_prose_route_noise_uses_proof_evidence': run_verify_interaction_prose_route_noise_uses_proof_evidence(),
         'verify_interaction_hash_terminal_route_from_proof_evidence': run_verify_interaction_hash_terminal_route_from_proof_evidence(),
         'verify_interaction_authored_query_hash_mismatch_blocks_with_evidence': run_verify_interaction_authored_query_hash_mismatch_blocks_with_evidence(),

package/runtime/tests/trust_boundary_regression.py

@@ -37,6 +37,12 @@ CASES = [
         'function': 'run_verify_interaction_reverse_terminal_route_from_proof_evidence',
         'expected_terminal': 'pass',
     },
+    {
+        'name': 'route-change-reverse-nested-terminal-url-pass',
+        'covers': ['route-changing interactions', 'proof-evidence-present'],
+        'function': 'run_verify_interaction_reverse_terminal_expected_url_from_nested_terminal_evidence',
+        'expected_terminal': 'pass',
+    },
     {
         'name': 'route-prose-noise-ignored',
         'covers': ['route-changing interactions', 'proof-evidence-present'],
@@ -109,6 +115,7 @@ CASES = [
 GENERIC_FAILURE_MARKERS = (
     'codex_invalid_json',
     'codex_no_final_response',
+    'codex_timeout',
     'max_iterations_reached',
     'stage_iteration_limit_reached',
     'unhandled_checkpoint',