@riddledc/riddle-proof 0.8.6 → 0.8.8

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-BO1h0Bmy.d.cts → proof-run-engine-BlocjMni.d.cts}

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -382,7 +382,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -659,7 +659,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship";
+    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup";
     state_path: string;
     stage: any;
     summary: string;

package/dist/{proof-run-engine-CIdpWNh6.d.ts → proof-run-engine-C_m8WJmX.d.ts}

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -382,7 +382,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship" | "run";
+    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -659,7 +659,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "setup" | "recon" | "author" | "implement" | "verify" | "ship";
+    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup";
     state_path: string;
     stage: any;
     summary: string;

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.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-BO1h0Bmy.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-BlocjMni.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-CIdpWNh6.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-C_m8WJmX.js';

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.6",
+  "version": "0.8.8",
   "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():
@@ -284,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.'
@@ -301,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',
@@ -328,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

@@ -1995,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')
@@ -2016,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',
@@ -2067,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):
@@ -2081,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 ''
@@ -2122,6 +2158,170 @@ def interaction_assertions_pass(value):
     return False
 
 
+INTERACTION_ASSERTION_CONTAINER_KEYS = ('assertions', 'checks', 'predicates', 'expectations')
+INTERACTION_FAILURE_FLAG_KEYS = (
+    'passed',
+    'ok',
+    'valid',
+    'success',
+    'proofReady',
+    'proof_ready',
+    'interactionPassed',
+    'interaction_passed',
+    'routeMatches',
+    'route_matches',
+)
+INTERACTION_FAILURE_STATUS_VALUES = {'fail', 'failed', 'failure', 'error', 'errored', 'timeout', 'timed_out'}
+INTERACTION_ASSERTION_NAME_KEYS = ('name', 'id', 'key', 'label', 'assertion', 'check', 'field')
+INTERACTION_ROUTE_CONTEXT_KEYS = (
+    'expected',
+    'observed',
+    'actual',
+    'start',
+    'before',
+    'after',
+    'terminal',
+    'final',
+    'expected_after',
+    'expectedAfter',
+    'expected_terminal',
+    'expectedTerminal',
+    'expected_final',
+    'expectedFinal',
+)
+
+
+def failure_label(prefix, key):
+    key = str(key or '').strip()
+    prefix = str(prefix or '').strip()
+    if prefix and key:
+        return prefix + '.' + key
+    return key or prefix or 'failed'
+
+
+def assertion_item_label(item, fallback):
+    if isinstance(item, dict):
+        for key in INTERACTION_ASSERTION_NAME_KEYS:
+            value = str(item.get(key) or '').strip()
+            if value:
+                return value
+    return fallback
+
+
+def collect_interaction_failed_assertions(value, prefix='', depth=0):
+    if depth > 6:
+        return []
+    failures = []
+    if isinstance(value, dict):
+        for key in INTERACTION_FAILURE_FLAG_KEYS:
+            if value.get(key) is False:
+                failures.append(failure_label(prefix, key))
+        status = str(value.get('status') or value.get('result') or '').strip().lower()
+        if status in INTERACTION_FAILURE_STATUS_VALUES:
+            failures.append(failure_label(prefix, assertion_item_label(value, 'status')))
+        for key in INTERACTION_ASSERTION_CONTAINER_KEYS:
+            checks = value.get(key)
+            container_prefix = failure_label(prefix, key)
+            if isinstance(checks, dict):
+                for check_key, check_value in checks.items():
+                    if check_value is False:
+                        failures.append(failure_label(container_prefix, check_key))
+                    elif isinstance(check_value, dict):
+                        nested = collect_interaction_failed_assertions(
+                            check_value,
+                            failure_label(container_prefix, check_key),
+                            depth + 1,
+                        )
+                        failures.extend(nested)
+                    elif isinstance(check_value, list):
+                        failures.extend(collect_interaction_failed_assertions(
+                            check_value,
+                            failure_label(container_prefix, check_key),
+                            depth + 1,
+                        ))
+            elif isinstance(checks, list):
+                for index, item in enumerate(checks):
+                    if item is False:
+                        failures.append(failure_label(container_prefix, str(index)))
+                    elif isinstance(item, dict):
+                        item_label = assertion_item_label(item, str(index))
+                        failures.extend(collect_interaction_failed_assertions(
+                            item,
+                            failure_label(container_prefix, item_label),
+                            depth + 1,
+                        ))
+        for key in EVIDENCE_CONTAINER_KEYS:
+            nested = value.get(key)
+            if isinstance(nested, (dict, list)):
+                failures.extend(collect_interaction_failed_assertions(nested, failure_label(prefix, key), depth + 1))
+    elif isinstance(value, list):
+        for index, item in enumerate(value):
+            if item is False:
+                failures.append(failure_label(prefix, str(index)))
+            elif isinstance(item, (dict, list)):
+                failures.extend(collect_interaction_failed_assertions(item, prefix, depth + 1))
+    deduped = []
+    seen = set()
+    for failure in failures:
+        failure = str(failure or '').strip()
+        if not failure or failure in seen:
+            continue
+        seen.add(failure)
+        deduped.append(failure)
+    return deduped
+
+
+def interaction_route_context_present(value, depth=0):
+    if depth > 6:
+        return False
+    if isinstance(value, dict):
+        if terminal_path_from_record(value):
+            return True
+        for key in INTERACTION_ROUTE_CONTEXT_KEYS:
+            nested = value.get(key)
+            if isinstance(nested, dict):
+                if record_path_candidate(nested, allow_location_keys=True):
+                    return True
+                query = str(nested.get('query') or nested.get('search') or '').strip()
+                hash_value = str(nested.get('hash') or nested.get('fragment') or '').strip()
+                if query or hash_value:
+                    return True
+                if interaction_route_context_present(nested, depth + 1):
+                    return True
+            elif isinstance(nested, str) and path_candidate(nested):
+                return True
+        for key in EVIDENCE_CONTAINER_KEYS:
+            nested = value.get(key)
+            if isinstance(nested, (dict, list)) and interaction_route_context_present(nested, depth + 1):
+                return True
+    elif isinstance(value, list):
+        return any(interaction_route_context_present(item, depth + 1) for item in value)
+    return False
+
+
+def failed_interaction_evidence_summary(proof_evidence):
+    failures = []
+    for record in proof_evidence_records(proof_evidence):
+        failures.extend(collect_interaction_failed_assertions(record))
+    deduped = []
+    seen = set()
+    for failure in failures:
+        if failure not in seen:
+            seen.add(failure)
+            deduped.append(failure)
+    if not deduped or not interaction_route_context_present(proof_evidence):
+        return ''
+    summary = 'Structured interaction proof evidence captured failed assertion(s): ' + ', '.join(deduped[:8]) + '.'
+    capture_errors = []
+    for record in proof_evidence_records(proof_evidence):
+        error = str(record.get('capture_error') or record.get('error') or '').strip()
+        if error:
+            capture_errors.append(error)
+    if capture_errors:
+        summary += ' Capture script error: ' + capture_errors[0][:300]
+    return summary
+
+
 def interaction_terminal_path_from_evidence(proof_evidence):
     for record in proof_evidence_records(proof_evidence):
         candidate = terminal_path_from_record(record)
@@ -2867,6 +3067,9 @@ def build_supervisor_assessment_request(state, payload, after_observation, requi
         evidence_basis.append('structured-artifacts')
     if supporting.get('playability_ready'):
         evidence_basis.append('playability')
+    interaction_failure_summary = str(state.get('structured_interaction_failure_summary') or '').strip()
+    if interaction_failure_summary:
+        evidence_basis.append('structured-interaction-failure')
     visual_delta = ((evidence_bundle or {}).get('after') or {}).get('visual_delta') or {}
     if visual_delta.get('status') == 'measured':
         evidence_basis.append('visual-delta')
@@ -2900,6 +3103,8 @@ def build_supervisor_assessment_request(state, payload, after_observation, requi
         evidence_bundle['artifact_usage'] = artifact_usage
     visual_delta_blocker = '' if audit_no_diff_mode(state) else visual_delta_blocker_for_mode(verification_mode, visual_delta)
     hard_blockers = [visual_delta_blocker] if visual_delta_blocker else []
+    if interaction_failure_summary:
+        hard_blockers.append(interaction_failure_summary)
     if verification_mode in PLAYABILITY_MODES and not supporting.get('playability_ready'):
         assessment = supporting.get('playability_assessment') or {}
         concerns = assessment.get('concerns') if isinstance(assessment, dict) else []
@@ -2925,6 +3130,10 @@ def build_supervisor_assessment_request(state, payload, after_observation, requi
         instructions.append(
             'For visual/UI polish, capture success is not proof. If visual_delta.status is unmeasured, missing, not_applicable, or measured with passed=false, choose needs_implementation or needs_richer_proof instead of ready_to_ship.'
         )
+    if interaction_failure_summary:
+        instructions.append(
+            'The structured interaction evidence contains failed assertions. Treat those failed assertions as a hard blocker for ready_to_ship; do not send this back to author unless the capture script itself is missing the needed evidence.'
+        )
     instructions.extend([
         'For playable/gameplay proof, screenshots are supporting evidence only. Do not mark ready_to_ship unless playability_assessment.passed is true and the proof shows accepted input, state/time progression, and playfield/canvas pixel motion.',
         'For data/audio/log/metrics/custom modes, judge the structured evidence bundle and proof_evidence_sample directly; screenshots are optional supporting context.',
@@ -2947,6 +3156,7 @@ def build_supervisor_assessment_request(state, payload, after_observation, requi
         'viewport_matrix': viewport_matrix,
         'evidence_bundle': evidence_bundle or {},
         'evidence_basis': evidence_basis,
+        'structured_interaction_failure_summary': interaction_failure_summary,
         'artifact_contract': artifact_contract,
         'artifact_production': artifact_production,
         'artifact_usage': artifact_usage,
@@ -3348,6 +3558,14 @@ if proof_evidence_required_for_mode(s.get('verification_mode')):
     if proof_evidence_blocker:
         summary_lines.append('Structured proof evidence gate: ' + proof_evidence_blocker)
 
+structured_interaction_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)
+    if structured_interaction_failure_summary:
+        summary_lines.append('Structured interaction evidence gate: ' + structured_interaction_failure_summary)
+s['structured_interaction_failure_summary'] = structured_interaction_failure_summary
+
 visual_delta_recovery = build_visual_delta_recovery_decision(
     s.get('verification_mode'),
     visual_delta,
@@ -3356,14 +3574,20 @@ visual_delta_recovery = build_visual_delta_recovery_decision(
 if visual_delta_recovery:
     summary_lines.append('Visual delta recovery: ' + visual_delta_recovery['summary'])
 
+has_judgable_failed_interaction_evidence = (
+    bool(structured_interaction_failure_summary)
+    and required_baseline_present
+    and not proof_evidence_blocker
+    and not visual_delta_recovery
+)
 has_good_evidence = (
     required_baseline_present
-    and after_observation.get('valid')
+    and (after_observation.get('valid') or has_judgable_failed_interaction_evidence)
     and not proof_evidence_blocker
     and not visual_delta_recovery
 )
 
-if has_good_evidence:
+if has_good_evidence and after_observation.get('valid'):
     s['capture_hint_saved'] = record_successful_capture_hint(
         s,
         server_path=s.get('expected_start_path') or expected_path or s.get('server_path') or '/',
@@ -3374,9 +3598,12 @@ if has_good_evidence:
     )
 
 if has_good_evidence:
+    if has_judgable_failed_interaction_evidence and isinstance(evidence_bundle.get('proof_session'), dict):
+        evidence_bundle['proof_session']['status'] = 'evidence_captured'
+        s['proof_session'] = evidence_bundle.get('proof_session') or {}
     supervisor_request = build_supervisor_assessment_request(s, after_payload, after_observation, required_baseline_present, expected_path, evidence_bundle)
     s['verify_status'] = 'evidence_captured'
-    s['merge_recommendation'] = 'pending-supervisor-judgment'
+    s['merge_recommendation'] = 'do-not-merge' if has_judgable_failed_interaction_evidence else 'pending-supervisor-judgment'
     s['proof_assessment'] = {}
     s['proof_assessment_source'] = None
     s['proof_assessment_request'] = supervisor_request
@@ -3386,11 +3613,16 @@ if has_good_evidence:
         fields_agent_may_update.append('implementation_notes')
     s['verify_decision_request'] = {
         'status': s['verify_status'],
-        'summary': 'Verify captured usable evidence and is waiting for supervising-agent proof assessment.',
+        'summary': (
+            'Verify captured structured interaction evidence with failed assertions and is waiting for supervising-agent proof assessment.'
+            if has_judgable_failed_interaction_evidence
+            else 'Verify captured usable evidence and is waiting for supervising-agent proof assessment.'
+        ),
         'expected_path': expected_path,
         'expected_start_path': s.get('expected_start_path') or expected_path,
         'route_expectation': s.get('route_expectation') or {},
         'latest_observation': after_observation,
+        'structured_interaction_failure_summary': structured_interaction_failure_summary,
         'next_stage_options': next_stage_options,
         'recommended_stage': None,
         'continue_with_stage': None,
@@ -3402,7 +3634,10 @@ if has_good_evidence:
             'Do not escalate to the human unless the supervising agent concludes the workflow is genuinely stuck or not converging.',
         ],
     }
-    summary_lines.append('Proof assessment: awaiting supervising agent judgment')
+    if has_judgable_failed_interaction_evidence:
+        summary_lines.append('Proof assessment: awaiting supervising agent judgment on failed interaction evidence')
+    else:
+        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, s.get('route_expectation') or {})