@riddledc/riddle-proof 0.8.5 → 0.8.7

package/dist/proof-run-core.cjs

@@ -215,6 +215,56 @@ function writeState(statePath, state) {
 function normalizeOptionalString(value) {
   return typeof value === "string" ? value.trim() : void 0;
 }
+var INTERACTION_VERIFICATION_MODES = /* @__PURE__ */ new Set(["interaction", "interactive", "user_flow", "user-flow", "workflow"]);
+function normalizeRoutePath(value) {
+  const raw = typeof value === "string" ? value.trim() : "";
+  if (!raw) return "";
+  try {
+    const url = /^https?:\/\//i.test(raw) ? new URL(raw) : new URL(raw.startsWith("/") || raw.startsWith("?") || raw.startsWith("#") ? raw : `/${raw}`, "https://riddle-proof.local");
+    const pathname = url.pathname.replace(/\/+$/, "") || "/";
+    return `${pathname}${url.search}${url.hash}`;
+  } catch {
+    const hashSplit = raw.split("#");
+    const beforeHash = hashSplit.shift() || "";
+    const hash = hashSplit.length ? `#${hashSplit.join("#")}` : "";
+    const querySplit = beforeHash.split("?");
+    const rawPath = querySplit.shift() || "";
+    const query = querySplit.length ? `?${querySplit.join("?")}` : "";
+    const pathname = `/${rawPath}`.replace(/\/+/g, "/").replace(/\/+$/, "") || "/";
+    return `${pathname}${query}${hash}`;
+  }
+}
+function isInteractionVerificationMode(value) {
+  return INTERACTION_VERIFICATION_MODES.has(typeof value === "string" ? value.trim().toLowerCase() : "");
+}
+function stringRecordValue(record, key) {
+  if (!record || typeof record !== "object") return "";
+  const value = record[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+function appendStateWarning(state, key, warning) {
+  const existing = Array.isArray(state[key]) ? state[key].filter((item) => typeof item === "string") : [];
+  if (!existing.includes(warning)) state[key] = [...existing, warning];
+}
+function interactionStartPathForAuthorPacket(state, parsed, refined) {
+  return normalizeRoutePath(
+    stringRecordValue(state, "expected_start_path") || stringRecordValue(refined, "expected_start_path") || stringRecordValue(parsed.interaction_contract, "start_path") || stringRecordValue(parsed.proof_contract, "start_path") || stringRecordValue(state, "server_path") || "/"
+  ) || "/";
+}
+function authorPacketServerPath(state, parsed, refined, serverPath, expectedTerminalPath) {
+  if (!isInteractionVerificationMode(state.verification_mode)) return serverPath;
+  const startPath = interactionStartPathForAuthorPacket(state, parsed, refined);
+  state.expected_start_path = startPath;
+  if (expectedTerminalPath && normalizeRoutePath(serverPath) === normalizeRoutePath(expectedTerminalPath) && normalizeRoutePath(serverPath) !== startPath) {
+    appendStateWarning(
+      state,
+      "author_warnings",
+      "Supervisor packet refined_inputs.server_path matched the terminal interaction route; kept the recon start route for capture."
+    );
+    return startPath;
+  }
+  return serverPath;
+}
 function knownEnvironmentIssuesFromNotes(notes) {
   const text = notes.toLowerCase();
   const issues = [];
@@ -873,17 +923,24 @@ function mergeStateFromParams(statePath, params) {
         state.proof_contract = parsed.proof_contract;
       }
       const refined = parsed?.refined_inputs || {};
+      const expectedTerminalPath = normalizeOptionalString(
+        typeof refined?.expected_terminal_path === "string" ? refined.expected_terminal_path : typeof parsed?.expected_terminal_path === "string" ? parsed.expected_terminal_path : ""
+      ) || "";
       if (typeof refined?.server_path === "string") {
-        state.server_path = normalizeOptionalString(refined.server_path) || "";
+        const refinedServerPath = normalizeOptionalString(refined.server_path) || "";
+        state.server_path = authorPacketServerPath(
+          state,
+          parsed,
+          refined,
+          refinedServerPath,
+          expectedTerminalPath
+        );
         state.server_path_source = "supervising_agent";
       }
       if (typeof refined?.wait_for_selector === "string") state.wait_for_selector = normalizeOptionalString(refined.wait_for_selector) || "";
       if (typeof refined?.reference === "string" && refined.reference.trim()) state.reference = refined.reference.trim();
-      if (typeof refined?.expected_terminal_path === "string") {
-        state.expected_terminal_path = normalizeOptionalString(refined.expected_terminal_path) || "";
-      }
-      if (typeof parsed?.expected_terminal_path === "string") {
-        state.expected_terminal_path = normalizeOptionalString(parsed.expected_terminal_path) || "";
+      if (expectedTerminalPath) {
+        state.expected_terminal_path = expectedTerminalPath;
       }
       if (typeof parsed?.confidence === "string") state.supervisor_author_confidence = normalizeOptionalString(parsed.confidence) || null;
       if (parsed?.rationale !== void 0) state.supervisor_author_rationale = parsed.rationale;

package/dist/proof-run-core.js

@@ -26,7 +26,7 @@ import {
   visualDeltaShipGateReason,
   workflowFile,
   writeState
-} from "./chunk-RV6LK7HU.js";
+} from "./chunk-5N5QFI2S.js";
 import "./chunk-MLKGABMK.js";
 export {
   BUNDLED_RIDDLE_PROOF_DIR,

package/dist/proof-run-engine.cjs

@@ -195,6 +195,56 @@ function writeState(statePath, state) {
 function normalizeOptionalString(value) {
   return typeof value === "string" ? value.trim() : void 0;
 }
+var INTERACTION_VERIFICATION_MODES = /* @__PURE__ */ new Set(["interaction", "interactive", "user_flow", "user-flow", "workflow"]);
+function normalizeRoutePath(value) {
+  const raw = typeof value === "string" ? value.trim() : "";
+  if (!raw) return "";
+  try {
+    const url = /^https?:\/\//i.test(raw) ? new URL(raw) : new URL(raw.startsWith("/") || raw.startsWith("?") || raw.startsWith("#") ? raw : `/${raw}`, "https://riddle-proof.local");
+    const pathname = url.pathname.replace(/\/+$/, "") || "/";
+    return `${pathname}${url.search}${url.hash}`;
+  } catch {
+    const hashSplit = raw.split("#");
+    const beforeHash = hashSplit.shift() || "";
+    const hash = hashSplit.length ? `#${hashSplit.join("#")}` : "";
+    const querySplit = beforeHash.split("?");
+    const rawPath = querySplit.shift() || "";
+    const query = querySplit.length ? `?${querySplit.join("?")}` : "";
+    const pathname = `/${rawPath}`.replace(/\/+/g, "/").replace(/\/+$/, "") || "/";
+    return `${pathname}${query}${hash}`;
+  }
+}
+function isInteractionVerificationMode(value) {
+  return INTERACTION_VERIFICATION_MODES.has(typeof value === "string" ? value.trim().toLowerCase() : "");
+}
+function stringRecordValue(record, key) {
+  if (!record || typeof record !== "object") return "";
+  const value = record[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+function appendStateWarning(state, key, warning) {
+  const existing = Array.isArray(state[key]) ? state[key].filter((item) => typeof item === "string") : [];
+  if (!existing.includes(warning)) state[key] = [...existing, warning];
+}
+function interactionStartPathForAuthorPacket(state, parsed, refined) {
+  return normalizeRoutePath(
+    stringRecordValue(state, "expected_start_path") || stringRecordValue(refined, "expected_start_path") || stringRecordValue(parsed.interaction_contract, "start_path") || stringRecordValue(parsed.proof_contract, "start_path") || stringRecordValue(state, "server_path") || "/"
+  ) || "/";
+}
+function authorPacketServerPath(state, parsed, refined, serverPath, expectedTerminalPath) {
+  if (!isInteractionVerificationMode(state.verification_mode)) return serverPath;
+  const startPath = interactionStartPathForAuthorPacket(state, parsed, refined);
+  state.expected_start_path = startPath;
+  if (expectedTerminalPath && normalizeRoutePath(serverPath) === normalizeRoutePath(expectedTerminalPath) && normalizeRoutePath(serverPath) !== startPath) {
+    appendStateWarning(
+      state,
+      "author_warnings",
+      "Supervisor packet refined_inputs.server_path matched the terminal interaction route; kept the recon start route for capture."
+    );
+    return startPath;
+  }
+  return serverPath;
+}
 function knownEnvironmentIssuesFromNotes(notes) {
   const text = notes.toLowerCase();
   const issues = [];
@@ -853,17 +903,24 @@ function mergeStateFromParams(statePath, params) {
         state.proof_contract = parsed.proof_contract;
       }
       const refined = parsed?.refined_inputs || {};
+      const expectedTerminalPath = normalizeOptionalString(
+        typeof refined?.expected_terminal_path === "string" ? refined.expected_terminal_path : typeof parsed?.expected_terminal_path === "string" ? parsed.expected_terminal_path : ""
+      ) || "";
       if (typeof refined?.server_path === "string") {
-        state.server_path = normalizeOptionalString(refined.server_path) || "";
+        const refinedServerPath = normalizeOptionalString(refined.server_path) || "";
+        state.server_path = authorPacketServerPath(
+          state,
+          parsed,
+          refined,
+          refinedServerPath,
+          expectedTerminalPath
+        );
         state.server_path_source = "supervising_agent";
       }
       if (typeof refined?.wait_for_selector === "string") state.wait_for_selector = normalizeOptionalString(refined.wait_for_selector) || "";
       if (typeof refined?.reference === "string" && refined.reference.trim()) state.reference = refined.reference.trim();
-      if (typeof refined?.expected_terminal_path === "string") {
-        state.expected_terminal_path = normalizeOptionalString(refined.expected_terminal_path) || "";
-      }
-      if (typeof parsed?.expected_terminal_path === "string") {
-        state.expected_terminal_path = normalizeOptionalString(parsed.expected_terminal_path) || "";
+      if (expectedTerminalPath) {
+        state.expected_terminal_path = expectedTerminalPath;
       }
       if (typeof parsed?.confidence === "string") state.supervisor_author_confidence = normalizeOptionalString(parsed.confidence) || null;
       if (parsed?.rationale !== void 0) state.supervisor_author_rationale = parsed.rationale;

package/dist/proof-run-engine.js

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

package/dist/runner.js

@@ -1,9 +1,9 @@
 import {
   runRiddleProof
-} from "./chunk-UIJ7X63P.js";
+} from "./chunk-5N6MQCLC.js";
 import "./chunk-YZUVEJ5B.js";
 import "./chunk-FMOYUYH2.js";
-import "./chunk-RV6LK7HU.js";
+import "./chunk-5N5QFI2S.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.5",
+  "version": "0.8.7",
   "description": "Reusable Riddle Proof contracts and helpers for evidence-backed agent changes.",
   "license": "MIT",
   "author": "RiddleDC",

package/runtime/lib/author.py

@@ -9,6 +9,7 @@ Instead it does two things:
 import json
 import os
 import sys
+from urllib.parse import urlparse
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from util import load_state, save_state
@@ -34,6 +35,31 @@ def normalize_path(value):
     return path
 
 
+def normalize_route_path(value):
+    raw = (value or '').strip()
+    if not raw:
+        return ''
+    parsed = urlparse(raw)
+    path = parsed.path or raw
+    query = parsed.query or ''
+    fragment = parsed.fragment or ''
+    if '?' in path:
+        path, query_tail = path.split('?', 1)
+        query = query or query_tail.split('#', 1)[0]
+    if '#' in path:
+        path, fragment_tail = path.split('#', 1)
+        fragment = fragment or fragment_tail
+    if not path.startswith('/'):
+        path = '/' + path.lstrip('/')
+    path = path.rstrip('/') or '/'
+    return path + (('?' + query) if query else '') + (('#' + fragment) if fragment else '')
+
+
+def is_interaction_mode(state):
+    mode = (state.get('verification_mode') or '').strip().lower()
+    return mode in ('interaction', 'interactive', 'user_flow', 'user-flow', 'workflow')
+
+
 def first_non_empty(*values):
     for value in values:
         if isinstance(value, str) and value.strip():
@@ -158,6 +184,7 @@ def author_request_payload(state, reference, baselines, current_plan, hypothesis
             'Keep capture_script concise Playwright statements.',
             'For visual/UI proof, include saveScreenshot(\'after-proof\') exactly once.',
             'For interaction proof, preserve the interaction contract and name the expected terminal route/state separately from the initial route.',
+            'For interaction proof, return a JSON-serializable evidence object with start route/state, terminal route/state, action, assertions, and matched UI text; catch waitForURL or selector timeouts and record them as failed assertions instead of throwing before evidence is emitted.',
             'For playable/gameplay proof, start the experience, send keyboard or pointer input, sample state before/after, measure non-HUD playfield/canvas pixel deltas across time, and return a JSON-serializable evidence object with playability or playability_evidence version riddle-proof.playability.v1.',
             'For data/audio/log/metric/custom proof, screenshots are optional; collect measurements inside page.evaluate, assign the result to an evidence variable, and return that evidence object from capture_script.',
             'Do not assign globalThis.__riddleProofEvidence, window.__riddleProofEvidence, or self.__riddleProofEvidence in the worker context. Avoid global evidence assignment unless it is inside page.evaluate for compatibility with older packets.',
@@ -283,6 +310,17 @@ expected_terminal_path = normalize_path(first_non_empty(
     supervisor_packet.get('expected_after_path'),
     s.get('expected_terminal_path'),
 ))
+author_warnings = []
+if is_interaction_mode(s):
+    interaction_start_path = normalize_route_path(first_non_empty(s.get('expected_start_path'), default_path, s.get('server_path'), '/')) or '/'
+    refined_route = normalize_route_path(refined_path)
+    terminal_route = normalize_route_path(expected_terminal_path)
+    if terminal_route and refined_route == terminal_route and refined_route != interaction_start_path:
+        refined_path = interaction_start_path
+        author_warnings.append(
+            'Supervisor packet refined_inputs.server_path matched the terminal interaction route; kept the recon start route for capture.'
+        )
+    s['expected_start_path'] = interaction_start_path
 confidence = provided_payload['confidence'] if provided_payload['confidence'] in ('high', 'medium', 'low') else 'medium'
 rationale = sanitize_rationale(provided_payload['rationale'])
 summary = provided_payload['summary'] or 'Supervising agent supplied the proof packet from recon observations.'
@@ -300,6 +338,7 @@ authored_packet = {
     'interaction_contract': provided_payload['interaction_contract'],
     'proof_contract': provided_payload['proof_contract'],
     'rationale': rationale,
+    'warnings': author_warnings,
     'confidence': confidence,
     'mode': 'supervising_agent',
     'model': ('supervising-agent:' + RUNTIME_MODEL_HINT) if RUNTIME_MODEL_HINT else 'supervising-agent',
@@ -327,7 +366,7 @@ s['author_mode'] = 'supervising_agent'
 s['author_model'] = authored_packet['model']
 s['author_confidence'] = confidence
 s['author_rationale'] = rationale
-s['author_warnings'] = []
+s['author_warnings'] = author_warnings
 s['author_runtime_model_hint'] = RUNTIME_MODEL_HINT
 s['author_packet'] = authored_packet
 s['author_summary'] = summary

package/runtime/lib/verify.py

@@ -558,6 +558,83 @@ def extract_proof_evidence(payload):
     return evidence
 
 
+def attach_interaction_capture_failure_evidence(state, payload, expected_path, after_observation):
+    if not isinstance(payload, dict):
+        return payload, None
+    mode = normalized_verification_mode(state.get('verification_mode'))
+    if mode not in INTERACTION_MODES:
+        return payload, None
+    if extract_proof_evidence(payload) is not None:
+        return payload, None
+
+    details = after_observation.get('details') if isinstance(after_observation, dict) else {}
+    if not isinstance(details, dict):
+        details = {}
+    expected = normalize_observed_path(expected_path)
+    observed_raw = str(details.get('observed_path_raw') or details.get('observed_path') or '').strip()
+    observed = normalize_observed_path(observed_raw)
+    route_matches = route_matches_expected(expected, observed_raw or observed) if expected and (observed_raw or observed) else None
+    error_messages = [
+        str(item).strip()
+        for item in (details.get('capture_error_messages') or [])
+        if str(item).strip()
+    ]
+    if route_matches is not False and not error_messages:
+        return payload, None
+
+    route_expectation = state.get('route_expectation') if isinstance(state.get('route_expectation'), dict) else {}
+    expected_parts = route_parts(expected)
+    observed_parts = route_parts(observed_raw or observed)
+    evidence = {
+        'version': 'riddle-proof.interaction.capture-failure.v1',
+        'synthetic': True,
+        'source': 'verify_capture_failure',
+        'mode': mode,
+        'passed': False,
+        'proofReady': False,
+        'authored_proof_evidence_present': False,
+        'evidence_summary': 'Interaction capture failed before the authored script emitted structured proof evidence.',
+        'expected': {
+            'path': expected,
+            'pathname': expected_parts.get('pathname') or '',
+            'query': expected_parts.get('query') or '',
+            'hash': expected_parts.get('hash') or '',
+        },
+        'observed': {
+            'path': observed,
+            'raw_path': observed_raw,
+            'pathname': observed_parts.get('pathname') or '',
+            'query': observed_parts.get('query') or '',
+            'hash': observed_parts.get('hash') or '',
+        },
+        'checks': {
+            'scriptCompleted': len(error_messages) == 0,
+            'routeMatches': bool(route_matches),
+            'authoredEvidenceReturned': False,
+        },
+        'route_expectation_source': route_expectation.get('source') or '',
+    }
+    if error_messages:
+        evidence['capture_error'] = error_messages[0][:1000]
+    if route_matches is False:
+        evidence['evidence_summary'] = (
+            'Interaction capture reached a different terminal route than expected before authored proof evidence was emitted.'
+        )
+
+    enriched = enrich_capture_payload(payload)
+    patched = dict(enriched)
+    result = dict(patched.get('result') or {})
+    result['proofEvidence'] = evidence
+    patched['result'] = result
+    console = list(patched.get('console') or [])
+    try:
+        console.append(PROOF_EVIDENCE_PREFIX + json.dumps(evidence, sort_keys=True))
+    except Exception:
+        pass
+    patched['console'] = console
+    return patched, evidence
+
+
 def proof_evidence_records(value):
     if isinstance(value, dict):
         return [value]
@@ -1918,16 +1995,22 @@ def route_parts(value):
 
 EXPLICIT_TERMINAL_PATH_KEYS = (
     'expected_terminal_path', 'expectedTerminalPath',
+    'expected_terminal_url', 'expectedTerminalUrl',
     'expected_terminal_route', 'expectedTerminalRoute',
     'terminal_path', 'terminalPath',
+    'terminal_url', 'terminalUrl',
     'terminal_route', 'terminalRoute',
     'expected_after_path', 'expectedAfterPath',
+    'expected_after_url', 'expectedAfterUrl',
     'expected_after_route', 'expectedAfterRoute',
     'after_path', 'afterPath',
+    'after_url', 'afterUrl',
     'after_route', 'afterRoute',
     'expected_final_path', 'expectedFinalPath',
+    'expected_final_url', 'expectedFinalUrl',
     'expected_final_route', 'expectedFinalRoute',
     'final_path', 'finalPath',
+    'final_url', 'finalUrl',
     'final_route', 'finalRoute',
 )
 LOCATION_PATH_KEYS = ('path', 'pathname', 'route', 'url', 'href')
@@ -1939,6 +2022,11 @@ AFTER_STATE_KEYS = (
     'final', 'final_state', 'finalState',
     'expected_final', 'expectedFinal',
 )
+EVIDENCE_CONTAINER_KEYS = (
+    'proofEvidence', 'proof_evidence',
+    'interactionEvidence', 'interaction_evidence',
+    'evidence',
+)
 CONTRACT_STATE_KEYS = (
     'interaction_contract', 'interactionContract',
     'proof_contract', 'proofContract',
@@ -1990,6 +2078,17 @@ def terminal_path_from_record(record, depth=0):
                 candidate = 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 = terminal_path_from_record(value, depth + 1)
+            if candidate:
+                return candidate
+        elif isinstance(value, list):
+            for item in value:
+                candidate = terminal_path_from_record(item, depth + 1)
+                if candidate:
+                    return candidate
     for key in CONTRACT_STATE_KEYS:
         value = record.get(key)
         if isinstance(value, dict):
@@ -2004,11 +2103,25 @@ def terminal_path_from_record(record, depth=0):
     return ''
 
 
+def text_path_candidate(value):
+    if not isinstance(value, str):
+        return ''
+    raw = value.strip().rstrip('.,;:)]}')
+    return path_candidate(raw)
+
+
 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)
+        candidate = text_path_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,;)]*)"""
+    )
+    for match in context_pattern.findall(value):
+        candidate = text_path_candidate(match)
         if candidate:
             return candidate
     return ''
@@ -3113,6 +3226,15 @@ after_observation = evaluate_capture_quality(after_payload, expected_path, verif
 details = after_observation.get('details') if isinstance(after_observation.get('details'), dict) else {}
 details['viewport_matrix'] = after_viewport_matrix
 after_observation['details'] = details
+after_payload, synthetic_interaction_failure_evidence = attach_interaction_capture_failure_evidence(s, after_payload, expected_path, after_observation)
+if synthetic_interaction_failure_evidence is not None:
+    s['synthetic_interaction_failure_evidence'] = synthetic_interaction_failure_evidence
+    if isinstance(results.get('after'), dict):
+        results['after']['raw'] = after_payload
+    after_observation = evaluate_capture_quality(after_payload, expected_path, verification_mode)
+    details = after_observation.get('details') if isinstance(after_observation.get('details'), dict) else {}
+    details['viewport_matrix'] = after_viewport_matrix
+    after_observation['details'] = details
 if after_viewport_matrix.get('status') == 'incomplete':
     missing_names = [
         str(item.get('name') or item.get('slug') or '').strip()

package/runtime/tests/recon_verify_smoke.py

@@ -340,14 +340,18 @@ class FakeRiddle:
                     'largeVisibleElements': [{'tag': 'h1', 'text': 'Proof'}],
                 }
                 proof_evidence = {
-                    'before': {'path': '/'},
-                    'action': 'clicked Proof',
-                    'after': {'path': '/proof/'},
-                    'assertions': {
-                        'startedOnHome': True,
-                        'clickedProofNavigation': True,
-                        'terminalPathIsProof': True,
-                        'proofContentVisible': True,
+                    'proofEvidence': {
+                        'version': 'riddle-proof.interaction.v1',
+                        'start': {'href': 'https://riddledc.com/'},
+                        'action': {'type': 'click', 'target': 'Proof'},
+                        'terminal': {'href': 'https://riddledc.com/proof/'},
+                        'afterUrl': 'https://riddledc.com/proof/',
+                        'assertions': {
+                            'startedOnHome': True,
+                            'clickedProofNavigation': True,
+                            'terminalPathIsProof': True,
+                            'proofContentVisible': True,
+                        },
                     },
                 }
                 return {
@@ -1921,6 +1925,63 @@ def run_author_applies_supervisor_packet():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_author_keeps_interaction_start_route():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-supervisor-interaction-start-'))
+    state_path = tempdir / 'state.json'
+    try:
+        state = base_state(tempdir, reference='before')
+        state.update({
+            'recon_status': 'ready_for_proof_plan',
+            'verification_mode': 'interaction',
+            'server_path': '/',
+            'expected_start_path': '/',
+            'before_cdn': 'https://cdn.example.com/before-home.png',
+            'recon_results': {
+                'baselines': {'before': {'path': '/', 'url': 'https://cdn.example.com/before-home.png'}},
+                'current_plan': {'target_path': '/'},
+            },
+            'author_request': {
+                'current_plan': {'target_path': '/'},
+                'observed_baselines': {'before': {'path': '/', 'url': 'https://cdn.example.com/before-home.png'}},
+            },
+            'supervisor_author_packet': {
+                'proof_plan': 'Start at /, click Proof, and verify the terminal /proof/ route.',
+                'capture_script': "clickedProofNavigation(); await saveScreenshot('after-proof');",
+                'refined_inputs': {
+                    'server_path': '/proof/',
+                    'expected_terminal_path': '/proof/',
+                    'wait_for_selector': '',
+                    'reference': 'before',
+                },
+                'rationale': ['The interaction starts on home and terminates on Proof.'],
+                'confidence': 'high',
+                'summary': 'Supervisor supplied the interaction proof packet.',
+            },
+        })
+        write_state(state_path, state)
+        os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+
+        fake = FakeRiddle()
+        load_util_with_fake(fake)
+        load_module('author_supervisor_interaction_start', AUTHOR_PATH)
+        after_author = json.loads(state_path.read_text())
+
+        assert after_author['author_status'] == 'ready'
+        assert after_author['server_path'] == '/'
+        assert after_author['expected_start_path'] == '/'
+        assert after_author['expected_terminal_path'] == '/proof/'
+        assert after_author['author_packet']['refined_inputs']['server_path'] == '/'
+        assert after_author['author_warnings']
+        assert 'terminal interaction route' in after_author['author_warnings'][0]
+        return {
+            'ok': True,
+            'server_path': after_author['server_path'],
+            'expected_terminal_path': after_author['expected_terminal_path'],
+        }
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_verify_requests_supervisor_assessment():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-verify-supervisor-'))
     state_path = tempdir / 'state.json'
@@ -2580,6 +2641,18 @@ def run_verify_interaction_authored_query_hash_mismatch_returns_author():
         assert capture_quality['mismatch']['observed_after_path'] == '/pricing/'
         assert 'page.waitForURL: Timeout 15000ms exceeded' in capture_quality['summary']
         assert any('capture plan should be revised' in reason for reason in capture_quality['reasons'])
+        supporting = after_verify['verify_results']['after']['supporting_artifacts']
+        assert supporting['proof_evidence_present'] is True
+        assert supporting['has_structured_payload'] is True
+        synthetic_evidence = after_verify['evidence_bundle']['proof_evidence']
+        assert synthetic_evidence['version'] == 'riddle-proof.interaction.capture-failure.v1'
+        assert synthetic_evidence['passed'] is False
+        assert synthetic_evidence['authored_proof_evidence_present'] is False
+        assert synthetic_evidence['checks']['routeMatches'] is False
+        assert synthetic_evidence['expected']['query'] == 'rp_probe=1'
+        assert synthetic_evidence['expected']['hash'] == '#pricing-probe'
+        assert synthetic_evidence['observed']['path'] == '/pricing'
+        assert 'page.waitForURL: Timeout 15000ms exceeded' in synthetic_evidence['capture_error']
         return {
             'ok': True,
             'summary': capture_quality['summary'],
@@ -2997,6 +3070,7 @@ if __name__ == '__main__':
         'recon_hint_root_preference': run_recon_prefers_hint_root_over_single_route_literal(),
         'capture_hint_rejects_route_specific_mode_only_match': run_capture_hint_rejects_route_specific_mode_only_match(),
         'author_applies_supervisor_packet': run_author_applies_supervisor_packet(),
+        'author_keeps_interaction_start_route': run_author_keeps_interaction_start_route(),
         'verify_requests_supervisor_assessment': run_verify_requests_supervisor_assessment(),
         'verify_routes_unmeasured_visual_delta_to_recovery': run_verify_routes_unmeasured_visual_delta_to_recovery(),
         'verify_structured_evidence_without_screenshot': run_verify_structured_evidence_without_screenshot(),