@riddledc/riddle-proof 0.8.38 → 0.8.40

package/dist/advanced/index.d.cts

@@ -1,5 +1,5 @@
 export { b as runner } from '../runner-4LJ5z0D-.cjs';
 export { l as engineHarness } from '../engine-harness-LBfqbFSe.cjs';
 export { p as proofRunCore } from '../proof-run-core-B1GeqkR8.cjs';
-export { p as proofRunEngine } from '../proof-run-engine-4dM37pEx.cjs';
+export { p as proofRunEngine } from '../proof-run-engine-DeHxtGnW.cjs';
 import '../types.cjs';

package/dist/advanced/index.d.ts

@@ -1,5 +1,5 @@
 export { b as runner } from '../runner-BdQpOkZD.js';
 export { l as engineHarness } from '../engine-harness-CMACHP6A.js';
 export { p as proofRunCore } from '../proof-run-core-B1GeqkR8.js';
-export { p as proofRunEngine } from '../proof-run-engine-BqaeqAze.js';
+export { p as proofRunEngine } from '../proof-run-engine-DYfmd8d7.js';
 import '../types.js';

package/dist/advanced/proof-run-engine.d.cts

@@ -1,2 +1,2 @@
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-4dM37pEx.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-DeHxtGnW.cjs';
 import '../proof-run-core-B1GeqkR8.cjs';

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

@@ -1,2 +1,2 @@
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-BqaeqAze.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from '../proof-run-engine-DYfmd8d7.js';
 import '../proof-run-core-B1GeqkR8.js';

package/dist/{chunk-U44KBAPH.js → chunk-MVJBPCZ4.js}

@@ -125,8 +125,10 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "submitRetries",
   "submitTimeoutMs",
   "summary",
+  "successCriteria",
   "sync",
   "timeout",
+  "title",
   "url",
   "unsubmittedJobRetries",
   "unsubmittedJobTimeoutMs",

package/dist/cli/index.js

@@ -1,4 +1,4 @@
-import "../chunk-U44KBAPH.js";
+import "../chunk-MVJBPCZ4.js";
 import "../chunk-DI2XNGEZ.js";
 import "../chunk-6KYXX4OE.js";
 import "../chunk-Z2LCVROU.js";

package/dist/cli.cjs

@@ -17667,8 +17667,10 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "submitRetries",
   "submitTimeoutMs",
   "summary",
+  "successCriteria",
   "sync",
   "timeout",
+  "title",
   "url",
   "unsubmittedJobRetries",
   "unsubmittedJobTimeoutMs",

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-U44KBAPH.js";
+import "./chunk-MVJBPCZ4.js";
 import "./chunk-DI2XNGEZ.js";
 import "./chunk-6KYXX4OE.js";
 import "./chunk-Z2LCVROU.js";

package/dist/{proof-run-engine-BqaeqAze.d.ts → proof-run-engine-DYfmd8d7.d.ts}

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "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: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "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: "author" | "recon" | "ship" | "implement" | "verify" | "setup";
+    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup";
     state_path: string;
     stage: any;
     summary: string;

package/dist/{proof-run-engine-4dM37pEx.d.cts → proof-run-engine-DeHxtGnW.d.cts}

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "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: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "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: "author" | "recon" | "ship" | "implement" | "verify" | "setup";
+    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup";
     state_path: string;
     stage: any;
     summary: string;

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

@@ -1,2 +1,2 @@
 import './proof-run-core-B1GeqkR8.cjs';
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-4dM37pEx.cjs';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-DeHxtGnW.cjs';

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

@@ -1,2 +1,2 @@
 import './proof-run-core-B1GeqkR8.js';
-export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-BqaeqAze.js';
+export { R as RiddleProofEngine, c as createRiddleProofEngine, e as executeWorkflow } from './proof-run-engine-DYfmd8d7.js';

package/package.json

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

package/runtime/lib/verify.py

@@ -2610,17 +2610,93 @@ def assertion_item_label(item, fallback):
     return fallback
 
 
-def collect_interaction_failed_assertions(value, prefix='', depth=0):
+def assertion_route_value_equivalent(expected, actual):
+    expected_candidate = path_candidate(expected)
+    actual_candidate = path_candidate(actual)
+    if expected_candidate and actual_candidate:
+        return normalize_observed_path(expected_candidate) == normalize_observed_path(actual_candidate)
+    return expected == actual
+
+
+EXPECTED_ACTUAL_ROUTE_KEY_ALIASES = {
+    'expected_path': ('path', 'pathname', 'terminal_path', 'after_path', 'final_path', 'observed_path', 'actual_path'),
+    'expected_url': ('url', 'href', 'terminal_url', 'terminal_href', 'after_url', 'after_href', 'final_url', 'final_href', 'observed_url', 'actual_url'),
+    'expected_href': ('href', 'url', 'terminal_href', 'terminal_url', 'after_href', 'after_url', 'final_href', 'final_url', 'observed_href', 'actual_href'),
+    'expected_route': ('route', 'path', 'pathname', 'terminal_route', 'terminal_path', 'after_route', 'after_path', 'final_route', 'final_path'),
+    'expected_terminal_path': ('terminal_path', 'path', 'pathname', 'after_path', 'final_path', 'observed_path', 'actual_path'),
+    'expected_terminal_url': ('terminal_url', 'url', 'href', 'after_url', 'final_url', 'observed_url', 'actual_url'),
+    'expected_terminal_href': ('terminal_href', 'href', 'url', 'after_href', 'final_href', 'observed_href', 'actual_href'),
+    'expected_terminal_route': ('terminal_route', 'terminal_path', 'route', 'path', 'pathname', 'after_route', 'after_path', 'final_route', 'final_path'),
+    'expected_after_path': ('after_path', 'path', 'pathname', 'terminal_path', 'final_path', 'observed_path', 'actual_path'),
+    'expected_after_url': ('after_url', 'url', 'href', 'terminal_url', 'final_url', 'observed_url', 'actual_url'),
+    'expected_after_href': ('after_href', 'href', 'url', 'terminal_href', 'final_href', 'observed_href', 'actual_href'),
+    'expected_after_route': ('after_route', 'after_path', 'route', 'path', 'pathname', 'terminal_route', 'terminal_path', 'final_route', 'final_path'),
+    'expected_final_path': ('final_path', 'path', 'pathname', 'terminal_path', 'after_path', 'observed_path', 'actual_path'),
+    'expected_final_url': ('final_url', 'url', 'href', 'terminal_url', 'after_url', 'observed_url', 'actual_url'),
+    'expected_final_href': ('final_href', 'href', 'url', 'terminal_href', 'after_href', 'observed_href', 'actual_href'),
+    'expected_final_route': ('final_route', 'final_path', 'route', 'path', 'pathname', 'terminal_route', 'terminal_path', 'after_route', 'after_path'),
+}
+
+
+def assertion_expected_actual_equivalent(expected, actual):
+    if isinstance(expected, str) and isinstance(actual, str):
+        return assertion_route_value_equivalent(expected, actual)
+    if isinstance(expected, dict) and isinstance(actual, dict):
+        for expected_key, expected_value in expected.items():
+            actual_keys = (expected_key,) + EXPECTED_ACTUAL_ROUTE_KEY_ALIASES.get(expected_key, ())
+            matched = False
+            for actual_key in actual_keys:
+                if actual_key not in actual:
+                    continue
+                if assertion_expected_actual_equivalent(expected_value, actual.get(actual_key)):
+                    matched = True
+                    break
+            if not matched:
+                return False
+        return True
+    return expected == actual
+
+
+def assertion_failure_is_route_equivalent(item):
+    if not isinstance(item, dict):
+        return False
+    has_failure_flag = any(item.get(key) is False for key in INTERACTION_FAILURE_FLAG_KEYS)
+    status = str(item.get('status') or item.get('result') or '').strip().lower()
+    if status in INTERACTION_FAILURE_STATUS_VALUES:
+        has_failure_flag = True
+    if not has_failure_flag or 'expected' not in item or 'actual' not in item:
+        return False
+    return assertion_expected_actual_equivalent(item.get('expected'), item.get('actual'))
+
+
+def collect_interaction_failed_assertions_internal(value, prefix='', depth=0):
     if depth > 6:
-        return []
+        return [], False
     failures = []
+    ignored_route_equivalent_failure = False
     if isinstance(value, dict):
+        pending_aggregate_failures = []
+        has_assertion_container = any(
+            isinstance(value.get(key), (dict, list))
+            for key in INTERACTION_ASSERTION_CONTAINER_KEYS
+        )
+        route_equivalent_failure = assertion_failure_is_route_equivalent(value)
         for key in INTERACTION_FAILURE_FLAG_KEYS:
             if value.get(key) is False:
-                failures.append(failure_label(prefix, key))
+                if route_equivalent_failure or has_assertion_container:
+                    ignored_route_equivalent_failure = ignored_route_equivalent_failure or route_equivalent_failure
+                    if has_assertion_container and not route_equivalent_failure:
+                        pending_aggregate_failures.append(failure_label(prefix, key))
+                else:
+                    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')))
+            if route_equivalent_failure or has_assertion_container:
+                ignored_route_equivalent_failure = ignored_route_equivalent_failure or route_equivalent_failure
+                if has_assertion_container and not route_equivalent_failure:
+                    pending_aggregate_failures.append(failure_label(prefix, assertion_item_label(value, 'status')))
+            else:
+                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)
@@ -2629,39 +2705,55 @@ def collect_interaction_failed_assertions(value, prefix='', depth=0):
                     if check_value is False:
                         failures.append(failure_label(container_prefix, check_key))
                     elif isinstance(check_value, dict):
-                        nested = collect_interaction_failed_assertions(
+                        nested, nested_ignored = collect_interaction_failed_assertions_internal(
                             check_value,
                             failure_label(container_prefix, check_key),
                             depth + 1,
                         )
                         failures.extend(nested)
+                        ignored_route_equivalent_failure = ignored_route_equivalent_failure or nested_ignored
                     elif isinstance(check_value, list):
-                        failures.extend(collect_interaction_failed_assertions(
+                        nested, nested_ignored = collect_interaction_failed_assertions_internal(
                             check_value,
                             failure_label(container_prefix, check_key),
                             depth + 1,
-                        ))
+                        )
+                        failures.extend(nested)
+                        ignored_route_equivalent_failure = ignored_route_equivalent_failure or nested_ignored
             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(
+                        nested, nested_ignored = collect_interaction_failed_assertions_internal(
                             item,
                             failure_label(container_prefix, item_label),
                             depth + 1,
-                        ))
+                        )
+                        failures.extend(nested)
+                        ignored_route_equivalent_failure = ignored_route_equivalent_failure or nested_ignored
         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))
+                nested_failures, nested_ignored = collect_interaction_failed_assertions_internal(nested, failure_label(prefix, key), depth + 1)
+                failures.extend(nested_failures)
+                ignored_route_equivalent_failure = ignored_route_equivalent_failure or nested_ignored
+        if pending_aggregate_failures and not failures and not ignored_route_equivalent_failure:
+            failures.extend(pending_aggregate_failures)
     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))
+                nested_failures, nested_ignored = collect_interaction_failed_assertions_internal(item, prefix, depth + 1)
+                failures.extend(nested_failures)
+                ignored_route_equivalent_failure = ignored_route_equivalent_failure or nested_ignored
+    return failures, ignored_route_equivalent_failure
+
+
+def collect_interaction_failed_assertions(value, prefix='', depth=0):
+    failures, _ignored_route_equivalent_failure = collect_interaction_failed_assertions_internal(value, prefix, depth)
     deduped = []
     seen = set()
     for failure in failures:

package/runtime/tests/recon_verify_smoke.py

@@ -106,6 +106,7 @@ class FakeRiddle:
                 'pricingQueryHashDropsTerminal',
                 'pricingQueryHashStructuredNegativeControl',
                 'pricingQueryHashPassesWithPageStateHashGap',
+                'clickedProofNavigationTrailingSlashFalseAssertions',
                 'clickedProofNavigation',
                 'clickedHomeNavigation',
                 'skipLinkTimeout',
@@ -621,6 +622,74 @@ class FakeRiddle:
                         'RIDDLE_PROOF_EVIDENCE:' + json.dumps(proof_evidence),
                     ],
                 }
+            if 'clickedProofNavigationTrailingSlashFalseAssertions' in script:
+                page_state = {
+                    'bodyTextLength': 4113,
+                    'visibleTextSample': 'RIDDLE PROOF Turn a URL into evidence an agent can cite.',
+                    'interactiveElements': 43,
+                    'visibleInteractiveElements': 42,
+                    'pathname': '/proof/',
+                    'href': 'https://riddledc.com/proof/',
+                    'title': 'Riddle Proof',
+                    'buttons': [],
+                    'headings': ['Riddle Proof'],
+                    'links': [{'text': 'Proof', 'href': '/proof/'}],
+                    'canvasCount': 0,
+                    'largeVisibleElements': [{'tag': 'main', 'text': 'Riddle Proof'}],
+                }
+                proof_evidence = {
+                    'version': 'riddle-proof.interaction.v1',
+                    'reference': 'prod',
+                    'start': {'url': 'https://riddledc.com/', 'path': '/'},
+                    'action': 'click visible Proof nav link',
+                    'matchedUiText': 'Proof',
+                    'matchedHref': 'https://riddledc.com/proof/',
+                    'terminal': {'url': 'https://riddledc.com/proof/', 'path': '/proof/'},
+                    'assertions': [
+                        {'name': 'start_path_is_root', 'expected': '/', 'actual': '/', 'passed': True},
+                        {'name': 'proof_nav_link_visible', 'expected': 'visible Proof link', 'actual': 'Proof', 'passed': True},
+                        {
+                            'name': 'terminal_url_exact',
+                            'expected': 'https://riddledc.com/proof/',
+                            'actual': 'https://riddledc.com/proof/',
+                            'passed': True,
+                        },
+                        {'name': 'terminal_path_exact', 'expected': '/proof', 'actual': '/proof/', 'passed': False},
+                        {
+                            'name': 'interaction_contract_preserved',
+                            'expected': {
+                                'start_path': '/',
+                                'expected_terminal_path': '/proof',
+                                'expected_url': 'https://riddledc.com/proof/',
+                                'action': 'click visible Proof nav link',
+                            },
+                            'actual': {
+                                'start_path': '/',
+                                'terminal_path': '/proof/',
+                                'terminal_url': 'https://riddledc.com/proof/',
+                                'action': 'click visible Proof nav link',
+                            },
+                            'passed': False,
+                        },
+                    ],
+                    'errors': [],
+                    'passed': False,
+                }
+                return {
+                    'ok': True,
+                    'screenshots': [{'url': 'https://cdn.example.com/proof-after.png'}],
+                    'outputs': [{'name': 'after-proof.png', 'url': 'https://cdn.example.com/proof-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 'clickedProofNavigationOcLiveShape' in script:
                 page_state = {
                     'bodyTextLength': 4113,
@@ -3198,6 +3267,72 @@ def run_verify_interaction_iife_structured_evidence_without_screenshot():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_verify_interaction_trailing_slash_false_assertions_are_normalized():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-trailing-slash-assertions-'))
+    state_path = tempdir / 'state.json'
+    try:
+        state = base_state(tempdir, reference='prod', prod_url='https://riddledc.com/')
+        state.update({
+            'remote_audit': True,
+            'workspace_kind': 'remote_audit',
+            'mode': 'server',
+            'recon_status': 'ready_for_proof_plan',
+            'author_status': 'ready',
+            'proof_plan_status': 'ready',
+            'implementation_status': 'not_required',
+            'implementation_mode': 'none',
+            'require_diff': False,
+            'allow_code_changes': False,
+            'verification_mode': 'interaction',
+            'server_path': '/',
+            'expected_start_path': '/',
+            'expected_terminal_path': '/proof',
+            'requested_expected_terminal_path': '/proof',
+            'proof_plan': 'Start at /, click Proof, and verify the terminal URL https://riddledc.com/proof/.',
+            'capture_script': "clickedProofNavigationTrailingSlashFalseAssertions(); await saveScreenshot('after-proof');",
+            'supervisor_author_packet': {
+                'proof_plan': 'Click Proof and prove the terminal route.',
+                'capture_script': "clickedProofNavigationTrailingSlashFalseAssertions(); await saveScreenshot('after-proof');",
+                'refined_inputs': {
+                    'server_path': '/',
+                    'expected_terminal_path': '/proof',
+                },
+            },
+            'recon_results': {'baselines': {}, 'mode': 'remote_audit'},
+        })
+        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_trailing_slash_false_assertions', VERIFY_PATH)
+        after_verify = json.loads(state_path.read_text())
+
+        assert after_verify['verify_status'] == 'evidence_captured'
+        assert after_verify['merge_recommendation'] == 'pending-supervisor-judgment'
+        assert after_verify['structured_interaction_failure_summary'] == ''
+        assert 'failed assertion' not in after_verify['proof_summary']
+        observation = after_verify['verify_results']['after']['observation']
+        assert observation['valid'] is True
+        assert observation['details']['proof_evidence_route_matched'] is True
+        assert observation['details']['observed_path_source'] == 'proof_evidence'
+        assert 'wrong route' not in observation['reason']
+        request = after_verify['verify_decision_request']
+        assert request['structured_interaction_failure_summary'] == ''
+        assert request['recommended_stage'] is None
+        route = after_verify['proof_assessment_request']['semantic_context']['route']
+        assert route['expected_after_path'] == '/proof'
+        assert route['after_observed_path'] == '/proof'
+        assert route['after_observed_path_raw'] == '/proof'
+        return {
+            'ok': True,
+            'expected_path': after_verify['route_expectation']['expected_path'],
+            'after_observed_path': route['after_observed_path'],
+        }
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_verify_interaction_proof_evidence_overrides_stale_expected_path():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-interaction-stale-route-'))
     state_path = tempdir / 'state.json'
@@ -4238,6 +4373,7 @@ if __name__ == '__main__':
         'remote_interaction_audit_verify_rejects_default_capture': run_remote_interaction_audit_verify_rejects_default_capture(),
         'verify_interaction_terminal_route_from_proof_evidence': run_verify_interaction_terminal_route_from_proof_evidence(),
         'verify_interaction_iife_structured_evidence_without_screenshot': run_verify_interaction_iife_structured_evidence_without_screenshot(),
+        'verify_interaction_trailing_slash_false_assertions_are_normalized': run_verify_interaction_trailing_slash_false_assertions_are_normalized(),
         'verify_interaction_proof_evidence_overrides_stale_expected_path': run_verify_interaction_proof_evidence_overrides_stale_expected_path(),
         'verify_interaction_proof_plan_placeholder_uses_live_evidence': run_verify_interaction_proof_plan_placeholder_uses_live_evidence(),
         'verify_interaction_reverse_terminal_route_from_proof_evidence': run_verify_interaction_reverse_terminal_route_from_proof_evidence(),