@riddledc/riddle-proof 0.8.5 → 0.8.7

package/dist/codex-exec-agent.cjs

@@ -377,6 +377,18 @@ function parseJsonObject(raw, schema) {
   }
   return null;
 }
+function parseJsonFromRunnerOutputs(outputs, schema) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const output of outputs) {
+    if (!output.text.trim() || seen.has(output.text)) continue;
+    seen.add(output.text);
+    const parsed = parseJsonObject(output.text, schema);
+    if (parsed) return { parsed, source: output.source };
+  }
+  const combined = outputs.map((output) => output.text).filter((text) => text.trim()).join("\n");
+  if (!combined.trim() || seen.has(combined)) return { parsed: null, source: "" };
+  return { parsed: parseJsonObject(combined, schema), source: "combined_output" };
+}
 function isHarnessVerificationOnlyBlocker(blocker) {
   const text = blocker.toLowerCase();
   return (text.includes("erofs") || text.includes("read-only file system")) && text.includes("node_modules") && (text.includes(".vite-temp") || text.includes("vite.config"));
@@ -396,6 +408,7 @@ function runnerMetrics(input) {
     stdout_chars: (input.stdout || "").length,
     stderr_chars: (input.stderr || "").length,
     final_message_chars: (input.finalText || "").length,
+    parsed_json_source: input.parsedJsonSource,
     exit_status: input.status ?? null,
     timed_out: input.timedOut || false,
     error_code: input.errorCode,
@@ -499,19 +512,25 @@ function createCodexExecJsonRunner(config = {}) {
         };
       }
       const finalText = (0, import_node_fs.existsSync)(lastMessagePath) ? (0, import_node_fs.readFileSync)(lastMessagePath, "utf-8") : String(proc.stdout || "");
-      const parsed = parseJsonObject(finalText, request.schema);
+      const stdoutText = String(proc.stdout || "");
+      const stderrText = String(proc.stderr || "");
+      const { parsed, source: parsedJsonSource } = parseJsonFromRunnerOutputs([
+        { source: (0, import_node_fs.existsSync)(lastMessagePath) ? "last_message" : "stdout", text: finalText },
+        { source: "stdout", text: stdoutText },
+        { source: "stderr", text: stderrText }
+      ], request.schema);
       if (!parsed) {
         return {
           ok: false,
-          stdout: proc.stdout || "",
-          stderr: proc.stderr || "",
+          stdout: stdoutText,
+          stderr: stderrText,
           metrics: runnerMetrics({
             request,
             config,
             startedAt,
             startedMs,
-            stdout: proc.stdout || "",
-            stderr: proc.stderr || "",
+            stdout: stdoutText,
+            stderr: stderrText,
             finalText,
             status: proc.status,
             errorCode: "invalid_json"
@@ -519,23 +538,24 @@ function createCodexExecJsonRunner(config = {}) {
           blocker: {
             code: "codex_invalid_json",
             message: `Codex completed ${request.purpose}, but did not return valid JSON.`,
-            details: { finalText, stdout: proc.stdout || "", stderr: proc.stderr || "" }
+            details: { finalText, stdout: stdoutText, stderr: stderrText }
           }
         };
       }
       return {
         ok: true,
         json: parsed,
-        stdout: proc.stdout || "",
-        stderr: proc.stderr || "",
+        stdout: stdoutText,
+        stderr: stderrText,
         metrics: runnerMetrics({
           request,
           config,
           startedAt,
           startedMs,
-          stdout: proc.stdout || "",
-          stderr: proc.stderr || "",
+          stdout: stdoutText,
+          stderr: stderrText,
           finalText,
+          parsedJsonSource,
           status: proc.status
         })
       };
@@ -647,6 +667,7 @@ 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 interaction proof, return a structured evidence object with start route/state, terminal route/state, action, assertions, and matched UI text. Catch waitForURL or selector timeouts and record them as failed assertions instead of throwing before evidence is emitted.",
           "For 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.",

package/dist/codex-exec-agent.js

@@ -2,7 +2,7 @@ import {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   runCodexExecAgentDoctor
-} from "./chunk-7F5LNUGR.js";
+} from "./chunk-PYCQNK66.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";
 export {

package/dist/engine-harness.cjs

@@ -172,6 +172,55 @@ function writeState(statePath, state) {
 function normalizeOptionalString(value) {
   return typeof value === "string" ? value.trim() : void 0;
 }
+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 = [];
@@ -652,17 +701,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;
@@ -842,7 +898,7 @@ function summarizeState(state) {
     state: selected
   };
 }
-var import_node_fs, import_node_crypto2, import_node_path, import_node_url, import_meta, WORKFLOW_STAGE_ORDER, CHECKPOINT_CONTRACT_VERSION, BUNDLED_RIDDLE_PROOF_DIR, RIDDLE_PROOF_DIR_CANDIDATES, VISUAL_FIRST_MODES, CHECKPOINT_CONTRACT_SPECS;
+var import_node_fs, import_node_crypto2, import_node_path, import_node_url, import_meta, WORKFLOW_STAGE_ORDER, CHECKPOINT_CONTRACT_VERSION, BUNDLED_RIDDLE_PROOF_DIR, RIDDLE_PROOF_DIR_CANDIDATES, INTERACTION_VERIFICATION_MODES, VISUAL_FIRST_MODES, CHECKPOINT_CONTRACT_SPECS;
 var init_proof_run_core = __esm({
   "src/proof-run-core.ts"() {
     "use strict";
@@ -861,6 +917,7 @@ var init_proof_run_core = __esm({
     RIDDLE_PROOF_DIR_CANDIDATES = [
       BUNDLED_RIDDLE_PROOF_DIR
     ];
+    INTERACTION_VERIFICATION_MODES = /* @__PURE__ */ new Set(["interaction", "interactive", "user_flow", "user-flow", "workflow"]);
     VISUAL_FIRST_MODES = /* @__PURE__ */ new Set([
       "visual",
       "render",

package/dist/engine-harness.js

@@ -2,10 +2,10 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-BDFSMWTI.js";
+} from "./chunk-E7ATYSYS.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/dist/index.cjs

@@ -172,6 +172,55 @@ function writeState(statePath, state) {
 function normalizeOptionalString(value) {
   return typeof value === "string" ? value.trim() : void 0;
 }
+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 = [];
@@ -652,17 +701,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;
@@ -842,7 +898,7 @@ function summarizeState(state) {
     state: selected
   };
 }
-var import_node_fs, import_node_crypto2, import_node_path, import_node_url, import_meta, WORKFLOW_STAGE_ORDER, CHECKPOINT_CONTRACT_VERSION, BUNDLED_RIDDLE_PROOF_DIR, RIDDLE_PROOF_DIR_CANDIDATES, VISUAL_FIRST_MODES, CHECKPOINT_CONTRACT_SPECS;
+var import_node_fs, import_node_crypto2, import_node_path, import_node_url, import_meta, WORKFLOW_STAGE_ORDER, CHECKPOINT_CONTRACT_VERSION, BUNDLED_RIDDLE_PROOF_DIR, RIDDLE_PROOF_DIR_CANDIDATES, INTERACTION_VERIFICATION_MODES, VISUAL_FIRST_MODES, CHECKPOINT_CONTRACT_SPECS;
 var init_proof_run_core = __esm({
   "src/proof-run-core.ts"() {
     "use strict";
@@ -861,6 +917,7 @@ var init_proof_run_core = __esm({
     RIDDLE_PROOF_DIR_CANDIDATES = [
       BUNDLED_RIDDLE_PROOF_DIR
     ];
+    INTERACTION_VERIFICATION_MODES = /* @__PURE__ */ new Set(["interaction", "interactive", "user_flow", "user-flow", "workflow"]);
     VISUAL_FIRST_MODES = /* @__PURE__ */ new Set([
       "visual",
       "render",
@@ -6805,6 +6862,18 @@ function parseJsonObject(raw, schema) {
   }
   return null;
 }
+function parseJsonFromRunnerOutputs(outputs, schema) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const output of outputs) {
+    if (!output.text.trim() || seen.has(output.text)) continue;
+    seen.add(output.text);
+    const parsed = parseJsonObject(output.text, schema);
+    if (parsed) return { parsed, source: output.source };
+  }
+  const combined = outputs.map((output) => output.text).filter((text) => text.trim()).join("\n");
+  if (!combined.trim() || seen.has(combined)) return { parsed: null, source: "" };
+  return { parsed: parseJsonObject(combined, schema), source: "combined_output" };
+}
 function isHarnessVerificationOnlyBlocker(blocker) {
   const text = blocker.toLowerCase();
   return (text.includes("erofs") || text.includes("read-only file system")) && text.includes("node_modules") && (text.includes(".vite-temp") || text.includes("vite.config"));
@@ -6824,6 +6893,7 @@ function runnerMetrics(input) {
     stdout_chars: (input.stdout || "").length,
     stderr_chars: (input.stderr || "").length,
     final_message_chars: (input.finalText || "").length,
+    parsed_json_source: input.parsedJsonSource,
     exit_status: input.status ?? null,
     timed_out: input.timedOut || false,
     error_code: input.errorCode,
@@ -6927,19 +6997,25 @@ function createCodexExecJsonRunner(config = {}) {
         };
       }
       const finalText = (0, import_node_fs4.existsSync)(lastMessagePath) ? (0, import_node_fs4.readFileSync)(lastMessagePath, "utf-8") : String(proc.stdout || "");
-      const parsed = parseJsonObject(finalText, request.schema);
+      const stdoutText = String(proc.stdout || "");
+      const stderrText = String(proc.stderr || "");
+      const { parsed, source: parsedJsonSource } = parseJsonFromRunnerOutputs([
+        { source: (0, import_node_fs4.existsSync)(lastMessagePath) ? "last_message" : "stdout", text: finalText },
+        { source: "stdout", text: stdoutText },
+        { source: "stderr", text: stderrText }
+      ], request.schema);
       if (!parsed) {
         return {
           ok: false,
-          stdout: proc.stdout || "",
-          stderr: proc.stderr || "",
+          stdout: stdoutText,
+          stderr: stderrText,
           metrics: runnerMetrics({
             request,
             config,
             startedAt,
             startedMs,
-            stdout: proc.stdout || "",
-            stderr: proc.stderr || "",
+            stdout: stdoutText,
+            stderr: stderrText,
             finalText,
             status: proc.status,
             errorCode: "invalid_json"
@@ -6947,23 +7023,24 @@ function createCodexExecJsonRunner(config = {}) {
           blocker: {
             code: "codex_invalid_json",
             message: `Codex completed ${request.purpose}, but did not return valid JSON.`,
-            details: { finalText, stdout: proc.stdout || "", stderr: proc.stderr || "" }
+            details: { finalText, stdout: stdoutText, stderr: stderrText }
           }
         };
       }
       return {
         ok: true,
         json: parsed,
-        stdout: proc.stdout || "",
-        stderr: proc.stderr || "",
+        stdout: stdoutText,
+        stderr: stderrText,
         metrics: runnerMetrics({
           request,
           config,
           startedAt,
           startedMs,
-          stdout: proc.stdout || "",
-          stderr: proc.stderr || "",
+          stdout: stdoutText,
+          stderr: stderrText,
           finalText,
+          parsedJsonSource,
           status: proc.status
         })
       };
@@ -7075,6 +7152,7 @@ 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 interaction proof, return a structured evidence object with start route/state, terminal route/state, action, assertions, and matched UI text. Catch waitForURL or selector timeouts and record them as failed assertions instead of throwing before evidence is emitted.",
           "For 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.",
@@ -10474,7 +10552,7 @@ function normalizeRouteInventoryPath(value, label) {
   const path6 = stringValue5(value);
   if (!path6) throw new Error(`${label} requires path.`);
   if (!path6.startsWith("/")) throw new Error(`${label}.path must start with /.`);
-  return normalizeRoutePath(path6);
+  return normalizeRoutePath2(path6);
 }
 function normalizeRouteInventoryRoute(input, index) {
   if (typeof input === "string") return { path: normalizeRouteInventoryPath(input, `checks route_inventory expected_routes[${index}]`) };
@@ -11491,7 +11569,7 @@ function expectedFailedNetworkMockConsoleEventSummary(event, evidence) {
     text: isRecord2(event) && typeof event.text === "string" ? event.text.slice(0, 300) : sample.slice(0, 300)
   };
 }
-function normalizeRoutePath(path6) {
+function normalizeRoutePath2(path6) {
   const value = path6 || "/";
   if (value === "/") return "/";
   return value.replace(/\/+$/, "") || "/";
@@ -11531,10 +11609,10 @@ function mountedExpectedRoutePath(targetUrl, expected) {
   return mountPrefix ? joinMountedRoutePath(mountPrefix, expected) : expected;
 }
 function routePathMatches(observed, expected, targetUrl) {
-  const normalizedObserved = normalizeRoutePath(observed);
-  const normalizedExpected = normalizeRoutePath(expected);
+  const normalizedObserved = normalizeRoutePath2(observed);
+  const normalizedExpected = normalizeRoutePath2(expected);
   if (normalizedObserved === normalizedExpected) return true;
-  return normalizedObserved === normalizeRoutePath(mountedExpectedRoutePath(targetUrl, expected));
+  return normalizedObserved === normalizeRoutePath2(mountedExpectedRoutePath(targetUrl, expected));
 }
 function successfulRoute(route, targetUrl) {
   const matched = route.matched || routePathMatches(route.observed, route.expected_path, targetUrl);

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   runRiddleProof
-} from "./chunk-UIJ7X63P.js";
+} from "./chunk-5N6MQCLC.js";
 import "./chunk-6F4PWJZI.js";
 import {
   RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION,
@@ -95,7 +95,7 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-BDFSMWTI.js";
+} from "./chunk-E7ATYSYS.js";
 import {
   RIDDLE_PROOF_RUN_STATE_VERSION,
   appendRunEvent,
@@ -112,7 +112,7 @@ import {
   RIDDLE_PROOF_RUN_CARD_VERSION,
   createRiddleProofRunCard
 } from "./chunk-FMOYUYH2.js";
-import "./chunk-RV6LK7HU.js";
+import "./chunk-5N5QFI2S.js";
 import {
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
@@ -134,7 +134,7 @@ import {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   runCodexExecAgentDoctor
-} from "./chunk-7F5LNUGR.js";
+} from "./chunk-PYCQNK66.js";
 import {
   applyTerminalMetadata,
   compactRecord,

package/dist/local-agent.cjs

@@ -379,6 +379,18 @@ function parseJsonObject(raw, schema) {
   }
   return null;
 }
+function parseJsonFromRunnerOutputs(outputs, schema) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const output of outputs) {
+    if (!output.text.trim() || seen.has(output.text)) continue;
+    seen.add(output.text);
+    const parsed = parseJsonObject(output.text, schema);
+    if (parsed) return { parsed, source: output.source };
+  }
+  const combined = outputs.map((output) => output.text).filter((text) => text.trim()).join("\n");
+  if (!combined.trim() || seen.has(combined)) return { parsed: null, source: "" };
+  return { parsed: parseJsonObject(combined, schema), source: "combined_output" };
+}
 function isHarnessVerificationOnlyBlocker(blocker) {
   const text = blocker.toLowerCase();
   return (text.includes("erofs") || text.includes("read-only file system")) && text.includes("node_modules") && (text.includes(".vite-temp") || text.includes("vite.config"));
@@ -398,6 +410,7 @@ function runnerMetrics(input) {
     stdout_chars: (input.stdout || "").length,
     stderr_chars: (input.stderr || "").length,
     final_message_chars: (input.finalText || "").length,
+    parsed_json_source: input.parsedJsonSource,
     exit_status: input.status ?? null,
     timed_out: input.timedOut || false,
     error_code: input.errorCode,
@@ -501,19 +514,25 @@ function createCodexExecJsonRunner(config = {}) {
         };
       }
       const finalText = (0, import_node_fs.existsSync)(lastMessagePath) ? (0, import_node_fs.readFileSync)(lastMessagePath, "utf-8") : String(proc.stdout || "");
-      const parsed = parseJsonObject(finalText, request.schema);
+      const stdoutText = String(proc.stdout || "");
+      const stderrText = String(proc.stderr || "");
+      const { parsed, source: parsedJsonSource } = parseJsonFromRunnerOutputs([
+        { source: (0, import_node_fs.existsSync)(lastMessagePath) ? "last_message" : "stdout", text: finalText },
+        { source: "stdout", text: stdoutText },
+        { source: "stderr", text: stderrText }
+      ], request.schema);
       if (!parsed) {
         return {
           ok: false,
-          stdout: proc.stdout || "",
-          stderr: proc.stderr || "",
+          stdout: stdoutText,
+          stderr: stderrText,
           metrics: runnerMetrics({
             request,
             config,
             startedAt,
             startedMs,
-            stdout: proc.stdout || "",
-            stderr: proc.stderr || "",
+            stdout: stdoutText,
+            stderr: stderrText,
             finalText,
             status: proc.status,
             errorCode: "invalid_json"
@@ -521,23 +540,24 @@ function createCodexExecJsonRunner(config = {}) {
           blocker: {
             code: "codex_invalid_json",
             message: `Codex completed ${request.purpose}, but did not return valid JSON.`,
-            details: { finalText, stdout: proc.stdout || "", stderr: proc.stderr || "" }
+            details: { finalText, stdout: stdoutText, stderr: stderrText }
           }
         };
       }
       return {
         ok: true,
         json: parsed,
-        stdout: proc.stdout || "",
-        stderr: proc.stderr || "",
+        stdout: stdoutText,
+        stderr: stderrText,
         metrics: runnerMetrics({
           request,
           config,
           startedAt,
           startedMs,
-          stdout: proc.stdout || "",
-          stderr: proc.stderr || "",
+          stdout: stdoutText,
+          stderr: stderrText,
           finalText,
+          parsedJsonSource,
           status: proc.status
         })
       };
@@ -649,6 +669,7 @@ 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 interaction proof, return a structured evidence object with start route/state, terminal route/state, action, assertions, and matched UI text. Catch waitForURL or selector timeouts and record them as failed assertions instead of throwing before evidence is emitted.",
           "For 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.",

package/dist/local-agent.js

@@ -3,7 +3,7 @@ import {
   createCodexExecAgentAdapter,
   createCodexExecJsonRunner,
   runCodexExecAgentDoctor
-} from "./chunk-7F5LNUGR.js";
+} from "./chunk-PYCQNK66.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";
 export {