@riddledc/riddle-proof 0.5.23 → 0.5.25

package/dist/{chunk-M4MISBQV.js → chunk-46355FJD.js}

@@ -89,8 +89,20 @@ function loadRunState(input) {
     state_path: statePath
   });
 }
+function isProtectedFinalStatus(status) {
+  return status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
+function shouldPreserveFinalizedRunState(filePath, incoming) {
+  const existing = readJson(filePath);
+  if (!existing?.finalized || !isProtectedFinalStatus(existing.status)) return false;
+  if (!incoming.finalized) return true;
+  if (existing.status === incoming.status) return false;
+  return !(existing.status === "ready_to_ship" && incoming.status === "shipped");
+}
 function persist(state) {
-  if (state.state_path) writeJson(state.state_path, state);
+  if (!state.state_path) return;
+  if (shouldPreserveFinalizedRunState(state.state_path, state)) return;
+  writeJson(state.state_path, state);
 }
 function recordEvent(state, event) {
   appendRunEvent(state, event);
@@ -325,6 +337,7 @@ function engineFailureBlocker(result, checkpoint) {
 }
 function terminalResult(state, status, result, summary, raw = {}) {
   setRunStatus(state, status);
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   const metadata = normalizeTerminalMetadata({
     riddleState: result ? fullRiddleState(result, state) : null,
     engineResult: result

package/dist/engine-harness.cjs

@@ -3091,8 +3091,20 @@ function loadRunState(input) {
     state_path: statePath
   });
 }
+function isProtectedFinalStatus(status) {
+  return status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
+function shouldPreserveFinalizedRunState(filePath, incoming) {
+  const existing = readJson(filePath);
+  if (!existing?.finalized || !isProtectedFinalStatus(existing.status)) return false;
+  if (!incoming.finalized) return true;
+  if (existing.status === incoming.status) return false;
+  return !(existing.status === "ready_to_ship" && incoming.status === "shipped");
+}
 function persist(state) {
-  if (state.state_path) writeJson(state.state_path, state);
+  if (!state.state_path) return;
+  if (shouldPreserveFinalizedRunState(state.state_path, state)) return;
+  writeJson(state.state_path, state);
 }
 function recordEvent(state, event) {
   appendRunEvent(state, event);
@@ -3327,6 +3339,7 @@ function engineFailureBlocker(result, checkpoint) {
 }
 function terminalResult(state, status, result, summary, raw = {}) {
   setRunStatus(state, status);
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   const metadata = normalizeTerminalMetadata({
     riddleState: result ? fullRiddleState(result, state) : null,
     engineResult: result

package/dist/engine-harness.js

@@ -2,7 +2,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-M4MISBQV.js";
+} from "./chunk-46355FJD.js";
 import "./chunk-7ZJAUEUN.js";
 import "./chunk-TMMKRKY5.js";
 export {

package/dist/index.cjs

@@ -3647,8 +3647,20 @@ function loadRunState(input) {
     state_path: statePath
   });
 }
+function isProtectedFinalStatus(status) {
+  return status === "ready_to_ship" || status === "shipped" || status === "completed";
+}
+function shouldPreserveFinalizedRunState(filePath, incoming) {
+  const existing = readJson(filePath);
+  if (!existing?.finalized || !isProtectedFinalStatus(existing.status)) return false;
+  if (!incoming.finalized) return true;
+  if (existing.status === incoming.status) return false;
+  return !(existing.status === "ready_to_ship" && incoming.status === "shipped");
+}
 function persist(state) {
-  if (state.state_path) writeJson(state.state_path, state);
+  if (!state.state_path) return;
+  if (shouldPreserveFinalizedRunState(state.state_path, state)) return;
+  writeJson(state.state_path, state);
 }
 function recordEvent(state, event) {
   appendRunEvent(state, event);
@@ -3883,6 +3895,7 @@ function engineFailureBlocker(result, checkpoint) {
 }
 function terminalResult(state, status, result, summary, raw = {}) {
   setRunStatus(state, status);
+  if (isProtectedFinalStatus(status)) state.finalized = true;
   const metadata = normalizeTerminalMetadata({
     riddleState: result ? fullRiddleState(result, state) : null,
     engineResult: result

package/dist/index.js

@@ -13,7 +13,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-M4MISBQV.js";
+} from "./chunk-46355FJD.js";
 import {
   runRiddleProof
 } from "./chunk-F6VFKS7K.js";

package/package.json

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

package/runtime/lib/verify.py

@@ -218,8 +218,15 @@ def abort_capture_failure(state, results, expected_path, message, raw_payload):
 def build_probe_capture_script(base_script='', verification_mode='proof'):
     pieces = []
     script = (base_script or '').strip()
+    pieces.append('let __riddleProofCaptureScriptError = null;')
     if script:
-        pieces.append(script.rstrip(';') + ';')
+        pieces.extend([
+            'try {',
+            script.rstrip(';') + ';',
+            '} catch (err) {',
+            '  __riddleProofCaptureScriptError = err;',
+            '}',
+        ])
     pieces.extend([
         f'await page.waitForTimeout({HYDRATION_WAIT_MS});',
         'const pageState = await page.evaluate(() => {',
@@ -273,6 +280,7 @@ def build_probe_capture_script(base_script='', verification_mode='proof'):
     ])
     if auto_screenshot_for_mode(verification_mode) and not capture_script_saves_screenshot(script):
         pieces.append("await saveScreenshot('after-proof');")
+    pieces.append('if (__riddleProofCaptureScriptError) throw __riddleProofCaptureScriptError;')
     pieces.append('return { pageState, proofEvidence: __riddleProofEvidenceValue };')
     return ' '.join(pieces)
 

package/runtime/tests/recon_verify_smoke.py

@@ -126,6 +126,44 @@ class FakeRiddle:
                         'RIDDLE_PROOF_EVIDENCE ' + json.dumps(proof_evidence),
                     ],
                 }
+            if 'throwAfterProofEvidence' in script:
+                assert '__riddleProofCaptureScriptError' in script
+                page_state = {
+                    'bodyTextLength': 96,
+                    'visibleTextSample': 'Neon step sequencer audio workbench',
+                    'interactiveElements': 0,
+                    'visibleInteractiveElements': 0,
+                    'pathname': '/s/pv-after/sequencer',
+                    'title': 'Sequencer',
+                    'buttons': [],
+                    'headings': ['Sequencer'],
+                    'links': [],
+                    'canvasCount': 1,
+                    'largeVisibleElements': [{'tag': 'canvas', 'text': ''}],
+                }
+                proof_evidence = {
+                    'proof_evidence_present': False,
+                    'evidence_summary': 'Captured structured audio evidence before the capture script threw.',
+                    'checks': {
+                        'route_ok': True,
+                        'ui_context_ok': True,
+                        'source_audio_ok': False,
+                    },
+                }
+                return {
+                    'ok': True,
+                    'outputs': [{'name': 'proof.json', 'url': 'https://cdn.example.com/proof.json'}],
+                    'result': {'pageState': page_state},
+                    'console': [
+                        'RIDDLE_PROOF_STATE:' + json.dumps(page_state),
+                        'RIDDLE_PROOF_EVIDENCE:' + json.dumps(proof_evidence),
+                    ],
+                    '_artifact_json': {
+                        'proof.json': {
+                            'script_error': 'Error: intentional capture script failure after evidence',
+                        },
+                    },
+                }
             if 'window.__riddleProofEvidence' in script or 'globalThis.__riddleProofEvidence' in script:
                 page_state = {
                     'bodyTextLength': 36,
@@ -1226,6 +1264,68 @@ def run_verify_audio_rejects_failed_nested_proof_evidence():
         shutil.rmtree(tempdir, ignore_errors=True)
 
 
+def run_verify_preserves_proof_evidence_on_capture_script_error():
+    tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-verify-script-error-evidence-'))
+    state_path = tempdir / 'state.json'
+    try:
+        state = base_state(tempdir, reference='before')
+        state.update({
+            'recon_status': 'ready_for_proof_plan',
+            'author_status': 'ready',
+            'proof_plan_status': 'ready',
+            'implementation_status': 'changes_detected',
+            'before_cdn': 'https://cdn.example.com/before.png',
+            'verification_mode': 'audio',
+            'server_path': '/sequencer',
+            'proof_plan': 'Measure the rendered synth transient envelope and compare attack/energy metrics.',
+            'capture_script': (
+                "await page.evaluate(() => { "
+                "document.body.dataset.throwAfterProofEvidence = '1'; "
+                "window.__riddleProofEvidence = { "
+                "proof_evidence_present: false, "
+                "evidence_summary: 'Captured structured audio evidence before the capture script threw.', "
+                "checks: { route_ok: true, ui_context_ok: true, source_audio_ok: false } "
+                "}; }); "
+                "throw new Error('intentional capture script failure after evidence');"
+            ),
+            'recon_results': {
+                'baselines': {'before': {'path': '/sequencer', 'url': 'https://cdn.example.com/before.png'}},
+            },
+        })
+        write_state(state_path, state)
+        os.environ['RIDDLE_PROOF_STATE_FILE'] = str(state_path)
+
+        fake = FakeRiddle()
+        load_util_with_fake(fake)
+        load_module('verify_preserves_script_error_evidence', VERIFY_PATH)
+        after_verify = json.loads(state_path.read_text())
+
+        assert after_verify['verify_status'] == 'capture_incomplete'
+        observation = after_verify['verify_results']['after']['observation']
+        assert observation['valid'] is False
+        artifact_summary = observation['details']['artifact_summary']
+        assert artifact_summary['proof_script_error'] is True
+        supporting = after_verify['verify_results']['after']['supporting_artifacts']
+        assert supporting['has_structured_payload'] is True
+        assert supporting['proof_evidence_present'] is True
+        assert 'Captured structured audio evidence before the capture script threw' in supporting['proof_evidence_sample']
+        capture_quality = after_verify['verify_decision_request']['capture_quality']
+        assert capture_quality['decision'] == 'failed_proof_evidence'
+        assert capture_quality['recommended_stage'] == 'author'
+        assert 'proof_evidence_present=false' in capture_quality['summary']
+        assert 'source_audio_ok' in capture_quality['summary']
+        assert 'Structured proof evidence gate' in after_verify['proof_summary']
+
+        return {
+            'ok': True,
+            'verify_status': after_verify['verify_status'],
+            'decision': capture_quality['decision'],
+            'proof_script_error': artifact_summary['proof_script_error'],
+        }
+    finally:
+        shutil.rmtree(tempdir, ignore_errors=True)
+
+
 def run_verify_capture_retry():
     tempdir = Path(tempfile.mkdtemp(prefix='riddle-proof-capture-retry-'))
     state_path = tempdir / 'state.json'
@@ -1543,6 +1643,7 @@ if __name__ == '__main__':
         'verify_structured_evidence_without_screenshot': run_verify_structured_evidence_without_screenshot(),
         'verify_audio_requires_proof_evidence': run_verify_audio_requires_proof_evidence(),
         'verify_audio_rejects_failed_nested_proof_evidence': run_verify_audio_rejects_failed_nested_proof_evidence(),
+        'verify_preserves_proof_evidence_on_capture_script_error': run_verify_preserves_proof_evidence_on_capture_script_error(),
         'verify_capture_retry': run_verify_capture_retry(),
         'missing_baseline_guard': run_verify_missing_baseline(),
         'ship_supervisor_gate': run_ship_missing_supervisor_gate(),