@riddledc/riddle-proof 0.8.73 → 0.8.75

package/dist/cli.cjs

@@ -18608,6 +18608,167 @@ function suggestRiddleProofProfileChecks(input) {
   };
 }
 
+// src/change-proof.ts
+var RIDDLE_PROOF_CHANGE_RESULT_VERSION = "riddle-proof.change-result.v1";
+var DEFAULT_BEFORE_STATUSES = ["passed", "product_regression"];
+var DEFAULT_AFTER_STATUSES = ["passed"];
+var DEFAULT_PROFILE_STATUS_TRANSITION_BEFORE = ["product_regression"];
+var DEFAULT_PROFILE_STATUS_TRANSITION_AFTER = ["passed"];
+var DEFAULT_CHECK_STATUS_TRANSITION_BEFORE = ["failed"];
+var DEFAULT_CHECK_STATUS_TRANSITION_AFTER = ["passed"];
+function listValue(value, fallback) {
+  if (Array.isArray(value)) return value;
+  if (value === void 0) return fallback;
+  return [value];
+}
+function includesValue(allowed, observed) {
+  return observed !== void 0 && allowed.includes(observed);
+}
+function groupResult(side, contract, result) {
+  const fallback = side === "before" ? DEFAULT_BEFORE_STATUSES : DEFAULT_AFTER_STATUSES;
+  const requiredStatus = listValue(contract?.required_status, fallback);
+  const label = contract?.label || side;
+  if (!result) {
+    return {
+      side,
+      label,
+      ok: false,
+      status: "missing",
+      required_status: requiredStatus,
+      message: `${label} profile result is missing.`
+    };
+  }
+  const ok = includesValue(requiredStatus, result.status);
+  return {
+    side,
+    label,
+    ok,
+    profile_name: result.profile_name,
+    status: result.status,
+    required_status: requiredStatus,
+    summary: result.summary,
+    message: ok ? void 0 : `${label} profile status ${result.status} did not match required status ${requiredStatus.join(", ")}.`
+  };
+}
+function findCheck(result, delta) {
+  return result.checks.find((check) => {
+    if (delta.check_label && check.label !== delta.check_label) return false;
+    if (delta.check_type && check.type !== delta.check_type) return false;
+    return Boolean(delta.check_label || delta.check_type);
+  });
+}
+function profileStatusTransitionResult(delta, before, after) {
+  const label = delta.label || "profile-status-transition";
+  if (!before || !after) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: before?.status,
+      after_observed: after?.status,
+      message: `${label} needs both before and after profile results.`
+    };
+  }
+  const beforeAllowed = listValue(delta.before_status, DEFAULT_PROFILE_STATUS_TRANSITION_BEFORE);
+  const afterAllowed = listValue(delta.after_status, DEFAULT_PROFILE_STATUS_TRANSITION_AFTER);
+  const passed = includesValue(beforeAllowed, before.status) && includesValue(afterAllowed, after.status);
+  return {
+    type: delta.type,
+    label,
+    status: passed ? "passed" : "failed",
+    before_observed: before.status,
+    after_observed: after.status,
+    message: passed ? void 0 : `${label} expected before ${beforeAllowed.join(", ")} and after ${afterAllowed.join(", ")}, got ${before.status} -> ${after.status}.`
+  };
+}
+function checkStatusTransitionResult(delta, before, after) {
+  const label = delta.label || delta.check_label || delta.check_type || "check-status-transition";
+  if (!delta.check_label && !delta.check_type) {
+    return {
+      type: delta.type,
+      label,
+      status: "configuration_error",
+      message: `${label} needs check_label or check_type.`
+    };
+  }
+  if (!before || !after) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: before?.status,
+      after_observed: after?.status,
+      message: `${label} needs both before and after profile results.`
+    };
+  }
+  const beforeCheck = findCheck(before, delta);
+  const afterCheck = findCheck(after, delta);
+  if (!beforeCheck || !afterCheck) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: beforeCheck?.status,
+      after_observed: afterCheck?.status,
+      message: `${label} was not present in ${!beforeCheck && !afterCheck ? "before or after" : !beforeCheck ? "before" : "after"} profile checks.`
+    };
+  }
+  const beforeAllowed = listValue(delta.before_status, DEFAULT_CHECK_STATUS_TRANSITION_BEFORE);
+  const afterAllowed = listValue(delta.after_status, DEFAULT_CHECK_STATUS_TRANSITION_AFTER);
+  const passed = includesValue(beforeAllowed, beforeCheck.status) && includesValue(afterAllowed, afterCheck.status);
+  return {
+    type: delta.type,
+    label,
+    status: passed ? "passed" : "failed",
+    before_observed: beforeCheck.status,
+    after_observed: afterCheck.status,
+    message: passed ? void 0 : `${label} expected before ${beforeAllowed.join(", ")} and after ${afterAllowed.join(", ")}, got ${beforeCheck.status} -> ${afterCheck.status}.`
+  };
+}
+function assessDelta(delta, before, after) {
+  if (delta.type === "profile_status_transition") {
+    return profileStatusTransitionResult(delta, before, after);
+  }
+  return checkStatusTransitionResult(delta, before, after);
+}
+function collapsedChangeStatus(groups, deltas) {
+  const groupResults = [groups.before, groups.after];
+  if (groupResults.some((group) => group.status === "environment_blocked")) return "environment_blocked";
+  if (groupResults.some((group) => group.status === "configuration_error")) return "configuration_error";
+  if (deltas.some((delta) => delta.status === "configuration_error")) return "configuration_error";
+  if (groupResults.some((group) => group.status === "needs_human_review")) return "needs_human_review";
+  if (groupResults.some((group) => group.status === "missing" || group.status === "proof_insufficient")) return "proof_insufficient";
+  if (!deltas.length || deltas.some((delta) => delta.status === "proof_insufficient")) return "proof_insufficient";
+  if (groupResults.some((group) => !group.ok)) return "product_regression";
+  if (deltas.some((delta) => delta.status === "failed")) return "product_regression";
+  return "passed";
+}
+function changeSummary(name, status, deltas) {
+  if (status === "passed") return `${name} passed ${deltas.length} change delta(s).`;
+  if (status === "environment_blocked") return `${name} could not compare reliable evidence because an environment was blocked.`;
+  if (status === "configuration_error") return `${name} has an invalid change proof contract.`;
+  if (status === "needs_human_review") return `${name} needs human review before the change proof can pass.`;
+  if (status === "proof_insufficient") return `${name} did not produce enough before/after evidence for a change proof.`;
+  return `${name} failed ${deltas.filter((delta) => delta.status === "failed").length} change delta(s).`;
+}
+function assessRiddleProofChange(contract, input) {
+  const groups = {
+    before: groupResult("before", contract.before, input.before_result),
+    after: groupResult("after", contract.after, input.after_result)
+  };
+  const deltas = (contract.deltas || []).map((delta) => assessDelta(delta, input.before_result, input.after_result));
+  const status = collapsedChangeStatus(groups, deltas);
+  return {
+    version: RIDDLE_PROOF_CHANGE_RESULT_VERSION,
+    contract_name: contract.name,
+    status,
+    groups,
+    deltas,
+    summary: changeSummary(contract.name, status, deltas),
+    metadata: contract.metadata
+  };
+}
+
 // src/cli.ts
 var RIDDLE_PROFILE_BALANCE_PREFLIGHT_MIN_SECONDS_PER_JOB = 30;
 var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
@@ -18619,8 +18780,13 @@ var KNOWN_CLI_OPTIONS = /* @__PURE__ */ new Set([
   "attempts",
   "balancePreflight",
   "baseUrl",
+  "afterResult",
+  "afterUrl",
+  "beforeResult",
+  "beforeUrl",
   "candidateJson",
   "candidatesJson",
+  "changeContract",
   "checkpointMode",
   "checkpointVisibility",
   "changedFiles",
@@ -18727,6 +18893,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 run-change-proof --profile <file|json|-> --change-contract <file|json|-> (--before-url <url> --after-url <url> | --before-result <file> --after-result <file>) [--viewport-name <name[,name...]>] [--output <dir>|--output-dir <dir>] [--result-format json|compact-json|summary|none; default json]",
     "  riddle-proof-loop profile-suggest --route /path|--url <url> [--changed-files a,b] [--selectors .a,.b] [--changed-text-json <file|json|->] [--format json|profile]",
     "  riddle-proof-loop regression-pack run [--pack oc-flow-regression|--pack-file <file>] [--local-core true|false; default true] [--hosted-riddle true|false; default false] [--format json|markdown|compact-json; default json] [--output <dir>|--output-dir <dir>]",
     "  riddle-proof-loop pr-comment --proof-dir <dir>|--run-response <file> [--result-json <file>] --pr <number|url> [--repo owner/name] [--dry-run] [--body-file <file>] [--comment-mode update|append]",
@@ -19792,14 +19959,19 @@ function parseProfileViewports(value) {
     };
   });
 }
-function normalizeProfileForCli(options) {
-  const rawProfile = readJsonValue(optionString(options, "profile"), "--profile");
+function readProfileRecordForCli(options) {
+  return readJsonValue(optionString(options, "profile"), "--profile");
+}
+function normalizeProfileRecordForCli(rawProfile, options) {
   return normalizeRiddleProofProfile(rawProfile, {
     url: optionString(options, "url") ?? optionString(options, "baseUrl"),
     route: optionString(options, "route"),
     viewports: parseProfileViewports(optionString(options, "viewports") || optionString(options, "viewport"))
   });
 }
+function normalizeProfileForCli(options) {
+  return normalizeProfileRecordForCli(readProfileRecordForCli(options), options);
+}
 function profileHttpStatusPreflightSummary(result) {
   const lines = [
     result.summary,
@@ -22471,6 +22643,136 @@ function writeProfileOutput(outputDir, result) {
   if (result.evidence?.dom_summary) (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "dom-summary.json"), `${JSON.stringify(result.evidence.dom_summary, null, 2)}
 `);
 }
+function readChangeContractForCli(options) {
+  const parsed = readJsonValue(optionString(options, "changeContract"), "--change-contract");
+  if (parsed.version !== void 0 && parsed.version !== "riddle-proof.change-contract.v1") {
+    throw new Error(`Unsupported change contract version ${parsed.version}. Expected riddle-proof.change-contract.v1.`);
+  }
+  if (typeof parsed.name !== "string" || !parsed.name.trim()) {
+    throw new Error("--change-contract must include a non-empty name.");
+  }
+  if (!Array.isArray(parsed.deltas) || !parsed.deltas.length) {
+    throw new Error("--change-contract must include at least one delta.");
+  }
+  return parsed;
+}
+function changeProofSideOutputDir(outputDir, side) {
+  return outputDir ? import_node_path6.default.join(outputDir, side) : void 0;
+}
+function profileOptionsForChangeProofSide(options, url, outputDir) {
+  const next = {
+    ...options,
+    url,
+    baseUrl: url
+  };
+  if (outputDir) {
+    next.output = outputDir;
+    next.outputDir = outputDir;
+  } else {
+    delete next.output;
+    delete next.outputDir;
+  }
+  return next;
+}
+function compactChangeProofResult(run, options) {
+  const outputDir = profileOutputDirOption(options);
+  return {
+    version: "riddle-proof.change-compact-result.v1",
+    contract_name: run.result.contract_name,
+    profile_name: run.profile.name,
+    status: run.result.status,
+    summary: run.result.summary,
+    before: {
+      source: run.beforeSource,
+      profile_name: run.beforeResult.profile_name,
+      status: run.beforeResult.status,
+      summary: run.beforeResult.summary
+    },
+    after: {
+      source: run.afterSource,
+      profile_name: run.afterResult.profile_name,
+      status: run.afterResult.status,
+      summary: run.afterResult.summary
+    },
+    deltas: run.result.deltas.map((delta) => ({
+      type: delta.type,
+      label: delta.label,
+      status: delta.status,
+      before_observed: delta.before_observed,
+      after_observed: delta.after_observed,
+      message: delta.message
+    })),
+    metadata: run.result.metadata,
+    output_dir: outputDir,
+    output_files: outputDir ? {
+      change_proof_result: "change-proof-result.json",
+      summary: "summary.md",
+      before_profile_result: "before/profile-result.json",
+      after_profile_result: "after/profile-result.json"
+    } : void 0
+  };
+}
+function changeProofResultMarkdown(run) {
+  const lines = [
+    "# Riddle Proof Change Proof",
+    "",
+    `Contract: ${run.result.contract_name}`,
+    `Profile: ${run.profile.name}`,
+    `Status: ${run.result.status}`,
+    "",
+    run.result.summary,
+    "",
+    "## Before",
+    "",
+    `- source: ${markdownInlineCode(run.beforeSource, 160)}`,
+    `- profile: ${run.beforeResult.profile_name}`,
+    `- status: ${run.beforeResult.status}`,
+    `- summary: ${run.beforeResult.summary}`,
+    "",
+    "## After",
+    "",
+    `- source: ${markdownInlineCode(run.afterSource, 160)}`,
+    `- profile: ${run.afterResult.profile_name}`,
+    `- status: ${run.afterResult.status}`,
+    `- summary: ${run.afterResult.summary}`,
+    "",
+    "## Deltas",
+    ""
+  ];
+  for (const delta of run.result.deltas) {
+    const observed = [
+      delta.before_observed !== void 0 ? `before ${markdownInlineCode(String(delta.before_observed))}` : "",
+      delta.after_observed !== void 0 ? `after ${markdownInlineCode(String(delta.after_observed))}` : ""
+    ].filter(Boolean).join(" -> ");
+    lines.push(`- ${delta.status}: ${delta.label}${observed ? ` (${observed})` : ""}${delta.message ? ` - ${delta.message}` : ""}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function writeChangeProofOutput(outputDir, run) {
+  if (!outputDir) return;
+  (0, import_node_fs6.mkdirSync)(outputDir, { recursive: true });
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "change-proof-result.json"), `${JSON.stringify(run.result, null, 2)}
+`);
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "summary.md"), changeProofResultMarkdown(run));
+  writeProfileOutput(changeProofSideOutputDir(outputDir, "before"), run.beforeResult);
+  writeProfileOutput(changeProofSideOutputDir(outputDir, "after"), run.afterResult);
+}
+function writeRunChangeProofResult(run, options) {
+  const format = runProfileResultFormatOption(options);
+  if (format === "none") return;
+  if (format === "summary") {
+    process.stdout.write(changeProofResultMarkdown(run));
+    return;
+  }
+  if (format === "compact-json") {
+    process.stdout.write(`${JSON.stringify(compactChangeProofResult(run, options), null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(run.result, null, 2)}
+`);
+}
 function writeRiddleJobReceipt(outputDir, input) {
   if (!outputDir) return;
   (0, import_node_fs6.mkdirSync)(outputDir, { recursive: true });
@@ -22776,13 +23078,16 @@ function runProfileAggregateInputPathsOption(options) {
   }
   return uniquePaths;
 }
-function readProfileResultForAggregate(resultPath) {
-  const parsed = readJsonValue(resultPath, resultPath);
+function readProfileResultForCli(resultPath, label = resultPath) {
+  const parsed = readJsonValue(resultPath, label);
   if (parsed.version !== "riddle-proof.profile-result.v1" || !Array.isArray(parsed.checks)) {
-    throw new Error(`Profile aggregate input is not a riddle-proof.profile-result.v1 result: ${resultPath}`);
+    throw new Error(`${label} is not a riddle-proof.profile-result.v1 result: ${resultPath}`);
   }
   return parsed;
 }
+function readProfileResultForAggregate(resultPath) {
+  return readProfileResultForCli(resultPath, resultPath);
+}
 function profileResultIsAggregateParent(result) {
   const mode = cliString(cliRecord(result.riddle)?.mode);
   return (mode === "split-viewports" || mode === "named-viewport-aggregate") && (result.evidence?.viewports?.length || 0) > 1;
@@ -23313,6 +23618,58 @@ async function runProfileForCli(profile, options) {
   }
   return runSingleRiddleProfileForCli(profile, options, { client, runner, outputDir: profileOutputDirOption(options) });
 }
+async function runChangeProofForCli(rawProfile, options) {
+  const contract = readChangeContractForCli(options);
+  const beforeResultPath = optionString(options, "beforeResult");
+  const afterResultPath = optionString(options, "afterResult");
+  const beforeUrl = optionString(options, "beforeUrl");
+  const afterUrl = optionString(options, "afterUrl");
+  const hasResultInputs = Boolean(beforeResultPath || afterResultPath);
+  const hasUrlInputs = Boolean(beforeUrl || afterUrl);
+  if (hasResultInputs && hasUrlInputs) {
+    throw new Error("run-change-proof accepts either --before-result/--after-result or --before-url/--after-url, not both.");
+  }
+  if (hasResultInputs && (!beforeResultPath || !afterResultPath)) {
+    throw new Error("run-change-proof requires both --before-result and --after-result.");
+  }
+  if (!hasResultInputs && (!beforeUrl || !afterUrl)) {
+    throw new Error("run-change-proof requires both --before-url and --after-url unless saved results are provided.");
+  }
+  const outputDir = profileOutputDirOption(options);
+  let profile;
+  let beforeResult;
+  let afterResult;
+  let beforeSource;
+  let afterSource;
+  if (hasResultInputs) {
+    if (!beforeResultPath || !afterResultPath) {
+      throw new Error("run-change-proof requires both --before-result and --after-result.");
+    }
+    profile = profileWithSelectedViewportNamesForCli(normalizeProfileRecordForCli(rawProfile, options), options);
+    beforeResult = readProfileResultForCli(beforeResultPath, "--before-result");
+    afterResult = readProfileResultForCli(afterResultPath, "--after-result");
+    beforeSource = beforeResultPath;
+    afterSource = afterResultPath;
+  } else {
+    if (!beforeUrl || !afterUrl) {
+      throw new Error("run-change-proof requires both --before-url and --after-url unless saved results are provided.");
+    }
+    const beforeOptions = profileOptionsForChangeProofSide(options, beforeUrl, changeProofSideOutputDir(outputDir, "before"));
+    const afterOptions = profileOptionsForChangeProofSide(options, afterUrl, changeProofSideOutputDir(outputDir, "after"));
+    const beforeProfile = profileWithSelectedViewportNamesForCli(normalizeProfileRecordForCli(rawProfile, beforeOptions), beforeOptions);
+    const afterProfile = profileWithSelectedViewportNamesForCli(normalizeProfileRecordForCli(rawProfile, afterOptions), afterOptions);
+    profile = beforeProfile;
+    beforeResult = await runProfileForCli(beforeProfile, beforeOptions);
+    afterResult = await runProfileForCli(afterProfile, afterOptions);
+    beforeSource = beforeUrl;
+    afterSource = afterUrl;
+  }
+  const result = assessRiddleProofChange(contract, {
+    before_result: beforeResult,
+    after_result: afterResult
+  });
+  return { profile, contract, beforeResult, afterResult, result, beforeSource, afterSource };
+}
 function requestForRun(options) {
   const statePath = optionString(options, "statePath");
   const withEngineModuleUrl = (request) => {
@@ -23373,6 +23730,13 @@ async function main() {
     process.exitCode = profileStatusExitCode(profile, result.status);
     return;
   }
+  if (command === "run-change-proof") {
+    const run = await runChangeProofForCli(readProfileRecordForCli(options), options);
+    writeChangeProofOutput(profileOutputDirOption(options), run);
+    writeRunChangeProofResult(run, options);
+    process.exitCode = run.result.status === "passed" ? 0 : 1;
+    return;
+  }
   if (command === "regression-pack") {
     const action = positional[1] || "run";
     if (action !== "run") throw new Error("Only `regression-pack run` is supported.");

package/dist/cli.js

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
-import "./chunk-ICIJTEHD.js";
+import "./chunk-AK2EPEVO.js";
 import "./chunk-B2DP2LET.js";
+import "./chunk-JFQXAJH2.js";
 import "./chunk-CWRIXP5H.js";
 import "./chunk-UE4I7RTI.js";
 import "./chunk-GG2D3MFZ.js";
+import "./chunk-6S7DZWVC.js";
+import "./chunk-KXLEN4SA.js";
 import "./chunk-WLUMLHII.js";
 import "./chunk-CGJX7LJO.js";
 import "./chunk-UTCL7FEZ.js";
 import "./chunk-EKZXU6MU.js";
 import "./chunk-DYE3URAQ.js";
-import "./chunk-JFQXAJH2.js";
-import "./chunk-KXLEN4SA.js";
 import "./chunk-NKHZASNQ.js";
 import "./chunk-ZAR7BWMN.js";
 import "./chunk-MLKGABMK.js";

package/dist/index.cjs

@@ -3418,6 +3418,8 @@ __export(index_exports, {
   RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION: () => RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION,
   RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION: () => RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
   RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION: () => RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+  RIDDLE_PROOF_CHANGE_CONTRACT_VERSION: () => RIDDLE_PROOF_CHANGE_CONTRACT_VERSION,
+  RIDDLE_PROOF_CHANGE_RESULT_VERSION: () => RIDDLE_PROOF_CHANGE_RESULT_VERSION,
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION: () => RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION: () => RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   RIDDLE_PROOF_HOSTED_PROFILE_ARTIFACTS: () => RIDDLE_PROOF_HOSTED_PROFILE_ARTIFACTS,
@@ -3450,6 +3452,7 @@ __export(index_exports, {
   assessBasicGameplayProgressionChecks: () => assessBasicGameplayProgressionChecks,
   assessBasicGameplayRoute: () => assessBasicGameplayRoute,
   assessPlayabilityEvidence: () => assessPlayabilityEvidence,
+  assessRiddleProofChange: () => assessRiddleProofChange,
   assessRiddleProofProfileArtifactCompleteness: () => assessRiddleProofProfileArtifactCompleteness,
   assessRiddleProofProfileEvidence: () => assessRiddleProofProfileEvidence,
   attachBasicGameplayArtifactScreenshotHashes: () => attachBasicGameplayArtifactScreenshotHashes,
@@ -19929,6 +19932,168 @@ function suggestRiddleProofProfileChecks(input) {
   };
 }
 
+// src/change-proof.ts
+var RIDDLE_PROOF_CHANGE_CONTRACT_VERSION = "riddle-proof.change-contract.v1";
+var RIDDLE_PROOF_CHANGE_RESULT_VERSION = "riddle-proof.change-result.v1";
+var DEFAULT_BEFORE_STATUSES = ["passed", "product_regression"];
+var DEFAULT_AFTER_STATUSES = ["passed"];
+var DEFAULT_PROFILE_STATUS_TRANSITION_BEFORE = ["product_regression"];
+var DEFAULT_PROFILE_STATUS_TRANSITION_AFTER = ["passed"];
+var DEFAULT_CHECK_STATUS_TRANSITION_BEFORE = ["failed"];
+var DEFAULT_CHECK_STATUS_TRANSITION_AFTER = ["passed"];
+function listValue3(value, fallback) {
+  if (Array.isArray(value)) return value;
+  if (value === void 0) return fallback;
+  return [value];
+}
+function includesValue(allowed, observed) {
+  return observed !== void 0 && allowed.includes(observed);
+}
+function groupResult(side, contract, result) {
+  const fallback = side === "before" ? DEFAULT_BEFORE_STATUSES : DEFAULT_AFTER_STATUSES;
+  const requiredStatus = listValue3(contract?.required_status, fallback);
+  const label = contract?.label || side;
+  if (!result) {
+    return {
+      side,
+      label,
+      ok: false,
+      status: "missing",
+      required_status: requiredStatus,
+      message: `${label} profile result is missing.`
+    };
+  }
+  const ok = includesValue(requiredStatus, result.status);
+  return {
+    side,
+    label,
+    ok,
+    profile_name: result.profile_name,
+    status: result.status,
+    required_status: requiredStatus,
+    summary: result.summary,
+    message: ok ? void 0 : `${label} profile status ${result.status} did not match required status ${requiredStatus.join(", ")}.`
+  };
+}
+function findCheck(result, delta) {
+  return result.checks.find((check) => {
+    if (delta.check_label && check.label !== delta.check_label) return false;
+    if (delta.check_type && check.type !== delta.check_type) return false;
+    return Boolean(delta.check_label || delta.check_type);
+  });
+}
+function profileStatusTransitionResult(delta, before, after) {
+  const label = delta.label || "profile-status-transition";
+  if (!before || !after) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: before?.status,
+      after_observed: after?.status,
+      message: `${label} needs both before and after profile results.`
+    };
+  }
+  const beforeAllowed = listValue3(delta.before_status, DEFAULT_PROFILE_STATUS_TRANSITION_BEFORE);
+  const afterAllowed = listValue3(delta.after_status, DEFAULT_PROFILE_STATUS_TRANSITION_AFTER);
+  const passed = includesValue(beforeAllowed, before.status) && includesValue(afterAllowed, after.status);
+  return {
+    type: delta.type,
+    label,
+    status: passed ? "passed" : "failed",
+    before_observed: before.status,
+    after_observed: after.status,
+    message: passed ? void 0 : `${label} expected before ${beforeAllowed.join(", ")} and after ${afterAllowed.join(", ")}, got ${before.status} -> ${after.status}.`
+  };
+}
+function checkStatusTransitionResult(delta, before, after) {
+  const label = delta.label || delta.check_label || delta.check_type || "check-status-transition";
+  if (!delta.check_label && !delta.check_type) {
+    return {
+      type: delta.type,
+      label,
+      status: "configuration_error",
+      message: `${label} needs check_label or check_type.`
+    };
+  }
+  if (!before || !after) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: before?.status,
+      after_observed: after?.status,
+      message: `${label} needs both before and after profile results.`
+    };
+  }
+  const beforeCheck = findCheck(before, delta);
+  const afterCheck = findCheck(after, delta);
+  if (!beforeCheck || !afterCheck) {
+    return {
+      type: delta.type,
+      label,
+      status: "proof_insufficient",
+      before_observed: beforeCheck?.status,
+      after_observed: afterCheck?.status,
+      message: `${label} was not present in ${!beforeCheck && !afterCheck ? "before or after" : !beforeCheck ? "before" : "after"} profile checks.`
+    };
+  }
+  const beforeAllowed = listValue3(delta.before_status, DEFAULT_CHECK_STATUS_TRANSITION_BEFORE);
+  const afterAllowed = listValue3(delta.after_status, DEFAULT_CHECK_STATUS_TRANSITION_AFTER);
+  const passed = includesValue(beforeAllowed, beforeCheck.status) && includesValue(afterAllowed, afterCheck.status);
+  return {
+    type: delta.type,
+    label,
+    status: passed ? "passed" : "failed",
+    before_observed: beforeCheck.status,
+    after_observed: afterCheck.status,
+    message: passed ? void 0 : `${label} expected before ${beforeAllowed.join(", ")} and after ${afterAllowed.join(", ")}, got ${beforeCheck.status} -> ${afterCheck.status}.`
+  };
+}
+function assessDelta(delta, before, after) {
+  if (delta.type === "profile_status_transition") {
+    return profileStatusTransitionResult(delta, before, after);
+  }
+  return checkStatusTransitionResult(delta, before, after);
+}
+function collapsedChangeStatus(groups, deltas) {
+  const groupResults = [groups.before, groups.after];
+  if (groupResults.some((group) => group.status === "environment_blocked")) return "environment_blocked";
+  if (groupResults.some((group) => group.status === "configuration_error")) return "configuration_error";
+  if (deltas.some((delta) => delta.status === "configuration_error")) return "configuration_error";
+  if (groupResults.some((group) => group.status === "needs_human_review")) return "needs_human_review";
+  if (groupResults.some((group) => group.status === "missing" || group.status === "proof_insufficient")) return "proof_insufficient";
+  if (!deltas.length || deltas.some((delta) => delta.status === "proof_insufficient")) return "proof_insufficient";
+  if (groupResults.some((group) => !group.ok)) return "product_regression";
+  if (deltas.some((delta) => delta.status === "failed")) return "product_regression";
+  return "passed";
+}
+function changeSummary(name, status, deltas) {
+  if (status === "passed") return `${name} passed ${deltas.length} change delta(s).`;
+  if (status === "environment_blocked") return `${name} could not compare reliable evidence because an environment was blocked.`;
+  if (status === "configuration_error") return `${name} has an invalid change proof contract.`;
+  if (status === "needs_human_review") return `${name} needs human review before the change proof can pass.`;
+  if (status === "proof_insufficient") return `${name} did not produce enough before/after evidence for a change proof.`;
+  return `${name} failed ${deltas.filter((delta) => delta.status === "failed").length} change delta(s).`;
+}
+function assessRiddleProofChange(contract, input) {
+  const groups = {
+    before: groupResult("before", contract.before, input.before_result),
+    after: groupResult("after", contract.after, input.after_result)
+  };
+  const deltas = (contract.deltas || []).map((delta) => assessDelta(delta, input.before_result, input.after_result));
+  const status = collapsedChangeStatus(groups, deltas);
+  return {
+    version: RIDDLE_PROOF_CHANGE_RESULT_VERSION,
+    contract_name: contract.name,
+    status,
+    groups,
+    deltas,
+    summary: changeSummary(contract.name, status, deltas),
+    metadata: contract.metadata
+  };
+}
+
 // src/riddle-client.ts
 var import_node_child_process4 = require("child_process");
 var import_node_fs5 = require("fs");
@@ -20903,6 +21068,8 @@ function buildRiddleProofPrCommentMarkdown(input) {
   RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION,
   RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION,
   RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION,
+  RIDDLE_PROOF_CHANGE_CONTRACT_VERSION,
+  RIDDLE_PROOF_CHANGE_RESULT_VERSION,
   RIDDLE_PROOF_CHECKPOINT_PACKET_VERSION,
   RIDDLE_PROOF_CHECKPOINT_RESPONSE_VERSION,
   RIDDLE_PROOF_HOSTED_PROFILE_ARTIFACTS,
@@ -20935,6 +21102,7 @@ function buildRiddleProofPrCommentMarkdown(input) {
   assessBasicGameplayProgressionChecks,
   assessBasicGameplayRoute,
   assessPlayabilityEvidence,
+  assessRiddleProofChange,
   assessRiddleProofProfileArtifactCompleteness,
   assessRiddleProofProfileEvidence,
   attachBasicGameplayArtifactScreenshotHashes,