@riddledc/riddle-proof 0.7.17 → 0.7.19

package/dist/basic-gameplay.cjs

@@ -440,6 +440,22 @@ function createBasicGameplayCatchRecords(assessment, evidence) {
         });
       }
     }
+    for (const failure of responsiveSetupFailures(route)) {
+      catches.push({
+        site: run.site || null,
+        route: route.name,
+        path: route.path,
+        code: failure.code,
+        label: failure.label,
+        type: failure.action_result?.action || "responsive_setup",
+        selector: stringValue(failure.action_result?.selector),
+        reason: failure.reason || "responsive_setup_failed",
+        phase: failure.viewport?.phase || void 0,
+        viewport: failure.viewport,
+        action_result: failure.action_result,
+        summary: `${route.name || route.path || "Route"}: responsive setup failed on ${failure.viewport?.label || "viewport"} (${failure.reason || "responsive_setup_failed"})`
+      });
+    }
     for (const check of assessBasicGameplayProgressionChecks(route).filter((item) => item.ok === false)) {
       catches.push({
         site: run.site || null,
@@ -576,7 +592,7 @@ function findBasicGameplayEvidence(value, seen, depth = 0) {
   return null;
 }
 function hasRouteShape(record) {
-  return Boolean(record && (record.initial || record.after_action || record.afterAction || record.after_cleanup || record.afterCleanup || record.action_results || record.actionResults || record.continued_cleanup_action_results || record.continuedCleanupActionResults) && (record.path || record.name));
+  return Boolean(record && (record.initial || record.after_action || record.afterAction || record.after_cleanup || record.afterCleanup || record.action_results || record.actionResults || record.continued_cleanup_action_results || record.continuedCleanupActionResults || record.responsive_viewports || record.responsiveViewports) && (record.path || record.name));
 }
 function changed(before, after) {
   const bodyTextChanged = Boolean(before.body_text_hash && after.body_text_hash && before.body_text_hash !== after.body_text_hash);
@@ -596,12 +612,15 @@ function canvasHashes(canvases) {
 }
 function augmentRouteAssessmentWithProgressionChecks(result, route) {
   const progressionFailures = assessBasicGameplayProgressionChecks(route).filter((check) => check.ok === false);
-  if (!progressionFailures.length) return result;
-  const failures = result.failures.includes("progression_assertion_failed") ? result.failures : [...result.failures, "progression_assertion_failed"];
+  const responsiveFailures = responsiveSetupFailures(route);
+  if (!progressionFailures.length && !responsiveFailures.length) return result;
+  const failures = new Set(result.failures);
+  if (progressionFailures.length) failures.add("progression_assertion_failed");
+  for (const failure of responsiveFailures) failures.add(failure.code);
   return {
     ...result,
     ok: false,
-    failures,
+    failures: [...failures],
     suite_failures: [
       ...result.suite_failures || [],
       ...progressionFailures.map((check) => ({
@@ -612,10 +631,36 @@ function augmentRouteAssessmentWithProgressionChecks(result, route) {
         state_path: check.state_path || null,
         state_call: check.state_call || null,
         property_path: check.property_path || null
-      }))
+      })),
+      ...responsiveFailures
     ]
   };
 }
+function responsiveSetupFailures(route) {
+  const failures = [];
+  for (const viewport of responsiveViewportsForRoute(route)) {
+    for (const actionResult of listValue(viewport.setup_action_results || viewport.setupActionResults)) {
+      if (!actionResult || actionResult.ok !== false) continue;
+      failures.push({
+        code: "responsive_setup_failed",
+        label: `${viewport.label || "responsive"} ${actionResult.action || "setup action"}`,
+        reason: stringValue(actionResult.reason) || "responsive_setup_failed",
+        selector: stringValue(actionResult.selector),
+        viewport: {
+          label: viewport.label || null,
+          width: numberValue(viewport.width) || null,
+          height: numberValue(viewport.height) || null,
+          phase: viewport.phase || null
+        },
+        action_result: actionResult
+      });
+    }
+  }
+  return failures;
+}
+function responsiveViewportsForRoute(route) {
+  return listValue(route.responsive_viewports || route.responsiveViewports).filter((item) => Boolean(recordValue(item)));
+}
 function progressionChecksForRoute(route) {
   return listValue(route.progression_checks || route.progressionChecks).filter((item) => Boolean(recordValue(item)));
 }

package/dist/basic-gameplay.d.cts

@@ -1,7 +1,7 @@
 declare const RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION = "riddle-proof.basic-gameplay.v1";
 declare const RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION = "riddle-proof.basic-gameplay.assessment.v1";
 declare const RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION = "riddle-proof.basic-gameplay.catch.v1";
-type BasicGameplayFailureCode = "route_http_error" | "fatal_page_error" | "route_blank_or_thin" | "no_game_surface" | "mobile_horizontal_overflow" | "primary_control_missing" | "primary_control_inert" | "progression_assertion_failed";
+type BasicGameplayFailureCode = "route_http_error" | "fatal_page_error" | "route_blank_or_thin" | "no_game_surface" | "mobile_horizontal_overflow" | "primary_control_missing" | "primary_control_inert" | "progression_assertion_failed" | "responsive_setup_failed";
 type BasicGameplayWarningCode = "canvas_inert" | "some_actions_failed" | "missing_reset_path" | "critical_console_error";
 interface BasicGameplayCanvasState {
     index?: number;
@@ -95,13 +95,29 @@ interface BasicGameplayProgressionCheck {
     [key: string]: unknown;
 }
 interface BasicGameplaySuiteFailure {
-    code: "progression_assertion_failed";
+    code: "progression_assertion_failed" | "responsive_setup_failed";
     label?: string;
     reason?: string | null;
     selector?: string | null;
     state_path?: string | null;
     state_call?: string | null;
     property_path?: string | null;
+    viewport?: {
+        label?: string | null;
+        width?: number | null;
+        height?: number | null;
+        phase?: string | null;
+    };
+    action_result?: BasicGameplayActionResult;
+}
+interface BasicGameplayResponsiveViewportEvidence {
+    label?: string;
+    width?: number;
+    height?: number;
+    phase?: string;
+    setup_action_results?: BasicGameplayActionResult[];
+    setupActionResults?: BasicGameplayActionResult[];
+    [key: string]: unknown;
 }
 interface BasicGameplayMobileEvidence {
     overflow_px?: number;
@@ -132,6 +148,8 @@ interface RiddleProofBasicGameplayRouteEvidence {
     continuedCleanupActionResults?: BasicGameplayActionResult[];
     restart_action_results?: BasicGameplayActionResult[];
     restartActionResults?: BasicGameplayActionResult[];
+    responsive_viewports?: BasicGameplayResponsiveViewportEvidence[];
+    responsiveViewports?: BasicGameplayResponsiveViewportEvidence[];
     progression_checks?: BasicGameplayProgressionCheck[];
     progressionChecks?: BasicGameplayProgressionCheck[];
     requires_reset?: boolean;
@@ -296,4 +314,4 @@ declare function createBasicGameplayCatchRecords(assessment: RiddleProofBasicGam
 declare function createBasicGameplayCatchSummary(input: CreateBasicGameplayCatchSummaryInput, options?: AssessBasicGameplayOptions): RiddleProofBasicGameplayCatchSummary;
 declare function extractBasicGameplayEvidence(...sources: unknown[]): RiddleProofBasicGameplayEvidence | null;
 
-export { type AssessBasicGameplayOptions, type AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, type BasicGameplayActionResult, type BasicGameplayActionType, type BasicGameplayArtifactResolution, type BasicGameplayAssessmentSummary, type BasicGameplayCanvasState, type BasicGameplayCatchRecord, type BasicGameplayChangeSummary, type BasicGameplayFailureCode, type BasicGameplayFixReference, type BasicGameplayMetric, type BasicGameplayMobileEvidence, type BasicGameplayProgressCheckType, type BasicGameplayProgressionCheck, type BasicGameplayProofArtifact, type BasicGameplayRouteReference, type BasicGameplaySnapshot, type BasicGameplaySuiteFailure, type BasicGameplayWarningCode, type CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, type RiddleProofBasicGameplayAssessment, type RiddleProofBasicGameplayCatchSummary, type RiddleProofBasicGameplayEvidence, type RiddleProofBasicGameplayRouteAssessment, type RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString };
+export { type AssessBasicGameplayOptions, type AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, type BasicGameplayActionResult, type BasicGameplayActionType, type BasicGameplayArtifactResolution, type BasicGameplayAssessmentSummary, type BasicGameplayCanvasState, type BasicGameplayCatchRecord, type BasicGameplayChangeSummary, type BasicGameplayFailureCode, type BasicGameplayFixReference, type BasicGameplayMetric, type BasicGameplayMobileEvidence, type BasicGameplayProgressCheckType, type BasicGameplayProgressionCheck, type BasicGameplayProofArtifact, type BasicGameplayResponsiveViewportEvidence, type BasicGameplayRouteReference, type BasicGameplaySnapshot, type BasicGameplaySuiteFailure, type BasicGameplayWarningCode, type CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, type RiddleProofBasicGameplayAssessment, type RiddleProofBasicGameplayCatchSummary, type RiddleProofBasicGameplayEvidence, type RiddleProofBasicGameplayRouteAssessment, type RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString };

package/dist/basic-gameplay.d.ts

@@ -1,7 +1,7 @@
 declare const RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION = "riddle-proof.basic-gameplay.v1";
 declare const RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION = "riddle-proof.basic-gameplay.assessment.v1";
 declare const RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION = "riddle-proof.basic-gameplay.catch.v1";
-type BasicGameplayFailureCode = "route_http_error" | "fatal_page_error" | "route_blank_or_thin" | "no_game_surface" | "mobile_horizontal_overflow" | "primary_control_missing" | "primary_control_inert" | "progression_assertion_failed";
+type BasicGameplayFailureCode = "route_http_error" | "fatal_page_error" | "route_blank_or_thin" | "no_game_surface" | "mobile_horizontal_overflow" | "primary_control_missing" | "primary_control_inert" | "progression_assertion_failed" | "responsive_setup_failed";
 type BasicGameplayWarningCode = "canvas_inert" | "some_actions_failed" | "missing_reset_path" | "critical_console_error";
 interface BasicGameplayCanvasState {
     index?: number;
@@ -95,13 +95,29 @@ interface BasicGameplayProgressionCheck {
     [key: string]: unknown;
 }
 interface BasicGameplaySuiteFailure {
-    code: "progression_assertion_failed";
+    code: "progression_assertion_failed" | "responsive_setup_failed";
     label?: string;
     reason?: string | null;
     selector?: string | null;
     state_path?: string | null;
     state_call?: string | null;
     property_path?: string | null;
+    viewport?: {
+        label?: string | null;
+        width?: number | null;
+        height?: number | null;
+        phase?: string | null;
+    };
+    action_result?: BasicGameplayActionResult;
+}
+interface BasicGameplayResponsiveViewportEvidence {
+    label?: string;
+    width?: number;
+    height?: number;
+    phase?: string;
+    setup_action_results?: BasicGameplayActionResult[];
+    setupActionResults?: BasicGameplayActionResult[];
+    [key: string]: unknown;
 }
 interface BasicGameplayMobileEvidence {
     overflow_px?: number;
@@ -132,6 +148,8 @@ interface RiddleProofBasicGameplayRouteEvidence {
     continuedCleanupActionResults?: BasicGameplayActionResult[];
     restart_action_results?: BasicGameplayActionResult[];
     restartActionResults?: BasicGameplayActionResult[];
+    responsive_viewports?: BasicGameplayResponsiveViewportEvidence[];
+    responsiveViewports?: BasicGameplayResponsiveViewportEvidence[];
     progression_checks?: BasicGameplayProgressionCheck[];
     progressionChecks?: BasicGameplayProgressionCheck[];
     requires_reset?: boolean;
@@ -296,4 +314,4 @@ declare function createBasicGameplayCatchRecords(assessment: RiddleProofBasicGam
 declare function createBasicGameplayCatchSummary(input: CreateBasicGameplayCatchSummaryInput, options?: AssessBasicGameplayOptions): RiddleProofBasicGameplayCatchSummary;
 declare function extractBasicGameplayEvidence(...sources: unknown[]): RiddleProofBasicGameplayEvidence | null;
 
-export { type AssessBasicGameplayOptions, type AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, type BasicGameplayActionResult, type BasicGameplayActionType, type BasicGameplayArtifactResolution, type BasicGameplayAssessmentSummary, type BasicGameplayCanvasState, type BasicGameplayCatchRecord, type BasicGameplayChangeSummary, type BasicGameplayFailureCode, type BasicGameplayFixReference, type BasicGameplayMetric, type BasicGameplayMobileEvidence, type BasicGameplayProgressCheckType, type BasicGameplayProgressionCheck, type BasicGameplayProofArtifact, type BasicGameplayRouteReference, type BasicGameplaySnapshot, type BasicGameplaySuiteFailure, type BasicGameplayWarningCode, type CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, type RiddleProofBasicGameplayAssessment, type RiddleProofBasicGameplayCatchSummary, type RiddleProofBasicGameplayEvidence, type RiddleProofBasicGameplayRouteAssessment, type RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString };
+export { type AssessBasicGameplayOptions, type AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, type BasicGameplayActionResult, type BasicGameplayActionType, type BasicGameplayArtifactResolution, type BasicGameplayAssessmentSummary, type BasicGameplayCanvasState, type BasicGameplayCatchRecord, type BasicGameplayChangeSummary, type BasicGameplayFailureCode, type BasicGameplayFixReference, type BasicGameplayMetric, type BasicGameplayMobileEvidence, type BasicGameplayProgressCheckType, type BasicGameplayProgressionCheck, type BasicGameplayProofArtifact, type BasicGameplayResponsiveViewportEvidence, type BasicGameplayRouteReference, type BasicGameplaySnapshot, type BasicGameplaySuiteFailure, type BasicGameplayWarningCode, type CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, type RiddleProofBasicGameplayAssessment, type RiddleProofBasicGameplayCatchSummary, type RiddleProofBasicGameplayEvidence, type RiddleProofBasicGameplayRouteAssessment, type RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString };

package/dist/basic-gameplay.js

@@ -16,7 +16,7 @@ import {
   extractBasicGameplayEvidence,
   resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   sanitizeBasicGameplayJsonString
-} from "./chunk-GHQR2VEI.js";
+} from "./chunk-6H742VFJ.js";
 export {
   BASIC_GAMEPLAY_ACTION_TYPES,
   BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES,

package/dist/{chunk-GHQR2VEI.js → chunk-6H742VFJ.js}

@@ -400,6 +400,22 @@ function createBasicGameplayCatchRecords(assessment, evidence) {
         });
       }
     }
+    for (const failure of responsiveSetupFailures(route)) {
+      catches.push({
+        site: run.site || null,
+        route: route.name,
+        path: route.path,
+        code: failure.code,
+        label: failure.label,
+        type: failure.action_result?.action || "responsive_setup",
+        selector: stringValue(failure.action_result?.selector),
+        reason: failure.reason || "responsive_setup_failed",
+        phase: failure.viewport?.phase || void 0,
+        viewport: failure.viewport,
+        action_result: failure.action_result,
+        summary: `${route.name || route.path || "Route"}: responsive setup failed on ${failure.viewport?.label || "viewport"} (${failure.reason || "responsive_setup_failed"})`
+      });
+    }
     for (const check of assessBasicGameplayProgressionChecks(route).filter((item) => item.ok === false)) {
       catches.push({
         site: run.site || null,
@@ -536,7 +552,7 @@ function findBasicGameplayEvidence(value, seen, depth = 0) {
   return null;
 }
 function hasRouteShape(record) {
-  return Boolean(record && (record.initial || record.after_action || record.afterAction || record.after_cleanup || record.afterCleanup || record.action_results || record.actionResults || record.continued_cleanup_action_results || record.continuedCleanupActionResults) && (record.path || record.name));
+  return Boolean(record && (record.initial || record.after_action || record.afterAction || record.after_cleanup || record.afterCleanup || record.action_results || record.actionResults || record.continued_cleanup_action_results || record.continuedCleanupActionResults || record.responsive_viewports || record.responsiveViewports) && (record.path || record.name));
 }
 function changed(before, after) {
   const bodyTextChanged = Boolean(before.body_text_hash && after.body_text_hash && before.body_text_hash !== after.body_text_hash);
@@ -556,12 +572,15 @@ function canvasHashes(canvases) {
 }
 function augmentRouteAssessmentWithProgressionChecks(result, route) {
   const progressionFailures = assessBasicGameplayProgressionChecks(route).filter((check) => check.ok === false);
-  if (!progressionFailures.length) return result;
-  const failures = result.failures.includes("progression_assertion_failed") ? result.failures : [...result.failures, "progression_assertion_failed"];
+  const responsiveFailures = responsiveSetupFailures(route);
+  if (!progressionFailures.length && !responsiveFailures.length) return result;
+  const failures = new Set(result.failures);
+  if (progressionFailures.length) failures.add("progression_assertion_failed");
+  for (const failure of responsiveFailures) failures.add(failure.code);
   return {
     ...result,
     ok: false,
-    failures,
+    failures: [...failures],
     suite_failures: [
       ...result.suite_failures || [],
       ...progressionFailures.map((check) => ({
@@ -572,10 +591,36 @@ function augmentRouteAssessmentWithProgressionChecks(result, route) {
         state_path: check.state_path || null,
         state_call: check.state_call || null,
         property_path: check.property_path || null
-      }))
+      })),
+      ...responsiveFailures
     ]
   };
 }
+function responsiveSetupFailures(route) {
+  const failures = [];
+  for (const viewport of responsiveViewportsForRoute(route)) {
+    for (const actionResult of listValue(viewport.setup_action_results || viewport.setupActionResults)) {
+      if (!actionResult || actionResult.ok !== false) continue;
+      failures.push({
+        code: "responsive_setup_failed",
+        label: `${viewport.label || "responsive"} ${actionResult.action || "setup action"}`,
+        reason: stringValue(actionResult.reason) || "responsive_setup_failed",
+        selector: stringValue(actionResult.selector),
+        viewport: {
+          label: viewport.label || null,
+          width: numberValue(viewport.width) || null,
+          height: numberValue(viewport.height) || null,
+          phase: viewport.phase || null
+        },
+        action_result: actionResult
+      });
+    }
+  }
+  return failures;
+}
+function responsiveViewportsForRoute(route) {
+  return listValue(route.responsive_viewports || route.responsiveViewports).filter((item) => Boolean(recordValue(item)));
+}
 function progressionChecksForRoute(route) {
   return listValue(route.progression_checks || route.progressionChecks).filter((item) => Boolean(recordValue(item)));
 }

package/dist/{chunk-7T5WT2WO.js → chunk-ZGSAXSBW.js}

@@ -456,11 +456,13 @@ function assessSetupActionsFromEvidence(profile, evidence) {
     message: failed.length ? `Setup actions failed in ${failed.length} viewport action(s).` : void 0
   };
 }
-function profileStatusFromEvidence(evidence, checks) {
+function profileStatusFromEvidence(profile, evidence, checks) {
   if (!evidence) return "proof_insufficient";
   const viewports = evidence.viewports || [];
+  const expectedViewportCount = profile.target.viewports?.length || 0;
   if (!viewports.length || !checks.length) return "proof_insufficient";
   if (viewports.some((viewport) => viewport.navigation_error)) return "environment_blocked";
+  if (expectedViewportCount && viewports.length < expectedViewportCount) return "proof_insufficient";
   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";
@@ -471,7 +473,7 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
     assessSetupActionsFromEvidence(profile, evidence),
     ...profile.checks.map((check) => assessCheckFromEvidence(check, evidence))
   ].filter((check) => Boolean(check)) : [];
-  const status = profileStatusFromEvidence(evidence, checks);
+  const status = profileStatusFromEvidence(profile, evidence, checks);
   const firstViewport = evidence?.viewports?.[0];
   const screenshots = (evidence?.viewports || []).map((viewport) => viewport.screenshot_label).filter((label) => Boolean(label));
   return {
@@ -751,8 +753,10 @@ function assessProfile(profile, evidence) {
     checks.push({ type: check.type, label: check.label || check.type, status: "needs_human_review", evidence: {}, message: "Unsupported check type." });
   }
   let status = "passed";
+  const expectedViewportCount = profile.target && Array.isArray(profile.target.viewports) ? profile.target.viewports.length : 0;
   if (!viewports.length || !checks.length) status = "proof_insufficient";
   else if (viewports.some((viewport) => viewport.navigation_error)) status = "environment_blocked";
+  else if (expectedViewportCount && viewports.length < expectedViewportCount) status = "proof_insufficient";
   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);
@@ -1021,33 +1025,44 @@ async function captureViewport(viewport) {
 }
 ${runtimeScriptAssessmentSource()}
 const viewports = [];
+function buildProfileEvidence(currentViewports) {
+  const expectedViewportCount = (profile.target.viewports || []).length;
+  return {
+    version: "riddle-proof.profile-evidence.v1",
+    profile_name: profile.name,
+    target_url: targetUrl,
+    baseline_policy: profile.baseline_policy || "invariant_only",
+    captured_at: capturedAt,
+    viewports: currentViewports.slice(),
+    console: {
+      events: consoleEvents,
+      fatal_count: consoleEvents.filter((event) => event.type === "error" || event.type === "assert").length,
+    },
+    page_errors: pageErrors,
+    dom_summary: {
+      expected_viewport_count: expectedViewportCount,
+      viewport_count: currentViewports.length,
+      partial: expectedViewportCount > 0 && currentViewports.length < expectedViewportCount,
+      routes: currentViewports.map((viewport) => viewport.route),
+      titles: currentViewports.map((viewport) => viewport.title),
+      overflow_px: currentViewports.map((viewport) => viewport.overflow_px),
+    },
+  };
+}
+async function saveProfileArtifacts(currentViewports) {
+  const evidence = buildProfileEvidence(currentViewports);
+  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;
+}
+let result = await saveProfileArtifacts(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);
+  result = await saveProfileArtifacts(viewports);
 }
 return result;
 `.trim();

package/dist/cli.cjs

@@ -7236,11 +7236,13 @@ function assessSetupActionsFromEvidence(profile, evidence) {
     message: failed.length ? `Setup actions failed in ${failed.length} viewport action(s).` : void 0
   };
 }
-function profileStatusFromEvidence(evidence, checks) {
+function profileStatusFromEvidence(profile, evidence, checks) {
   if (!evidence) return "proof_insufficient";
   const viewports = evidence.viewports || [];
+  const expectedViewportCount = profile.target.viewports?.length || 0;
   if (!viewports.length || !checks.length) return "proof_insufficient";
   if (viewports.some((viewport) => viewport.navigation_error)) return "environment_blocked";
+  if (expectedViewportCount && viewports.length < expectedViewportCount) return "proof_insufficient";
   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";
@@ -7251,7 +7253,7 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
     assessSetupActionsFromEvidence(profile, evidence),
     ...profile.checks.map((check) => assessCheckFromEvidence(check, evidence))
   ].filter((check) => Boolean(check)) : [];
-  const status = profileStatusFromEvidence(evidence, checks);
+  const status = profileStatusFromEvidence(profile, evidence, checks);
   const firstViewport = evidence?.viewports?.[0];
   const screenshots = (evidence?.viewports || []).map((viewport) => viewport.screenshot_label).filter((label) => Boolean(label));
   return {
@@ -7515,8 +7517,10 @@ function assessProfile(profile, evidence) {
     checks.push({ type: check.type, label: check.label || check.type, status: "needs_human_review", evidence: {}, message: "Unsupported check type." });
   }
   let status = "passed";
+  const expectedViewportCount = profile.target && Array.isArray(profile.target.viewports) ? profile.target.viewports.length : 0;
   if (!viewports.length || !checks.length) status = "proof_insufficient";
   else if (viewports.some((viewport) => viewport.navigation_error)) status = "environment_blocked";
+  else if (expectedViewportCount && viewports.length < expectedViewportCount) status = "proof_insufficient";
   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);
@@ -7785,33 +7789,44 @@ async function captureViewport(viewport) {
 }
 ${runtimeScriptAssessmentSource()}
 const viewports = [];
+function buildProfileEvidence(currentViewports) {
+  const expectedViewportCount = (profile.target.viewports || []).length;
+  return {
+    version: "riddle-proof.profile-evidence.v1",
+    profile_name: profile.name,
+    target_url: targetUrl,
+    baseline_policy: profile.baseline_policy || "invariant_only",
+    captured_at: capturedAt,
+    viewports: currentViewports.slice(),
+    console: {
+      events: consoleEvents,
+      fatal_count: consoleEvents.filter((event) => event.type === "error" || event.type === "assert").length,
+    },
+    page_errors: pageErrors,
+    dom_summary: {
+      expected_viewport_count: expectedViewportCount,
+      viewport_count: currentViewports.length,
+      partial: expectedViewportCount > 0 && currentViewports.length < expectedViewportCount,
+      routes: currentViewports.map((viewport) => viewport.route),
+      titles: currentViewports.map((viewport) => viewport.title),
+      overflow_px: currentViewports.map((viewport) => viewport.overflow_px),
+    },
+  };
+}
+async function saveProfileArtifacts(currentViewports) {
+  const evidence = buildProfileEvidence(currentViewports);
+  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;
+}
+let result = await saveProfileArtifacts(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);
+  result = await saveProfileArtifacts(viewports);
 }
 return result;
 `.trim();

package/dist/cli.js

@@ -10,7 +10,7 @@ import {
   profileStatusExitCode,
   resolveRiddleProofProfileTargetUrl,
   resolveRiddleProofProfileTimeoutSec
-} from "./chunk-7T5WT2WO.js";
+} from "./chunk-ZGSAXSBW.js";
 import {
   createRiddleApiClient,
   parseRiddleViewport

package/dist/index.cjs

@@ -8210,6 +8210,22 @@ function createBasicGameplayCatchRecords(assessment, evidence) {
         });
       }
     }
+    for (const failure of responsiveSetupFailures(route)) {
+      catches.push({
+        site: run.site || null,
+        route: route.name,
+        path: route.path,
+        code: failure.code,
+        label: failure.label,
+        type: failure.action_result?.action || "responsive_setup",
+        selector: stringValue4(failure.action_result?.selector),
+        reason: failure.reason || "responsive_setup_failed",
+        phase: failure.viewport?.phase || void 0,
+        viewport: failure.viewport,
+        action_result: failure.action_result,
+        summary: `${route.name || route.path || "Route"}: responsive setup failed on ${failure.viewport?.label || "viewport"} (${failure.reason || "responsive_setup_failed"})`
+      });
+    }
     for (const check of assessBasicGameplayProgressionChecks(route).filter((item) => item.ok === false)) {
       catches.push({
         site: run.site || null,
@@ -8346,7 +8362,7 @@ function findBasicGameplayEvidence(value, seen, depth = 0) {
   return null;
 }
 function hasRouteShape(record) {
-  return Boolean(record && (record.initial || record.after_action || record.afterAction || record.after_cleanup || record.afterCleanup || record.action_results || record.actionResults || record.continued_cleanup_action_results || record.continuedCleanupActionResults) && (record.path || record.name));
+  return Boolean(record && (record.initial || record.after_action || record.afterAction || record.after_cleanup || record.afterCleanup || record.action_results || record.actionResults || record.continued_cleanup_action_results || record.continuedCleanupActionResults || record.responsive_viewports || record.responsiveViewports) && (record.path || record.name));
 }
 function changed(before, after) {
   const bodyTextChanged = Boolean(before.body_text_hash && after.body_text_hash && before.body_text_hash !== after.body_text_hash);
@@ -8366,12 +8382,15 @@ function canvasHashes(canvases) {
 }
 function augmentRouteAssessmentWithProgressionChecks(result, route) {
   const progressionFailures = assessBasicGameplayProgressionChecks(route).filter((check) => check.ok === false);
-  if (!progressionFailures.length) return result;
-  const failures = result.failures.includes("progression_assertion_failed") ? result.failures : [...result.failures, "progression_assertion_failed"];
+  const responsiveFailures = responsiveSetupFailures(route);
+  if (!progressionFailures.length && !responsiveFailures.length) return result;
+  const failures = new Set(result.failures);
+  if (progressionFailures.length) failures.add("progression_assertion_failed");
+  for (const failure of responsiveFailures) failures.add(failure.code);
   return {
     ...result,
     ok: false,
-    failures,
+    failures: [...failures],
     suite_failures: [
       ...result.suite_failures || [],
       ...progressionFailures.map((check) => ({
@@ -8382,10 +8401,36 @@ function augmentRouteAssessmentWithProgressionChecks(result, route) {
         state_path: check.state_path || null,
         state_call: check.state_call || null,
         property_path: check.property_path || null
-      }))
+      })),
+      ...responsiveFailures
     ]
   };
 }
+function responsiveSetupFailures(route) {
+  const failures = [];
+  for (const viewport of responsiveViewportsForRoute(route)) {
+    for (const actionResult of listValue2(viewport.setup_action_results || viewport.setupActionResults)) {
+      if (!actionResult || actionResult.ok !== false) continue;
+      failures.push({
+        code: "responsive_setup_failed",
+        label: `${viewport.label || "responsive"} ${actionResult.action || "setup action"}`,
+        reason: stringValue4(actionResult.reason) || "responsive_setup_failed",
+        selector: stringValue4(actionResult.selector),
+        viewport: {
+          label: viewport.label || null,
+          width: numberValue2(viewport.width) || null,
+          height: numberValue2(viewport.height) || null,
+          phase: viewport.phase || null
+        },
+        action_result: actionResult
+      });
+    }
+  }
+  return failures;
+}
+function responsiveViewportsForRoute(route) {
+  return listValue2(route.responsive_viewports || route.responsiveViewports).filter((item) => Boolean(recordValue3(item)));
+}
 function progressionChecksForRoute(route) {
   return listValue2(route.progression_checks || route.progressionChecks).filter((item) => Boolean(recordValue3(item)));
 }
@@ -8980,11 +9025,13 @@ function assessSetupActionsFromEvidence(profile, evidence) {
     message: failed.length ? `Setup actions failed in ${failed.length} viewport action(s).` : void 0
   };
 }
-function profileStatusFromEvidence(evidence, checks) {
+function profileStatusFromEvidence(profile, evidence, checks) {
   if (!evidence) return "proof_insufficient";
   const viewports = evidence.viewports || [];
+  const expectedViewportCount = profile.target.viewports?.length || 0;
   if (!viewports.length || !checks.length) return "proof_insufficient";
   if (viewports.some((viewport) => viewport.navigation_error)) return "environment_blocked";
+  if (expectedViewportCount && viewports.length < expectedViewportCount) return "proof_insufficient";
   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";
@@ -8995,7 +9042,7 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
     assessSetupActionsFromEvidence(profile, evidence),
     ...profile.checks.map((check) => assessCheckFromEvidence(check, evidence))
   ].filter((check) => Boolean(check)) : [];
-  const status = profileStatusFromEvidence(evidence, checks);
+  const status = profileStatusFromEvidence(profile, evidence, checks);
   const firstViewport = evidence?.viewports?.[0];
   const screenshots = (evidence?.viewports || []).map((viewport) => viewport.screenshot_label).filter((label) => Boolean(label));
   return {
@@ -9275,8 +9322,10 @@ function assessProfile(profile, evidence) {
     checks.push({ type: check.type, label: check.label || check.type, status: "needs_human_review", evidence: {}, message: "Unsupported check type." });
   }
   let status = "passed";
+  const expectedViewportCount = profile.target && Array.isArray(profile.target.viewports) ? profile.target.viewports.length : 0;
   if (!viewports.length || !checks.length) status = "proof_insufficient";
   else if (viewports.some((viewport) => viewport.navigation_error)) status = "environment_blocked";
+  else if (expectedViewportCount && viewports.length < expectedViewportCount) status = "proof_insufficient";
   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);
@@ -9545,33 +9594,44 @@ async function captureViewport(viewport) {
 }
 ${runtimeScriptAssessmentSource()}
 const viewports = [];
+function buildProfileEvidence(currentViewports) {
+  const expectedViewportCount = (profile.target.viewports || []).length;
+  return {
+    version: "riddle-proof.profile-evidence.v1",
+    profile_name: profile.name,
+    target_url: targetUrl,
+    baseline_policy: profile.baseline_policy || "invariant_only",
+    captured_at: capturedAt,
+    viewports: currentViewports.slice(),
+    console: {
+      events: consoleEvents,
+      fatal_count: consoleEvents.filter((event) => event.type === "error" || event.type === "assert").length,
+    },
+    page_errors: pageErrors,
+    dom_summary: {
+      expected_viewport_count: expectedViewportCount,
+      viewport_count: currentViewports.length,
+      partial: expectedViewportCount > 0 && currentViewports.length < expectedViewportCount,
+      routes: currentViewports.map((viewport) => viewport.route),
+      titles: currentViewports.map((viewport) => viewport.title),
+      overflow_px: currentViewports.map((viewport) => viewport.overflow_px),
+    },
+  };
+}
+async function saveProfileArtifacts(currentViewports) {
+  const evidence = buildProfileEvidence(currentViewports);
+  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;
+}
+let result = await saveProfileArtifacts(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);
+  result = await saveProfileArtifacts(viewports);
 }
 return result;
 `.trim();

package/dist/index.d.cts

@@ -9,6 +9,6 @@ export { CodexExecAgentConfig, CodexJsonRequest, CodexJsonResult, CodexJsonRunne
 export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.cjs';
 export { BuildVisualProofSessionInput, RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION, RIDDLE_PROOF_VISUAL_SESSION_VERSION, VisualProofSessionMismatch, buildVisualProofSession, compareVisualProofSessionFingerprint, parseVisualProofSession, visualSessionFingerprint, visualSessionFingerprintBasis } from './proof-session.cjs';
 export { AssessPlayabilityOptions, RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION, RIDDLE_PROOF_PLAYABILITY_VERSION, RiddleProofPlayabilityAssessment, RiddleProofPlayabilityEvidence, assessPlayabilityEvidence, extractPlayabilityEvidence, isRiddleProofPlayabilityMode } from './playability.cjs';
-export { AssessBasicGameplayOptions, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.cjs';
+export { AssessBasicGameplayOptions, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayResponsiveViewportEvidence, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.cjs';
 export { NormalizeRiddleProofProfileOptions, RIDDLE_PROOF_PROFILE_CHECK_TYPES, RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION, RIDDLE_PROOF_PROFILE_RESULT_VERSION, RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES, RIDDLE_PROOF_PROFILE_STATUSES, RIDDLE_PROOF_PROFILE_VERSION, RiddleProofProfile, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileResult, RiddleProofProfileRouteEvidence, RiddleProofProfileRunner, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from './profile.cjs';
 export { DEFAULT_RIDDLE_API_BASE_URL, DEFAULT_RIDDLE_API_KEY_FILE, RiddleApiError, RiddleClientConfig, RiddleFetch, RiddlePollJobResult, RiddlePreviewDeployResult, RiddleRunScriptInput, RiddleServerPreviewInput, RiddleServerPreviewResult, createRiddleApiClient, deployRiddleStaticPreview, isTerminalRiddleJobStatus, parseRiddleViewport, pollRiddleJob, resolveRiddleApiKey, riddleRequestJson, runRiddleScript, runRiddleServerPreview } from './riddle-client.cjs';

package/dist/index.d.ts

@@ -9,6 +9,6 @@ export { CodexExecAgentConfig, CodexJsonRequest, CodexJsonResult, CodexJsonRunne
 export { CreateCaptureDiagnosticInput, DEFAULT_DIAGNOSTIC_ARRAY_LIMIT, DEFAULT_DIAGNOSTIC_HISTORY_LIMIT, DEFAULT_DIAGNOSTIC_STRING_LIMIT, RIDDLE_PROOF_CAPTURE_DIAGNOSTIC_VERSION, RiddleProofArtifactSummary, RiddleProofCaptureArtifactSummary, RiddleProofCaptureDiagnostic, RiddleProofDiagnosticRedactionOptions, appendCaptureDiagnostic, createCaptureDiagnostic, redactForProofDiagnostics, summarizeCaptureArtifacts } from './diagnostics.js';
 export { BuildVisualProofSessionInput, RIDDLE_PROOF_VISUAL_SESSION_FINGERPRINT_VERSION, RIDDLE_PROOF_VISUAL_SESSION_VERSION, VisualProofSessionMismatch, buildVisualProofSession, compareVisualProofSessionFingerprint, parseVisualProofSession, visualSessionFingerprint, visualSessionFingerprintBasis } from './proof-session.js';
 export { AssessPlayabilityOptions, RIDDLE_PROOF_PLAYABILITY_ASSESSMENT_VERSION, RIDDLE_PROOF_PLAYABILITY_VERSION, RiddleProofPlayabilityAssessment, RiddleProofPlayabilityEvidence, assessPlayabilityEvidence, extractPlayabilityEvidence, isRiddleProofPlayabilityMode } from './playability.js';
-export { AssessBasicGameplayOptions, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.js';
+export { AssessBasicGameplayOptions, AttachBasicGameplayArtifactOptions, BASIC_GAMEPLAY_ACTION_TYPES, BASIC_GAMEPLAY_PROGRESS_CHECK_TYPES, BasicGameplayActionResult, BasicGameplayActionType, BasicGameplayArtifactResolution, BasicGameplayAssessmentSummary, BasicGameplayCanvasState, BasicGameplayCatchRecord, BasicGameplayChangeSummary, BasicGameplayFailureCode, BasicGameplayFixReference, BasicGameplayMetric, BasicGameplayMobileEvidence, BasicGameplayProgressCheckType, BasicGameplayProgressionCheck, BasicGameplayProofArtifact, BasicGameplayResponsiveViewportEvidence, BasicGameplayRouteReference, BasicGameplaySnapshot, BasicGameplaySuiteFailure, BasicGameplayWarningCode, CreateBasicGameplayCatchSummaryInput, RIDDLE_PROOF_BASIC_GAMEPLAY_ASSESSMENT_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_CATCH_VERSION, RIDDLE_PROOF_BASIC_GAMEPLAY_VERSION, RiddleProofBasicGameplayAssessment, RiddleProofBasicGameplayCatchSummary, RiddleProofBasicGameplayEvidence, RiddleProofBasicGameplayRouteAssessment, RiddleProofBasicGameplayRouteEvidence, assessBasicGameplayEvidence, assessBasicGameplayProgressionCheck, assessBasicGameplayProgressionChecks, assessBasicGameplayRoute, attachBasicGameplayArtifactScreenshotHashes, augmentBasicGameplayAssessmentWithProgressionChecks, compactBasicGameplayText, createBasicGameplayCatchRecords, createBasicGameplayCatchSummary, extractBasicGameplayEvidence, resolveBasicGameplayProgressionCheckWithArtifactScreenshots, sanitizeBasicGameplayJsonString } from './basic-gameplay.js';
 export { NormalizeRiddleProofProfileOptions, RIDDLE_PROOF_PROFILE_CHECK_TYPES, RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION, RIDDLE_PROOF_PROFILE_RESULT_VERSION, RIDDLE_PROOF_PROFILE_SETUP_ACTION_TYPES, RIDDLE_PROOF_PROFILE_STATUSES, RIDDLE_PROOF_PROFILE_VERSION, RiddleProofProfile, RiddleProofProfileArtifactRef, RiddleProofProfileBaselinePolicy, RiddleProofProfileCheck, RiddleProofProfileCheckResult, RiddleProofProfileCheckType, RiddleProofProfileEvidence, RiddleProofProfileFailureAction, RiddleProofProfileResult, RiddleProofProfileRouteEvidence, RiddleProofProfileRunner, RiddleProofProfileSetupAction, RiddleProofProfileSetupActionType, RiddleProofProfileStatus, RiddleProofProfileTarget, RiddleProofProfileViewport, RiddleProofProfileViewportEvidence, assessRiddleProofProfileEvidence, buildRiddleProofProfileScript, collectRiddleProfileArtifactRefs, createRiddleProofProfileConfigurationError, createRiddleProofProfileEnvironmentBlockedResult, createRiddleProofProfileInsufficientResult, extractRiddleProofProfileResult, normalizeRiddleProofProfile, profileStatusExitCode, resolveRiddleProofProfileRouteUrl, resolveRiddleProofProfileTargetUrl, resolveRiddleProofProfileTimeoutSec, slugifyRiddleProofProfileName, summarizeRiddleProofProfileResult } from './profile.js';
 export { DEFAULT_RIDDLE_API_BASE_URL, DEFAULT_RIDDLE_API_KEY_FILE, RiddleApiError, RiddleClientConfig, RiddleFetch, RiddlePollJobResult, RiddlePreviewDeployResult, RiddleRunScriptInput, RiddleServerPreviewInput, RiddleServerPreviewResult, createRiddleApiClient, deployRiddleStaticPreview, isTerminalRiddleJobStatus, parseRiddleViewport, pollRiddleJob, resolveRiddleApiKey, riddleRequestJson, runRiddleScript, runRiddleServerPreview } from './riddle-client.js';

package/dist/index.js

@@ -36,7 +36,7 @@ import {
   extractBasicGameplayEvidence,
   resolveBasicGameplayProgressionCheckWithArtifactScreenshots,
   sanitizeBasicGameplayJsonString
-} from "./chunk-GHQR2VEI.js";
+} from "./chunk-6H742VFJ.js";
 import {
   RIDDLE_PROOF_PROFILE_CHECK_TYPES,
   RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION,
@@ -58,7 +58,7 @@ import {
   resolveRiddleProofProfileTimeoutSec,
   slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult
-} from "./chunk-7T5WT2WO.js";
+} from "./chunk-ZGSAXSBW.js";
 import {
   DEFAULT_RIDDLE_API_BASE_URL,
   DEFAULT_RIDDLE_API_KEY_FILE,

package/dist/profile.cjs

@@ -499,11 +499,13 @@ function assessSetupActionsFromEvidence(profile, evidence) {
     message: failed.length ? `Setup actions failed in ${failed.length} viewport action(s).` : void 0
   };
 }
-function profileStatusFromEvidence(evidence, checks) {
+function profileStatusFromEvidence(profile, evidence, checks) {
   if (!evidence) return "proof_insufficient";
   const viewports = evidence.viewports || [];
+  const expectedViewportCount = profile.target.viewports?.length || 0;
   if (!viewports.length || !checks.length) return "proof_insufficient";
   if (viewports.some((viewport) => viewport.navigation_error)) return "environment_blocked";
+  if (expectedViewportCount && viewports.length < expectedViewportCount) return "proof_insufficient";
   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";
@@ -514,7 +516,7 @@ function assessRiddleProofProfileEvidence(profile, evidence, options = {}) {
     assessSetupActionsFromEvidence(profile, evidence),
     ...profile.checks.map((check) => assessCheckFromEvidence(check, evidence))
   ].filter((check) => Boolean(check)) : [];
-  const status = profileStatusFromEvidence(evidence, checks);
+  const status = profileStatusFromEvidence(profile, evidence, checks);
   const firstViewport = evidence?.viewports?.[0];
   const screenshots = (evidence?.viewports || []).map((viewport) => viewport.screenshot_label).filter((label) => Boolean(label));
   return {
@@ -794,8 +796,10 @@ function assessProfile(profile, evidence) {
     checks.push({ type: check.type, label: check.label || check.type, status: "needs_human_review", evidence: {}, message: "Unsupported check type." });
   }
   let status = "passed";
+  const expectedViewportCount = profile.target && Array.isArray(profile.target.viewports) ? profile.target.viewports.length : 0;
   if (!viewports.length || !checks.length) status = "proof_insufficient";
   else if (viewports.some((viewport) => viewport.navigation_error)) status = "environment_blocked";
+  else if (expectedViewportCount && viewports.length < expectedViewportCount) status = "proof_insufficient";
   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);
@@ -1064,33 +1068,44 @@ async function captureViewport(viewport) {
 }
 ${runtimeScriptAssessmentSource()}
 const viewports = [];
+function buildProfileEvidence(currentViewports) {
+  const expectedViewportCount = (profile.target.viewports || []).length;
+  return {
+    version: "riddle-proof.profile-evidence.v1",
+    profile_name: profile.name,
+    target_url: targetUrl,
+    baseline_policy: profile.baseline_policy || "invariant_only",
+    captured_at: capturedAt,
+    viewports: currentViewports.slice(),
+    console: {
+      events: consoleEvents,
+      fatal_count: consoleEvents.filter((event) => event.type === "error" || event.type === "assert").length,
+    },
+    page_errors: pageErrors,
+    dom_summary: {
+      expected_viewport_count: expectedViewportCount,
+      viewport_count: currentViewports.length,
+      partial: expectedViewportCount > 0 && currentViewports.length < expectedViewportCount,
+      routes: currentViewports.map((viewport) => viewport.route),
+      titles: currentViewports.map((viewport) => viewport.title),
+      overflow_px: currentViewports.map((viewport) => viewport.overflow_px),
+    },
+  };
+}
+async function saveProfileArtifacts(currentViewports) {
+  const evidence = buildProfileEvidence(currentViewports);
+  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;
+}
+let result = await saveProfileArtifacts(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);
+  result = await saveProfileArtifacts(viewports);
 }
 return result;
 `.trim();

package/dist/profile.js

@@ -19,7 +19,7 @@ import {
   resolveRiddleProofProfileTimeoutSec,
   slugifyRiddleProofProfileName,
   summarizeRiddleProofProfileResult
-} from "./chunk-7T5WT2WO.js";
+} from "./chunk-ZGSAXSBW.js";
 export {
   RIDDLE_PROOF_PROFILE_CHECK_TYPES,
   RIDDLE_PROOF_PROFILE_EVIDENCE_VERSION,

package/dist/proof-run-engine.d.cts

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -382,7 +382,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -659,7 +659,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;

package/dist/proof-run-engine.d.ts

@@ -292,7 +292,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     blocking?: boolean;
     details?: Record<string, unknown>;
     ok: boolean;
-    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;
@@ -382,7 +382,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     continueWithStage?: WorkflowStage | null;
     blocking?: boolean;
     details?: Record<string, unknown>;
-    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     checkpoint: string;
@@ -659,7 +659,7 @@ declare function executeWorkflow(params: WorkflowParams, pluginConfig: any, reso
     error?: undefined;
 } | {
     ok: boolean;
-    action: "recon" | "author" | "ship" | "implement" | "verify" | "setup" | "run";
+    action: "author" | "recon" | "ship" | "implement" | "verify" | "setup" | "run";
     state_path: string;
     stage: any;
     summary: string;

package/package.json

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