@riddledc/riddle-proof 0.8.24 → 0.8.26

package/dist/cli.cjs

@@ -244,6 +244,36 @@ function normalizeCaptureScript(value) {
   const script = normalizeOptionalString(value) || "";
   return script ? guardProofEvidenceGlobalAssignments(script) : "";
 }
+function compactCaptureScriptForHeuristics(script) {
+  return script.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:])\/\/.*$/gm, "$1 ").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function interactionCaptureScriptLooksPassive(script) {
+  const text = compactCaptureScriptForHeuristics(script);
+  if (!text) return true;
+  const actionPatterns = [
+    /\bpage\.(click|dblclick|tap|fill|press|type|check|uncheck|selectoption|dispatch(event)?|goto|reload)\s*\(/,
+    /\blocator\s*\([^)]*\)\s*\.\s*(click|dblclick|tap|fill|press|type|check|uncheck|selectoption|dispatch(event)?)\s*\(/,
+    /\b(getby(role|text|label|testid|placeholder|title)|getbyalttext)\s*\([^)]*\)\s*\.\s*(click|dblclick|tap|fill|press|type|check|uncheck|selectoption)\s*\(/,
+    /\bkeyboard\s*\.\s*(press|type|inserttext)\s*\(/,
+    /\bmouse\s*\.\s*(click|dblclick|down|up|move)\s*\(/,
+    /\btouchscreen\s*\.\s*tap\s*\(/
+  ];
+  if (actionPatterns.some((pattern) => pattern.test(text))) return false;
+  const evidencePatterns = [
+    /\breturn\s+[{[]/,
+    /\breturn\s+\w+/,
+    /__riddleproofevidence/,
+    /\bproof_evidence\b/,
+    /\brouteexpectationsource\b/,
+    /\bexpectedurl\b/,
+    /\bassertions?\b/
+  ];
+  return !evidencePatterns.some((pattern) => pattern.test(text));
+}
+function setStructuredInteractionCaptureFailure(state, summary) {
+  const existing = typeof state.structured_interaction_capture_failure_summary === "string" ? state.structured_interaction_capture_failure_summary.trim() : "";
+  if (!existing) state.structured_interaction_capture_failure_summary = summary;
+}
 function appendProofSummaryLine(state, line) {
   const text = String(line || "").trim();
   if (!text) return;
@@ -484,6 +514,9 @@ function proofAssessmentHardBlockersForState(state = {}) {
   }
   add(state?.structured_interaction_capture_failure_summary);
   add(state?.structured_interaction_failure_summary);
+  if (isInteractionVerificationMode(normalizedVerificationMode(state)) && !stateHasProofEvidence(state)) {
+    add("interaction proof evidence is required before ready_to_ship; proof_evidence_present=false");
+  }
   const mergeRecommendation = String(state?.merge_recommendation || "").trim();
   if (mergeRecommendation === "do-not-merge" && blockers.length) {
     add("merge_recommendation=do-not-merge because the proof bundle contains hard blockers.");
@@ -519,7 +552,22 @@ function stateHasAfterEvidence(state = {}) {
   const observation = objectValue(after.observation);
   const supporting = objectValue(after.supporting_artifacts);
   return Boolean(
-    observation.valid === true && (supporting.has_structured_payload === true || supporting.proof_evidence_present === true || observation.telemetry_ready === true || Object.keys(objectValue(bundle.proof_evidence)).length > 0 || Object.keys(objectValue(after.proof_evidence)).length > 0)
+    observation.valid === true && (supporting.has_structured_payload === true || stateHasProofEvidence(state) || observation.telemetry_ready === true)
+  );
+}
+function stateHasProofEvidence(state = {}) {
+  if (state?.proof_evidence_present === true) return true;
+  if (state?.proof_evidence !== void 0 && state?.proof_evidence !== null) {
+    if (typeof state.proof_evidence !== "object") return true;
+    if (Object.keys(objectValue(state.proof_evidence)).length > 0) return true;
+  }
+  const bundle = objectValue(state?.evidence_bundle);
+  const after = objectValue(bundle.after);
+  const supporting = objectValue(after.supporting_artifacts);
+  const request = objectValue(state?.proof_assessment_request);
+  const structuredEvidence = objectValue(request.structured_evidence);
+  return Boolean(
+    supporting.proof_evidence_present === true || structuredEvidence.proof_evidence_present === true || Object.keys(objectValue(bundle.proof_evidence)).length > 0 || Object.keys(objectValue(after.proof_evidence)).length > 0
   );
 }
 function validateShipGate(state = {}) {
@@ -725,6 +773,11 @@ function mergeStateFromParams(statePath, params) {
       state.supervisor_author_packet = parsed;
       if (typeof parsed?.proof_plan === "string") state.proof_plan = normalizeOptionalString(parsed.proof_plan) || "";
       if (typeof parsed?.capture_script === "string") state.capture_script = normalizeCaptureScript(parsed.capture_script);
+      if (isInteractionVerificationMode(state.verification_mode) && interactionCaptureScriptLooksPassive(state.capture_script || "")) {
+        const warning = "Interaction proof capture script appears passive: it does not perform a browser interaction or return structured proof evidence.";
+        appendStateWarning(state, "author_warnings", warning);
+        setStructuredInteractionCaptureFailure(state, warning);
+      }
       if (parsed?.baseline_understanding_used && typeof parsed.baseline_understanding_used === "object") {
         state.author_baseline_understanding_used = parsed.baseline_understanding_used;
       }
@@ -3156,6 +3209,7 @@ var init_proof_run_engine = __esm({
 });
 
 // src/cli.ts
+var import_node_child_process5 = require("child_process");
 var import_node_fs6 = require("fs");
 var import_node_path6 = __toESM(require("path"), 1);
 
@@ -16851,6 +16905,7 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "intervalMs",
   "job",
   "jobId",
+  "localCore",
   "maxIterations",
   "navigationTimeout",
   "output",
@@ -16860,6 +16915,8 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "pollAttempts",
   "pollIntervalMs",
   "port",
+  "pack",
+  "packFile",
   "profile",
   "progressEveryMs",
   "quiet",
@@ -16910,6 +16967,7 @@ function usage() {
     "  riddle-proof-loop run-profile --profile <file|json|-> --url <base-url> [--base-url <base-url>] [--runner riddle] [--viewport-name <name[,name...]>] [--strict true|false; default false] [--split-viewports true|false; default false] [--balance-preflight true|false; default true] [--poll-attempts n] [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json] [--quiet]",
     "  riddle-proof-loop run-profile aggregate --profile <file|json|-> --url <base-url> [--base-url <base-url>] --input-dir <dir>|--inputs <path[,path...]> [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json]",
     "  riddle-proof-loop run-profile recover --profile <file|json|-> --url <base-url> [--base-url <base-url>] --job <job-id> [--viewport-name <name[,name...]>] [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json]",
+    "  riddle-proof-loop regression-pack run [--pack oc-flow-regression|--pack-file <file>] [--local-core true|false; default true] [--format json|markdown|compact-json; default json] [--output <dir>|--output-dir <dir>]",
     "  riddle-proof-loop profile-body-assertions --artifact <file|url|-> --candidates-json <file|json|-> [--required-json <file|json|->] [--format json|body-contains]",
     "  riddle-proof-loop profile-http-status-preflight --profile <file|json|-> --url <base-url> [--format json|summary]",
     "  riddle-proof-loop riddle-preview-deploy <build-dir> <label> [--framework spa|static]",
@@ -16988,6 +17046,27 @@ function runProfileViewportNamesOption(options) {
 }
 var DEFAULT_PROFILE_UNSUBMITTED_RETRY_TIMEOUT_MS = 9e4;
 var DEFAULT_PROFILE_UNSUBMITTED_RETRIES = 2;
+function cliPackageRoot() {
+  const entryPath = process.argv[1] ? (() => {
+    try {
+      return (0, import_node_fs6.realpathSync)(process.argv[1]);
+    } catch {
+      return process.argv[1];
+    }
+  })() : "";
+  const candidates = [
+    entryPath ? import_node_path6.default.resolve(import_node_path6.default.dirname(entryPath), "..") : "",
+    import_node_path6.default.resolve(process.cwd(), "packages", "riddle-proof"),
+    process.cwd()
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    if ((0, import_node_fs6.existsSync)(import_node_path6.default.join(candidate, "runtime", "tests", "trust_boundary_regression.py")) && (0, import_node_fs6.existsSync)(import_node_path6.default.join(candidate, "examples", "regression-packs"))) {
+      return candidate;
+    }
+  }
+  return candidates[0] || process.cwd();
+}
+var CLI_PACKAGE_ROOT = cliPackageRoot();
 function optionNumber(options, ...keys) {
   for (const key of keys) {
     const value = optionString(options, key);
@@ -17068,6 +17147,292 @@ function writeRunProfileResult(result, options) {
   process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
 }
+function regressionPackResultFormatOption(options) {
+  const format = optionString(options, "format") ?? optionString(options, "resultFormat") ?? "json";
+  if (format === "md" || format === "summary") return "markdown";
+  if (format === "json" || format === "compact-json" || format === "markdown") return format;
+  throw new Error("--format must be json, compact-json, or markdown.");
+}
+function regressionPackPathForCli(options) {
+  const packFile = optionString(options, "packFile");
+  if (packFile) return import_node_path6.default.resolve(packFile);
+  const pack = optionString(options, "pack") || "oc-flow-regression";
+  if ((0, import_node_fs6.existsSync)(pack)) return import_node_path6.default.resolve(pack);
+  const normalized = pack.endsWith(".json") ? pack : `${pack}.json`;
+  return import_node_path6.default.join(CLI_PACKAGE_ROOT, "examples", "regression-packs", normalized);
+}
+function readRegressionPackForCli(options) {
+  const filePath = regressionPackPathForCli(options);
+  if (!(0, import_node_fs6.existsSync)(filePath)) throw new Error(`Regression pack not found: ${filePath}`);
+  const parsed = JSON.parse((0, import_node_fs6.readFileSync)(filePath, "utf-8"));
+  if (parsed.version !== "riddle-proof.regression-pack.v1") {
+    throw new Error(`${filePath} is not a riddle-proof.regression-pack.v1 manifest.`);
+  }
+  return { filePath, pack: parsed };
+}
+function regressionPackStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+}
+function regressionPackRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function regressionPackCommandForLocalCore(pack) {
+  const suite = regressionPackRecord(pack.local_core_suite);
+  return cliString(suite.command) || "python3 packages/riddle-proof/runtime/tests/trust_boundary_regression.py";
+}
+function regressionPackLocalCoreScriptPath() {
+  return import_node_path6.default.join(CLI_PACKAGE_ROOT, "runtime", "tests", "trust_boundary_regression.py");
+}
+function tailLines(text, limit = 40) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  return lines.slice(-limit);
+}
+function parseRegressionPackLocalCoreStdout(stdout) {
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    const start = stdout.indexOf("{");
+    const end = stdout.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      return JSON.parse(stdout.slice(start, end + 1));
+    }
+    throw new Error("Local core suite did not emit parseable JSON.");
+  }
+}
+function regressionPackCaseNames(result) {
+  const results = Array.isArray(result.results) ? result.results : [];
+  return results.map((item) => cliString(regressionPackRecord(item).name)).filter((item) => Boolean(item));
+}
+function regressionPackFailedCaseNames(result) {
+  const failed = Array.isArray(result.failed) ? result.failed : [];
+  const namedFailed = failed.map((item) => cliString(regressionPackRecord(item).name)).filter((item) => Boolean(item));
+  if (namedFailed.length) return namedFailed;
+  const results = Array.isArray(result.results) ? result.results : [];
+  return results.map(regressionPackRecord).filter((item) => item.ok === false).map((item) => cliString(item.name)).filter((item) => Boolean(item));
+}
+function regressionPackMarkersSeen(result, markers) {
+  const encoded = JSON.stringify(result);
+  return markers.filter((marker) => encoded.includes(marker));
+}
+function runRegressionPackLocalCore(pack) {
+  const script = regressionPackLocalCoreScriptPath();
+  const suite = regressionPackRecord(pack.local_core_suite);
+  const requiredCases = regressionPackStringArray(suite.required_cases);
+  const forbiddenMarkers = regressionPackStringArray(pack.forbidden_terminal_markers);
+  const command = regressionPackCommandForLocalCore(pack);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!(0, import_node_fs6.existsSync)(script)) {
+    return {
+      requested: true,
+      ok: false,
+      command,
+      started_at: startedAt,
+      finished_at: (/* @__PURE__ */ new Date()).toISOString(),
+      error: `Local core suite script not found: ${script}`,
+      required_cases: requiredCases,
+      missing_required_cases: requiredCases,
+      forbidden_terminal_markers_seen: []
+    };
+  }
+  const child = (0, import_node_child_process5.spawnSync)("python3", [script], {
+    cwd: CLI_PACKAGE_ROOT,
+    encoding: "utf-8",
+    timeout: 12e4
+  });
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let parsed = null;
+  let parseError;
+  try {
+    parsed = parseRegressionPackLocalCoreStdout(child.stdout || "");
+  } catch (error) {
+    parseError = error instanceof Error ? error.message : String(error);
+  }
+  const caseNames = parsed ? regressionPackCaseNames(parsed) : [];
+  const missingRequiredCases = requiredCases.filter((caseId) => !caseNames.includes(caseId));
+  const failedCases = parsed ? regressionPackFailedCaseNames(parsed) : [];
+  const markersSeen = parsed ? regressionPackMarkersSeen(parsed, forbiddenMarkers) : [];
+  const ok = child.status === 0 && parsed?.ok === true && !missingRequiredCases.length && !failedCases.length && !markersSeen.length;
+  return {
+    requested: true,
+    ok,
+    command,
+    executed: {
+      binary: "python3",
+      args: [import_node_path6.default.relative(CLI_PACKAGE_ROOT, script)],
+      cwd: CLI_PACKAGE_ROOT
+    },
+    exit_code: child.status,
+    signal: child.signal,
+    started_at: startedAt,
+    finished_at: finishedAt,
+    suite: cliString(parsed?.suite) || null,
+    case_count: typeof parsed?.case_count === "number" ? parsed.case_count : caseNames.length,
+    passed_case_count: caseNames.length - failedCases.length,
+    required_cases: requiredCases,
+    observed_cases: caseNames,
+    missing_required_cases: missingRequiredCases,
+    failed_cases: failedCases,
+    forbidden_terminal_markers_seen: markersSeen,
+    parse_error: parseError,
+    stderr_tail: tailLines(child.stderr || ""),
+    stdout_tail: ok ? void 0 : tailLines(child.stdout || "")
+  };
+}
+function openClawHandoffPromptForRegressionPack(pack, input) {
+  const minimumVersions = regressionPackRecord(pack.minimum_versions);
+  const runtimeGate = regressionPackRecord(pack.runtime_gate);
+  const liveSuite = regressionPackRecord(pack.openclaw_live_suite);
+  const target = regressionPackRecord(liveSuite.target);
+  const cases = Array.isArray(liveSuite.cases) ? liveSuite.cases.map(regressionPackRecord) : [];
+  const fields = regressionPackStringArray(liveSuite.result_log_fields);
+  const forbiddenMarkers = regressionPackStringArray(pack.forbidden_terminal_markers);
+  const lines = [
+    "Run the Riddle Proof OC flow regression pack in small serial chunks.",
+    "",
+    `First call ${cliString(runtimeGate.tool) || "riddle_proof_status"} and count only fresh loaded-runtime runs. Required loaded versions are at least:`,
+    ...Object.entries(minimumVersions).map(([name, version]) => `- ${name}: ${version}`),
+    "",
+    "Target/default flags:",
+    ...Object.entries(target).map(([key, value]) => `- ${key}: ${JSON.stringify(value)}`),
+    "",
+    "Rules:",
+    "- Run cases serially, not as one broad parallel batch.",
+    "- If loaded metadata is stale, stop and restart/reload the gateway before counting results.",
+    "- If any generic lifecycle marker appears, report the exact marker and artifact, then stop the counted batch.",
+    `- Forbidden terminal markers: ${forbiddenMarkers.join(", ") || "none"}.`,
+    fields.length ? `- Log fields for every counted run: ${fields.join(", ")}.` : "",
+    "",
+    "Cases:",
+    ...cases.map((testCase, index) => {
+      const expect = regressionPackRecord(testCase.expect);
+      return [
+        `${index + 1}. ${cliString(testCase.id) || "unnamed-case"}: ${cliString(testCase.intent) || "no intent"}`,
+        `   Expect: ${JSON.stringify(expect)}`
+      ].join("\n");
+    }),
+    "",
+    input.localCoreOk ? "Local generic core suite is green, so OC should only be validating wrapper/runtime behavior." : "Local generic core suite is not green or was not run; do not count OC failures as wrapper-only until local core is green."
+  ].filter((line) => line !== "");
+  return lines.join("\n");
+}
+function compactRegressionPackRunResult(result) {
+  const localCore = regressionPackRecord(result.local_core);
+  const openClaw = regressionPackRecord(result.openclaw_live_suite);
+  return {
+    version: result.version,
+    pack_id: result.pack_id,
+    ok: result.ok,
+    local_core: {
+      requested: localCore.requested,
+      ok: localCore.ok,
+      command: localCore.command,
+      case_count: localCore.case_count,
+      missing_required_cases: localCore.missing_required_cases,
+      failed_cases: localCore.failed_cases,
+      forbidden_terminal_markers_seen: localCore.forbidden_terminal_markers_seen
+    },
+    openclaw_live_case_count: openClaw.case_count,
+    output_dir: result.output_dir
+  };
+}
+function regressionPackRunMarkdown(result) {
+  const localCore = regressionPackRecord(result.local_core);
+  const runtimeGate = regressionPackRecord(result.runtime_gate);
+  const minimumVersions = regressionPackRecord(result.minimum_versions);
+  const openClaw = regressionPackRecord(result.openclaw_live_suite);
+  const lines = [
+    `# ${cliString(result.public_name) || cliString(result.pack_id) || "Riddle Proof Regression Pack"}`,
+    "",
+    `Status: ${result.ok ? "passed" : "failed"}`,
+    `Pack: ${cliString(result.pack_id) || "unknown"}`,
+    "",
+    "## Local Core",
+    "",
+    `- requested: ${localCore.requested === true}`,
+    `- ok: ${localCore.ok === true}`,
+    `- command: ${cliString(localCore.command) || "n/a"}`,
+    `- cases: ${localCore.case_count ?? "n/a"}`,
+    `- missing required: ${regressionPackStringArray(localCore.missing_required_cases).join(", ") || "none"}`,
+    `- failed cases: ${regressionPackStringArray(localCore.failed_cases).join(", ") || "none"}`,
+    `- forbidden markers seen: ${regressionPackStringArray(localCore.forbidden_terminal_markers_seen).join(", ") || "none"}`,
+    "",
+    "## Runtime Gate",
+    "",
+    `- tool: ${cliString(runtimeGate.tool) || "n/a"}`,
+    ...Object.entries(minimumVersions).map(([name, version]) => `- ${name}: ${version}`),
+    "",
+    "## OpenClaw Live Suite",
+    "",
+    `- case count: ${openClaw.case_count ?? "n/a"}`,
+    `- result log fields: ${regressionPackStringArray(openClaw.result_log_fields).join(", ") || "n/a"}`,
+    "",
+    "## OC Handoff Prompt",
+    "",
+    "```text",
+    cliString(result.openclaw_handoff_prompt) || "",
+    "```",
+    ""
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function writeRegressionPackOutput(outputDir, result) {
+  if (!outputDir) return;
+  (0, import_node_fs6.mkdirSync)(outputDir, { recursive: true });
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "regression-pack-result.json"), `${JSON.stringify(result, null, 2)}
+`);
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "summary.md"), regressionPackRunMarkdown(result));
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "oc-handoff.md"), `${cliString(result.openclaw_handoff_prompt) || ""}
+`);
+}
+function runRegressionPackForCli(options) {
+  const { filePath, pack } = readRegressionPackForCli(options);
+  const localCoreRequested = optionBoolean(options, "localCore") ?? true;
+  const localCore = localCoreRequested ? runRegressionPackLocalCore(pack) : { requested: false, ok: true, command: regressionPackCommandForLocalCore(pack) };
+  const liveSuite = regressionPackRecord(pack.openclaw_live_suite);
+  const liveCases = Array.isArray(liveSuite.cases) ? liveSuite.cases : [];
+  const localCoreRecord = regressionPackRecord(localCore);
+  const localCoreValidated = localCoreRecord.requested === true && localCoreRecord.ok === true;
+  const ok = localCoreRequested ? localCoreValidated : true;
+  const result = {
+    version: "riddle-proof.regression-pack-run-result.v1",
+    ok,
+    local_core_validated: localCoreValidated,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    pack_path: filePath,
+    pack_id: cliString(pack.pack_id) || null,
+    public_name: cliString(pack.public_name) || null,
+    description: cliString(pack.description) || null,
+    minimum_versions: regressionPackRecord(pack.minimum_versions),
+    runtime_gate: regressionPackRecord(pack.runtime_gate),
+    forbidden_terminal_markers: regressionPackStringArray(pack.forbidden_terminal_markers),
+    local_core: localCore,
+    openclaw_live_suite: {
+      target: regressionPackRecord(liveSuite.target),
+      result_log_fields: regressionPackStringArray(liveSuite.result_log_fields),
+      case_count: liveCases.length,
+      case_ids: liveCases.map((item) => cliString(regressionPackRecord(item).id)).filter(Boolean)
+    },
+    openclaw_handoff_prompt: openClawHandoffPromptForRegressionPack(pack, { localCoreOk: localCoreValidated }),
+    output_dir: profileOutputDirOption(options) || null
+  };
+  writeRegressionPackOutput(profileOutputDirOption(options), result);
+  return result;
+}
+function writeRegressionPackRunResult(result, options) {
+  const format = regressionPackResultFormatOption(options);
+  if (format === "markdown") {
+    process.stdout.write(regressionPackRunMarkdown(result));
+    return;
+  }
+  if (format === "compact-json") {
+    process.stdout.write(`${JSON.stringify(compactRegressionPackRunResult(result), null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+}
 function previewFrameworkOption(options) {
   const framework = optionString(options, "framework") ?? "static";
   if (framework === "spa" || framework === "static") return framework;
@@ -20732,6 +21097,14 @@ async function main() {
     process.exitCode = profileStatusExitCode(profile, result.status);
     return;
   }
+  if (command === "regression-pack") {
+    const action = positional[1] || "run";
+    if (action !== "run") throw new Error("Only `regression-pack run` is supported.");
+    const result = runRegressionPackForCli(options);
+    writeRegressionPackRunResult(result, options);
+    process.exitCode = result.ok ? 0 : 1;
+    return;
+  }
   if (command === "profile-http-status-preflight") {
     const profile = normalizeProfileForCli(options);
     const result = await preflightRiddleProofProfileHttpStatusChecks(profile);

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import "./chunk-UTQJHWCQ.js";
+import "./chunk-WULFU42E.js";
 import "./chunk-PEWAIEER.js";
 import "./chunk-TWTEUS7R.js";
-import "./chunk-2DW2LBUD.js";
+import "./chunk-EMVMXVJV.js";
 import "./chunk-YZUVEJ5B.js";
 import "./chunk-FMOYUYH2.js";
-import "./chunk-FU73I4V3.js";
+import "./chunk-RF72NWHM.js";
 import "./chunk-4FOHZ7JG.js";
 import "./chunk-JFQXAJH2.js";
 import "./chunk-EEIYUZXE.js";

package/dist/engine-harness.cjs

@@ -244,6 +244,36 @@ function normalizeCaptureScript(value) {
   const script = normalizeOptionalString(value) || "";
   return script ? guardProofEvidenceGlobalAssignments(script) : "";
 }
+function compactCaptureScriptForHeuristics(script) {
+  return script.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:])\/\/.*$/gm, "$1 ").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function interactionCaptureScriptLooksPassive(script) {
+  const text = compactCaptureScriptForHeuristics(script);
+  if (!text) return true;
+  const actionPatterns = [
+    /\bpage\.(click|dblclick|tap|fill|press|type|check|uncheck|selectoption|dispatch(event)?|goto|reload)\s*\(/,
+    /\blocator\s*\([^)]*\)\s*\.\s*(click|dblclick|tap|fill|press|type|check|uncheck|selectoption|dispatch(event)?)\s*\(/,
+    /\b(getby(role|text|label|testid|placeholder|title)|getbyalttext)\s*\([^)]*\)\s*\.\s*(click|dblclick|tap|fill|press|type|check|uncheck|selectoption)\s*\(/,
+    /\bkeyboard\s*\.\s*(press|type|inserttext)\s*\(/,
+    /\bmouse\s*\.\s*(click|dblclick|down|up|move)\s*\(/,
+    /\btouchscreen\s*\.\s*tap\s*\(/
+  ];
+  if (actionPatterns.some((pattern) => pattern.test(text))) return false;
+  const evidencePatterns = [
+    /\breturn\s+[{[]/,
+    /\breturn\s+\w+/,
+    /__riddleproofevidence/,
+    /\bproof_evidence\b/,
+    /\brouteexpectationsource\b/,
+    /\bexpectedurl\b/,
+    /\bassertions?\b/
+  ];
+  return !evidencePatterns.some((pattern) => pattern.test(text));
+}
+function setStructuredInteractionCaptureFailure(state, summary) {
+  const existing = typeof state.structured_interaction_capture_failure_summary === "string" ? state.structured_interaction_capture_failure_summary.trim() : "";
+  if (!existing) state.structured_interaction_capture_failure_summary = summary;
+}
 function appendProofSummaryLine(state, line) {
   const text = String(line || "").trim();
   if (!text) return;
@@ -484,6 +514,9 @@ function proofAssessmentHardBlockersForState(state = {}) {
   }
   add(state?.structured_interaction_capture_failure_summary);
   add(state?.structured_interaction_failure_summary);
+  if (isInteractionVerificationMode(normalizedVerificationMode(state)) && !stateHasProofEvidence(state)) {
+    add("interaction proof evidence is required before ready_to_ship; proof_evidence_present=false");
+  }
   const mergeRecommendation = String(state?.merge_recommendation || "").trim();
   if (mergeRecommendation === "do-not-merge" && blockers.length) {
     add("merge_recommendation=do-not-merge because the proof bundle contains hard blockers.");
@@ -519,7 +552,22 @@ function stateHasAfterEvidence(state = {}) {
   const observation = objectValue(after.observation);
   const supporting = objectValue(after.supporting_artifacts);
   return Boolean(
-    observation.valid === true && (supporting.has_structured_payload === true || supporting.proof_evidence_present === true || observation.telemetry_ready === true || Object.keys(objectValue(bundle.proof_evidence)).length > 0 || Object.keys(objectValue(after.proof_evidence)).length > 0)
+    observation.valid === true && (supporting.has_structured_payload === true || stateHasProofEvidence(state) || observation.telemetry_ready === true)
+  );
+}
+function stateHasProofEvidence(state = {}) {
+  if (state?.proof_evidence_present === true) return true;
+  if (state?.proof_evidence !== void 0 && state?.proof_evidence !== null) {
+    if (typeof state.proof_evidence !== "object") return true;
+    if (Object.keys(objectValue(state.proof_evidence)).length > 0) return true;
+  }
+  const bundle = objectValue(state?.evidence_bundle);
+  const after = objectValue(bundle.after);
+  const supporting = objectValue(after.supporting_artifacts);
+  const request = objectValue(state?.proof_assessment_request);
+  const structuredEvidence = objectValue(request.structured_evidence);
+  return Boolean(
+    supporting.proof_evidence_present === true || structuredEvidence.proof_evidence_present === true || Object.keys(objectValue(bundle.proof_evidence)).length > 0 || Object.keys(objectValue(after.proof_evidence)).length > 0
   );
 }
 function validateShipGate(state = {}) {
@@ -725,6 +773,11 @@ function mergeStateFromParams(statePath, params) {
       state.supervisor_author_packet = parsed;
       if (typeof parsed?.proof_plan === "string") state.proof_plan = normalizeOptionalString(parsed.proof_plan) || "";
       if (typeof parsed?.capture_script === "string") state.capture_script = normalizeCaptureScript(parsed.capture_script);
+      if (isInteractionVerificationMode(state.verification_mode) && interactionCaptureScriptLooksPassive(state.capture_script || "")) {
+        const warning = "Interaction proof capture script appears passive: it does not perform a browser interaction or return structured proof evidence.";
+        appendStateWarning(state, "author_warnings", warning);
+        setStructuredInteractionCaptureFailure(state, warning);
+      }
       if (parsed?.baseline_understanding_used && typeof parsed.baseline_understanding_used === "object") {
         state.author_baseline_understanding_used = parsed.baseline_understanding_used;
       }

package/dist/engine-harness.js

@@ -2,10 +2,10 @@ import {
   createDisabledRiddleProofAgentAdapter,
   readRiddleProofRunStatus,
   runRiddleProofEngineHarness
-} from "./chunk-2DW2LBUD.js";
+} from "./chunk-EMVMXVJV.js";
 import "./chunk-YZUVEJ5B.js";
 import "./chunk-FMOYUYH2.js";
-import "./chunk-FU73I4V3.js";
+import "./chunk-RF72NWHM.js";
 import "./chunk-4FOHZ7JG.js";
 import "./chunk-VY4Y5U57.js";
 import "./chunk-MLKGABMK.js";

package/dist/index.cjs

@@ -244,6 +244,36 @@ function normalizeCaptureScript(value) {
   const script = normalizeOptionalString(value) || "";
   return script ? guardProofEvidenceGlobalAssignments(script) : "";
 }
+function compactCaptureScriptForHeuristics(script) {
+  return script.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:])\/\/.*$/gm, "$1 ").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function interactionCaptureScriptLooksPassive(script) {
+  const text = compactCaptureScriptForHeuristics(script);
+  if (!text) return true;
+  const actionPatterns = [
+    /\bpage\.(click|dblclick|tap|fill|press|type|check|uncheck|selectoption|dispatch(event)?|goto|reload)\s*\(/,
+    /\blocator\s*\([^)]*\)\s*\.\s*(click|dblclick|tap|fill|press|type|check|uncheck|selectoption|dispatch(event)?)\s*\(/,
+    /\b(getby(role|text|label|testid|placeholder|title)|getbyalttext)\s*\([^)]*\)\s*\.\s*(click|dblclick|tap|fill|press|type|check|uncheck|selectoption)\s*\(/,
+    /\bkeyboard\s*\.\s*(press|type|inserttext)\s*\(/,
+    /\bmouse\s*\.\s*(click|dblclick|down|up|move)\s*\(/,
+    /\btouchscreen\s*\.\s*tap\s*\(/
+  ];
+  if (actionPatterns.some((pattern) => pattern.test(text))) return false;
+  const evidencePatterns = [
+    /\breturn\s+[{[]/,
+    /\breturn\s+\w+/,
+    /__riddleproofevidence/,
+    /\bproof_evidence\b/,
+    /\brouteexpectationsource\b/,
+    /\bexpectedurl\b/,
+    /\bassertions?\b/
+  ];
+  return !evidencePatterns.some((pattern) => pattern.test(text));
+}
+function setStructuredInteractionCaptureFailure(state, summary) {
+  const existing = typeof state.structured_interaction_capture_failure_summary === "string" ? state.structured_interaction_capture_failure_summary.trim() : "";
+  if (!existing) state.structured_interaction_capture_failure_summary = summary;
+}
 function appendProofSummaryLine(state, line) {
   const text = String(line || "").trim();
   if (!text) return;
@@ -484,6 +514,9 @@ function proofAssessmentHardBlockersForState(state = {}) {
   }
   add(state?.structured_interaction_capture_failure_summary);
   add(state?.structured_interaction_failure_summary);
+  if (isInteractionVerificationMode(normalizedVerificationMode(state)) && !stateHasProofEvidence(state)) {
+    add("interaction proof evidence is required before ready_to_ship; proof_evidence_present=false");
+  }
   const mergeRecommendation = String(state?.merge_recommendation || "").trim();
   if (mergeRecommendation === "do-not-merge" && blockers.length) {
     add("merge_recommendation=do-not-merge because the proof bundle contains hard blockers.");
@@ -519,7 +552,22 @@ function stateHasAfterEvidence(state = {}) {
   const observation = objectValue(after.observation);
   const supporting = objectValue(after.supporting_artifacts);
   return Boolean(
-    observation.valid === true && (supporting.has_structured_payload === true || supporting.proof_evidence_present === true || observation.telemetry_ready === true || Object.keys(objectValue(bundle.proof_evidence)).length > 0 || Object.keys(objectValue(after.proof_evidence)).length > 0)
+    observation.valid === true && (supporting.has_structured_payload === true || stateHasProofEvidence(state) || observation.telemetry_ready === true)
+  );
+}
+function stateHasProofEvidence(state = {}) {
+  if (state?.proof_evidence_present === true) return true;
+  if (state?.proof_evidence !== void 0 && state?.proof_evidence !== null) {
+    if (typeof state.proof_evidence !== "object") return true;
+    if (Object.keys(objectValue(state.proof_evidence)).length > 0) return true;
+  }
+  const bundle = objectValue(state?.evidence_bundle);
+  const after = objectValue(bundle.after);
+  const supporting = objectValue(after.supporting_artifacts);
+  const request = objectValue(state?.proof_assessment_request);
+  const structuredEvidence = objectValue(request.structured_evidence);
+  return Boolean(
+    supporting.proof_evidence_present === true || structuredEvidence.proof_evidence_present === true || Object.keys(objectValue(bundle.proof_evidence)).length > 0 || Object.keys(objectValue(after.proof_evidence)).length > 0
   );
 }
 function validateShipGate(state = {}) {
@@ -725,6 +773,11 @@ function mergeStateFromParams(statePath, params) {
       state.supervisor_author_packet = parsed;
       if (typeof parsed?.proof_plan === "string") state.proof_plan = normalizeOptionalString(parsed.proof_plan) || "";
       if (typeof parsed?.capture_script === "string") state.capture_script = normalizeCaptureScript(parsed.capture_script);
+      if (isInteractionVerificationMode(state.verification_mode) && interactionCaptureScriptLooksPassive(state.capture_script || "")) {
+        const warning = "Interaction proof capture script appears passive: it does not perform a browser interaction or return structured proof evidence.";
+        appendStateWarning(state, "author_warnings", warning);
+        setStructuredInteractionCaptureFailure(state, warning);
+      }
       if (parsed?.baseline_understanding_used && typeof parsed.baseline_understanding_used === "object") {
         state.author_baseline_understanding_used = parsed.baseline_understanding_used;
       }