@riddledc/riddle-proof 0.6.0 → 0.7.1

package/dist/cli.cjs

@@ -31,6 +31,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/proof-run-core.ts
+function normalizedMode(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function previewModeFromWorkflowMode(value) {
+  const mode = normalizedMode(value);
+  return mode === "server" || mode === "static" ? mode : void 0;
+}
+function noImplementationModeInput(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function noImplementationModeFor(params, state) {
+  const input = noImplementationModeInput(params);
+  const stateInput = noImplementationModeInput(state);
+  const mode = normalizedMode(input.mode ?? input.workflow_mode ?? stateInput.mode ?? stateInput.workflow_mode);
+  const implementationMode = normalizedMode(input.implementation_mode ?? stateInput.implementation_mode);
+  const requireDiff = input.require_diff ?? stateInput.require_diff;
+  const allowCodeChanges = input.allow_code_changes ?? stateInput.allow_code_changes;
+  return mode === "audit" || mode === "profile" || implementationMode === "none" || requireDiff === false || allowCodeChanges === false;
+}
 function currentDistDir() {
   const meta = typeof import_meta === "object" ? import_meta : {};
   if (typeof meta.url === "string" && meta.url) {
@@ -114,7 +133,7 @@ function buildSetupArgs(params, config) {
     allow_static_preview_fallback: params.allow_static_preview_fallback ? "true" : "",
     context: params.context || "",
     reviewer: params.reviewer || config.defaultReviewer,
-    mode: params.mode || "",
+    mode: previewModeFromWorkflowMode(params.mode) || "",
     build_command: params.build_command || "npm run build",
     build_output: params.build_output || "build",
     server_image: params.server_image || "node:20-slim",
@@ -539,7 +558,8 @@ function mergeStateFromParams(statePath, params) {
     "auth_cookies_json",
     "auth_headers_json",
     "proof_plan",
-    "implementation_notes"
+    "implementation_notes",
+    "implementation_mode"
   ];
   for (const field of stringFields) {
     if (params[field] !== void 0) {
@@ -554,7 +574,17 @@ function mergeStateFromParams(statePath, params) {
     if (issues.length) state.implementation_environment_issues = issues;
   }
   if (params.reference !== void 0) state.reference = params.reference;
-  if (params.mode !== void 0) state.mode = params.mode;
+  if (params.mode !== void 0) {
+    const previewMode = previewModeFromWorkflowMode(params.mode);
+    if (previewMode) {
+      state.mode = previewMode;
+    } else {
+      state.workflow_mode = normalizeOptionalString(params.mode);
+    }
+  }
+  if (params.implementation_mode !== void 0) state.implementation_mode = normalizeOptionalString(params.implementation_mode);
+  if (params.require_diff !== void 0) state.require_diff = params.require_diff;
+  if (params.allow_code_changes !== void 0) state.allow_code_changes = params.allow_code_changes;
   if (params.allow_static_preview_fallback !== void 0) {
     state.allow_static_preview_fallback = params.allow_static_preview_fallback;
   }
@@ -699,6 +729,11 @@ function summarizeState(state) {
     repo: state.repo || null,
     branch: state.branch || null,
     mode: state.mode || null,
+    workflow_mode: state.workflow_mode || null,
+    implementation_mode: state.implementation_mode || null,
+    require_diff: state.require_diff ?? null,
+    allow_code_changes: state.allow_code_changes ?? null,
+    no_implementation_mode: noImplementationModeFor(state),
     reference: state.reference || null,
     before_ref: state.before_ref || null,
     allow_static_preview_fallback: Boolean(state.allow_static_preview_fallback),
@@ -997,8 +1032,11 @@ function authorReady(state) {
 function implementationReady(state) {
   return ["changes_detected", "completed"].includes(state?.implementation_status || "");
 }
-function stageAfterAuthor(state) {
-  return implementationReady(state) ? "verify" : "implement";
+function implementationRequired(params, state) {
+  return !noImplementationModeFor(params, state);
+}
+function stageAfterAuthor(state, params) {
+  return implementationReady(state) || !implementationRequired(params, state) ? "verify" : "implement";
 }
 function latestReconAttempt(state) {
   const history = Array.isArray(state?.recon_results?.attempt_history) ? state.recon_results.attempt_history : [];
@@ -1208,7 +1246,7 @@ function recommendedAdvanceStage(state) {
   if (!state?.workspace_ready) return "setup";
   if (!state?.recon_results || ["needs_agent_decision", "needs_supervisor_judgment"].includes(state?.recon_status || "")) return "recon";
   if (!authorReady(state)) return "author";
-  if (!implementationReady(state)) return "implement";
+  if (!implementationReady(state) && !noImplementationModeFor(state)) return "implement";
   if (state?.verify_status === "capture_incomplete") return verifyAssessment(state).continueWithStage || verifyAssessment(state).recommendedStage || "author";
   if (state?.verify_status === "evidence_captured") return verifyAssessment(state).continueWithStage || verifyAssessment(state).recommendedStage;
   if (!(state?.after_cdn || "").trim()) return "verify";
@@ -1833,6 +1871,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         checkpoint: params.advance_stage === "setup" ? "setup_review" : null,
         autoApproved: setupRes.autoApproved || false
       });
+      mergeStateFromParams(config.statePath, params);
       state = readState(config.statePath);
       if (params.advance_stage === "setup") {
         return checkpoint(
@@ -2130,7 +2169,8 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
           }
         );
       }
-      const authorNextStage = stageAfterAuthor(state);
+      const noImplementationMode = !implementationRequired(params, state);
+      const authorNextStage = stageAfterAuthor(state, params);
       const explicitAuthorDebug = params.advance_stage === "author";
       recordAttempt("author", "completed", "Author applied the supervising agent's proof packet to recon observations.", {
         autoApproved: authorRes.autoApproved || false,
@@ -2148,7 +2188,7 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
         return checkpoint(
           "author",
           "author_review",
-          authorNextStage === "verify" ? "Author applied the supervising agent's proof packet. Because implementation is already recorded, you can continue straight into verify." : "Author applied the supervising agent's proof packet. Inspect it if needed, then continue into implement.",
+          authorNextStage === "verify" ? noImplementationMode ? "Author applied the supervising agent's proof packet. Audit/no-diff mode disables implementation, so you can continue straight into verify." : "Author applied the supervising agent's proof packet. Because implementation is already recorded, you can continue straight into verify." : "Author applied the supervising agent's proof packet. Inspect it if needed, then continue into implement.",
           {
             nextActions: authorNextStage === "verify" ? ["inspect_proof_packet", "advance_run_to_verify", "rerun_author"] : ["inspect_proof_packet", "advance_run_to_implement", "rerun_author"],
             advanceOptions: authorNextStage === "verify" ? ["author", "verify", "recon"] : ["author", "implement", "recon"],
@@ -2181,13 +2221,14 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
     }
     if (!effectiveAdvanceStage) {
       const recommended = recommendedAdvanceStage(state);
+      const noImplementationMode = !implementationRequired(params, state);
       return checkpoint(
-        recommended || "implement",
+        recommended || (noImplementationMode ? "verify" : "implement"),
         "awaiting_stage_advance",
         "Proof authoring is ready. The wrapper will not guess the next stage from here, explicitly choose whether to revisit recon/author, validate implementation, capture verify evidence, or ship.",
         {
           nextActions: ["inspect_state", "set_advance_stage", "resume_run"],
-          advanceOptions: ["recon", "author", "implement", "verify", "ship"],
+          advanceOptions: noImplementationMode ? ["recon", "author", "verify", "ship"] : ["recon", "author", "implement", "verify", "ship"],
           recommendedAdvanceStage: recommended,
           details: { executed },
           executed
@@ -2195,6 +2236,26 @@ async function executeWorkflow(params, pluginConfig, resolvedConfig) {
       );
     }
     if (effectiveAdvanceStage === "implement") {
+      if (!implementationRequired(params, state)) {
+        recordAttempt("implement", "checkpoint", "Implementation stage was skipped because audit/no-diff mode disables code changes.", {
+          checkpoint: "implement_disabled_for_audit",
+          details: { executed }
+        });
+        return checkpoint(
+          "verify",
+          "implement_disabled_for_audit",
+          "Audit/no-diff mode disables implementation. Continue to verify against the existing target; do not launch an implementation agent or require a git diff.",
+          {
+            nextActions: ["advance_run_to_verify", "inspect_author_packet", "rerun_recon_if_target_changed"],
+            advanceOptions: ["verify", "author", "recon"],
+            recommendedAdvanceStage: "verify",
+            continueWithStage: "verify",
+            blocking: false,
+            details: { executed },
+            executed
+          }
+        );
+      }
       const implementRes = runOne("implement");
       executed.push(executedStep(implementRes));
       if (implementRes.haltedForApproval) {
@@ -2285,7 +2346,8 @@ ${implementRes.stderr || ""}`;
     }
     if (effectiveAdvanceStage === "verify") {
       state = readState(config.statePath);
-      if (!["changes_detected", "completed"].includes(state?.implementation_status || "")) {
+      const needsImplementation = implementationRequired(params, state);
+      if (needsImplementation && !implementationReady(state)) {
         return checkpoint(
           "implement",
           "implement_required",
@@ -2302,6 +2364,18 @@ ${implementRes.stderr || ""}`;
           }
         );
       }
+      if (!needsImplementation && !implementationReady(state)) {
+        recordAttempt("implement", "completed", "Implementation stage is not required for this audit/no-diff run.", {
+          checkpoint: "implementation_not_required",
+          details: { executed }
+        });
+        state = updateState(config.statePath, (currentState) => {
+          currentState.implementation_status = "not_required";
+          currentState.implementation_mode = currentState.implementation_mode || "none";
+          if (currentState.require_diff === void 0) currentState.require_diff = false;
+          if (currentState.allow_code_changes === void 0) currentState.allow_code_changes = false;
+        });
+      }
       const hasIncomingProofAssessment = typeof params.proof_assessment_json === "string" && params.proof_assessment_json.trim().length > 0;
       const canReuseVerifyEvidence = (params.advance_stage !== "verify" || hasIncomingProofAssessment) && state?.verify_status === "evidence_captured" && Boolean((state?.after_cdn || "").trim()) && (state?.active_checkpoint === "verify_supervisor_judgment" || hasSupervisorProofAssessment(state));
       let verifyRes = { ok: true, step: "verify", reusedEvidence: canReuseVerifyEvidence };
@@ -2324,8 +2398,13 @@ ${implementRes.stderr || ""}`;
       const verifySummary = state?.verify_summary || state?.proof_summary || null;
       const proofAssessment = verifyAssessment(state);
       const convergenceSignals = nonConvergenceSignals(state, proofAssessment);
-      const verifyRecommendedStage = proofAssessment.recommendedStage || null;
-      const verifyContinueWithStage = shouldEscalateVerifyToHuman(state, proofAssessment) ? null : proofAssessment.continueWithStage || verifyRecommendedStage || null;
+      const rawVerifyRecommendedStage = proofAssessment.recommendedStage || null;
+      const verifyRecommendedStage = !needsImplementation && rawVerifyRecommendedStage === "implement" ? "verify" : rawVerifyRecommendedStage;
+      const rawVerifyContinueWithStage = shouldEscalateVerifyToHuman(state, proofAssessment) ? null : proofAssessment.continueWithStage || verifyRecommendedStage || null;
+      const verifyContinueWithStage = !needsImplementation && rawVerifyContinueWithStage === "implement" ? "verify" : rawVerifyContinueWithStage;
+      const verifyLoopAdvanceOptions = needsImplementation ? ["author", "verify", "implement", "recon"] : ["author", "verify", "recon"];
+      const verifyReviewAdvanceOptions = needsImplementation ? ["verify", "author", "implement", "recon", "ship"] : ["verify", "author", "recon"];
+      const verifyRetryAdvanceOptions = needsImplementation ? ["author", "implement", "ship", "verify", "recon"] : ["author", "verify", "recon"];
       const verifyDetails = {
         executed,
         verifyStatus,
@@ -2363,7 +2442,7 @@ ${implementRes.stderr || ""}`;
           {
             ok: true,
             nextActions: ["inspect_after_capture", "continue_internal_loop_with_checkpoint", "return_to_recon_if_baseline_is_wrong"],
-            advanceOptions: ["author", "verify", "implement", "recon"],
+            advanceOptions: verifyLoopAdvanceOptions,
             recommendedAdvanceStage: verifyRecommendedStage || "author",
             continueWithStage: verifyContinueWithStage || "author",
             blocking: false,
@@ -2391,7 +2470,7 @@ ${implementRes.stderr || ""}`;
           summary,
           {
             nextActions: ["inspect_evidence", "author_proof_assessment_json", "continue_internal_loop_with_checkpoint"],
-            advanceOptions: ["verify", "author", "implement", "recon", "ship"],
+            advanceOptions: verifyReviewAdvanceOptions,
             recommendedAdvanceStage: "verify",
             continueWithStage: "verify",
             blocking: false,
@@ -2421,7 +2500,7 @@ ${implementRes.stderr || ""}`;
           {
             ok: false,
             nextActions: ["inspect_retry_history", "summarize_internal_loop", "ask_human_for_direction"],
-            advanceOptions: ["author", "implement", "ship", "verify", "recon"],
+            advanceOptions: verifyRetryAdvanceOptions,
             recommendedAdvanceStage: null,
             continueWithStage: null,
             blocking: true,
@@ -2436,7 +2515,7 @@ ${implementRes.stderr || ""}`;
           }
         );
       }
-      const shouldAutoShip = verifyContinueWithStage === "ship" && (params.ship_after_verify || params.continue_from_checkpoint || params.advance_stage !== "verify");
+      const shouldAutoShip = verifyContinueWithStage === "ship" && needsImplementation && (params.ship_after_verify || params.continue_from_checkpoint || params.advance_stage !== "verify");
       if (shouldAutoShip) {
         const shipGate = validateShipGate(state);
         if (!shipGate.ok) {
@@ -2494,6 +2573,33 @@ ${implementRes.stderr || ""}`;
         };
       }
       if (proofAssessment.decision === "ready_to_ship") {
+        if (!needsImplementation) {
+          recordAttempt("verify", "completed", "Verify captured a proof packet for audit/no-diff mode; shipping remains disabled.", {
+            autoApproved: verifyRes.autoApproved || false,
+            checkpoint: "verify_audit_complete",
+            details: verifyDetails
+          });
+          return checkpoint(
+            "verify",
+            "verify_audit_complete",
+            "The supervising agent judged the audit proof sufficient. Audit/no-diff mode disables ship, PR creation, implementation agents, and git-diff requirements.",
+            {
+              nextActions: ["inspect_evidence", "report_audit_result", "rerun_verify_if_needed"],
+              advanceOptions: ["verify", "author", "recon"],
+              recommendedAdvanceStage: "verify",
+              continueWithStage: null,
+              blocking: false,
+              details: verifyDetails,
+              verifyStatus,
+              verifySummary,
+              afterCdn: state?.after_cdn || null,
+              mergeRecommendation: state?.merge_recommendation || null,
+              verifyDecisionRequest,
+              proofAssessment: proofAssessment.raw,
+              executed
+            }
+          );
+        }
         const shipGate = validateShipGate(state);
         if (!shipGate.ok) {
           recordAttempt("verify", "checkpoint", "Verify cannot mark ship ready because the hard ship gate is missing required evidence or approval.", {
@@ -2550,8 +2656,8 @@ ${implementRes.stderr || ""}`;
         unresolvedSummary,
         {
           ok: true,
-          nextActions: convergenceSignals.warning ? ["inspect_retry_history", "decide_whether_to_keep_iterating_or_escalate", "continue_internal_loop_with_checkpoint"] : ["inspect_proof_assessment", "continue_internal_loop_with_checkpoint", "return_to_implement_if_fix_failed"],
-          advanceOptions: ["author", "implement", "ship", "verify", "recon"],
+          nextActions: convergenceSignals.warning ? ["inspect_retry_history", "decide_whether_to_keep_iterating_or_escalate", "continue_internal_loop_with_checkpoint"] : needsImplementation ? ["inspect_proof_assessment", "continue_internal_loop_with_checkpoint", "return_to_implement_if_fix_failed"] : ["inspect_proof_assessment", "continue_internal_loop_with_checkpoint", "rerun_author_if_proof_contract_is_wrong"],
+          advanceOptions: verifyRetryAdvanceOptions,
           recommendedAdvanceStage: verifyRecommendedStage,
           continueWithStage: verifyContinueWithStage,
           blocking: false,
@@ -2568,6 +2674,23 @@ ${implementRes.stderr || ""}`;
     }
     if (effectiveAdvanceStage === "ship") {
       state = readState(config.statePath);
+      if (!implementationRequired(params, state)) {
+        return checkpoint(
+          "verify",
+          "ship_disabled_for_audit",
+          "Audit/no-diff mode disables ship and PR creation. Report the audit result from verify evidence instead.",
+          {
+            ok: false,
+            nextActions: ["inspect_verify_state", "report_audit_result"],
+            advanceOptions: ["verify", "author", "recon"],
+            recommendedAdvanceStage: "verify",
+            continueWithStage: "verify",
+            blocking: true,
+            details: { executed },
+            executed
+          }
+        );
+      }
       const shipAssessment = verifyAssessment(state);
       const shipGate = validateShipGate(state);
       if (state?.verify_status !== "evidence_captured") {
@@ -2772,6 +2895,7 @@ var init_proof_run_engine = __esm({
 
 // src/cli.ts
 var import_node_fs6 = require("fs");
+var import_node_path6 = __toESM(require("path"), 1);
 
 // src/engine-harness.ts
 var import_node_child_process2 = require("child_process");
@@ -3967,6 +4091,9 @@ function normalizeRunParams(input) {
     context: input.context,
     reviewer: input.reviewer,
     mode: input.mode,
+    implementation_mode: input.implementation_mode,
+    require_diff: input.require_diff,
+    allow_code_changes: input.allow_code_changes,
     build_command: input.build_command,
     build_output: input.build_output,
     server_image: input.server_image,
@@ -4280,7 +4407,7 @@ function stageFromWorkflowParams(params) {
   if (params.ship_after_verify) return "ship";
   if (params.proof_assessment_json) return "verify";
   if (params.implementation_notes) return "verify";
-  if (params.author_packet_json) return "implement";
+  if (params.author_packet_json) return noImplementationModeFor(params) ? "verify" : "implement";
   if (params.recon_assessment_json) return "author";
   return "setup";
 }
@@ -4310,6 +4437,9 @@ function initialRunParams(request, input, state) {
     context: request.context,
     reviewer: request.reviewer,
     mode: request.mode,
+    implementation_mode: request.implementation_mode,
+    require_diff: request.require_diff,
+    allow_code_changes: request.allow_code_changes,
     build_command: request.build_command,
     build_output: request.build_output,
     server_image: request.server_image,
@@ -6631,6 +6761,778 @@ function createRiddleApiClient(config = {}) {
   };
 }
 
+// src/profile.ts
+var RIDDLE_PROOF_PROFILE_VERSION = "riddle-proof.profile.v1";
+var RIDDLE_PROOF_PROFILE_RESULT_VERSION = "riddle-proof.profile-result.v1";
+var RIDDLE_PROOF_PROFILE_STATUSES = [
+  "passed",
+  "product_regression",
+  "proof_insufficient",
+  "environment_blocked",
+  "configuration_error",
+  "needs_human_review"
+];
+var RIDDLE_PROOF_PROFILE_CHECK_TYPES = [
+  "route_loaded",
+  "selector_visible",
+  "selector_count_at_least",
+  "text_visible",
+  "text_absent",
+  "no_horizontal_overflow",
+  "no_mobile_horizontal_overflow",
+  "no_fatal_console_errors"
+];
+var DEFAULT_VIEWPORTS = [
+  { name: "desktop", width: 1280, height: 800 }
+];
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function jsonRecord(value) {
+  if (!isRecord(value)) return void 0;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toJsonValue(child)]));
+}
+function toJsonValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (Array.isArray(value)) return value.map(toJsonValue);
+  if (isRecord(value)) return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, toJsonValue(child)]));
+  return String(value);
+}
+function normalizeName(value, fallback) {
+  const name = stringValue2(value) || fallback;
+  return name.replace(/\s+/g, " ").trim();
+}
+function slugifyRiddleProofProfileName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "profile";
+}
+function normalizeViewport(input, index) {
+  if (!isRecord(input)) throw new Error(`target.viewports[${index}] must be an object.`);
+  const width = numberValue(input.width);
+  const height = numberValue(input.height);
+  if (!width || !height || width < 100 || height < 100) {
+    throw new Error(`target.viewports[${index}] requires numeric width and height >= 100.`);
+  }
+  return {
+    name: normalizeName(input.name || input.label, `viewport-${index + 1}`),
+    width: Math.round(width),
+    height: Math.round(height)
+  };
+}
+function normalizeViewports(value) {
+  if (value === void 0) return [...DEFAULT_VIEWPORTS];
+  if (!Array.isArray(value) || value.length === 0) throw new Error("target.viewports must be a non-empty array.");
+  return value.map(normalizeViewport);
+}
+function isSupportedCheckType(value) {
+  return RIDDLE_PROOF_PROFILE_CHECK_TYPES.includes(value);
+}
+function normalizeCheck(input, index) {
+  if (!isRecord(input)) throw new Error(`checks[${index}] must be an object.`);
+  const type = stringValue2(input.type);
+  if (!type) throw new Error(`checks[${index}].type is required.`);
+  if (!isSupportedCheckType(type)) {
+    throw new Error(`checks[${index}].type ${type} is not supported. Supported checks: ${RIDDLE_PROOF_PROFILE_CHECK_TYPES.join(", ")}`);
+  }
+  if ((type === "selector_visible" || type === "selector_count_at_least") && !stringValue2(input.selector)) {
+    throw new Error(`checks[${index}] ${type} requires selector.`);
+  }
+  if ((type === "text_visible" || type === "text_absent") && !stringValue2(input.text) && !stringValue2(input.pattern)) {
+    throw new Error(`checks[${index}] ${type} requires text or pattern.`);
+  }
+  if (type === "selector_count_at_least" && numberValue(input.min_count) === void 0) {
+    throw new Error(`checks[${index}] selector_count_at_least requires min_count.`);
+  }
+  return {
+    type,
+    label: stringValue2(input.label),
+    expected_path: stringValue2(input.expected_path),
+    selector: stringValue2(input.selector),
+    text: stringValue2(input.text),
+    pattern: stringValue2(input.pattern),
+    flags: stringValue2(input.flags),
+    min_count: numberValue(input.min_count),
+    max_overflow_px: numberValue(input.max_overflow_px)
+  };
+}
+function normalizeFailurePolicy(input) {
+  const defaults = {
+    product_regression: "fail",
+    proof_insufficient: "fail",
+    environment_blocked: "neutral",
+    configuration_error: "fail",
+    needs_human_review: "fail"
+  };
+  if (!isRecord(input)) return defaults;
+  const next = { ...defaults };
+  for (const [key, value] of Object.entries(input)) {
+    if (!RIDDLE_PROOF_PROFILE_STATUSES.includes(key)) continue;
+    if (value === "fail" || value === "neutral" || value === "review") {
+      next[key] = value;
+    }
+  }
+  return next;
+}
+function normalizeRiddleProofProfile(input, options = {}) {
+  if (!isRecord(input)) throw new Error("profile must be a JSON object.");
+  const version = stringValue2(input.version) || RIDDLE_PROOF_PROFILE_VERSION;
+  if (version !== RIDDLE_PROOF_PROFILE_VERSION) {
+    throw new Error(`Unsupported profile version ${version}. Expected ${RIDDLE_PROOF_PROFILE_VERSION}.`);
+  }
+  const targetInput = isRecord(input.target) ? input.target : {};
+  const checks = Array.isArray(input.checks) ? input.checks.map(normalizeCheck) : [];
+  if (!checks.length) throw new Error("profile.checks must contain at least one check.");
+  const targetUrl = stringValue2(options.url) || stringValue2(targetInput.url);
+  const route = stringValue2(options.route) || stringValue2(targetInput.route);
+  if (!targetUrl && !route) throw new Error("profile.target requires url or route, or pass --url.");
+  return {
+    version: RIDDLE_PROOF_PROFILE_VERSION,
+    name: normalizeName(input.name, "riddle-proof-profile"),
+    target: {
+      url: targetUrl,
+      route,
+      viewports: options.viewports?.length ? options.viewports : normalizeViewports(targetInput.viewports),
+      auth: stringValue2(targetInput.auth) || "none",
+      wait_for_selector: stringValue2(targetInput.wait_for_selector) || stringValue2(targetInput.waitForSelector),
+      wait_ms: numberValue(targetInput.wait_ms) ?? numberValue(targetInput.waitMs)
+    },
+    checks,
+    artifacts: Array.isArray(input.artifacts) ? input.artifacts.map((item) => String(item)).filter(Boolean) : ["screenshot", "console", "dom_summary", "proof_json"],
+    baseline_policy: stringValue2(input.baseline_policy) || stringValue2(input.baselinePolicy) || "invariant_only",
+    failure_policy: normalizeFailurePolicy(input.failure_policy || input.failurePolicy),
+    metadata: jsonRecord(input.metadata)
+  };
+}
+function resolveRiddleProofProfileTargetUrl(profile) {
+  const route = profile.target.route || "";
+  const targetUrl = profile.target.url || "";
+  if (/^https?:\/\//i.test(route)) return route;
+  if (targetUrl && route) return new URL(route, targetUrl).href;
+  if (targetUrl) return targetUrl;
+  throw new Error("profile target URL could not be resolved.");
+}
+function routeForViewport(viewport) {
+  return viewport?.route || {
+    requested: "",
+    observed: "",
+    matched: false,
+    error: "missing viewport evidence"
+  };
+}
+function checkLabel(check) {
+  return check.label || check.type;
+}
+function selectorKey(check) {
+  return check.selector || "";
+}
+function textKey(check) {
+  return check.pattern ? `pattern:${check.pattern}/${check.flags || ""}` : `text:${check.text || ""}`;
+}
+function matchText(sample, check) {
+  if (check.pattern) {
+    try {
+      return new RegExp(check.pattern, check.flags || "").test(sample);
+    } catch {
+      return false;
+    }
+  }
+  return sample.includes(check.text || "");
+}
+function successfulRoute(route) {
+  return route.matched && !route.error && (route.http_status === null || route.http_status === void 0 || route.http_status < 400);
+}
+function assessCheckFromEvidence(check, evidence) {
+  const viewports = evidence.viewports || [];
+  if (!viewports.length) {
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: "failed",
+      evidence: {},
+      message: "No viewport evidence was captured."
+    };
+  }
+  if (check.type === "route_loaded") {
+    const expectedPath = check.expected_path || new URL(evidence.target_url).pathname || "/";
+    const failed = viewports.filter((viewport) => !successfulRoute({
+      ...viewport.route,
+      expected_path: expectedPath,
+      matched: viewport.route.observed === expectedPath || viewport.route.matched
+    }));
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        expected_path: expectedPath,
+        observed_paths: viewports.map((viewport) => viewport.route.observed),
+        http_statuses: viewports.map((viewport) => viewport.route.http_status ?? null)
+      },
+      message: failed.length ? `Route did not load as ${expectedPath} in ${failed.length} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "selector_visible") {
+    const key = selectorKey(check);
+    const failed = viewports.filter((viewport) => (viewport.selectors?.[key]?.visible_count || 0) < 1);
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        selector: key,
+        visible_counts: viewports.map((viewport) => viewport.selectors?.[key]?.visible_count || 0)
+      },
+      message: failed.length ? `Selector ${key} was not visible in ${failed.length} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "selector_count_at_least") {
+    const key = selectorKey(check);
+    const minCount = check.min_count ?? 1;
+    const failed = viewports.filter((viewport) => (viewport.selectors?.[key]?.count || 0) < minCount);
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        selector: key,
+        min_count: minCount,
+        counts: viewports.map((viewport) => viewport.selectors?.[key]?.count || 0)
+      },
+      message: failed.length ? `Selector ${key} count was below ${minCount} in ${failed.length} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "text_visible" || check.type === "text_absent") {
+    const key = textKey(check);
+    const expectedVisible = check.type === "text_visible";
+    const matches = viewports.map((viewport) => {
+      const fromEvidence = viewport.text_matches?.[key];
+      return typeof fromEvidence === "boolean" ? fromEvidence : matchText(viewport.body_text_sample || "", check);
+    });
+    const failed = matches.filter((matched) => matched !== expectedVisible).length;
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed ? "failed" : "passed",
+      evidence: {
+        text: check.text || null,
+        pattern: check.pattern || null,
+        matches
+      },
+      message: failed ? `Text assertion failed in ${failed} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "no_horizontal_overflow" || check.type === "no_mobile_horizontal_overflow") {
+    const maxOverflow = check.max_overflow_px ?? 4;
+    const applicable = check.type === "no_mobile_horizontal_overflow" ? viewports.filter((viewport) => viewport.width <= 820) : viewports;
+    if (!applicable.length) {
+      return {
+        type: check.type,
+        label: checkLabel(check),
+        status: "failed",
+        evidence: { max_overflow_px: maxOverflow },
+        message: "No applicable viewport evidence was captured for overflow check."
+      };
+    }
+    const failed = applicable.filter((viewport) => (viewport.overflow_px ?? 0) > maxOverflow);
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: failed.length ? "failed" : "passed",
+      evidence: {
+        max_overflow_px: maxOverflow,
+        overflow_px: applicable.map((viewport) => viewport.overflow_px ?? null),
+        viewports: applicable.map((viewport) => viewport.name)
+      },
+      message: failed.length ? `Horizontal overflow exceeded ${maxOverflow}px in ${failed.length} viewport(s).` : void 0
+    };
+  }
+  if (check.type === "no_fatal_console_errors") {
+    const fatalCount = (evidence.console?.fatal_count || 0) + (evidence.page_errors?.length || 0);
+    return {
+      type: check.type,
+      label: checkLabel(check),
+      status: fatalCount ? "failed" : "passed",
+      evidence: {
+        console_fatal_count: evidence.console?.fatal_count || 0,
+        page_error_count: evidence.page_errors?.length || 0
+      },
+      message: fatalCount ? `${fatalCount} fatal browser error(s) were captured.` : void 0
+    };
+  }
+  return {
+    type: check.type,
+    label: checkLabel(check),
+    status: "needs_human_review",
+    evidence: {},
+    message: "Unsupported check type."
+  };
+}
+function profileStatusFromEvidence(evidence, checks) {
+  if (!evidence) return "proof_insufficient";
+  const viewports = evidence.viewports || [];
+  if (!viewports.length || !checks.length) return "proof_insufficient";
+  if (viewports.some((viewport) => viewport.navigation_error)) return "environment_blocked";
+  if (checks.some((check) => check.status === "needs_human_review")) return "needs_human_review";
+  if (checks.some((check) => check.status === "failed")) return "product_regression";
+  return "passed";
+}
+function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
+  const capturedAt = evidence?.captured_at || (/* @__PURE__ */ new Date()).toISOString();
+  const checks = evidence ? profile.checks.map((check) => assessCheckFromEvidence(check, evidence)) : [];
+  const status = profileStatusFromEvidence(evidence, checks);
+  const firstViewport = evidence?.viewports?.[0];
+  const screenshots = (evidence?.viewports || []).map((viewport) => viewport.screenshot_label).filter((label) => Boolean(label));
+  return {
+    version: RIDDLE_PROOF_PROFILE_RESULT_VERSION,
+    profile_name: profile.name,
+    runner: options.runner || "riddle",
+    status,
+    baseline_policy: profile.baseline_policy,
+    route: routeForViewport(firstViewport),
+    artifacts: {
+      screenshots,
+      console: "console.json",
+      proof_json: "proof.json",
+      dom_summary: "dom-summary.json",
+      riddle_artifacts: options.artifacts
+    },
+    checks,
+    summary: summarizeRiddleProofProfileResult({ profile_name: profile.name, status, checks, viewports: evidence?.viewports || [] }),
+    captured_at: capturedAt,
+    evidence,
+    riddle: options.riddle
+  };
+}
+function summarizeRiddleProofProfileResult(input) {
+  const passedChecks = input.checks.filter((check) => check.status === "passed").length;
+  const failedChecks = input.checks.filter((check) => check.status === "failed").length;
+  const viewportNames = input.viewports.map((viewport) => viewport.name).join(", ");
+  if (input.status === "passed") {
+    return `${input.profile_name} passed ${passedChecks} check(s) across ${input.viewports.length} viewport(s)${viewportNames ? ` (${viewportNames})` : ""}.`;
+  }
+  if (input.status === "product_regression") {
+    return `${input.profile_name} failed ${failedChecks} product invariant(s) across ${input.viewports.length} viewport(s).`;
+  }
+  if (input.status === "environment_blocked") {
+    return `${input.profile_name} could not collect reliable evidence because navigation or the browser environment was blocked.`;
+  }
+  if (input.status === "proof_insufficient") {
+    return `${input.profile_name} did not produce enough evidence for a profile judgment.`;
+  }
+  if (input.status === "configuration_error") {
+    return `${input.profile_name} has a profile configuration error.`;
+  }
+  return `${input.profile_name} collected artifacts but needs human review.`;
+}
+function profileStatusExitCode(profile, status) {
+  if (status === "passed") return 0;
+  return profile.failure_policy[status] === "neutral" ? 0 : 1;
+}
+function createRiddleProofProfileEnvironmentBlockedResult(input) {
+  const message = input.error instanceof Error ? input.error.message : input.error ? String(input.error) : "Riddle runner did not complete successfully.";
+  return {
+    version: RIDDLE_PROOF_PROFILE_RESULT_VERSION,
+    profile_name: input.profile.name,
+    runner: input.runner || "riddle",
+    status: "environment_blocked",
+    baseline_policy: input.profile.baseline_policy,
+    route: { requested: resolveRiddleProofProfileTargetUrl(input.profile), observed: "", matched: false, error: message },
+    artifacts: { screenshots: [], proof_json: "proof.json", riddle_artifacts: input.artifacts },
+    checks: [],
+    summary: `${input.profile.name} could not collect reliable evidence because the runner was blocked.`,
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    riddle: input.riddle,
+    error: message
+  };
+}
+function createRiddleProofProfileInsufficientResult(input) {
+  const message = input.error instanceof Error ? input.error.message : input.error ? String(input.error) : "No proof.json profile result artifact was found.";
+  return {
+    version: RIDDLE_PROOF_PROFILE_RESULT_VERSION,
+    profile_name: input.profile.name,
+    runner: input.runner || "riddle",
+    status: "proof_insufficient",
+    baseline_policy: input.profile.baseline_policy,
+    route: { requested: resolveRiddleProofProfileTargetUrl(input.profile), observed: "", matched: false, error: message },
+    artifacts: { screenshots: [], proof_json: "proof.json", riddle_artifacts: input.artifacts },
+    checks: [],
+    summary: `${input.profile.name} did not produce enough evidence for a profile judgment.`,
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    riddle: input.riddle,
+    error: message
+  };
+}
+function runtimeScriptAssessmentSource() {
+  return String.raw`
+function routeOk(route) {
+  return Boolean(route && route.matched && !route.error && (route.http_status == null || route.http_status < 400));
+}
+function textMatches(sample, check) {
+  if (check.pattern) {
+    try { return new RegExp(check.pattern, check.flags || "").test(sample || ""); } catch { return false; }
+  }
+  return String(sample || "").includes(check.text || "");
+}
+function assessProfile(profile, evidence) {
+  const checks = [];
+  const viewports = evidence.viewports || [];
+  for (const check of profile.checks || []) {
+    if (check.type === "route_loaded") {
+      const expectedPath = check.expected_path || new URL(evidence.target_url).pathname || "/";
+      const failed = viewports.filter((viewport) => {
+        const route = { ...(viewport.route || {}), expected_path: expectedPath };
+        route.matched = route.observed === expectedPath || route.matched;
+        return !routeOk(route);
+      });
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed.length ? "failed" : "passed",
+        evidence: {
+          expected_path: expectedPath,
+          observed_paths: viewports.map((viewport) => viewport.route && viewport.route.observed),
+          http_statuses: viewports.map((viewport) => viewport.route ? viewport.route.http_status ?? null : null),
+        },
+        message: failed.length ? "Route did not load as " + expectedPath + " in " + failed.length + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "selector_visible") {
+      const selector = check.selector || "";
+      const failed = viewports.filter((viewport) => !viewport.selectors || !viewport.selectors[selector] || viewport.selectors[selector].visible_count < 1);
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed.length ? "failed" : "passed",
+        evidence: { selector, visible_counts: viewports.map((viewport) => viewport.selectors && viewport.selectors[selector] ? viewport.selectors[selector].visible_count : 0) },
+        message: failed.length ? "Selector " + selector + " was not visible in " + failed.length + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "selector_count_at_least") {
+      const selector = check.selector || "";
+      const minCount = check.min_count == null ? 1 : check.min_count;
+      const failed = viewports.filter((viewport) => !viewport.selectors || !viewport.selectors[selector] || viewport.selectors[selector].count < minCount);
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed.length ? "failed" : "passed",
+        evidence: { selector, min_count: minCount, counts: viewports.map((viewport) => viewport.selectors && viewport.selectors[selector] ? viewport.selectors[selector].count : 0) },
+        message: failed.length ? "Selector " + selector + " count was below " + minCount + " in " + failed.length + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "text_visible" || check.type === "text_absent") {
+      const key = check.pattern ? "pattern:" + check.pattern + "/" + (check.flags || "") : "text:" + (check.text || "");
+      const expectedVisible = check.type === "text_visible";
+      const matches = viewports.map((viewport) => viewport.text_matches && typeof viewport.text_matches[key] === "boolean" ? viewport.text_matches[key] : textMatches(viewport.body_text_sample || "", check));
+      const failed = matches.filter((matched) => matched !== expectedVisible).length;
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed ? "failed" : "passed",
+        evidence: { text: check.text, pattern: check.pattern, matches },
+        message: failed ? "Text assertion failed in " + failed + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "no_horizontal_overflow" || check.type === "no_mobile_horizontal_overflow") {
+      const maxOverflow = check.max_overflow_px == null ? 4 : check.max_overflow_px;
+      const applicable = check.type === "no_mobile_horizontal_overflow" ? viewports.filter((viewport) => viewport.width <= 820) : viewports;
+      if (!applicable.length) {
+        checks.push({
+          type: check.type,
+          label: check.label || check.type,
+          status: "failed",
+          evidence: { max_overflow_px: maxOverflow },
+          message: "No applicable viewport evidence was captured for overflow check.",
+        });
+        continue;
+      }
+      const failed = applicable.filter((viewport) => (viewport.overflow_px || 0) > maxOverflow);
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: failed.length ? "failed" : "passed",
+        evidence: { max_overflow_px: maxOverflow, overflow_px: applicable.map((viewport) => viewport.overflow_px ?? null), viewports: applicable.map((viewport) => viewport.name) },
+        message: failed.length ? "Horizontal overflow exceeded " + maxOverflow + "px in " + failed.length + " viewport(s)." : undefined,
+      });
+      continue;
+    }
+    if (check.type === "no_fatal_console_errors") {
+      const fatalCount = ((evidence.console && evidence.console.fatal_count) || 0) + ((evidence.page_errors || []).length);
+      checks.push({
+        type: check.type,
+        label: check.label || check.type,
+        status: fatalCount ? "failed" : "passed",
+        evidence: { console_fatal_count: (evidence.console && evidence.console.fatal_count) || 0, page_error_count: (evidence.page_errors || []).length },
+        message: fatalCount ? String(fatalCount) + " fatal browser error(s) were captured." : undefined,
+      });
+      continue;
+    }
+    checks.push({ type: check.type, label: check.label || check.type, status: "needs_human_review", evidence: {}, message: "Unsupported check type." });
+  }
+  let status = "passed";
+  if (!viewports.length || !checks.length) status = "proof_insufficient";
+  else if (viewports.some((viewport) => viewport.navigation_error)) status = "environment_blocked";
+  else if (checks.some((check) => check.status === "needs_human_review")) status = "needs_human_review";
+  else if (checks.some((check) => check.status === "failed")) status = "product_regression";
+  const screenshotLabels = viewports.map((viewport) => viewport.screenshot_label).filter(Boolean);
+  const route = viewports[0] && viewports[0].route ? viewports[0].route : { requested: evidence.target_url, observed: "", matched: false, error: "missing viewport evidence" };
+  const passedChecks = checks.filter((check) => check.status === "passed").length;
+  const failedChecks = checks.filter((check) => check.status === "failed").length;
+  const viewportNames = viewports.map((viewport) => viewport.name).join(", ");
+  let summary = profile.name + " collected artifacts but needs human review.";
+  if (status === "passed") summary = profile.name + " passed " + passedChecks + " check(s) across " + viewports.length + " viewport(s)" + (viewportNames ? " (" + viewportNames + ")." : ".");
+  if (status === "product_regression") summary = profile.name + " failed " + failedChecks + " product invariant(s) across " + viewports.length + " viewport(s).";
+  if (status === "environment_blocked") summary = profile.name + " could not collect reliable evidence because navigation or the browser environment was blocked.";
+  if (status === "proof_insufficient") summary = profile.name + " did not produce enough evidence for a profile judgment.";
+  return {
+    version: "riddle-proof.profile-result.v1",
+    profile_name: profile.name,
+    runner: "riddle",
+    status,
+    baseline_policy: profile.baseline_policy || "invariant_only",
+    route,
+    artifacts: { screenshots: screenshotLabels, console: "console.json", proof_json: "proof.json", dom_summary: "dom-summary.json" },
+    checks,
+    summary,
+    captured_at: evidence.captured_at,
+    evidence,
+  };
+}
+`;
+}
+function buildRiddleProofProfileScript(profile) {
+  const targetUrl = resolveRiddleProofProfileTargetUrl(profile);
+  const slug = slugifyRiddleProofProfileName(profile.name);
+  const serializableProfile = JSON.stringify(profile);
+  const serializableTargetUrl = JSON.stringify(targetUrl);
+  const serializableSlug = JSON.stringify(slug);
+  return String.raw`
+const profile = ${serializableProfile};
+const targetUrl = ${serializableTargetUrl};
+const profileSlug = ${serializableSlug};
+const capturedAt = new Date().toISOString();
+const consoleEvents = [];
+const pageErrors = [];
+page.on("console", (message) => {
+  const type = message.type();
+  if (type === "error" || type === "warning" || type === "assert") {
+    consoleEvents.push({
+      type,
+      text: message.text().slice(0, 1000),
+      location: message.location ? message.location() : undefined,
+    });
+  }
+});
+page.on("pageerror", (error) => {
+  pageErrors.push({ message: String(error && error.message ? error.message : error).slice(0, 1000) });
+});
+function textKey(check) {
+  return check.pattern ? "pattern:" + check.pattern + "/" + (check.flags || "") : "text:" + (check.text || "");
+}
+function textMatches(sample, check) {
+  if (check.pattern) {
+    try { return new RegExp(check.pattern, check.flags || "").test(sample || ""); } catch { return false; }
+  }
+  return String(sample || "").includes(check.text || "");
+}
+function expectedPathFor(check) {
+  return check.expected_path || new URL(targetUrl).pathname || "/";
+}
+async function selectorStats(selector) {
+  return page.locator(selector).evaluateAll((elements) => {
+    const isVisible = (element) => {
+      const style = window.getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      return style && style.visibility !== "hidden" && style.display !== "none" && rect.width > 0 && rect.height > 0;
+    };
+    return { count: elements.length, visible_count: elements.filter(isVisible).length };
+  }).catch((error) => ({ count: 0, visible_count: 0, error: String(error && error.message ? error.message : error).slice(0, 500) }));
+}
+async function captureViewport(viewport) {
+  await page.setViewportSize({ width: viewport.width, height: viewport.height });
+  let httpStatus = null;
+  let navigationError;
+  let waitError;
+  try {
+    const response = await page.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 45000 });
+    httpStatus = response ? response.status() : null;
+  } catch (error) {
+    navigationError = String(error && error.message ? error.message : error).slice(0, 1000);
+  }
+  if (!navigationError && profile.target.wait_for_selector) {
+    try {
+      await page.waitForSelector(profile.target.wait_for_selector, { state: "visible", timeout: 15000 });
+    } catch (error) {
+      waitError = String(error && error.message ? error.message : error).slice(0, 1000);
+    }
+  }
+  if (!navigationError && profile.target.wait_ms) {
+    await page.waitForTimeout(profile.target.wait_ms);
+  }
+  const dom = await page.evaluate(() => {
+    const body = document.body;
+    const documentElement = document.documentElement;
+    const text = (body ? body.innerText : "").replace(/\s+/g, " ").trim();
+    return {
+      url: location.href,
+      pathname: location.pathname,
+      title: document.title,
+      body_text_length: text.length,
+      body_text_sample: text.slice(0, 8000),
+      scroll_width: documentElement ? documentElement.scrollWidth : 0,
+      client_width: documentElement ? documentElement.clientWidth : window.innerWidth,
+    };
+  }).catch((error) => ({
+    url: page.url(),
+    pathname: "",
+    title: "",
+    body_text_length: 0,
+    body_text_sample: "",
+    scroll_width: 0,
+    client_width: viewport.width,
+    evaluation_error: String(error && error.message ? error.message : error).slice(0, 1000),
+  }));
+  const selectors = {};
+  const text_matches = {};
+  for (const check of profile.checks || []) {
+    if ((check.type === "selector_visible" || check.type === "selector_count_at_least") && check.selector) {
+      selectors[check.selector] = await selectorStats(check.selector);
+    }
+    if ((check.type === "text_visible" || check.type === "text_absent") && (check.text || check.pattern)) {
+      text_matches[textKey(check)] = textMatches(dom.body_text_sample || "", check);
+    }
+  }
+  const screenshotLabel = profileSlug + "-" + viewport.name;
+  try {
+    if (typeof saveScreenshot === "function") await saveScreenshot(screenshotLabel);
+  } catch (error) {
+    pageErrors.push({ message: "saveScreenshot failed: " + String(error && error.message ? error.message : error).slice(0, 500) });
+  }
+  const expectedPath = profile.checks.find((check) => check.type === "route_loaded" && check.expected_path)?.expected_path || new URL(targetUrl).pathname || "/";
+  return {
+    name: viewport.name,
+    width: viewport.width,
+    height: viewport.height,
+    url: dom.url,
+    route: {
+      requested: targetUrl,
+      observed: dom.pathname,
+      expected_path: expectedPath,
+      matched: dom.pathname === expectedPath,
+      http_status: httpStatus,
+      error: navigationError || waitError || undefined,
+    },
+    title: dom.title,
+    body_text_length: dom.body_text_length,
+    body_text_sample: dom.body_text_sample,
+    scroll_width: dom.scroll_width,
+    client_width: dom.client_width,
+    overflow_px: Math.max(0, (dom.scroll_width || 0) - (dom.client_width || viewport.width)),
+    selectors,
+    text_matches,
+    screenshot_label: screenshotLabel,
+    navigation_error: navigationError,
+    wait_error: waitError,
+  };
+}
+${runtimeScriptAssessmentSource()}
+const viewports = [];
+for (const viewport of profile.target.viewports || []) {
+  viewports.push(await captureViewport(viewport));
+}
+const evidence = {
+  version: "riddle-proof.profile-evidence.v1",
+  profile_name: profile.name,
+  target_url: targetUrl,
+  baseline_policy: profile.baseline_policy || "invariant_only",
+  captured_at: capturedAt,
+  viewports,
+  console: {
+    events: consoleEvents,
+    fatal_count: consoleEvents.filter((event) => event.type === "error" || event.type === "assert").length,
+  },
+  page_errors: pageErrors,
+  dom_summary: {
+    viewport_count: viewports.length,
+    routes: viewports.map((viewport) => viewport.route),
+    titles: viewports.map((viewport) => viewport.title),
+    overflow_px: viewports.map((viewport) => viewport.overflow_px),
+  },
+};
+const result = assessProfile(profile, evidence);
+if (typeof saveJson === "function") {
+  await saveJson("proof.json", result);
+  await saveJson("console.json", { events: consoleEvents, page_errors: pageErrors });
+  await saveJson("dom-summary.json", evidence.dom_summary);
+}
+return result;
+`.trim();
+}
+function collectRiddleProfileArtifactRefs(input) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  function add(item, source) {
+    if (!isRecord(item)) return;
+    const name = stringValue2(item.name) || stringValue2(item.filename) || "";
+    const url = stringValue2(item.url);
+    const path7 = stringValue2(item.path);
+    if (!name && !url && !path7) return;
+    const key = `${name}:${url || path7 || ""}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    refs.push({
+      name,
+      url,
+      path: path7,
+      kind: stringValue2(item.kind) || stringValue2(item.type),
+      content_type: stringValue2(item.content_type) || stringValue2(item.contentType),
+      source
+    });
+  }
+  function visit(value, source) {
+    if (Array.isArray(value)) {
+      for (const item of value) add(item, source);
+      return;
+    }
+    if (!isRecord(value)) return;
+    for (const key of ["artifacts", "outputs", "screenshots", "files"]) {
+      if (Array.isArray(value[key])) visit(value[key], key);
+    }
+  }
+  visit(input, "artifacts");
+  return refs;
+}
+function extractRiddleProofProfileResult(input) {
+  if (!isRecord(input)) return void 0;
+  if (input.version === RIDDLE_PROOF_PROFILE_RESULT_VERSION) return input;
+  const candidates = [
+    input.result,
+    input.return_value,
+    input.value,
+    input.profile_result,
+    isRecord(input["proof.json"]) ? input["proof.json"] : void 0,
+    isRecord(input._proof_json) ? input._proof_json : void 0
+  ];
+  for (const candidate of candidates) {
+    const result = extractRiddleProofProfileResult(candidate);
+    if (result) return result;
+  }
+  if (isRecord(input._artifact_json)) {
+    return extractRiddleProofProfileResult(input._artifact_json["proof.json"]);
+  }
+  return void 0;
+}
+
 // src/cli.ts
 function usage() {
   return [
@@ -6640,6 +7542,7 @@ function usage() {
     "  riddle-proof-loop respond --state-path <path> --response-json <file|json|->",
     "  riddle-proof-loop respond --state-path <path> --decision <decision> --summary <text> [--payload-json <file|json|->]",
     "  riddle-proof-loop status --state-path <path>",
+    "  riddle-proof-loop run-profile --profile <file|json|-> --url <base-url> [--runner riddle] [--output <dir>]",
     "  riddle-proof-loop riddle-preview-deploy <build-dir> <label>",
     "  riddle-proof-loop riddle-server-preview <directory> --script-file <file> [--path /route] [--wait-for-selector selector]",
     "  riddle-proof-loop riddle-run-script --url <url> --script-file <file> [--viewport 1280x720]",
@@ -6831,6 +7734,173 @@ function riddleClientConfig(options) {
     apiBaseUrl: optionString(options, "apiBaseUrl")
   };
 }
+function parseProfileViewports(value) {
+  if (!value) return void 0;
+  return value.split(",").map((part, index) => {
+    const trimmed = part.trim();
+    const named = /^([a-zA-Z0-9_-]+)=(\d+x\d+)$/.exec(trimmed);
+    const viewport = parseRiddleViewport(named ? named[2] : trimmed);
+    if (!viewport) throw new Error(`Invalid viewport ${trimmed}.`);
+    return {
+      name: named ? named[1] : `viewport-${index + 1}`,
+      width: viewport.width,
+      height: viewport.height
+    };
+  });
+}
+function normalizeProfileForCli(options) {
+  const rawProfile = readJsonValue(optionString(options, "profile"), "--profile");
+  return normalizeRiddleProofProfile(rawProfile, {
+    url: optionString(options, "url"),
+    route: optionString(options, "route"),
+    viewports: parseProfileViewports(optionString(options, "viewports") || optionString(options, "viewport"))
+  });
+}
+function profileResultMarkdown(result) {
+  const lines = [
+    `# Riddle Proof Profile: ${result.profile_name}`,
+    "",
+    `Status: ${result.status}`,
+    `Runner: ${result.runner}`,
+    `Captured: ${result.captured_at}`,
+    "",
+    result.summary,
+    "",
+    "## Checks",
+    ""
+  ];
+  for (const check of result.checks) {
+    lines.push(`- ${check.status}: ${check.label || check.type}`);
+    if (check.message) lines.push(`  ${check.message}`);
+  }
+  if (result.artifacts.riddle_artifacts?.length) {
+    lines.push("", "## Riddle Artifacts", "");
+    for (const artifact of result.artifacts.riddle_artifacts.slice(0, 40)) {
+      lines.push(`- ${artifact.name || artifact.kind || "artifact"}${artifact.url ? `: ${artifact.url}` : ""}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function writeProfileOutput(outputDir, result) {
+  if (!outputDir) return;
+  (0, import_node_fs6.mkdirSync)(outputDir, { recursive: true });
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "profile-result.json"), `${JSON.stringify(result, null, 2)}
+`);
+  (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "summary.md"), profileResultMarkdown(result));
+  if (result.evidence) (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "proof.json"), `${JSON.stringify(result, null, 2)}
+`);
+  if (result.evidence?.console) (0, import_node_fs6.writeFileSync)(import_node_path6.default.join(outputDir, "console.json"), `${JSON.stringify(result.evidence.console, null, 2)}
+`);
+  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)}
+`);
+}
+async function readArtifactJson(artifact) {
+  const target = artifact.url || artifact.path;
+  if (!target) return void 0;
+  try {
+    const raw = artifact.url ? await (await fetch(artifact.url)).text() : (0, import_node_fs6.existsSync)(target) ? (0, import_node_fs6.readFileSync)(target, "utf-8") : "";
+    if (!raw.trim()) return void 0;
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function profileResultFromRiddleArtifacts(profile, artifacts, fallbackInputs) {
+  for (const input of fallbackInputs) {
+    const result = extractRiddleProofProfileResult(input);
+    if (result) return result;
+  }
+  const proofArtifacts = artifacts.filter((artifact) => /(^|\/)proof\.json(?:\.json)?$/i.test(artifact.name || artifact.url || artifact.path || "")).sort((left, right) => {
+    const leftName = left.name || left.url || left.path || "";
+    const rightName = right.name || right.url || right.path || "";
+    return Number(/proof\.json\.json$/i.test(rightName)) - Number(/proof\.json\.json$/i.test(leftName));
+  });
+  for (const artifact of proofArtifacts) {
+    const parsed = await readArtifactJson(artifact);
+    const result = extractRiddleProofProfileResult(parsed);
+    if (result) return result;
+  }
+  const evidenceArtifacts = artifacts.filter((artifact) => /profile-evidence|evidence\.json/i.test(artifact.name || artifact.url || artifact.path || ""));
+  for (const artifact of evidenceArtifacts) {
+    const parsed = await readArtifactJson(artifact);
+    if (parsed?.version === "riddle-proof.profile-evidence.v1") {
+      return assessRiddleProofProfileEvidence(profile, parsed, { artifacts });
+    }
+  }
+  return void 0;
+}
+function withRiddleMetadata(result, input) {
+  return {
+    ...result,
+    riddle: {
+      ...result.riddle || {},
+      job_id: input.job_id || result.riddle?.job_id,
+      status: input.status ?? result.riddle?.status,
+      terminal: input.terminal ?? result.riddle?.terminal
+    },
+    artifacts: {
+      ...result.artifacts,
+      riddle_artifacts: input.artifacts || result.artifacts.riddle_artifacts
+    }
+  };
+}
+async function runProfileForCli(profile, options) {
+  const runner = optionString(options, "runner") || "riddle";
+  if (runner !== "riddle") {
+    throw new Error(`Unsupported --runner ${runner}. The current CLI supports --runner riddle.`);
+  }
+  const targetUrl = resolveRiddleProofProfileTargetUrl(profile);
+  const client = createRiddleApiClient(riddleClientConfig(options));
+  let created;
+  try {
+    created = await client.runScript({
+      url: targetUrl,
+      script: buildRiddleProofProfileScript(profile),
+      viewport: profile.target.viewports[0],
+      timeoutSec: optionString(options, "timeout") ? Number(optionString(options, "timeout")) : void 0,
+      sync: options.sync === true ? true : void 0
+    });
+  } catch (error) {
+    return createRiddleProofProfileEnvironmentBlockedResult({ profile, runner, error });
+  }
+  const jobId = typeof created.job_id === "string" ? created.job_id : typeof created.id === "string" ? created.id : "";
+  if (!jobId) {
+    const directResult = extractRiddleProofProfileResult(created);
+    return directResult ? withRiddleMetadata(directResult, { artifacts: collectRiddleProfileArtifactRefs(created) }) : createRiddleProofProfileInsufficientResult({ profile, runner, error: "Riddle run response was missing job_id.", artifacts: collectRiddleProfileArtifactRefs(created) });
+  }
+  const poll = await client.pollJob(jobId, {
+    wait: true,
+    attempts: optionString(options, "attempts") ? Number(optionString(options, "attempts")) : void 0,
+    intervalMs: optionString(options, "intervalMs") ? Number(optionString(options, "intervalMs")) : void 0
+  });
+  const artifacts = collectRiddleProfileArtifactRefs(poll.artifacts);
+  if (!poll.ok || !poll.terminal) {
+    return createRiddleProofProfileEnvironmentBlockedResult({
+      profile,
+      runner,
+      error: `Riddle job ${jobId} ended with status ${poll.status || "unknown"}.`,
+      riddle: { job_id: jobId, status: poll.status, terminal: poll.terminal },
+      artifacts
+    });
+  }
+  const artifactResult = await profileResultFromRiddleArtifacts(profile, artifacts, [poll.job, poll.artifacts, created]);
+  if (!artifactResult) {
+    return createRiddleProofProfileInsufficientResult({
+      profile,
+      runner,
+      riddle: { job_id: jobId, status: poll.status, terminal: poll.terminal },
+      artifacts
+    });
+  }
+  return withRiddleMetadata(artifactResult, {
+    job_id: jobId,
+    status: poll.status,
+    terminal: poll.terminal,
+    artifacts
+  });
+}
 function requestForRun(options) {
   const statePath = optionString(options, "statePath");
   const withEngineModuleUrl = (request) => {
@@ -6877,6 +7947,15 @@ async function main() {
 `);
     return;
   }
+  if (command === "run-profile") {
+    const profile = normalizeProfileForCli(options);
+    const result = await runProfileForCli(profile, options);
+    writeProfileOutput(optionString(options, "output"), result);
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    process.exitCode = profileStatusExitCode(profile, result.status);
+    return;
+  }
   if (command === "riddle-preview-deploy") {
     const buildDir = positional[1];
     const label = positional[2];