@riddledc/riddle-proof 0.7.3 → 0.7.5

package/dist/{chunk-3266V3MO.js → chunk-EXF7V6TJ.js}

@@ -608,12 +608,12 @@ function createCodexExecAgentAdapter(config = {}, runner = createCodexExecJsonRu
           "Use the recon-approved route and baseline context; make the plan name the concrete target, expected before state, expected after state, and stop condition.",
           "Choose the evidence modality from verification_mode and success_criteria: screenshots for visual/UI proof, interactions plus screenshots for interaction proof, structured metrics/logs/JSON/audio analysis for non-visual proof.",
           "For playable/gameplay proof, treat screenshots as supporting artifacts only: start the game, send keyboard or pointer input, measure state before/after, measure non-HUD canvas/playfield pixel deltas across time, and return playability evidence with version riddle-proof.playability.v1.",
-          "For structured proof, collect meaningful measurements inside page.evaluate and set window.__riddleProofEvidence in that browser page context to a JSON-serializable object. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
-          "Do not assign globalThis.__riddleProofEvidence, window.__riddleProofEvidence, or self.__riddleProofEvidence outside page.evaluate; the Riddle worker context may not expose those globals safely.",
+          "For structured proof, collect meaningful measurements inside page.evaluate, assign them to an evidence variable, and return that object from capture_script. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
+          "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.",
           "Do not call Playwright page.* APIs inside page.evaluate; page.evaluate runs in the browser page, while page.waitForFunction, page.waitForSelector, page.click, and saveScreenshot belong in the outer capture script.",
           "When page.evaluate needs data from the outer Playwright script, pass exactly one serializable argument object; do not pass multiple positional arguments.",
           "When setting Playwright wait timeouts, use the correct signature: await page.waitForFunction(fn, undefined, { timeout: 60000 }). Do not write page.waitForFunction(fn, { timeout: 60000 }); that passes the object as the page argument and leaves the default timeout in place.",
-          "For audio/data/metric proof, return and persist the same evidence object: const evidence = await page.evaluate(async () => { /* browser measurements */ window.__riddleProofEvidence = { ... }; return window.__riddleProofEvidence; }); Then assert evidence fields before saving screenshots.",
+          "For audio/data/metric proof, return the same evidence object: const evidence = await page.evaluate(async () => ({ /* browser measurements */ })); Then assert evidence fields before saving screenshots and return evidence from capture_script.",
           "If a capture attempt errors or proof_evidence is absent, revise the capture_script to make structured evidence easier to collect; do not only add more screenshots for non-visual proof.",
           "When checking visible copy, normalize text before exact matching: const normalizedText = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim(); Avoid raw innerText.includes(exact sentence) because browser line wrapping can split copy.",
           "Prefer success-oriented evidence booleans such as newCopyVisible: true and oldCopyAbsent: true. If a positive assertion is false while screenshots/text samples look right, fix the capture script instead of leaving contradictory proof evidence.",

package/dist/{chunk-3ICNKAWF.js → chunk-F7BNWDF6.js}

@@ -1081,6 +1081,20 @@ async function routeCheckpoint(request, state, result, agent, input) {
       })
     };
   }
+  if (checkpoint === "verify_audit_complete") {
+    return {
+      terminal: terminalResult(
+        state,
+        "completed",
+        result,
+        result.summary || "Riddle Proof audit complete.",
+        {
+          audit_complete: true,
+          ship_disabled: true
+        }
+      )
+    };
+  }
   if (input.dry_run || request.dry_run) {
     return {
       blocker: {

package/dist/cli.cjs

@@ -5267,6 +5267,20 @@ async function routeCheckpoint(request, state, result, agent, input) {
       })
     };
   }
+  if (checkpoint === "verify_audit_complete") {
+    return {
+      terminal: terminalResult(
+        state,
+        "completed",
+        result,
+        result.summary || "Riddle Proof audit complete.",
+        {
+          audit_complete: true,
+          ship_disabled: true
+        }
+      )
+    };
+  }
   if (input.dry_run || request.dry_run) {
     return {
       blocker: {
@@ -6294,12 +6308,12 @@ function createCodexExecAgentAdapter(config = {}, runner = createCodexExecJsonRu
           "Use the recon-approved route and baseline context; make the plan name the concrete target, expected before state, expected after state, and stop condition.",
           "Choose the evidence modality from verification_mode and success_criteria: screenshots for visual/UI proof, interactions plus screenshots for interaction proof, structured metrics/logs/JSON/audio analysis for non-visual proof.",
           "For playable/gameplay proof, treat screenshots as supporting artifacts only: start the game, send keyboard or pointer input, measure state before/after, measure non-HUD canvas/playfield pixel deltas across time, and return playability evidence with version riddle-proof.playability.v1.",
-          "For structured proof, collect meaningful measurements inside page.evaluate and set window.__riddleProofEvidence in that browser page context to a JSON-serializable object. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
-          "Do not assign globalThis.__riddleProofEvidence, window.__riddleProofEvidence, or self.__riddleProofEvidence outside page.evaluate; the Riddle worker context may not expose those globals safely.",
+          "For structured proof, collect meaningful measurements inside page.evaluate, assign them to an evidence variable, and return that object from capture_script. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
+          "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.",
           "Do not call Playwright page.* APIs inside page.evaluate; page.evaluate runs in the browser page, while page.waitForFunction, page.waitForSelector, page.click, and saveScreenshot belong in the outer capture script.",
           "When page.evaluate needs data from the outer Playwright script, pass exactly one serializable argument object; do not pass multiple positional arguments.",
           "When setting Playwright wait timeouts, use the correct signature: await page.waitForFunction(fn, undefined, { timeout: 60000 }). Do not write page.waitForFunction(fn, { timeout: 60000 }); that passes the object as the page argument and leaves the default timeout in place.",
-          "For audio/data/metric proof, return and persist the same evidence object: const evidence = await page.evaluate(async () => { /* browser measurements */ window.__riddleProofEvidence = { ... }; return window.__riddleProofEvidence; }); Then assert evidence fields before saving screenshots.",
+          "For audio/data/metric proof, return the same evidence object: const evidence = await page.evaluate(async () => ({ /* browser measurements */ })); Then assert evidence fields before saving screenshots and return evidence from capture_script.",
           "If a capture attempt errors or proof_evidence is absent, revise the capture_script to make structured evidence easier to collect; do not only add more screenshots for non-visual proof.",
           "When checking visible copy, normalize text before exact matching: const normalizedText = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim(); Avoid raw innerText.includes(exact sentence) because browser line wrapping can split copy.",
           "Prefer success-oriented evidence booleans such as newCopyVisible: true and oldCopyAbsent: true. If a positive assertion is false while screenshots/text samples look right, fix the capture script instead of leaving contradictory proof evidence.",

package/dist/cli.js

@@ -18,7 +18,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-3ICNKAWF.js";
+} from "./chunk-F7BNWDF6.js";
 import "./chunk-4DM3OTWH.js";
 import "./chunk-3UHWI3FO.js";
 import "./chunk-SGXB5S4B.js";
@@ -29,7 +29,7 @@ import "./chunk-JFQXAJH2.js";
 import {
   createCodexExecAgentAdapter,
   runCodexExecAgentDoctor
-} from "./chunk-3266V3MO.js";
+} from "./chunk-EXF7V6TJ.js";
 import "./chunk-DUFDZJOF.js";
 
 // src/cli.ts

package/dist/codex-exec-agent.cjs

@@ -647,12 +647,12 @@ function createCodexExecAgentAdapter(config = {}, runner = createCodexExecJsonRu
           "Use the recon-approved route and baseline context; make the plan name the concrete target, expected before state, expected after state, and stop condition.",
           "Choose the evidence modality from verification_mode and success_criteria: screenshots for visual/UI proof, interactions plus screenshots for interaction proof, structured metrics/logs/JSON/audio analysis for non-visual proof.",
           "For playable/gameplay proof, treat screenshots as supporting artifacts only: start the game, send keyboard or pointer input, measure state before/after, measure non-HUD canvas/playfield pixel deltas across time, and return playability evidence with version riddle-proof.playability.v1.",
-          "For structured proof, collect meaningful measurements inside page.evaluate and set window.__riddleProofEvidence in that browser page context to a JSON-serializable object. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
-          "Do not assign globalThis.__riddleProofEvidence, window.__riddleProofEvidence, or self.__riddleProofEvidence outside page.evaluate; the Riddle worker context may not expose those globals safely.",
+          "For structured proof, collect meaningful measurements inside page.evaluate, assign them to an evidence variable, and return that object from capture_script. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
+          "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.",
           "Do not call Playwright page.* APIs inside page.evaluate; page.evaluate runs in the browser page, while page.waitForFunction, page.waitForSelector, page.click, and saveScreenshot belong in the outer capture script.",
           "When page.evaluate needs data from the outer Playwright script, pass exactly one serializable argument object; do not pass multiple positional arguments.",
           "When setting Playwright wait timeouts, use the correct signature: await page.waitForFunction(fn, undefined, { timeout: 60000 }). Do not write page.waitForFunction(fn, { timeout: 60000 }); that passes the object as the page argument and leaves the default timeout in place.",
-          "For audio/data/metric proof, return and persist the same evidence object: const evidence = await page.evaluate(async () => { /* browser measurements */ window.__riddleProofEvidence = { ... }; return window.__riddleProofEvidence; }); Then assert evidence fields before saving screenshots.",
+          "For audio/data/metric proof, return the same evidence object: const evidence = await page.evaluate(async () => ({ /* browser measurements */ })); Then assert evidence fields before saving screenshots and return evidence from capture_script.",
           "If a capture attempt errors or proof_evidence is absent, revise the capture_script to make structured evidence easier to collect; do not only add more screenshots for non-visual proof.",
           "When checking visible copy, normalize text before exact matching: const normalizedText = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim(); Avoid raw innerText.includes(exact sentence) because browser line wrapping can split copy.",
           "Prefer success-oriented evidence booleans such as newCopyVisible: true and oldCopyAbsent: true. If a positive assertion is false while screenshots/text samples look right, fix the capture script instead of leaving contradictory proof evidence.",

package/dist/codex-exec-agent.js

@@ -2,7 +2,7 @@ import {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   runCodexExecAgentDoctor
-} from "./chunk-3266V3MO.js";
+} from "./chunk-EXF7V6TJ.js";
 import "./chunk-DUFDZJOF.js";
 export {
   createCodexExecAgentAdapter,

package/dist/engine-harness.cjs

@@ -5196,6 +5196,20 @@ async function routeCheckpoint(request, state, result, agent, input) {
       })
     };
   }
+  if (checkpoint === "verify_audit_complete") {
+    return {
+      terminal: terminalResult(
+        state,
+        "completed",
+        result,
+        result.summary || "Riddle Proof audit complete.",
+        {
+          audit_complete: true,
+          ship_disabled: true
+        }
+      )
+    };
+  }
   if (input.dry_run || request.dry_run) {
     return {
       blocker: {

package/dist/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-3ICNKAWF.js";
+} from "./chunk-F7BNWDF6.js";
 import "./chunk-4DM3OTWH.js";
 import "./chunk-3UHWI3FO.js";
 import "./chunk-SGXB5S4B.js";

package/dist/index.cjs

@@ -5919,6 +5919,20 @@ async function routeCheckpoint(request, state, result, agent, input) {
       })
     };
   }
+  if (checkpoint === "verify_audit_complete") {
+    return {
+      terminal: terminalResult(
+        state,
+        "completed",
+        result,
+        result.summary || "Riddle Proof audit complete.",
+        {
+          audit_complete: true,
+          ship_disabled: true
+        }
+      )
+    };
+  }
   if (input.dry_run || request.dry_run) {
     return {
       blocker: {
@@ -6946,12 +6960,12 @@ function createCodexExecAgentAdapter(config = {}, runner = createCodexExecJsonRu
           "Use the recon-approved route and baseline context; make the plan name the concrete target, expected before state, expected after state, and stop condition.",
           "Choose the evidence modality from verification_mode and success_criteria: screenshots for visual/UI proof, interactions plus screenshots for interaction proof, structured metrics/logs/JSON/audio analysis for non-visual proof.",
           "For playable/gameplay proof, treat screenshots as supporting artifacts only: start the game, send keyboard or pointer input, measure state before/after, measure non-HUD canvas/playfield pixel deltas across time, and return playability evidence with version riddle-proof.playability.v1.",
-          "For structured proof, collect meaningful measurements inside page.evaluate and set window.__riddleProofEvidence in that browser page context to a JSON-serializable object. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
-          "Do not assign globalThis.__riddleProofEvidence, window.__riddleProofEvidence, or self.__riddleProofEvidence outside page.evaluate; the Riddle worker context may not expose those globals safely.",
+          "For structured proof, collect meaningful measurements inside page.evaluate, assign them to an evidence variable, and return that object from capture_script. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
+          "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.",
           "Do not call Playwright page.* APIs inside page.evaluate; page.evaluate runs in the browser page, while page.waitForFunction, page.waitForSelector, page.click, and saveScreenshot belong in the outer capture script.",
           "When page.evaluate needs data from the outer Playwright script, pass exactly one serializable argument object; do not pass multiple positional arguments.",
           "When setting Playwright wait timeouts, use the correct signature: await page.waitForFunction(fn, undefined, { timeout: 60000 }). Do not write page.waitForFunction(fn, { timeout: 60000 }); that passes the object as the page argument and leaves the default timeout in place.",
-          "For audio/data/metric proof, return and persist the same evidence object: const evidence = await page.evaluate(async () => { /* browser measurements */ window.__riddleProofEvidence = { ... }; return window.__riddleProofEvidence; }); Then assert evidence fields before saving screenshots.",
+          "For audio/data/metric proof, return the same evidence object: const evidence = await page.evaluate(async () => ({ /* browser measurements */ })); Then assert evidence fields before saving screenshots and return evidence from capture_script.",
           "If a capture attempt errors or proof_evidence is absent, revise the capture_script to make structured evidence easier to collect; do not only add more screenshots for non-visual proof.",
           "When checking visible copy, normalize text before exact matching: const normalizedText = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim(); Avoid raw innerText.includes(exact sentence) because browser line wrapping can split copy.",
           "Prefer success-oriented evidence booleans such as newCopyVisible: true and oldCopyAbsent: true. If a positive assertion is false while screenshots/text samples look right, fix the capture script instead of leaving contradictory proof evidence.",

package/dist/index.js

@@ -84,7 +84,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-3ICNKAWF.js";
+} from "./chunk-F7BNWDF6.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
@@ -123,7 +123,7 @@ import {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   runCodexExecAgentDoctor
-} from "./chunk-3266V3MO.js";
+} from "./chunk-EXF7V6TJ.js";
 import {
   applyTerminalMetadata,
   compactRecord,

package/dist/local-agent.cjs

@@ -649,12 +649,12 @@ function createCodexExecAgentAdapter(config = {}, runner = createCodexExecJsonRu
           "Use the recon-approved route and baseline context; make the plan name the concrete target, expected before state, expected after state, and stop condition.",
           "Choose the evidence modality from verification_mode and success_criteria: screenshots for visual/UI proof, interactions plus screenshots for interaction proof, structured metrics/logs/JSON/audio analysis for non-visual proof.",
           "For playable/gameplay proof, treat screenshots as supporting artifacts only: start the game, send keyboard or pointer input, measure state before/after, measure non-HUD canvas/playfield pixel deltas across time, and return playability evidence with version riddle-proof.playability.v1.",
-          "For structured proof, collect meaningful measurements inside page.evaluate and set window.__riddleProofEvidence in that browser page context to a JSON-serializable object. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
-          "Do not assign globalThis.__riddleProofEvidence, window.__riddleProofEvidence, or self.__riddleProofEvidence outside page.evaluate; the Riddle worker context may not expose those globals safely.",
+          "For structured proof, collect meaningful measurements inside page.evaluate, assign them to an evidence variable, and return that object from capture_script. Screenshots are optional supporting context for data/audio/log/metric/custom modes.",
+          "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.",
           "Do not call Playwright page.* APIs inside page.evaluate; page.evaluate runs in the browser page, while page.waitForFunction, page.waitForSelector, page.click, and saveScreenshot belong in the outer capture script.",
           "When page.evaluate needs data from the outer Playwright script, pass exactly one serializable argument object; do not pass multiple positional arguments.",
           "When setting Playwright wait timeouts, use the correct signature: await page.waitForFunction(fn, undefined, { timeout: 60000 }). Do not write page.waitForFunction(fn, { timeout: 60000 }); that passes the object as the page argument and leaves the default timeout in place.",
-          "For audio/data/metric proof, return and persist the same evidence object: const evidence = await page.evaluate(async () => { /* browser measurements */ window.__riddleProofEvidence = { ... }; return window.__riddleProofEvidence; }); Then assert evidence fields before saving screenshots.",
+          "For audio/data/metric proof, return the same evidence object: const evidence = await page.evaluate(async () => ({ /* browser measurements */ })); Then assert evidence fields before saving screenshots and return evidence from capture_script.",
           "If a capture attempt errors or proof_evidence is absent, revise the capture_script to make structured evidence easier to collect; do not only add more screenshots for non-visual proof.",
           "When checking visible copy, normalize text before exact matching: const normalizedText = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim(); Avoid raw innerText.includes(exact sentence) because browser line wrapping can split copy.",
           "Prefer success-oriented evidence booleans such as newCopyVisible: true and oldCopyAbsent: true. If a positive assertion is false while screenshots/text samples look right, fix the capture script instead of leaving contradictory proof evidence.",

package/dist/local-agent.js

@@ -3,7 +3,7 @@ import {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   runCodexExecAgentDoctor
-} from "./chunk-3266V3MO.js";
+} from "./chunk-EXF7V6TJ.js";
 import "./chunk-DUFDZJOF.js";
 export {
   createCodexExecAgentAdapter as createLocalAgentAdapter,

package/package.json

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

package/runtime/lib/author.py

@@ -151,9 +151,9 @@ def author_request_payload(state, reference, baselines, current_plan, hypothesis
             'Return the authored packet via author_packet_json when possible. You may also set proof_plan, capture_script, server_path, and wait_for_selector directly.',
             'Keep capture_script concise Playwright statements.',
             'For visual/UI proof, include saveScreenshot(\'after-proof\') exactly once.',
-            '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 set window.__riddleProofEvidence.playability or playability_evidence with version riddle-proof.playability.v1.',
-            'For data/audio/log/metric/custom proof, screenshots are optional; set window.__riddleProofEvidence inside page.evaluate to a JSON-serializable object with the measured observations the verifier should judge.',
-            'Do not assign globalThis.__riddleProofEvidence, window.__riddleProofEvidence, or self.__riddleProofEvidence outside page.evaluate; the Riddle worker context may not expose those globals safely.',
+            '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.',
             'When page.evaluate needs data from the outer Playwright script, pass exactly one serializable argument object; do not pass multiple positional arguments.',
             'Do not begin capture_script with page.goto unless an in-app navigation is genuinely required after the preview opens the target route.',
             'Only escalate to the human after the supervising agent concludes the workflow is genuinely stuck or not converging.',

package/runtime/lib/verify.py

@@ -316,10 +316,13 @@ def build_probe_capture_script(base_script='', verification_mode='proof', proof_
     pieces = []
     script = (base_script or '').strip()
     pieces.append('let __riddleProofCaptureScriptError = null;')
+    pieces.append('let __riddleProofCaptureScriptResult = null;')
     if script:
         pieces.extend([
             'try {',
+            '__riddleProofCaptureScriptResult = await (async () => {',
             script.rstrip(';') + ';',
+            '})();',
             '} catch (err) {',
             '  __riddleProofCaptureScriptError = err;',
             '}',
@@ -359,17 +362,13 @@ def build_probe_capture_script(base_script='', verification_mode='proof', proof_
         '  };',
         '});',
         'console.log(' + json.dumps(PAGE_STATE_PREFIX) + ' + JSON.stringify(pageState));',
-        'let __riddleProofEvidenceValue = null;',
-        'try {',
+        'let __riddleProofEvidenceValue = __riddleProofCaptureScriptResult ?? null;',
+        'if (__riddleProofEvidenceValue === null || __riddleProofEvidenceValue === undefined) { try {',
         '  __riddleProofEvidenceValue = await page.evaluate(() => {',
-        '    const root = (typeof window !== "undefined" && window) || (typeof globalThis !== "undefined" && globalThis) || (typeof self !== "undefined" && self) || {};',
+        '    const root = (typeof window !== "undefined" && window) || {};',
         '    return root.__riddleProofEvidence ?? root.riddleProofEvidence ?? null;',
         '  });',
-        '} catch {}',
-        'if (__riddleProofEvidenceValue === null || __riddleProofEvidenceValue === undefined) {',
-        '  const __riddleProofEvidenceRoot = (typeof globalThis !== "undefined" && globalThis) || (typeof window !== "undefined" && window) || (typeof self !== "undefined" && self) || {};',
-        '  __riddleProofEvidenceValue = __riddleProofEvidenceRoot.__riddleProofEvidence ?? __riddleProofEvidenceRoot.riddleProofEvidence ?? null;',
-        '}',
+        '} catch {} }',
         'if (__riddleProofEvidenceValue !== null && __riddleProofEvidenceValue !== undefined) {',
         '  try { console.log(' + json.dumps(PROOF_EVIDENCE_PREFIX) + ' + JSON.stringify(__riddleProofEvidenceValue)); }',
         '  catch (err) { console.log(' + json.dumps(PROOF_EVIDENCE_PREFIX) + ' + JSON.stringify({ serialization_error: String(err) })); }',

package/runtime/tests/recon_verify_smoke.py

@@ -197,7 +197,7 @@ class FakeRiddle:
                         },
                     },
                 }
-            if 'window.__riddleProofEvidence' in script or 'globalThis.__riddleProofEvidence' in script:
+            if 'attack_ms_after' in script or 'window.__riddleProofEvidence' in script or 'globalThis.__riddleProofEvidence' in script:
                 page_state = {
                     'bodyTextLength': 36,
                     'visibleTextSample': 'Neon step sequencer audio workbench',
@@ -1626,10 +1626,10 @@ def run_verify_structured_evidence_without_screenshot():
             'server_path': '/sequencer',
             'proof_plan': 'Measure the rendered synth transient envelope and compare attack/energy metrics.',
             'capture_script': (
-                "await page.evaluate(() => { "
-                "window.__riddleProofEvidence = { "
+                "const evidence = await page.evaluate(() => ({ "
                 "modality: 'audio', attack_ms_before: 42, attack_ms_after: 12, "
-                "transient_energy_delta_db: 4.8, passed: true }; });"
+                "transient_energy_delta_db: 4.8, passed: true })); "
+                "return evidence;"
             ),
             'recon_results': {
                 'baselines': {'before': {'path': '/sequencer', 'url': 'https://cdn.example.com/before.png'}},
@@ -1657,8 +1657,9 @@ def run_verify_structured_evidence_without_screenshot():
         assert script_calls, 'verify should run a proof capture script'
         capture_script = script_calls[-1]
         assert 'globalThis.__riddleProofEvidence ??' not in capture_script
-        assert 'typeof globalThis !== "undefined"' in capture_script
-        assert '__riddleProofEvidenceRoot.__riddleProofEvidence' in capture_script
+        assert 'typeof globalThis !== "undefined"' not in capture_script
+        assert '__riddleProofEvidenceRoot.__riddleProofEvidence' not in capture_script
+        assert '__riddleProofCaptureScriptResult = await (async () =>' in capture_script
         assert 'attack_ms_after' in supporting['proof_evidence_sample']
         assert after_verify['evidence_bundle']['proof_evidence']['attack_ms_after'] == 12
         assert after_verify['evidence_bundle']['after']['proof_evidence']['attack_ms_after'] == 12