diff --git a/docs/CLI.md b/docs/CLI.md
index 63b4915f..70cc2a16 100644
--- a/docs/CLI.md
+++ b/docs/CLI.md
@@ -518,7 +518,7 @@ Notes:
 - Raw audit surfaces stay separate: `offers.json` preserves structured offers, `comparison.csv` preserves the tabular comparison with appended currency and total-status audit fields, `meta.json` preserves workflow diagnostics, and `deals-context.json` preserves `query`, report-derived `highlights`, raw `offers`, and `meta` for agent handoff.
 - `compact` and `context` modes summarize the same report guidance as `deals.md`; `json` mode still returns raw offers and meta.
 - Expect warnings for stale, inferred, or missing price freshness; unknown or out-of-stock availability; weak query relevance; suspicious titles; duplicate same-title or same-product pressure; workflow alerts; and advisory region handling.
-- Treat `--region` as advisory unless `meta.selection.region_authoritative=true`. If `meta.alerts` includes `reasonCode=region_unenforced`, do not present the output as a trustworthy regional comparison.
+- Treat `--region` as advisory unless `meta.selection.region_authoritative=true`. If `meta.alerts` includes `reasonCode=region_unenforced`, do not present the output as a trustworthy regional comparison. The alert is emitted only for selected provider diagnostics that did not enforce the requested region; enforced-region diagnostics do not create that warning.
 - The Market Baseline section is computed only from deterministic same-currency evidence. If sample size or currency coverage is insufficient, the report says `market baseline unavailable` instead of inventing savings.
 - Seller trust, return policy, warranty, condition, shipping certainty, and price history are not guaranteed fields. Treat them as unavailable unless the raw offer attributes and report text explicitly include them.
 - When a run returns no final offers, inspect `meta.primaryConstraintSummary` first.
@@ -618,7 +618,7 @@ Notes:
 - Workflow outputs can include typed `nextStepGuidance` with `readiness`, `reasonCode`, `primaryAction`, command examples, `paramsExamples`, `validationChecks`, `fallbackPolicy`, and `doNotProceedIf` blockers.
 - Harvest outputs separate operational completion, guidance readiness, and product readiness. `success:true` or `ok:true` means the command completed and wrote artifacts; top-level `ready` is product-ready only when `productSuccess=true`, `artifactAuthority=product_ready`, and `evidenceAuthority` is non-diagnostic. `readiness` and `guidanceReadiness` expose the next-step guidance state.
 - Treat product readiness as the gate between artifact completion and design readiness. Continue to Canvas only when top-level `ready=true`, `productSuccess=true`, `artifactAuthority=product_ready`, ranked references are non-empty, manifest-backed authority evidence exists, and no `doNotProceedIf` condition applies. For canonical Pinterest pin-media harvests, Canvas continuation requires `evidenceAuthority=pin_media_ready` and manifest-backed `pin-media-index.json`; `snapshot_ready` and `motion_ready` are not substitutes for pin-media readiness.
-- Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when their first-party pin-media artifact is captured, persisted, present in its manifest-backed index, and free of blocking warnings. Screenshot and screencast artifacts can inform diagnostics or motion design, but they do not satisfy required Pinterest pin-media readiness. The exact `login_or_challenge_state` and strict byte-backed `interface_chrome_shell` diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. Screenshot failure after pin-media success is a non-blocking caveat when pin-media authority is complete. `pin-media-index.json` remains Pinterest authority, `media-analysis.json` remains advisory, and `motion-evidence.json` remains browser replay authority. Multimodal agents reason over those artifacts directly.
+- Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when their first-party pin-media artifact is captured, persisted, present in its manifest-backed index, and free of blocking warnings. Screenshot and screencast artifacts can inform diagnostics or motion design, but they do not satisfy required Pinterest pin-media readiness. The exact `login_or_challenge_state` and strict byte-backed `interface_chrome_shell` diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. When pin-media authority is complete, unavailable supplemental viewport screenshot evidence is recorded as skipped and satisfied by pin media, not as product-readiness failure. `pin-media-index.json` remains Pinterest authority, `media-analysis.json` remains advisory, and `motion-evidence.json` remains browser replay authority. Multimodal agents reason over those artifacts directly.
 - CLI completion text includes `guidanceReadiness=<value> productSuccess=false artifactAuthority=<value> evidenceAuthority=<value>` when guidance readiness exists but product readiness is false. Product-ready runs can still emit `readiness=<value>`.
 - For `needs_recovery`, `blocked`, or `diagnostic_only`, follow the primary recovery action first. Common blockers are zero references, empty ranked references, failed required screenshot, screencast, or pin-media evidence, provider unavailability, login or challenge screens, and diagnostic-only captures.
 - The ready follow-through path is explicit: read `advanced-brief.md`, `meta-prompt.md`, `evidence.json`, `ranked-references.json`, `bundle-manifest.json`, `media-analysis.json` when present, and screenshot, screencast, or pin-media evidence first; load `opendevbrowser_skill_load opendevbrowser-best-practices "quick start"`, `opendevbrowser_skill_load opendevbrowser-design-agent "canvas-contract"`, and `opendevbrowser_skill_load opendevbrowser-motion-design "quick start"`; continue only if `canvas-plan.request.json` exists; open a Canvas session; fill the session ids in `canvas-plan.request.json`; run `opendevbrowser canvas --command canvas.plan.set --params-file ./canvas-plan.request.json`; confirm `planStatus=accepted`; then patch only the governance blocks called out by `design-agent-handoff.json`.
diff --git a/docs/SURFACE_REFERENCE.md b/docs/SURFACE_REFERENCE.md
index 0bb829bc..fe266e7e 100644
--- a/docs/SURFACE_REFERENCE.md
+++ b/docs/SURFACE_REFERENCE.md
@@ -578,6 +578,7 @@ Auth and policy:
 - Workflow and macro execute browser options: `research run`, `shopping run`, `product-video run`, `inspiredesign run`, `inspiredesign harvest`, and `macro-resolve --execute` accept `--browser-mode auto|extension|managed`; `extension` reuses relay-backed browser state, while `managed` runs a deterministic managed browser. Workflow `--profile <name>` selects a named managed profile for provider browser fallback; registry-backed explicit CDP profiles use `cdp-profile start` plus `connect --profile` for browser/session primitives until workflows expose an explicit-CDP transport selector.
 - Workflow and macro execute cookie options: `research run`, `shopping run`, `product-video run`, `inspiredesign run`, `inspiredesign harvest`, and `macro-resolve --execute` accept `--use-cookies` and `--cookie-policy-override off|auto|required` (`--cookie-policy` alias) so provider macros can require observable cookie-backed browser sessions.
 - Workflow and macro execute override flags: `research run`, `shopping run`, `product-video run`, `inspiredesign run`, `inspiredesign harvest`, and `macro-resolve --execute` accept `--challenge-automation-mode off|browser|browser_with_helper`, which maps to `challengeAutomationMode` with `run > session > config` precedence.
+- Shopping `--region` remains advisory unless workflow output reports `region_authoritative=true`. The `region_unenforced` alert is emitted only for selected provider diagnostics that did not enforce the requested region; enforced-region diagnostics do not create that warning.
 - Inspiredesign harvest flags: `--query`, repeatable `--provider`, `--max-references 1..10`, and `--visual-evidence off|auto|required`. Harvest requires `--query` or at least one `--url`, keeps the daemon method as `inspiredesign.run`, defaults to `mode=path`, `visualEvidence=required`, and `maxReferences=5`, and keeps explicit `--url` references before discovered references.
 - Before trusting daemon-backed `inspiredesign harvest` results, run `npx opendevbrowser status --daemon --output-format json` and require `data.fingerprintCurrent === true`; restart or isolate the daemon when it is false or missing.
 - Inspiredesign harvest supports browser-native site recipes for visually driven sites. `--provider social/pinterest` selects the Pinterest recipe and should use a dedicated managed headed profile with cookies and `--cookie-policy required` for non-Google logged-in search; use extension `/ops` when live active-tab reuse is required. Registry-backed explicit CDP profiles are available for browser/session primitives, but provider workflows do not yet expose an explicit-CDP transport selector. Query-based Pinterest harvests become product-ready only through query-discovered canonical `/pin/{id}/` references plus manifest-backed first-party pin-media bytes; login/challenge and search-shell diagnostics are recovery paths, not product-ready evidence. Compatible Pinterest URL recovery can run as `--provider social/pinterest --url <pinterest-url>` without `--query`; use one canonical `/pin/{id}/` URL per harvest when validating design-ready pin media. Generic provider plus URL recovery without query remains rejected. Pinterest is not registered as a default full social provider.
@@ -595,7 +596,7 @@ Auth and policy:
 - Workflow response keys: artifact-bearing workflow success payloads use `artifact_path`; provider follow-up summaries use `meta.primaryConstraintSummary`; typed recovery and handoff payloads use `nextStepGuidance.readiness`, `reasonCode`, `primaryAction`, `paramsExamples`, `validationChecks`, `fallbackPolicy`, and `doNotProceedIf` when available. Inspiredesign harvest also reports product `ready`, `guidanceReady`, `guidanceReadiness`, `productSuccess`, `harvestReadiness`, `readiness`, `rankedReferenceCount`, `evidenceAuthority`, and `artifactAuthority` so wrapper success is not confused with design readiness. Product `ready` is true only when authority gates pass.
 - `design-contract.json.colorSystem.tokens` and `implementation-plan.json.tokenStrategy.colors` use explicit `{ light, dark }` semantic token maps. `design-agent-handoff.json.implementationContext.tokenStrategy` carries the same dual-mode token strategy for implementation agents.
 - Continue to Canvas only when top-level `ready=true`, `productSuccess=true`, `artifactAuthority=product_ready`, ranked references are non-empty, no matching `doNotProceedIf` blockers remain active, and manifest-backed authority evidence exists. Strict proof reviews should inspect `evidence.json`, `ranked-references.json`, `pin-media-index.json`, `motion-evidence.json`, `media-analysis.json`, and `bundle-manifest.json` directly before accepting release or Canvas follow-through evidence. For canonical Pinterest pin-media harvests, Canvas continuation requires `evidenceAuthority=pin_media_ready` and manifest-backed `pin-media-index.json`; `snapshot_ready` and `motion_ready` are not substitutes for pin-media readiness. For `needs_recovery`, `blocked`, or `diagnostic_only`, follow recovery-first guidance and do not treat emitted artifacts as design-ready.
-- Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when their first-party pin-media artifact is captured, persisted, present in its manifest-backed index, and free of blocking warnings. `pin-media-index.json` remains the only pin-media readiness and provenance authority for persisted first-party bytes. Screenshot and screencast artifacts can inform diagnostics or motion design, but they do not satisfy required Pinterest pin-media readiness. The exact `login_or_challenge_state` and strict byte-backed `interface_chrome_shell` diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. Screenshot failure after pin-media success is a non-blocking caveat when pin-media authority is complete. `media-analysis.json` remains advisory, and `motion-evidence.json` remains browser replay authority.
+- Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when their first-party pin-media artifact is captured, persisted, present in its manifest-backed index, and free of blocking warnings. `pin-media-index.json` remains the only pin-media readiness and provenance authority for persisted first-party bytes. Screenshot and screencast artifacts can inform diagnostics or motion design, but they do not satisfy required Pinterest pin-media readiness. The exact `login_or_challenge_state` and strict byte-backed `interface_chrome_shell` diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. When pin-media authority is complete, unavailable supplemental viewport screenshot evidence is recorded as skipped and satisfied by pin media, not as product-readiness failure. `media-analysis.json` remains advisory, and `motion-evidence.json` remains browser replay authority.
 - Routine workflow bundles should omit output roots and inspect the returned `artifact_path` first. When output roots are omitted, persisted bundles use `.opendevbrowser/<namespace>/<runId>` and include `bundle-manifest.json`. CLI invocations resolve omitted roots from cwd before daemon dispatch; direct daemon RPC uses `core.workspaceRoot/.opendevbrowser`; direct OpenCode workflow tools use `deps.workspaceRoot/.opendevbrowser`. If a wrapper must pass an explicit workflow root, prefer `.opendevbrowser`; explicit external output roots remain caller-controlled for intentional temp, release, debug, audit, screenshot, and screencast lanes.
 - `artifacts cleanup --expired-only` without `--output-dir` targets the current working directory's `.opendevbrowser` root. Use `--output-dir /tmp/opendevbrowser` only when intentionally cleaning an explicit temp artifact root.
 - Browser evidence omitted outputs use workspace-local artifact roots: screenshots write `.opendevbrowser/screenshot/<uuid>/capture.png` with `path` and `artifact_path`, and screencasts write `.opendevbrowser/screencast/<uuid>` with replay files. Explicit `--path` and `--output-dir` remain caller-controlled. Browser screenshot, screencast, Canvas, annotation, desktop audit, and release proof outputs are intentional non-bundle lanes, do not promise `bundle-manifest.json`, and are not targets for bundle manifest cleanup.
diff --git a/scripts/product-video-fixture-live-probe.mjs b/scripts/product-video-fixture-live-probe.mjs
index ec33d46d..8fd05aa7 100644
--- a/scripts/product-video-fixture-live-probe.mjs
+++ b/scripts/product-video-fixture-live-probe.mjs
@@ -29,6 +29,22 @@ const PNG_BYTES = Buffer.from(
   "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jX1QAAAAASUVORK5CYII=",
   "base64"
 );
+const PRODUCT_VIDEO_PASS_STATUS = "pass";
+const PRODUCT_VIDEO_READINESS_GATES = [
+  { file: "manifest.json", path: ["readiness", "presentation", "status"], label: "manifest.readiness.presentation.status" },
+  { file: "manifest.json", path: ["readiness", "productVideo", "status"], label: "manifest.readiness.productVideo.status" },
+  { file: "presentation-readiness.json", path: ["summary", "status"], label: "presentation-readiness.json.summary.status" },
+  { file: "presentation-readiness.json", path: ["presentationReadiness", "status"], label: "presentation-readiness.json.presentationReadiness.status" },
+  { file: "presentation-readiness.json", path: ["productVideoReadiness", "status"], label: "presentation-readiness.json.productVideoReadiness.status" },
+  { file: "product.json", path: ["presentationReadiness", "status"], label: "product.json.presentationReadiness.status" },
+  { file: "product.json", path: ["productVideoReadiness", "status"], label: "product.json.productVideoReadiness.status" }
+];
+const PRODUCT_VIDEO_REQUIRED_BUNDLE_FILES = [
+  "manifest.json",
+  "presentation-readiness.json",
+  "product.json",
+  "bundle-manifest.json"
+];
 
 function parseArgs(argv) {
   const options = {
@@ -65,9 +81,17 @@ function parseArgs(argv) {
   return options;
 }
 
-function createProductFixtureServer() {
+function resolveFixtureRequestOrigin(request) {
+  const host = typeof request.headers.host === "string" && request.headers.host.length > 0
+    ? request.headers.host
+    : "127.0.0.1";
+  return `http://${host}`;
+}
+
+export function createProductFixtureServer() {
   return http.createServer((request, response) => {
-    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    const requestOrigin = resolveFixtureRequestOrigin(request);
+    const url = new URL(request.url ?? "/", requestOrigin);
     if (url.pathname.startsWith("/assets/")) {
       response.writeHead(200, {
         "content-type": "image/png",
@@ -84,12 +108,13 @@ function createProductFixtureServer() {
     }
 
     response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    const productDescription = "Type Desk Organizer. Connectivity Wireless charging and magnetic cable routing. Widget Pro keeps your desk clear with integrated charging and storage.";
     response.end(`<!doctype html>
 <html lang="en">
   <head>
     <meta charset="utf-8">
     <title>Widget Pro | Acme Labs</title>
-    <meta name="description" content="Widget Pro is a compact desk accessory that combines cable routing, wireless charging, and quick-access storage.">
+    <meta name="description" content="${productDescription}">
     <script type="application/ld+json">
       {
         "@context": "https://schema.org",
@@ -100,10 +125,10 @@ function createProductFixtureServer() {
           "name": "Acme Labs"
         },
         "image": [
-          "http://127.0.0.1:${url.port}/assets/widget-01.png",
-          "http://127.0.0.1:${url.port}/assets/widget-02.png"
+          "${requestOrigin}/assets/widget-01.png",
+          "${requestOrigin}/assets/widget-02.png"
         ],
-        "description": "Widget Pro keeps your desk clear with integrated charging and storage.",
+        "description": "${productDescription}",
         "offers": {
           "@type": "Offer",
           "priceCurrency": "USD",
@@ -130,7 +155,7 @@ function createProductFixtureServer() {
         <h1>Widget Pro</h1>
         <p class="price">$79.99</p>
         <p>Widget Pro is the all-in-one desktop organizer for creators who want fewer cables, cleaner lines, and instant charging access.</p>
-        <img src="http://127.0.0.1:${url.port}/assets/widget-01.png" alt="Widget Pro front view">
+        <img src="${requestOrigin}/assets/widget-01.png" alt="Widget Pro front view">
       </section>
       <section class="grid">
         <article>
@@ -144,7 +169,7 @@ function createProductFixtureServer() {
         <article>
           <h2>Why it works</h2>
           <p>Designed for hybrid desks, Widget Pro reduces clutter without taking over the workspace.</p>
-          <img src="http://127.0.0.1:${url.port}/assets/widget-02.png" alt="Widget Pro lifestyle scene">
+          <img src="${requestOrigin}/assets/widget-02.png" alt="Widget Pro lifestyle scene">
         </article>
       </section>
     </main>
@@ -157,7 +182,60 @@ function getReviewBundleRoot() {
   return path.join(process.cwd(), "artifacts", "skill-runtime-audit", "review-bundles", "product-video-fixture");
 }
 
-export function validateProductVideoArtifactBundle(artifactPath) {
+function readJsonObject(filePath) {
+  if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+    return { value: null, detail: "missing" };
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { value: null, detail: "invalid_shape" };
+    }
+    return { value: parsed, detail: null };
+  } catch {
+    return { value: null, detail: "invalid_json" };
+  }
+}
+
+function isOutsidePath(relativePath) {
+  return relativePath === "" || relativePath.startsWith("..") || path.isAbsolute(relativePath);
+}
+
+function validateExpectedProductVideoRoot(artifactPath, expectedRoot) {
+  if (typeof expectedRoot !== "string" || expectedRoot.trim() === "") {
+    return "missing_product_video_expected_output_root";
+  }
+  if (!fs.existsSync(expectedRoot) || !fs.statSync(expectedRoot).isDirectory()) {
+    return "product_video_expected_output_root_missing_on_disk";
+  }
+  const realArtifactPath = fs.realpathSync(artifactPath);
+  const realExpectedRoot = fs.realpathSync(expectedRoot);
+  const expectedProductVideoRoot = path.join(realExpectedRoot, "product-video");
+  const relativePath = path.relative(expectedProductVideoRoot, realArtifactPath);
+  if (isOutsidePath(relativePath) || relativePath.includes(path.sep)) {
+    return "product_video_artifact_path_outside_expected_output_root";
+  }
+  return null;
+}
+
+function validateBundleManifest(artifactPath, manifestPath) {
+  const parsed = readJsonObject(manifestPath);
+  if (parsed.detail) return `product_video_bundle_manifest_${parsed.detail}`;
+  if (parsed.value.run_id !== path.basename(artifactPath)) {
+    return "product_video_bundle_manifest_run_id_mismatch";
+  }
+  if (!Array.isArray(parsed.value.files) || parsed.value.files.some((file) => typeof file !== "string")) {
+    return "product_video_bundle_manifest_files_invalid";
+  }
+  for (const requiredFile of PRODUCT_VIDEO_REQUIRED_BUNDLE_FILES) {
+    if (!parsed.value.files.includes(requiredFile)) {
+      return `product_video_bundle_manifest_missing_required_file:${requiredFile}`;
+    }
+  }
+  return null;
+}
+
+export function validateProductVideoArtifactBundle(artifactPath, expectedRoot) {
   if (typeof artifactPath !== "string" || artifactPath.trim() === "") {
     return { artifactPath: null, detail: "missing_product_video_artifact_path" };
   }
@@ -167,13 +245,77 @@ export function validateProductVideoArtifactBundle(artifactPath) {
   if (path.basename(path.dirname(artifactPath)) !== "product-video") {
     return { artifactPath, detail: "product_video_artifact_namespace_mismatch" };
   }
+  const rootDetail = validateExpectedProductVideoRoot(artifactPath, expectedRoot);
+  if (rootDetail) {
+    return { artifactPath, detail: rootDetail };
+  }
   const manifestPath = path.join(artifactPath, "bundle-manifest.json");
   if (!fs.existsSync(manifestPath) || !fs.statSync(manifestPath).isFile()) {
     return { artifactPath, detail: "product_video_bundle_manifest_missing" };
   }
+  const manifestDetail = validateBundleManifest(artifactPath, manifestPath);
+  if (manifestDetail) {
+    return { artifactPath, detail: manifestDetail };
+  }
   return { artifactPath, detail: null };
 }
 
+function valueAtPath(record, pathParts) {
+  let value = record;
+  for (const pathPart of pathParts) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+    value = value[pathPart];
+  }
+  return value;
+}
+
+export function validateProductVideoReadinessBundle(artifactPath, expectedRoot) {
+  const artifactValidation = validateProductVideoArtifactBundle(artifactPath, expectedRoot);
+  if (artifactValidation.detail) return { ...artifactValidation, statuses: [] };
+
+  const statuses = [];
+  const jsonByFile = new Map();
+  for (const gate of PRODUCT_VIDEO_READINESS_GATES) {
+    let parsed = jsonByFile.get(gate.file);
+    if (!parsed) {
+      parsed = readJsonObject(path.join(artifactPath, gate.file));
+      jsonByFile.set(gate.file, parsed);
+    }
+    if (parsed.detail) {
+      return {
+        artifactPath,
+        detail: `product_video_readiness_file_${parsed.detail}:${gate.file}`,
+        statuses
+      };
+    }
+    const status = valueAtPath(parsed.value, gate.path);
+    statuses.push({ label: gate.label, status: typeof status === "string" ? status : null });
+    if (status !== PRODUCT_VIDEO_PASS_STATUS) {
+      return {
+        artifactPath,
+        detail: `product_video_readiness_not_pass:${gate.label}=${typeof status === "string" ? status : "missing"}`,
+        statuses
+      };
+    }
+  }
+
+  return { artifactPath, detail: null, statuses };
+}
+
+export function validateProductVideoWorkflowReadinessArtifact(workflowStatus, artifactPath, expectedRoot) {
+  const artifactValidation = workflowStatus === 0
+    ? validateProductVideoArtifactBundle(artifactPath, expectedRoot)
+    : { artifactPath, detail: null };
+  const readinessValidation = workflowStatus === 0 && artifactValidation.detail === null
+    ? validateProductVideoReadinessBundle(artifactPath, expectedRoot)
+    : { artifactPath, detail: null, statuses: [] };
+  return {
+    artifactPath,
+    detail: artifactValidation.detail ?? readinessValidation.detail,
+    statuses: readinessValidation.statuses
+  };
+}
+
 export function productVideoWorkflowFailureDetail(workflow, artifactDetail) {
   if (workflow.status !== 0) {
     return workflow.detail ?? `product_video_workflow_failed:${workflow.status}`;
@@ -243,9 +385,11 @@ async function runProbe(options) {
 
       const metadataOnlyData = metadataOnlyWorkflow.json?.data ?? {};
       const metadataOnlyArtifactPath = typeof metadataOnlyData.artifact_path === "string" ? metadataOnlyData.artifact_path : null;
-      const metadataOnlyArtifactValidation = metadataOnlyWorkflow.status === 0
-        ? validateProductVideoArtifactBundle(metadataOnlyArtifactPath)
-        : { artifactPath: metadataOnlyArtifactPath, detail: null };
+      const metadataOnlyArtifactValidation = validateProductVideoWorkflowReadinessArtifact(
+        metadataOnlyWorkflow.status,
+        metadataOnlyArtifactPath,
+        outputDir
+      );
       const persistedMetadataOnlyArtifactPath = metadataOnlyWorkflow.status === 0
         && metadataOnlyArtifactValidation.detail === null
         ? persistArtifactBundle(metadataOnlyArtifactPath, runId, "metadata-only")
@@ -263,10 +407,14 @@ async function runProbe(options) {
       pushStep(report, {
         id: "workflow.product_video_run_no_screenshots",
         status: metadataOnlyOk ? "pass" : "fail",
-        detail: metadataOnlyOk ? null : productVideoWorkflowFailureDetail(metadataOnlyWorkflow, metadataOnlyArtifactValidation.detail),
+        detail: metadataOnlyOk ? null : productVideoWorkflowFailureDetail(
+          metadataOnlyWorkflow,
+          metadataOnlyArtifactValidation.detail
+        ),
         data: {
           artifactPath: persistedMetadataOnlyArtifactPath,
           sourceArtifactPath: metadataOnlyArtifactPath,
+          readiness: metadataOnlyArtifactValidation.statuses,
           images: Array.isArray(metadataOnlyData.images) ? metadataOnlyData.images.length : 0,
           screenshots: Array.isArray(metadataOnlyData.screenshots) ? metadataOnlyData.screenshots.length : 0,
           title: metadataOnlyData.manifest?.product?.title ?? null,
@@ -295,9 +443,11 @@ async function runProbe(options) {
 
       const data = workflow.json?.data ?? {};
       const artifactPath = typeof data.artifact_path === "string" ? data.artifact_path : null;
-      const artifactValidation = workflow.status === 0
-        ? validateProductVideoArtifactBundle(artifactPath)
-        : { artifactPath, detail: null };
+      const artifactValidation = validateProductVideoWorkflowReadinessArtifact(
+        workflow.status,
+        artifactPath,
+        screenshotOutputDir
+      );
       const persistedArtifactPath = workflow.status === 0
         && artifactValidation.detail === null
         ? persistArtifactBundle(artifactPath, runId, "with-screenshots")
@@ -324,10 +474,14 @@ async function runProbe(options) {
       pushStep(report, {
         id: "workflow.product_video_run",
         status: workflowOk ? "pass" : "fail",
-        detail: workflowOk ? null : productVideoWorkflowFailureDetail(workflow, artifactValidation.detail),
+        detail: workflowOk ? null : productVideoWorkflowFailureDetail(
+          workflow,
+          artifactValidation.detail
+        ),
         data: {
           artifactPath: persistedArtifactPath,
           sourceArtifactPath: artifactPath,
+          readiness: artifactValidation.statuses,
           images: Array.isArray(data.images) ? data.images.length : 0,
           screenshots: Array.isArray(data.screenshots) ? data.screenshots.length : 0,
           title: data.manifest?.product?.title ?? null,
diff --git a/skills/opendevbrowser-best-practices/SKILL.md b/skills/opendevbrowser-best-practices/SKILL.md
index c7886bf0..516cbb69 100644
--- a/skills/opendevbrowser-best-practices/SKILL.md
+++ b/skills/opendevbrowser-best-practices/SKILL.md
@@ -161,7 +161,7 @@ Rules:
 - for multi-pin Pinterest design harvests, run query discovery with `--query ... --provider social/pinterest` and trust the broad-query harvest only when query-discovered canonical `https://www.pinterest.com/pin/<id>/` URLs become ranked references with manifest-backed first-party pin-media bytes in the same bundle; omitted `--output-dir` runs return `artifact_path`, so inspect that path before assuming `.opendevbrowser/inspiredesign/<runId>`; if the query bundle remains diagnostic-only, read `meta.discovery.acceptedUrls` and `discovery-diagnostics.json`, keep only canonical pin URLs, then use one canonical recovery harvest per selected pin with omitted `--output-dir`
 - `discovery-diagnostics.json` records accepted and rejected URL counts, blocker diagnostics, and recovery actions; login/challenge and search-shell diagnostics are recovery paths, not product-ready evidence
 - canonical Pinterest pin harvests and recovery paths use `captureMode=off` and open the exact canonical pin in the active managed or extension workflow session before byte-backed pin-media extraction, which is required for reliable GIF and video pin capture in live sessions
-- trust multi-pin Pinterest harvest outputs only when top-level `ready=true`, `productSuccess=true`, `artifactAuthority=product_ready`, `evidenceAuthority=pin_media_ready`, `ranked-references.json` is non-empty, and `pin-media-index.json` proves pin-media-first manifest-backed authority for the selected pin; `snapshot_ready` and `motion_ready` are not substitutes for canonical pin-media readiness, screenshot failure after pin-media success is a non-blocking caveat when pin-media authority is complete, `media-analysis.json` remains advisory, and `motion-evidence.json` remains browser replay authority
+- trust multi-pin Pinterest harvest outputs only when top-level `ready=true`, `productSuccess=true`, `artifactAuthority=product_ready`, `evidenceAuthority=pin_media_ready`, `ranked-references.json` is non-empty, and `pin-media-index.json` proves pin-media-first manifest-backed authority for the selected pin; `snapshot_ready` and `motion_ready` are not substitutes for canonical pin-media readiness, unavailable supplemental viewport screenshot evidence is recorded as skipped and satisfied by pin media when authority is complete, `media-analysis.json` remains advisory, and `motion-evidence.json` remains browser replay authority
 - treat `media-analysis.json` as a deterministic design-fact surface from trusted saved pin media, not as readiness authority; `pin-media-index.json` remains the only pin-media readiness and provenance authority
 - use `media-analysis.json` for palette, tone, layout, OCR-free typography structure, text-region layout, sampled saved-media motion facts, `motionSignature`, limitations, and non-goals; do not claim readable text extraction, exact copy, font families, OCR, model vision, Tesseract, OpenCV, Sharp, browser canvas analysis, browser replay evidence, interaction choreography, new dependencies, or raw `mediaAnalysis` in `canvas-plan.request.json`
 - for richer `media-analysis.json`, prefer hosts with FFmpeg and FFprobe available; they are recommended optional host tools, are not bundled static binaries, and are not downloaded by default
diff --git a/skills/opendevbrowser-design-agent/assets/templates/inspiredesign-advanced-brief.v1.json b/skills/opendevbrowser-design-agent/assets/templates/inspiredesign-advanced-brief.v1.json
index dff5b0f7..e7c02b0b 100644
--- a/skills/opendevbrowser-design-agent/assets/templates/inspiredesign-advanced-brief.v1.json
+++ b/skills/opendevbrowser-design-agent/assets/templates/inspiredesign-advanced-brief.v1.json
@@ -25,12 +25,12 @@
         "rebrands"
       ],
       "businessFocus": [
-        "premium SaaS marketing",
-        "product launches",
-        "AI consulting services",
-        "enterprise advisory landing pages",
-        "docs-first brands",
-        "brand refresh surfaces"
+        "premium brand campaigns",
+        "editorial product or service launches",
+        "hospitality and lifestyle experiences",
+        "public service landing pages",
+        "reference-led brand refresh surfaces",
+        "portfolio and campaign surfaces"
       ],
       "keywords": [
         "landing",
diff --git a/src/providers/shopping-report/rules.ts b/src/providers/shopping-report/rules.ts
index 5931752c..d1bc882e 100644
--- a/src/providers/shopping-report/rules.ts
+++ b/src/providers/shopping-report/rules.ts
@@ -76,6 +76,7 @@ const SOFT_DESCRIPTOR_TOKENS = new Set([
 ]);
 
 const BUDGET_PRICE_TOKEN_PATTERN = /\b(?:under|below|less than|no more than|max(?:imum)?|budget|up to)\s+(?:[$\u20ac\u00a3\u00a5]\s*)?(\d+(?:[.,]\d+)?)(?:\s*(?:usd|cad|eur|gbp))?\b|[$\u20ac\u00a3\u00a5]\s*(\d+(?:[.,]\d+)?)/gi;
+const COMPACT_QUANTITY_PACK_TOKEN_PATTERN = /^\d+pack$/;
 
 const PRODUCT_EVIDENCE_ATTRIBUTE_KEYS = new Set([
   "brand",
@@ -90,6 +91,7 @@ const PRODUCT_EVIDENCE_ATTRIBUTE_KEYS = new Set([
 ]);
 
 const normalizeToken = (token: string): string => {
+  if (COMPACT_QUANTITY_PACK_TOKEN_PATTERN.test(token)) return "pack";
   if (token === "ergo") return "ergonomic";
   if (token === "mic" || token === "microphones") return "microphone";
   if (token === "mice") return "mouse";
diff --git a/src/providers/workflows.ts b/src/providers/workflows.ts
index eeff299f..3d07754e 100644
--- a/src/providers/workflows.ts
+++ b/src/providers/workflows.ts
@@ -133,7 +133,8 @@ import {
 import { filterByTimebox } from "./timebox";
 import {
   SHOPPING_PROVIDER_IDS,
-  SHOPPING_PROVIDER_PROFILES
+  SHOPPING_PROVIDER_PROFILES,
+  type ShoppingRegionSupportDiagnostic
 } from "./shopping";
 import { createLogger, redactSensitive } from "../core/logging";
 import { normalizeProviderReasonCode } from "./errors";
@@ -883,6 +884,22 @@ const summarizeShoppingOfferFilterConstraint = (args: {
   return null;
 };
 
+const buildShoppingRegionAlerts = (
+  diagnostics: readonly ShoppingRegionSupportDiagnostic[],
+  requestedRegion?: string
+): Array<Record<string, JsonValue>> => {
+  const unenforcedDiagnostics = diagnostics.filter((entry) => !entry.enforced);
+  if (unenforcedDiagnostics.length === 0) return [];
+  return [{
+    signal: "region_unenforced",
+    reasonCode: "region_unenforced",
+    state: "warning",
+    reason: "Default shopping adapters currently use provider default storefronts, so requested region filters are advisory only and not authoritative.",
+    providers: unenforcedDiagnostics.map((entry) => entry.provider),
+    requested_region: requestedRegion ?? unenforcedDiagnostics[0]?.requestedRegion ?? ""
+  }];
+};
+
 const selectResearchPrimaryConstraintFailures = (
   failures: ProviderFailureEntry[]
 ): ProviderFailureEntry[] => failures.filter((failure) => failure.error.code !== "timeout");
@@ -1279,6 +1296,17 @@ export const workflowTestUtils = {
     reasonCode: ProviderReasonCode,
     count: number
   ): Record<string, number> => incrementReasonCodeDistribution(reasonCodeDistribution, reasonCode, count),
+  buildShoppingRegionAlerts: (
+    diagnostics: readonly ShoppingRegionSupportDiagnostic[],
+    requestedRegion?: string
+  ): Array<Record<string, JsonValue>> => buildShoppingRegionAlerts(diagnostics, requestedRegion),
+  finalizeInspiredesignResponseGuidance: (args: {
+    renderedResponse: Record<string, unknown>;
+    meta: Record<string, unknown>;
+    finalProductReadiness: InspiredesignWorkflowProductReadiness;
+    fallbackFollowthroughSummary: string;
+  }): { response: Record<string, unknown>; meta: Record<string, unknown> } =>
+    finalizeInspiredesignResponseGuidance(args),
   summarizeShoppingOfferFilterConstraint: (args: {
     diagnostics: ShoppingOfferFilterDiagnostic[];
     budget?: number;
@@ -1777,6 +1805,14 @@ type InspiredesignPinMediaArtifactCollation = {
 const INSPIREDESIGN_CAPTURE_UNAVAILABLE_FAILURE =
   "Deep capture requested, but browser capture is unavailable in this execution lane.";
 const REQUIRED_VISUAL_EVIDENCE_MISSING_FAILURE = "Required visual evidence was not captured.";
+const PIN_MEDIA_VISUAL_AUTHORITY_SATISFIED_WARNING = "pin_media_visual_authority_satisfied";
+const PIN_MEDIA_VISUAL_SUPPLEMENTAL_UNAVAILABLE_WARNING = "supplemental_visual_evidence_unavailable";
+const PIN_MEDIA_SUPPLEMENTAL_VISUAL_FAILURE_WARNINGS = new Set([
+  "finalize_failed",
+  "primary_visual_capture_unavailable",
+  "primary_visual_capture_failed",
+  "required_visual_evidence_missing"
+]);
 const INSPIREDESIGN_VISUAL_POLICY_BLOCKER_REASONS = new Set<InspiredesignVisualPolicyDecision["reason"]>([
   "policy_blocked",
   "auth_required",
@@ -3231,17 +3267,85 @@ const hasWorkflowPrimaryPinMediaDesignEvidence = (
 	if (!pinMediaIndexEntry) return false;
 	return isInspiredesignAuthoritativeRankedReference(
 		{
-		id: reference.id,
-		url: reference.url,
-		evidenceAuthority: "pin_media_ready"
+				id: reference.id,
+				url: reference.url,
+				evidenceAuthority: "pin_media_ready"
 		},
 		{ pinMedia: [pinMediaIndexEntry] }
 	);
 };
 
+const hasWorkflowManifestBackedPinMediaDesignEvidence = (
+  reference: InspiredesignReferenceEvidence,
+  persistedArtifactPaths: ReadonlySet<string>
+): boolean => {
+  if (!hasWorkflowPrimaryPinMediaDesignEvidence(reference)) return false;
+  const pinMedia = reference.capture?.pinMedia;
+  if (!pinMedia || pinMedia.status !== "captured") return false;
+  const persistedPinMedia = persistInspiredesignPinterestPinMediaEvidence(pinMedia);
+  const pinMediaIndexEntry = buildInspiredesignPinterestPinMediaIndexEntry(persistedPinMedia);
+  return typeof pinMediaIndexEntry?.path === "string" && persistedArtifactPaths.has(pinMediaIndexEntry.path);
+};
+
+const normalizePinMediaSatisfiedVisualWarnings = (warnings: readonly string[]): string[] => {
+  const retainedWarnings = warnings.filter((warning) => !PIN_MEDIA_SUPPLEMENTAL_VISUAL_FAILURE_WARNINGS.has(warning));
+  return Array.from(new Set([
+    ...retainedWarnings,
+    PIN_MEDIA_VISUAL_SUPPLEMENTAL_UNAVAILABLE_WARNING,
+    PIN_MEDIA_VISUAL_AUTHORITY_SATISFIED_WARNING
+  ]));
+};
+
+const hasVisualPolicyWarning = (warnings: readonly string[]): boolean => (
+  warnings.some((warning) => warning.startsWith("policy:"))
+);
+
+const isPinMediaSupplementalVisualUnavailable = (
+  visual: InspiredesignPersistedVisualEvidence
+): boolean => (
+  visual.status !== "captured"
+  && !hasVisualPolicyWarning(visual.warnings)
+  && visual.warnings.some((warning) => PIN_MEDIA_SUPPLEMENTAL_VISUAL_FAILURE_WARNINGS.has(warning))
+);
+
+const normalizeReferenceVisualEvidenceAfterPinMedia = (
+  reference: InspiredesignReferenceEvidence,
+  persistedArtifactPaths: ReadonlySet<string>
+): InspiredesignReferenceEvidence => {
+  if (!hasWorkflowManifestBackedPinMediaDesignEvidence(reference, persistedArtifactPaths)) return reference;
+  const visual = normalizeInspiredesignCaptureEvidence(reference.capture)?.visual;
+  if (!visual) return reference;
+  const persistedVisual = persistInspiredesignVisualEvidence(visual);
+  if (persistedVisual.status === "captured" && persistedVisual.path) return reference;
+  if (!isPinMediaSupplementalVisualUnavailable(persistedVisual)) return reference;
+  const {
+    bytes: _bytes,
+    failure: _failure,
+    path: _path,
+    sha256: _sha256,
+    ...visualWithoutArtifactFailure
+  } = persistedVisual;
+  const skippedVisual: InspiredesignPersistedVisualEvidence = {
+    ...visualWithoutArtifactFailure,
+    status: "skipped",
+    warnings: normalizePinMediaSatisfiedVisualWarnings(persistedVisual.warnings)
+  };
+  return {
+    ...reference,
+    capture: mergeCaptureVisualEvidence(reference.capture, skippedVisual)
+  };
+};
+
+const normalizeVisualEvidenceAfterPinMedia = (
+  references: InspiredesignReferenceEvidence[],
+  persistedArtifactPaths: ReadonlySet<string>
+): InspiredesignReferenceEvidence[] => (
+  references.map((reference) => normalizeReferenceVisualEvidenceAfterPinMedia(reference, persistedArtifactPaths))
+);
+
 const PIN_MEDIA_FINALIZATION_FAILURE_REASONS = new Set([
-	"pin_media_temp_path_missing",
-	"pin_media_temp_path_mismatch",
+		"pin_media_temp_path_missing",
+		"pin_media_temp_path_mismatch",
 	"pin_media_temp_file_unavailable",
 	"pin_media_temp_file_too_large",
 	"unsupported_byte_signature",
@@ -3620,7 +3724,7 @@ const failReferenceForRequiredVisualEvidence = (
 
 const isPolicySkippedVisualEvidence = (
   visual: InspiredesignVisualEvidenceRuntimeMetadata | InspiredesignPersistedVisualEvidence
-): boolean => visual.status === "skipped" && visual.warnings.some((warning) => warning.startsWith("policy:"));
+): boolean => visual.status === "skipped" && hasVisualPolicyWarning(visual.warnings);
 
 const finalizeInspiredesignReferenceVisual = async (
   reference: InspiredesignReferenceEvidence,
@@ -4218,13 +4322,17 @@ const buildSavedMediaMotionNotice = (args: {
   };
 };
 
-type VisualEvidenceAfterPinMediaStatus = "captured" | "failed" | "skipped";
+type VisualEvidenceAfterPinMediaStatus = "captured" | "skipped";
 
 type VisualEvidenceAfterPinMediaReference = {
   referenceId: string;
   url: string;
   status: VisualEvidenceAfterPinMediaStatus;
-  reason: "screenshot_captured_after_pin_media" | "screenshot_failed_after_pin_media" | "screenshot_not_attempted_after_pin_media";
+  reason:
+    | "screenshot_captured_after_pin_media"
+    | "screenshot_not_attempted_after_pin_media"
+    | "screenshot_policy_skipped_after_pin_media"
+    | "screenshot_skipped_after_pin_media";
   pinMediaPath: string;
   screenshotPath?: string;
   failure?: string;
@@ -4238,6 +4346,15 @@ type VisualEvidenceAfterPinMediaNotice = {
   references: VisualEvidenceAfterPinMediaReference[];
 };
 
+const visualAfterPinMediaSkippedReason = (args: {
+  policySkipped: boolean;
+  skippedByPinMediaAuthority: boolean;
+}): VisualEvidenceAfterPinMediaReference["reason"] => {
+  if (args.policySkipped) return "screenshot_policy_skipped_after_pin_media";
+  if (args.skippedByPinMediaAuthority) return "screenshot_skipped_after_pin_media";
+  return "screenshot_not_attempted_after_pin_media";
+};
+
 type StillImageMotionCaptureNotice = {
   status: "not_applicable";
   reason: "still_image_pin_media";
@@ -4285,22 +4402,24 @@ const visualAfterPinMediaReference = (
       warnings: screenshot.warnings
     };
   }
-  const failed = visual?.status === "failed";
+  const warnings = visual?.warnings ?? [];
+  const skippedByPinMediaAuthority = warnings.includes(PIN_MEDIA_VISUAL_AUTHORITY_SATISFIED_WARNING);
   return {
     referenceId: reference.id,
     url: reference.url,
-    status: failed ? "failed" : "skipped",
-    reason: failed ? "screenshot_failed_after_pin_media" : "screenshot_not_attempted_after_pin_media",
+    status: "skipped",
+    reason: visualAfterPinMediaSkippedReason({
+      policySkipped: hasVisualPolicyWarning(warnings),
+      skippedByPinMediaAuthority
+    }),
     pinMediaPath: pinMedia.path,
-    ...(visual?.failure ? { failure: visual.failure } : {}),
-    warnings: visual?.warnings ?? []
+    warnings
   };
 };
 
 const aggregateVisualAfterPinMediaStatus = (
   references: readonly VisualEvidenceAfterPinMediaReference[]
 ): VisualEvidenceAfterPinMediaStatus => {
-  if (references.some((reference) => reference.status === "failed")) return "failed";
   if (references.every((reference) => reference.status === "captured")) return "captured";
   return "skipped";
 };
@@ -5227,6 +5346,69 @@ const INSPIREDESIGN_PRODUCT_READY_ONLY_ARTIFACTS = new Set<string>([
   INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest,
   INSPIREDESIGN_HANDOFF_FILES.prototypeGuidance
 ]);
+const PRODUCT_READY_FOLLOWTHROUGH_MARKERS = [
+  "canvas-plan.request.json",
+  "continue in canvas",
+  "product-ready",
+  "submit canvas-plan"
+] as const;
+type InspiredesignWorkflowProductReadiness = ReturnType<typeof buildInspiredesignProductReadinessFields>;
+
+const hasProductReadyFollowthroughMarker = (value: unknown): boolean => {
+  if (typeof value !== "string") return false;
+  const normalized = value.toLowerCase();
+  return PRODUCT_READY_FOLLOWTHROUGH_MARKERS.some((marker) => normalized.includes(marker));
+};
+
+const shouldBlockFinalInspiredesignFollowthrough = (args: {
+  renderedResponse: Record<string, unknown>;
+  meta: Record<string, unknown>;
+  finalProductReadiness: InspiredesignWorkflowProductReadiness;
+  fallbackFollowthroughSummary: string;
+}): boolean => {
+  if (args.finalProductReadiness.productSuccess) return false;
+  return [
+    args.meta.productSuccess,
+    args.renderedResponse.followthroughSummary,
+    args.renderedResponse.suggestedNextAction,
+    args.fallbackFollowthroughSummary
+  ].some((value) => value === true || hasProductReadyFollowthroughMarker(value));
+};
+
+const finalizeInspiredesignResponseGuidance = (args: {
+  renderedResponse: Record<string, unknown>;
+  meta: Record<string, unknown>;
+  finalProductReadiness: InspiredesignWorkflowProductReadiness;
+  fallbackFollowthroughSummary: string;
+}): { response: Record<string, unknown>; meta: Record<string, unknown> } => {
+  const productReadyDemoted = shouldBlockFinalInspiredesignFollowthrough(args);
+  const renderedFollowthroughSummary = typeof args.renderedResponse.followthroughSummary === "string"
+    ? args.renderedResponse.followthroughSummary
+    : args.fallbackFollowthroughSummary;
+  const followthroughSummary = productReadyDemoted
+    ? PRODUCT_READINESS_BLOCKED_SUMMARY
+    : renderedFollowthroughSummary;
+  const renderedSuggestedNextAction = typeof args.renderedResponse.suggestedNextAction === "string"
+    ? args.renderedResponse.suggestedNextAction
+    : followthroughSummary;
+  const suggestedNextAction = productReadyDemoted
+    ? PRODUCT_READINESS_BLOCKED_SUMMARY
+    : renderedSuggestedNextAction;
+  return {
+    response: {
+      ...args.renderedResponse,
+      ...args.finalProductReadiness,
+      followthroughSummary,
+      suggestedNextAction
+    },
+    meta: {
+      ...args.meta,
+      ...args.finalProductReadiness,
+      followthroughSummary,
+      suggestedNextAction
+    }
+  };
+};
 
 const isPinterestWorkflowReferenceUrl = (value: string): boolean => {
   try {
@@ -6684,16 +6866,7 @@ export const runShoppingWorkflow = async (
   const regionEnforced = plan.compiled.regionDiagnostics.length > 0
     ? plan.compiled.regionDiagnostics.every((entry) => entry.enforced)
     : false;
-  if (plan.compiled.regionDiagnostics.length > 0) {
-    alerts.push({
-      signal: "region_unenforced",
-      reasonCode: "region_unenforced",
-      state: "warning",
-      reason: "Default shopping adapters currently use provider default storefronts, so requested region filters are advisory only and not authoritative.",
-      providers: plan.compiled.regionDiagnostics.map((entry) => entry.provider),
-      requested_region: workflowInput.region ?? plan.compiled.regionDiagnostics[0]?.requestedRegion ?? ""
-    });
-  }
+  alerts.push(...buildShoppingRegionAlerts(plan.compiled.regionDiagnostics, workflowInput.region));
   let meta = withPrimaryConstraintMeta({
     selection: {
       providers: plan.compiled.effectiveProviderIds,
@@ -6964,13 +7137,14 @@ export const runInspiredesignWorkflow = async (
       captureStatus: capture.captureStatus
     });
   }
-  const motionCollation = await finalizeInspiredesignMotionArtifacts(references, motionEvidenceTempDir);
+	const motionCollation = await finalizeInspiredesignMotionArtifacts(references, motionEvidenceTempDir);
 	const pinMediaCollation = await finalizeInspiredesignPinMediaArtifacts(motionCollation.references, pinMediaEvidenceTempDir);
 	const visualCollation = await finalizeInspiredesignVisualArtifacts(pinMediaCollation.references, workflowInput.visualEvidence);
-  const finalReferences = attachInspiredesignDiscoveryProvenance(
-    visualCollation.references,
-    buildDiscoveryProvenanceByUrl(discovery)
-  );
+	const pinMediaArtifactPaths = new Set(pinMediaCollation.files.map((file) => file.path));
+	const finalReferences = attachInspiredesignDiscoveryProvenance(
+		normalizeVisualEvidenceAfterPinMedia(visualCollation.references, pinMediaArtifactPaths),
+		buildDiscoveryProvenanceByUrl(discovery)
+	);
 	const mediaAnalysisTempDirs: string[] = [];
 	let mediaAnalysis = buildDiagnosticInspiredesignMediaAnalysis();
 	let mediaAnalysisFailure: string | undefined;
@@ -7129,10 +7303,10 @@ export const runInspiredesignWorkflow = async (
     rankedPinMediaReadyReferenceCount,
     rankedAuthoritativePinterestReferenceCount
   );
-	const quality = packet.referencePatternBoard.qualitySummary;
-	const existingMetrics = typeof meta.metrics === "object" && meta.metrics !== null && !Array.isArray(meta.metrics)
-	? meta.metrics as Record<string, unknown>
-	: {};
+  const quality = packet.referencePatternBoard.qualitySummary;
+  const existingMetrics = typeof meta.metrics === "object" && meta.metrics !== null && !Array.isArray(meta.metrics)
+    ? meta.metrics as Record<string, unknown>
+    : {};
   let followthroughSummary = buildInspiredesignGuidanceFollowthroughSummary(
     packet.followthrough,
     meta,
@@ -7147,16 +7321,16 @@ export const runInspiredesignWorkflow = async (
   }
   const metaWithGuidance = {
     ...meta,
-	...(mediaAnalysisFailure ? { mediaAnalysisFailure } : {}),
-	metrics: {
-		...existingMetrics,
-		attempted_reference_count: quality.attemptedReferenceCount,
-		missing_screenshot_count: quality.missingScreenshotCount,
-		all_attempt_failed_capture_count: quality.allAttemptFailedCaptureCount,
-		all_attempt_missing_screenshot_count: quality.allAttemptMissingScreenshotCount,
-		all_attempt_visual_failure_count: quality.allAttemptVisualFailureCount,
-		all_attempt_motion_failure_count: quality.allAttemptMotionFailureCount
-	},
+    ...(mediaAnalysisFailure ? { mediaAnalysisFailure } : {}),
+    metrics: {
+      ...existingMetrics,
+      attempted_reference_count: quality.attemptedReferenceCount,
+      missing_screenshot_count: quality.missingScreenshotCount,
+      all_attempt_failed_capture_count: quality.allAttemptFailedCaptureCount,
+      all_attempt_missing_screenshot_count: quality.allAttemptMissingScreenshotCount,
+      all_attempt_visual_failure_count: quality.allAttemptVisualFailureCount,
+      all_attempt_motion_failure_count: quality.allAttemptMotionFailureCount
+    },
     ...productReadiness,
     pinterestEvidenceRequired,
     followthroughSummary,
@@ -7175,41 +7349,47 @@ export const runInspiredesignWorkflow = async (
     designMarkdown: packet.designMarkdown,
     implementationPlanMarkdown: packet.implementationPlanMarkdown,
     prototypeGuidanceMarkdown: packet.prototypeGuidanceMarkdown,
-	    evidence: packet.evidence,
-	    visualEvidence: packet.visualEvidence,
-	    screenshotIndex: packet.screenshotIndex,
-	    motionEvidence: packet.motionEvidence,
-	    authorityScreenshotIndex: manifestBackedScreenshotIndex,
-	    authorityMotionEvidence: manifestBackedMotionEvidence,
-      pinMediaEvidence: packet.pinMediaEvidence,
-      pinMediaIndex: packet.pinMediaIndex,
-      authorityPinMediaIndex: manifestBackedPinMediaIndex,
-      mediaAnalysis: packet.mediaAnalysis,
-	    rankedReferences: packet.rankedReferences,
+    evidence: packet.evidence,
+    visualEvidence: packet.visualEvidence,
+    screenshotIndex: packet.screenshotIndex,
+    motionEvidence: packet.motionEvidence,
+    authorityScreenshotIndex: manifestBackedScreenshotIndex,
+    authorityMotionEvidence: manifestBackedMotionEvidence,
+    pinMediaEvidence: packet.pinMediaEvidence,
+    pinMediaIndex: packet.pinMediaIndex,
+    authorityPinMediaIndex: manifestBackedPinMediaIndex,
+    mediaAnalysis: packet.mediaAnalysis,
+    rankedReferences: packet.rankedReferences,
     referencePatternBoard: buildInspiredesignRankedArtifactPatternBoard(
       packet.generationPlan.referencePatternBoard,
       packet.referencePatternBoard
     ),
     metaPromptMarkdown: packet.metaPromptMarkdown,
-	    nextStepGuidance,
-	    meta: metaWithGuidance
-	  });
-	  const renderedProductSuccess = (rendered.response as { productSuccess?: unknown }).productSuccess === true;
-	  const finalProductReadiness = renderedProductSuccess && productReadiness.productSuccess
-	    ? productReadiness
-	    : {
-	      ...productReadiness,
-	      ready: false,
-	      productSuccess: false,
-	      artifactAuthority: "diagnostic_only" as const,
-	      evidenceAuthority: "diagnostic_only" as const
-		    };
-	  const renderedFilesForBundle = finalProductReadiness.productSuccess
-	    ? rendered.files
-	    : rendered.files.filter((file) => !INSPIREDESIGN_PRODUCT_READY_ONLY_ARTIFACTS.has(file.path));
-	  const bundle = await createArtifactBundle({
-	    namespace: "inspiredesign",
-	    outputDir: artifactRoot,
+    nextStepGuidance,
+    meta: metaWithGuidance
+  });
+  const renderedProductSuccess = (rendered.response as { productSuccess?: unknown }).productSuccess === true;
+  const finalProductReadiness = renderedProductSuccess && productReadiness.productSuccess
+    ? productReadiness
+    : {
+      ...productReadiness,
+      ready: false,
+      productSuccess: false,
+      artifactAuthority: "diagnostic_only" as const,
+      evidenceAuthority: "diagnostic_only" as const
+    };
+  const renderedFilesForBundle = finalProductReadiness.productSuccess
+    ? rendered.files
+    : rendered.files.filter((file) => !INSPIREDESIGN_PRODUCT_READY_ONLY_ARTIFACTS.has(file.path));
+  const finalGuidance = finalizeInspiredesignResponseGuidance({
+    renderedResponse: rendered.response,
+    meta: metaWithGuidance,
+    finalProductReadiness,
+    fallbackFollowthroughSummary: followthroughSummary
+  });
+  const bundle = await createArtifactBundle({
+    namespace: "inspiredesign",
+    outputDir: artifactRoot,
 	    ttlHours: workflowInput.ttlHours,
 	    files: [
         ...renderedFilesForBundle,
@@ -7222,24 +7402,20 @@ export const runInspiredesignWorkflow = async (
 
   if (workflowInput.mode === "path") {
     return {
-      ...rendered.response,
-      ...finalProductReadiness,
+      ...finalGuidance.response,
       artifact_path: bundle.basePath,
       meta: {
-        ...metaWithGuidance,
-        ...finalProductReadiness,
+        ...finalGuidance.meta,
         artifact_manifest: bundle.manifest
       }
     };
   }
 
   return {
-    ...rendered.response,
-    ...finalProductReadiness,
+    ...finalGuidance.response,
     artifact_path: bundle.basePath,
     meta: {
-      ...metaWithGuidance,
-      ...finalProductReadiness,
+      ...finalGuidance.meta,
       artifact_manifest: bundle.manifest
     }
   };
diff --git a/src/public-surface/generated-manifest.json b/src/public-surface/generated-manifest.json
index 52c72100..41ab054c 100644
--- a/src/public-surface/generated-manifest.json
+++ b/src/public-surface/generated-manifest.json
@@ -569,7 +569,7 @@
         ],
         "notes": [
           "Routine workflow runs should omit --output-dir and inspect the returned artifact_path first; when --output-dir is omitted, persisted bundles use .opendevbrowser/<namespace>/<runId>. If a wrapper requires an explicit workflow root, use --output-dir .opendevbrowser so the runtime appends <namespace>/<runId>.",
-          "Treat --region as advisory unless the workflow output reports region_authoritative=true."
+          "Treat --region as advisory unless the workflow output reports region_authoritative=true. The region_unenforced alert is emitted only for selected provider diagnostics that did not enforce the requested region; enforced-region diagnostics do not create that warning."
         ],
         "groupId": "provider_workflows",
         "groupTitle": "Provider Workflows",
@@ -656,7 +656,7 @@
           "Canonical Pinterest pin-media harvest opens the exact canonical pin in the active managed or extension workflow session before extracting persisted first-party bytes. Extension /ops remains the best live-tab reuse path, and explicit CDP profiles remain a browser/session primitive lane until provider workflows expose an explicit-CDP transport selector.",
           "Harvest JSON is metadata-only: screenshots, motion evidence, and pin-media evidence are artifact files referenced by relative paths, hashes, viewport metadata, frame counts, dimensions, provenance, and warnings.",
           "ranked-references.json includes rejectedReferences for captured-but-rejected diagnostics such as interface_chrome_shell without promoting those captures into design references.",
-          "Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when first-party pin-media evidence is captured, persisted, manifest-backed, and free of blocking warnings. Snapshot and screencast artifacts can inform diagnostics or motion, but they do not satisfy required Pinterest pin-media readiness. The exact login_or_challenge_state and strict byte-backed interface_chrome_shell diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. Screenshot failure after pin-media success is a non-blocking caveat when pin-media authority is complete; pin-media-index.json remains Pinterest authority, media-analysis.json remains advisory, and motion-evidence.json remains browser replay authority.",
+          "Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when first-party pin-media evidence is captured, persisted, manifest-backed, and free of blocking warnings. Snapshot and screencast artifacts can inform diagnostics or motion, but they do not satisfy required Pinterest pin-media readiness. The exact login_or_challenge_state and strict byte-backed interface_chrome_shell diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. When pin-media authority is complete, unavailable supplemental viewport screenshot evidence is recorded as skipped and satisfied by pin media, not as product-readiness failure; pin-media-index.json remains Pinterest authority, media-analysis.json remains advisory, and motion-evidence.json remains browser replay authority.",
           "Load opendevbrowser-motion-design before turning harvest motion posture into implementation timing, scroll choreography, reduced-motion behavior, or temporal proof."
         ],
         "groupId": "provider_workflows",
@@ -2661,7 +2661,8 @@
         "cliEquivalent": "shopping",
         "example": "npx opendevbrowser shopping run --query \"wireless ergonomic mouse\" --providers shopping/bestbuy,shopping/ebay --budget 150 --browser-mode managed --use-cookies --challenge-automation-mode browser_with_helper --mode json --output-format json",
         "notes": [
-          "Routine workflow runs should omit --output-dir and inspect the returned artifact_path first; when --output-dir is omitted, persisted bundles use .opendevbrowser/<namespace>/<runId>. If a wrapper requires an explicit workflow root, use --output-dir .opendevbrowser so the runtime appends <namespace>/<runId>."
+          "Routine workflow runs should omit --output-dir and inspect the returned artifact_path first; when --output-dir is omitted, persisted bundles use .opendevbrowser/<namespace>/<runId>. If a wrapper requires an explicit workflow root, use --output-dir .opendevbrowser so the runtime appends <namespace>/<runId>.",
+          "Treat --region as advisory unless the workflow output reports region_authoritative=true. The region_unenforced alert is emitted only for selected provider diagnostics that did not enforce the requested region; enforced-region diagnostics do not create that warning."
         ]
       },
       {
@@ -2680,6 +2681,7 @@
         "example": "npx opendevbrowser inspiredesign run --brief \"Extract a reusable dashboard design contract from live references\" --url https://linear.app --browser-mode managed --use-cookies --challenge-automation-mode browser_with_helper --include-prototype-guidance --output-format json",
         "notes": [
           "Routine workflow runs should omit --output-dir and inspect the returned artifact_path first; when --output-dir is omitted, persisted bundles use .opendevbrowser/<namespace>/<runId>. If a wrapper requires an explicit workflow root, use --output-dir .opendevbrowser so the runtime appends <namespace>/<runId>.",
+          "Continue only when top-level ready=true, productSuccess=true, artifactAuthority=product_ready, ranked references are non-empty, no matching nextStepGuidance.doNotProceedIf blockers remain active, manifest-backed authority evidence exists, evidenceAuthority is not diagnostic_only, and canonical Pinterest pin-media harvests report evidenceAuthority=pin_media_ready with manifest-backed pin-media-index.json.",
           "FFmpeg and FFprobe are recommended optional host tools for richer media-analysis.json output; OpenDevBrowser does not bundle static FFmpeg binaries or download them by default. Resolution is OPENDEVBROWSER_FFMPEG_PATH and OPENDEVBROWSER_FFPROBE_PATH, then inspiredesign.mediaAnalysis.ffmpegPath and inspiredesign.mediaAnalysis.ffprobePath, then ffmpeg and ffprobe on PATH, then common absolute install directories for implicit PATH-source ENOENT misses only. Invalid env or config paths stay diagnostic and do not fall back. Missing binaries degrade media-analysis.json only, do not fail pin-media readiness, and never make media-analysis.json satisfy product readiness.",
           "status-capabilities reports FFmpeg and FFprobe availability under host.mediaAnalysis so operators can verify optional media-analysis host capability before Inspiredesign runs."
         ]
diff --git a/src/public-surface/generated-manifest.ts b/src/public-surface/generated-manifest.ts
index b61f590f..dbb9b2cc 100644
--- a/src/public-surface/generated-manifest.ts
+++ b/src/public-surface/generated-manifest.ts
@@ -586,7 +586,7 @@ export const PUBLIC_SURFACE_MANIFEST = {
         ],
         "notes": [
           "Routine workflow runs should omit --output-dir and inspect the returned artifact_path first; when --output-dir is omitted, persisted bundles use .opendevbrowser/<namespace>/<runId>. If a wrapper requires an explicit workflow root, use --output-dir .opendevbrowser so the runtime appends <namespace>/<runId>.",
-          "Treat --region as advisory unless the workflow output reports region_authoritative=true."
+          "Treat --region as advisory unless the workflow output reports region_authoritative=true. The region_unenforced alert is emitted only for selected provider diagnostics that did not enforce the requested region; enforced-region diagnostics do not create that warning."
         ],
         "groupId": "provider_workflows",
         "groupTitle": "Provider Workflows",
@@ -673,7 +673,7 @@ export const PUBLIC_SURFACE_MANIFEST = {
           "Canonical Pinterest pin-media harvest opens the exact canonical pin in the active managed or extension workflow session before extracting persisted first-party bytes. Extension /ops remains the best live-tab reuse path, and explicit CDP profiles remain a browser/session primitive lane until provider workflows expose an explicit-CDP transport selector.",
           "Harvest JSON is metadata-only: screenshots, motion evidence, and pin-media evidence are artifact files referenced by relative paths, hashes, viewport metadata, frame counts, dimensions, provenance, and warnings.",
           "ranked-references.json includes rejectedReferences for captured-but-rejected diagnostics such as interface_chrome_shell without promoting those captures into design references.",
-          "Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when first-party pin-media evidence is captured, persisted, manifest-backed, and free of blocking warnings. Snapshot and screencast artifacts can inform diagnostics or motion, but they do not satisfy required Pinterest pin-media readiness. The exact login_or_challenge_state and strict byte-backed interface_chrome_shell diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. Screenshot failure after pin-media success is a non-blocking caveat when pin-media authority is complete; pin-media-index.json remains Pinterest authority, media-analysis.json remains advisory, and motion-evidence.json remains browser replay authority.",
+          "Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when first-party pin-media evidence is captured, persisted, manifest-backed, and free of blocking warnings. Snapshot and screencast artifacts can inform diagnostics or motion, but they do not satisfy required Pinterest pin-media readiness. The exact login_or_challenge_state and strict byte-backed interface_chrome_shell diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. When pin-media authority is complete, unavailable supplemental viewport screenshot evidence is recorded as skipped and satisfied by pin media, not as product-readiness failure; pin-media-index.json remains Pinterest authority, media-analysis.json remains advisory, and motion-evidence.json remains browser replay authority.",
           "Load opendevbrowser-motion-design before turning harvest motion posture into implementation timing, scroll choreography, reduced-motion behavior, or temporal proof."
         ],
         "groupId": "provider_workflows",
@@ -2678,7 +2678,8 @@ export const PUBLIC_SURFACE_MANIFEST = {
         "cliEquivalent": "shopping",
         "example": "npx opendevbrowser shopping run --query \"wireless ergonomic mouse\" --providers shopping/bestbuy,shopping/ebay --budget 150 --browser-mode managed --use-cookies --challenge-automation-mode browser_with_helper --mode json --output-format json",
         "notes": [
-          "Routine workflow runs should omit --output-dir and inspect the returned artifact_path first; when --output-dir is omitted, persisted bundles use .opendevbrowser/<namespace>/<runId>. If a wrapper requires an explicit workflow root, use --output-dir .opendevbrowser so the runtime appends <namespace>/<runId>."
+          "Routine workflow runs should omit --output-dir and inspect the returned artifact_path first; when --output-dir is omitted, persisted bundles use .opendevbrowser/<namespace>/<runId>. If a wrapper requires an explicit workflow root, use --output-dir .opendevbrowser so the runtime appends <namespace>/<runId>.",
+          "Treat --region as advisory unless the workflow output reports region_authoritative=true. The region_unenforced alert is emitted only for selected provider diagnostics that did not enforce the requested region; enforced-region diagnostics do not create that warning."
         ]
       },
       {
@@ -2697,6 +2698,7 @@ export const PUBLIC_SURFACE_MANIFEST = {
         "example": "npx opendevbrowser inspiredesign run --brief \"Extract a reusable dashboard design contract from live references\" --url https://linear.app --browser-mode managed --use-cookies --challenge-automation-mode browser_with_helper --include-prototype-guidance --output-format json",
         "notes": [
           "Routine workflow runs should omit --output-dir and inspect the returned artifact_path first; when --output-dir is omitted, persisted bundles use .opendevbrowser/<namespace>/<runId>. If a wrapper requires an explicit workflow root, use --output-dir .opendevbrowser so the runtime appends <namespace>/<runId>.",
+          "Continue only when top-level ready=true, productSuccess=true, artifactAuthority=product_ready, ranked references are non-empty, no matching nextStepGuidance.doNotProceedIf blockers remain active, manifest-backed authority evidence exists, evidenceAuthority is not diagnostic_only, and canonical Pinterest pin-media harvests report evidenceAuthority=pin_media_ready with manifest-backed pin-media-index.json.",
           "FFmpeg and FFprobe are recommended optional host tools for richer media-analysis.json output; OpenDevBrowser does not bundle static FFmpeg binaries or download them by default. Resolution is OPENDEVBROWSER_FFMPEG_PATH and OPENDEVBROWSER_FFPROBE_PATH, then inspiredesign.mediaAnalysis.ffmpegPath and inspiredesign.mediaAnalysis.ffprobePath, then ffmpeg and ffprobe on PATH, then common absolute install directories for implicit PATH-source ENOENT misses only. Invalid env or config paths stay diagnostic and do not fall back. Missing binaries degrade media-analysis.json only, do not fail pin-media readiness, and never make media-analysis.json satisfy product readiness.",
           "status-capabilities reports FFmpeg and FFprobe availability under host.mediaAnalysis so operators can verify optional media-analysis host capability before Inspiredesign runs."
         ]
diff --git a/src/public-surface/source.ts b/src/public-surface/source.ts
index 4d42da0d..06e9f60a 100644
--- a/src/public-surface/source.ts
+++ b/src/public-surface/source.ts
@@ -867,7 +867,7 @@ const CLI_COMMAND_NOTES: Partial<Record<PublicSurfaceCliCommandName, readonly st
   ],
   shopping: [
     WORKFLOW_OUTPUT_PREFERENCE_NOTE,
-    "Treat --region as advisory unless the workflow output reports region_authoritative=true."
+    "Treat --region as advisory unless the workflow output reports region_authoritative=true. The region_unenforced alert is emitted only for selected provider diagnostics that did not enforce the requested region; enforced-region diagnostics do not create that warning."
   ],
   "product-video": [
     WORKFLOW_OUTPUT_PREFERENCE_NOTE,
@@ -897,7 +897,7 @@ const CLI_COMMAND_NOTES: Partial<Record<PublicSurfaceCliCommandName, readonly st
     "Canonical Pinterest pin-media harvest opens the exact canonical pin in the active managed or extension workflow session before extracting persisted first-party bytes. Extension /ops remains the best live-tab reuse path, and explicit CDP profiles remain a browser/session primitive lane until provider workflows expose an explicit-CDP transport selector.",
     "Harvest JSON is metadata-only: screenshots, motion evidence, and pin-media evidence are artifact files referenced by relative paths, hashes, viewport metadata, frame counts, dimensions, provenance, and warnings.",
     "ranked-references.json includes rejectedReferences for captured-but-rejected diagnostics such as interface_chrome_shell without promoting those captures into design references.",
-    "Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when first-party pin-media evidence is captured, persisted, manifest-backed, and free of blocking warnings. Snapshot and screencast artifacts can inform diagnostics or motion, but they do not satisfy required Pinterest pin-media readiness. The exact login_or_challenge_state and strict byte-backed interface_chrome_shell diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. Screenshot failure after pin-media success is a non-blocking caveat when pin-media authority is complete; pin-media-index.json remains Pinterest authority, media-analysis.json remains advisory, and motion-evidence.json remains browser replay authority.",
+    "Pinterest product readiness is pin-media-first: canonical pin URLs become product-ready only when first-party pin-media evidence is captured, persisted, manifest-backed, and free of blocking warnings. Snapshot and screencast artifacts can inform diagnostics or motion, but they do not satisfy required Pinterest pin-media readiness. The exact login_or_challenge_state and strict byte-backed interface_chrome_shell diagnostics are non-blocking only for trusted first-party manifest-backed pin-media bytes; broader login, challenge, captcha, search-shell, promoted, ad, blank, tiny, or chrome-only blockers still demote readiness unless query-discovered canonical pins also produce complete pin-media authority. When pin-media authority is complete, unavailable supplemental viewport screenshot evidence is recorded as skipped and satisfied by pin media, not as product-readiness failure; pin-media-index.json remains Pinterest authority, media-analysis.json remains advisory, and motion-evidence.json remains browser replay authority.",
     "Load opendevbrowser-motion-design before turning harvest motion posture into implementation timing, scroll choreography, reduced-motion behavior, or temporal proof."
   ],
   "macro-resolve": [
@@ -1063,7 +1063,8 @@ const TOOL_SURFACE_NOTES: Partial<Record<string, readonly string[]>> = {
     WORKFLOW_OUTPUT_PREFERENCE_NOTE
   ],
   opendevbrowser_shopping_run: [
-    WORKFLOW_OUTPUT_PREFERENCE_NOTE
+    WORKFLOW_OUTPUT_PREFERENCE_NOTE,
+    "Treat --region as advisory unless the workflow output reports region_authoritative=true. The region_unenforced alert is emitted only for selected provider diagnostics that did not enforce the requested region; enforced-region diagnostics do not create that warning."
   ],
   opendevbrowser_product_video_run: [
     WORKFLOW_OUTPUT_PREFERENCE_NOTE
@@ -1073,6 +1074,7 @@ const TOOL_SURFACE_NOTES: Partial<Record<string, readonly string[]>> = {
   ],
   opendevbrowser_inspiredesign_run: [
     WORKFLOW_OUTPUT_PREFERENCE_NOTE,
+    "Continue only when top-level ready=true, productSuccess=true, artifactAuthority=product_ready, ranked references are non-empty, no matching nextStepGuidance.doNotProceedIf blockers remain active, manifest-backed authority evidence exists, evidenceAuthority is not diagnostic_only, and canonical Pinterest pin-media harvests report evidenceAuthority=pin_media_ready with manifest-backed pin-media-index.json.",
     MEDIA_ANALYSIS_DEPENDENCY_NOTE,
     MEDIA_ANALYSIS_STATUS_NOTE
   ]
diff --git a/tests/media-analysis-dependency-guidance.test.ts b/tests/media-analysis-dependency-guidance.test.ts
index 11833f13..08209022 100644
--- a/tests/media-analysis-dependency-guidance.test.ts
+++ b/tests/media-analysis-dependency-guidance.test.ts
@@ -233,7 +233,7 @@ describe("media-analysis dependency guidance", () => {
       expect(content, `${section.label} should preserve pin-media authority`).toContain("pin-media-index.json");
       expect(content, `${section.label} should preserve media-analysis advisory status`).toContain("media-analysis.json");
       expect(content, `${section.label} should preserve browser replay authority`).toContain("motion-evidence.json");
-      expect(normalizedContent, `${section.label} should describe screenshot failure as non-blocking`).toContain("screenshot failure after pin-media success is a non-blocking caveat");
+      expect(normalizedContent, `${section.label} should describe skipped supplemental screenshots`).toContain("unavailable supplemental viewport screenshot evidence is recorded as skipped");
     }
   });
 
diff --git a/tests/product-video-fixture-live-probe.test.ts b/tests/product-video-fixture-live-probe.test.ts
index e67d0b48..edbb19c6 100644
--- a/tests/product-video-fixture-live-probe.test.ts
+++ b/tests/product-video-fixture-live-probe.test.ts
@@ -3,37 +3,143 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import {
+  createProductFixtureServer,
   productVideoWorkflowFailureDetail,
-  validateProductVideoArtifactBundle
+  validateProductVideoArtifactBundle,
+  validateProductVideoReadinessBundle,
+  validateProductVideoWorkflowReadinessArtifact
 } from "../scripts/product-video-fixture-live-probe.mjs";
 
+const passReadiness = {
+  status: "pass",
+  warnings: [],
+  reasonCodes: ["positive_spec_promoted"],
+  criteria: []
+};
+
+const bundleManifestFiles = [
+  "images/widget-01.png",
+  "manifest.json",
+  "product.json",
+  "presentation-readiness.json",
+  "bundle-manifest.json"
+];
+
+type BundleOptions = {
+  files?: string[];
+  manifestRunId?: string;
+  runId?: string;
+  status?: string;
+};
+
+const writeReadinessBundle = (root: string, options: BundleOptions = {}) => {
+  const runId = options.runId ?? "run-1";
+  const status = options.status ?? "pass";
+  const run = join(root, "product-video", runId);
+  mkdirSync(run, { recursive: true });
+  writeFileSync(join(run, "bundle-manifest.json"), `${JSON.stringify({
+    run_id: options.manifestRunId ?? runId,
+    files: options.files ?? bundleManifestFiles
+  })}\n`);
+  const readiness = { ...passReadiness, status };
+  writeFileSync(join(run, "manifest.json"), `${JSON.stringify({
+    readiness: {
+      presentation: readiness,
+      productVideo: readiness
+    }
+  })}\n`);
+  writeFileSync(join(run, "presentation-readiness.json"), `${JSON.stringify({
+    summary: { status },
+    presentationReadiness: readiness,
+    productVideoReadiness: readiness
+  })}\n`);
+  writeFileSync(join(run, "product.json"), `${JSON.stringify({
+    presentationReadiness: readiness,
+    productVideoReadiness: readiness
+  })}\n`);
+  return run;
+};
+
+const listenOnLocalhost = async (server: ReturnType<typeof createProductFixtureServer>): Promise<string> => {
+  await new Promise<void>((resolve, reject) => {
+    const onError = (error: Error) => {
+      server.off("error", onError);
+      reject(error);
+    };
+    server.once("error", onError);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", onError);
+      resolve();
+    });
+  });
+
+  const address = server.address();
+  if (typeof address !== "object" || address === null) {
+    throw new Error("Fixture server did not return a TCP address.");
+  }
+  return `http://127.0.0.1:${address.port}`;
+};
+
+const closeServer = async (server: ReturnType<typeof createProductFixtureServer>): Promise<void> => {
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+};
+
 describe("product-video fixture live probe artifact validation", () => {
+  it("serves fixture image URLs on the actual local server port", async () => {
+    const server = createProductFixtureServer();
+    const baseUrl = await listenOnLocalhost(server);
+    try {
+      const productResponse = await fetch(`${baseUrl}/product/widget-pro`);
+      expect(productResponse.ok).toBe(true);
+      const html = await productResponse.text();
+
+      expect(html).toContain(`${baseUrl}/assets/widget-01.png`);
+      expect(html).not.toContain("127.0.0.1:/assets/");
+
+      const imageResponse = await fetch(`${baseUrl}/assets/widget-01.png`);
+      expect(imageResponse.ok).toBe(true);
+      expect(imageResponse.headers.get("content-type")).toBe("image/png");
+      expect((await imageResponse.arrayBuffer()).byteLength).toBeGreaterThan(0);
+    } finally {
+      await closeServer(server);
+    }
+  });
+
   it("requires product-video namespace and a real bundle manifest file", () => {
     const root = mkdtempSync(join(tmpdir(), "odb-product-video-fixture-"));
     try {
-      const validRun = join(root, "product-video", "run-1");
+      const validRun = writeReadinessBundle(root);
       const wrongNamespaceRun = join(root, "product-assets", "run-1");
       const directoryManifestRun = join(root, "product-video", "run-2");
-      mkdirSync(validRun, { recursive: true });
       mkdirSync(wrongNamespaceRun, { recursive: true });
       mkdirSync(directoryManifestRun, { recursive: true });
-      writeFileSync(join(validRun, "bundle-manifest.json"), "{}\n");
-      writeFileSync(join(wrongNamespaceRun, "bundle-manifest.json"), "{}\n");
+      writeFileSync(join(wrongNamespaceRun, "bundle-manifest.json"), `${JSON.stringify({
+        run_id: "run-1",
+        files: bundleManifestFiles
+      })}\n`);
       mkdirSync(join(directoryManifestRun, "bundle-manifest.json"));
 
-      expect(validateProductVideoArtifactBundle(validRun)).toEqual({
+      expect(validateProductVideoArtifactBundle(validRun, root)).toEqual({
         artifactPath: validRun,
         detail: null
       });
-      expect(validateProductVideoArtifactBundle(wrongNamespaceRun)).toEqual({
+      expect(validateProductVideoArtifactBundle(wrongNamespaceRun, root)).toEqual({
         artifactPath: wrongNamespaceRun,
         detail: "product_video_artifact_namespace_mismatch"
       });
-      expect(validateProductVideoArtifactBundle(directoryManifestRun)).toEqual({
+      expect(validateProductVideoArtifactBundle(directoryManifestRun, root)).toEqual({
         artifactPath: directoryManifestRun,
         detail: "product_video_bundle_manifest_missing"
       });
-      expect(validateProductVideoArtifactBundle("")).toEqual({
+      expect(validateProductVideoArtifactBundle("", root)).toEqual({
         artifactPath: null,
         detail: "missing_product_video_artifact_path"
       });
@@ -42,6 +148,57 @@ describe("product-video fixture live probe artifact validation", () => {
     }
   });
 
+  it("rejects artifacts outside the expected output root", () => {
+    const root = mkdtempSync(join(tmpdir(), "odb-product-video-outside-root-"));
+    try {
+      const expectedRoot = join(root, "expected-output");
+      mkdirSync(expectedRoot, { recursive: true });
+      const run = writeReadinessBundle(join(root, "actual-output"));
+
+      expect(validateProductVideoArtifactBundle(run, expectedRoot)).toEqual({
+        artifactPath: run,
+        detail: "product_video_artifact_path_outside_expected_output_root"
+      });
+      expect(validateProductVideoWorkflowReadinessArtifact(0, run, expectedRoot)).toEqual({
+        artifactPath: run,
+        detail: "product_video_artifact_path_outside_expected_output_root",
+        statuses: []
+      });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects bundle manifests with a run_id mismatch", () => {
+    const root = mkdtempSync(join(tmpdir(), "odb-product-video-run-id-"));
+    try {
+      const run = writeReadinessBundle(root, { manifestRunId: "other-run" });
+
+      expect(validateProductVideoArtifactBundle(run, root)).toEqual({
+        artifactPath: run,
+        detail: "product_video_bundle_manifest_run_id_mismatch"
+      });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects bundle manifests missing required sidecars", () => {
+    const root = mkdtempSync(join(tmpdir(), "odb-product-video-sidecars-"));
+    try {
+      const run = writeReadinessBundle(root, {
+        files: ["images/widget-01.png", "manifest.json", "product.json", "bundle-manifest.json"]
+      });
+
+      expect(validateProductVideoArtifactBundle(run, root)).toEqual({
+        artifactPath: run,
+        detail: "product_video_bundle_manifest_missing_required_file:presentation-readiness.json"
+      });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
   it("reports workflow command failures before artifact validation failures", () => {
     expect(productVideoWorkflowFailureDetail({
       status: 1,
@@ -52,4 +209,57 @@ describe("product-video fixture live probe artifact validation", () => {
       detail: null
     }, "missing_product_video_artifact_path")).toBe("missing_product_video_artifact_path");
   });
+
+  it("requires pass readiness across manifest, readiness sidecar, and product sidecar", () => {
+    const root = mkdtempSync(join(tmpdir(), "odb-product-video-readiness-"));
+    try {
+      const run = writeReadinessBundle(root);
+
+      expect(validateProductVideoReadinessBundle(run, root)).toMatchObject({
+        artifactPath: run,
+        detail: null,
+        statuses: expect.arrayContaining([
+          { label: "manifest.readiness.presentation.status", status: "pass" },
+          { label: "presentation-readiness.json.summary.status", status: "pass" },
+          { label: "product.json.productVideoReadiness.status", status: "pass" }
+        ])
+      });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("fails readiness validation when any production gate is partial", () => {
+    const root = mkdtempSync(join(tmpdir(), "odb-product-video-readiness-partial-"));
+    try {
+      const run = writeReadinessBundle(root, { status: "partial" });
+
+      expect(validateProductVideoReadinessBundle(run, root)).toEqual({
+        artifactPath: run,
+        detail: "product_video_readiness_not_pass:manifest.readiness.presentation.status=partial",
+        statuses: [
+          { label: "manifest.readiness.presentation.status", status: "partial" }
+        ]
+      });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("fails workflow artifact validation on partial sidecars before wrapper success can pass", () => {
+    const root = mkdtempSync(join(tmpdir(), "odb-product-video-workflow-readiness-"));
+    try {
+      const run = writeReadinessBundle(root, { status: "partial" });
+
+      expect(validateProductVideoWorkflowReadinessArtifact(0, run, root)).toEqual({
+        artifactPath: run,
+        detail: "product_video_readiness_not_pass:manifest.readiness.presentation.status=partial",
+        statuses: [
+          { label: "manifest.readiness.presentation.status", status: "partial" }
+        ]
+      });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
 });
diff --git a/tests/providers-inspiredesign-brief-expansion.test.ts b/tests/providers-inspiredesign-brief-expansion.test.ts
index 1871cd3d..41ff8837 100644
--- a/tests/providers-inspiredesign-brief-expansion.test.ts
+++ b/tests/providers-inspiredesign-brief-expansion.test.ts
@@ -74,6 +74,23 @@ describe("inspiredesign brief expansion", () => {
     expect(result.format.route.navigationModel).toBe("global-header");
   });
 
+  it("keeps default editorial business focus vertical-neutral for hospitality briefs", async () => {
+    const { expandInspiredesignBrief } = await loadBriefExpansion();
+    const result = expandInspiredesignBrief(
+      "Premium independent restaurant landing page with editorial food photography, reservation CTA, warm hospitality, cinematic whitespace, and refined typography."
+    );
+
+    expect(result.format.id).toBe("premium-editorial-landing-page");
+    expect(result.format.businessFocus).toEqual(expect.arrayContaining([
+      "premium brand campaigns",
+      "hospitality and lifestyle experiences"
+    ]));
+    expect(result.advancedBrief).not.toContain("premium SaaS marketing");
+    expect(result.advancedBrief).not.toContain("AI consulting services");
+    expect(result.advancedBrief).not.toContain("enterprise advisory landing pages");
+    expect(result.advancedBrief).not.toContain("docs-first brands");
+  });
+
   it("removes negated dashboard phrases with modifiers before scoring", async () => {
     const { expandInspiredesignBrief } = await loadBriefExpansion();
     const result = expandInspiredesignBrief(
diff --git a/tests/providers-inspiredesign-workflow.test.ts b/tests/providers-inspiredesign-workflow.test.ts
index 5f33f019..ee0aa5e6 100644
--- a/tests/providers-inspiredesign-workflow.test.ts
+++ b/tests/providers-inspiredesign-workflow.test.ts
@@ -2812,7 +2812,7 @@ describe("inspiredesign workflow", () => {
 	expect(motionEvidence.motionEvidence).toEqual([]);
 	});
 
-	it("keeps pin-media product readiness when post-pin screenshot fails and handoff names the saved media", async () => {
+	it("keeps pin-media product readiness when post-pin screenshot is unavailable and records visual lane as skipped", async () => {
 	const runtime = toRuntime({
 		fetch: async (input: { url: string }) => makeAggregate({
 		records: [
@@ -2868,39 +2868,130 @@ describe("inspiredesign workflow", () => {
 		};
 		motionCapture?: { status: string; reason: string; authority: string };
 	};
-	const screenshotIndex = JSON.parse(readFileSync(join(artifactPath, "screenshot-index.json"), "utf8")) as {
-		screenshots: unknown[];
-	};
-	const rankedReferencesText = readFileSync(join(artifactPath, "ranked-references.json"), "utf8");
-	const handoffText = readFileSync(join(artifactPath, INSPIREDESIGN_HANDOFF_FILES.designAgentHandoff), "utf8");
-	const implementationPlanText = readFileSync(join(artifactPath, INSPIREDESIGN_HANDOFF_FILES.implementationPlanMarkdown), "utf8");
+		const screenshotIndex = JSON.parse(readFileSync(join(artifactPath, "screenshot-index.json"), "utf8")) as {
+			screenshots: unknown[];
+		};
+		const visualEvidence = JSON.parse(readFileSync(join(artifactPath, "visual-evidence.json"), "utf8")) as {
+			visualEvidence: Array<{ visual: { status: string; path?: string; failure?: string; warnings: string[] } }>;
+		};
+		const rankedReferencesText = readFileSync(join(artifactPath, "ranked-references.json"), "utf8");
+		const handoffText = readFileSync(join(artifactPath, INSPIREDESIGN_HANDOFF_FILES.designAgentHandoff), "utf8");
+		const implementationPlanText = readFileSync(join(artifactPath, INSPIREDESIGN_HANDOFF_FILES.implementationPlanMarkdown), "utf8");
 	const prototypeGuidanceText = readFileSync(join(artifactPath, INSPIREDESIGN_HANDOFF_FILES.prototypeGuidance), "utf8");
 
 	expect(output).toEqual(expect.objectContaining({
 		productSuccess: true,
 		artifactAuthority: "product_ready",
 		evidenceAuthority: "pin_media_ready"
+		}));
+		expect(screenshotIndex.screenshots).toEqual([]);
+		expect(visualEvidence.visualEvidence[0]?.visual).toEqual(expect.objectContaining({
+			status: "skipped",
+			warnings: expect.arrayContaining(["pin_media_visual_authority_satisfied"])
+		}));
+		expect(visualEvidence.visualEvidence[0]?.visual.failure).toBeUndefined();
+		expect(visualEvidence.visualEvidence[0]?.visual.path).toBeUndefined();
+		expect(evidence.visualEvidenceAfterPinMedia).toEqual(expect.objectContaining({
+			status: "skipped",
+			authority: "pin_media_ready",
+			references: [expect.objectContaining({
+			status: "skipped",
+			reason: "screenshot_skipped_after_pin_media",
+			pinMediaPath: "pin-media-evidence/b7a5656033e1/main.jpg"
+			})]
+		}));
+	expect(evidence.motionCapture).toEqual(expect.objectContaining({
+		status: "not_applicable",
+		reason: "still_image_pin_media",
+		authority: "motion_evidence_browser_replay_only"
 	}));
-	expect(screenshotIndex.screenshots).toEqual([]);
+		for (const payload of [rankedReferencesText, handoffText, implementationPlanText, prototypeGuidanceText]) {
+			expect(payload).toContain("pin-media-evidence/b7a5656033e1/main.jpg");
+			expect(payload).not.toContain("No live reference cues were captured");
+			expect(payload).not.toContain("Screenshot failure");
+		}
+		});
+
+	it("does not treat policy-skipped post-pin visual evidence as pin-media-satisfied supplemental evidence", async () => {
+	const runtime = toRuntime({
+		fetch: async (input: { url: string }) => makeAggregate({
+		records: [
+			normalizeRecord("social/pinterest", "social", {
+			url: input.url,
+			title: "Pinterest recovered image pin reference",
+			content: "Pin media is available, but viewport capture is policy-blocked.",
+			attributes: {
+				pinterestMediaClassification: {
+				kind: "unknown_pin",
+				mediaSignals: ["pin_url"],
+				rejectionReasons: ["visual_policy_blocked"],
+				sourcePageQuality: "pin_media"
+				}
+			}
+			})
+		]
+		})
+	});
+
+	const output = await runInspiredesignWorkflow(runtime, {
+		brief: "Design a restaurant landing page with Pinterest references",
+		harvest: true,
+		providers: ["social/pinterest"],
+		urls: ["https://www.pinterest.com/pin/27654985208435505/"],
+		outputDir: makeOutputDir(),
+		mode: "path",
+		visualEvidence: "required",
+		includePrototypeGuidance: true
+	}, {
+		capturePinMediaEvidence: async (_url, options) => {
+		writeFileSync(options.pinMediaEvidencePath, validPinMediaBytes());
+		return makePinterestImagePinMediaCapture(_url, options, "https://i.pinimg.com/originals/pin-main-final.jpg");
+		},
+		captureVisualEvidence: async () => ({
+		status: "skipped" as const,
+		kind: "viewport" as const,
+		fullPage: false,
+		capturedAt: "2026-05-23T00:00:00.000Z",
+		warnings: ["policy:policy_blocked"],
+		failure: "Policy blocked viewport capture."
+		})
+	});
+
+	const artifactPath = String(output.artifact_path);
+	const visualEvidence = JSON.parse(readFileSync(join(artifactPath, "visual-evidence.json"), "utf8")) as {
+		visualEvidence: Array<{ visual: { status: string; path?: string; failure?: string; warnings: string[] } }>;
+	};
+	const evidence = JSON.parse(readFileSync(join(artifactPath, "evidence.json"), "utf8")) as {
+		visualEvidenceAfterPinMedia?: {
+		status: string;
+		authority: string;
+		references: Array<{ status: string; reason: string; pinMediaPath?: string; warnings?: string[] }>;
+		};
+	};
+
+	expect(output).toEqual(expect.objectContaining({
+		productSuccess: true,
+		artifactAuthority: "product_ready",
+		evidenceAuthority: "pin_media_ready"
+	}));
+	expect(visualEvidence.visualEvidence[0]?.visual).toEqual(expect.objectContaining({
+		status: "skipped",
+		failure: "Policy blocked viewport capture.",
+		warnings: ["policy:policy_blocked"]
+	}));
+	expect(visualEvidence.visualEvidence[0]?.visual.warnings).not.toContain("pin_media_visual_authority_satisfied");
+	expect(visualEvidence.visualEvidence[0]?.visual.warnings).not.toContain("supplemental_visual_evidence_unavailable");
+	expect(visualEvidence.visualEvidence[0]?.visual.path).toBeUndefined();
 	expect(evidence.visualEvidenceAfterPinMedia).toEqual(expect.objectContaining({
-		status: "failed",
+		status: "skipped",
 		authority: "pin_media_ready",
 		references: [expect.objectContaining({
-		status: "failed",
-		reason: "screenshot_failed_after_pin_media",
-		failure: "Primary visual evidence capture unavailable after pin media.",
-		pinMediaPath: "pin-media-evidence/b7a5656033e1/main.jpg"
+		status: "skipped",
+		reason: "screenshot_policy_skipped_after_pin_media",
+		pinMediaPath: "pin-media-evidence/b7a5656033e1/main.jpg",
+		warnings: ["policy:policy_blocked"]
 		})]
 	}));
-	expect(evidence.motionCapture).toEqual(expect.objectContaining({
-		status: "not_applicable",
-		reason: "still_image_pin_media",
-		authority: "motion_evidence_browser_replay_only"
-	}));
-	for (const payload of [rankedReferencesText, handoffText, implementationPlanText, prototypeGuidanceText]) {
-		expect(payload).toContain("pin-media-evidence/b7a5656033e1/main.jpg");
-		expect(payload).not.toContain("No live reference cues were captured");
-	}
 	});
 
 	it("persists pin media for canonical pins even when provider classification sees login chrome", async () => {
diff --git a/tests/providers-shopping-report.test.ts b/tests/providers-shopping-report.test.ts
index 76df2f55..43a5e972 100644
--- a/tests/providers-shopping-report.test.ts
+++ b/tests/providers-shopping-report.test.ts
@@ -364,6 +364,19 @@ describe("shopping-report", () => {
     expect(emptyQueryRelevance.missingTokens).toEqual([]);
   });
 
+  it("matches compact quantity pack title tokens without accepting unrelated words", () => {
+    const compactPackRelevance = assessQueryRelevance("pack", "Durcord USB C Cable 2Pack 100W 6ft");
+    const hyphenatedPackRelevance = assessQueryRelevance("pack", "Durcord USB C Cable 2-pack 100W 6ft");
+    const unrelatedBackpackRelevance = assessQueryRelevance("pack", "Travel Backpack");
+
+    expect(compactPackRelevance.status).toBe("strong");
+    expect(compactPackRelevance.missingTokens).toEqual([]);
+    expect(hyphenatedPackRelevance.status).toBe("strong");
+    expect(hyphenatedPackRelevance.missingTokens).toEqual([]);
+    expect(unrelatedBackpackRelevance.status).toBe("weak");
+    expect(unrelatedBackpackRelevance.missingTokens).toEqual(["pack"]);
+  });
+
   it("ignores budget price numbers in query relevance while preserving product spec numbers", () => {
     const budgetBriefing = buildShoppingBriefing(briefingInput({
       query: "ergonomic mouse under $150",
diff --git a/tests/providers-workflows-branches.test.ts b/tests/providers-workflows-branches.test.ts
index b76c6376..aaaaa3b2 100644
--- a/tests/providers-workflows-branches.test.ts
+++ b/tests/providers-workflows-branches.test.ts
@@ -1623,6 +1623,139 @@ describe("workflow branch coverage", () => {
       2
     )).toEqual({ auth_required: 1, rate_limited: 2 });
 
+    const enforcedRegionDiagnostic = {
+      provider: "shopping/canada",
+      requestedRegion: "CA",
+      enforced: true,
+      strategy: "default_storefront" as const,
+      storefrontDomain: "example.ca",
+      reason: "provider_search_path_ignores_region" as const
+    };
+    const unenforcedRegionDiagnostic = {
+      provider: "shopping/amazon",
+      requestedRegion: "CA",
+      enforced: false,
+      strategy: "default_storefront" as const,
+      storefrontDomain: "amazon.com",
+      reason: "provider_search_path_ignores_region" as const
+    };
+    expect(workflowTestUtils.buildShoppingRegionAlerts([enforcedRegionDiagnostic], "CA")).toEqual([]);
+    expect(workflowTestUtils.buildShoppingRegionAlerts([
+      enforcedRegionDiagnostic,
+      unenforcedRegionDiagnostic
+    ])).toEqual([
+      expect.objectContaining({
+        signal: "region_unenforced",
+        reasonCode: "region_unenforced",
+        providers: ["shopping/amazon"],
+        requested_region: "CA"
+      })
+    ]);
+
+    const finalizedInspiredesignGuidance = workflowTestUtils.finalizeInspiredesignResponseGuidance({
+      renderedResponse: {
+        followthroughSummary: "Continue in Canvas with this product-ready packet.",
+        suggestedNextAction: "Submit canvas-plan.request.json to Canvas.",
+        productSuccess: true,
+        artifactAuthority: "product_ready"
+      },
+      meta: {
+        followthroughSummary: "Continue in Canvas with this product-ready packet.",
+        suggestedNextAction: "Submit canvas-plan.request.json to Canvas.",
+        productSuccess: true
+      },
+      finalProductReadiness: {
+        ready: false,
+        readiness: "diagnostic_only",
+        guidanceReady: true,
+        guidanceReadiness: "ready",
+        harvestReadiness: "ready",
+        productSuccess: false,
+        artifactAuthority: "diagnostic_only",
+        evidenceAuthority: "diagnostic_only",
+        rankedReferenceCount: 1,
+        authoritativeReferenceCount: 0,
+        snapshotReadyReferenceCount: 0,
+        motionReadyReferenceCount: 0,
+        pinMediaReadyReferenceCount: 0
+      },
+      fallbackFollowthroughSummary: "Continue in Canvas with this product-ready packet."
+    });
+    expect(finalizedInspiredesignGuidance.response).toEqual(expect.objectContaining({
+      followthroughSummary: "Canvas continuation unavailable until ranked references include authoritative visual, motion, or pin-media evidence.",
+      suggestedNextAction: "Canvas continuation unavailable until ranked references include authoritative visual, motion, or pin-media evidence.",
+      productSuccess: false,
+      artifactAuthority: "diagnostic_only"
+    }));
+    expect(finalizedInspiredesignGuidance.meta).toEqual(expect.objectContaining({
+      followthroughSummary: "Canvas continuation unavailable until ranked references include authoritative visual, motion, or pin-media evidence.",
+      suggestedNextAction: "Canvas continuation unavailable until ranked references include authoritative visual, motion, or pin-media evidence.",
+      productSuccess: false,
+      artifactAuthority: "diagnostic_only"
+    }));
+    const finalizedStaleRenderedGuidance = workflowTestUtils.finalizeInspiredesignResponseGuidance({
+      renderedResponse: {
+        followthroughSummary: "Continue in Canvas with this product-ready packet.",
+        suggestedNextAction: "Submit canvas-plan.request.json to Canvas."
+      },
+      meta: {
+        productSuccess: false
+      },
+      finalProductReadiness: {
+        ready: false,
+        readiness: "diagnostic_only",
+        guidanceReady: true,
+        guidanceReadiness: "ready",
+        harvestReadiness: "ready",
+        productSuccess: false,
+        artifactAuthority: "diagnostic_only",
+        evidenceAuthority: "diagnostic_only",
+        rankedReferenceCount: 1,
+        authoritativeReferenceCount: 0,
+        snapshotReadyReferenceCount: 0,
+        motionReadyReferenceCount: 0,
+        pinMediaReadyReferenceCount: 0
+      },
+      fallbackFollowthroughSummary: "Diagnostic guidance should remain available."
+    });
+    expect(finalizedStaleRenderedGuidance.response).toEqual(expect.objectContaining({
+      followthroughSummary: "Canvas continuation unavailable until ranked references include authoritative visual, motion, or pin-media evidence.",
+      suggestedNextAction: "Canvas continuation unavailable until ranked references include authoritative visual, motion, or pin-media evidence.",
+      productSuccess: false,
+      artifactAuthority: "diagnostic_only"
+    }));
+    const finalizedRecoveryGuidance = workflowTestUtils.finalizeInspiredesignResponseGuidance({
+      renderedResponse: {
+        followthroughSummary: "Primary constraint: Pinterest requires recovery before capture. Retry with a logged-in managed profile.",
+        suggestedNextAction: "Retry with a logged-in managed profile."
+      },
+      meta: {
+        productSuccess: false
+      },
+      finalProductReadiness: {
+        ready: false,
+        readiness: "diagnostic_only",
+        guidanceReady: false,
+        guidanceReadiness: "needs_recovery",
+        harvestReadiness: "needs_recovery",
+        productSuccess: false,
+        artifactAuthority: "diagnostic_only",
+        evidenceAuthority: "diagnostic_only",
+        rankedReferenceCount: 0,
+        authoritativeReferenceCount: 0,
+        snapshotReadyReferenceCount: 0,
+        motionReadyReferenceCount: 0,
+        pinMediaReadyReferenceCount: 0
+      },
+      fallbackFollowthroughSummary: "Primary constraint: Pinterest requires recovery before capture."
+    });
+    expect(finalizedRecoveryGuidance.response).toEqual(expect.objectContaining({
+      followthroughSummary: "Primary constraint: Pinterest requires recovery before capture. Retry with a logged-in managed profile.",
+      suggestedNextAction: "Retry with a logged-in managed profile.",
+      productSuccess: false,
+      artifactAuthority: "diagnostic_only"
+    }));
+
     for (const malformedGuidance of [
       { recommendedNextCommands: ["retry command"] },
       { reason: "Retry later." },
diff --git a/tests/public-surface-manifest.test.ts b/tests/public-surface-manifest.test.ts
index f5b48dfc..4d5f22e9 100644
--- a/tests/public-surface-manifest.test.ts
+++ b/tests/public-surface-manifest.test.ts
@@ -116,9 +116,16 @@ describe("public surface manifest", () => {
   it("documents inspiredesign readiness blockers and Pinterest evidence prerequisites", () => {
     const inspiredesignCommand = GENERATED_MANIFEST.cli.commands.find((command) => command.name === "inspiredesign");
     const notes = inspiredesignCommand?.notes.join(" ") ?? "";
+    const shoppingCommand = GENERATED_MANIFEST.cli.commands.find((command) => command.name === "shopping");
+    const shoppingNotes = shoppingCommand?.notes.join(" ") ?? "";
+    const shoppingTool = GENERATED_MANIFEST.tools.entries.find((entry) => entry.name === "opendevbrowser_shopping_run");
+    const shoppingToolNotes = shoppingTool?.notes?.join(" ") ?? "";
     const inspiredesignTool = GENERATED_MANIFEST.tools.entries.find((entry) => entry.name === "opendevbrowser_inspiredesign_run");
+    const toolNotes = inspiredesignTool?.notes?.join(" ") ?? "";
     const helpText = getHelpText();
 
+    expect(shoppingNotes).toContain("region_unenforced alert is emitted only for selected provider diagnostics that did not enforce the requested region");
+    expect(shoppingToolNotes).toContain("region_unenforced alert is emitted only for selected provider diagnostics that did not enforce the requested region");
     expect(notes).toContain("Canvas continuation requires top-level ready=true, productSuccess=true, artifactAuthority=product_ready, non-empty ranked references");
     expect(notes).toContain("Canonical Pinterest pin-media harvests require evidenceAuthority=pin_media_ready and manifest-backed pin-media-index.json");
     expect(notes).toContain("Canonical Pinterest pin-media harvests require evidenceAuthority=pin_media_ready and manifest-backed pin-media-index.json");
@@ -133,6 +140,12 @@ describe("public surface manifest", () => {
     expect(notes).toContain("diagnostic-only captures");
     expect(inspiredesignTool?.description).toContain("screenshot and screencast evidence for non-Pinterest capture lanes");
     expect(inspiredesignTool?.description).toContain("required manifest-backed pin-media authority for canonical Pinterest pins");
+    expect(toolNotes).toContain("Continue only when top-level ready=true, productSuccess=true, artifactAuthority=product_ready");
+    expect(toolNotes).toContain("ranked references are non-empty");
+    expect(toolNotes).toContain("no matching nextStepGuidance.doNotProceedIf blockers remain active");
+    expect(toolNotes).toContain("manifest-backed authority evidence exists");
+    expect(toolNotes).toContain("evidenceAuthority is not diagnostic_only");
+    expect(toolNotes).toContain("canonical Pinterest pin-media harvests report evidenceAuthority=pin_media_ready with manifest-backed pin-media-index.json");
     expect(helpText).toContain("Require top-level ready=true, productSuccess=true, artifactAuthority=product_ready, non-empty ranked references");
     expect(helpText).toContain("Canonical Pinterest pin-media harvests require evidenceAuthority=pin_media_ready plus manifest-backed pin-media-index.json");
     expect(helpText).toContain("snapshot_ready and motion_ready are not substitutes");
@@ -148,7 +161,7 @@ describe("public surface manifest", () => {
     expect(notes).toContain("manifest-backed first-party pin-media bytes");
     expect(notes).toContain("discovery-diagnostics.json records accepted and rejected URLs, blocker diagnostics, and recovery context");
     expect(notes).toContain("login/challenge and search-shell diagnostics are recovery paths, not product-ready evidence");
-    expect(notes).toContain("Screenshot failure after pin-media success is a non-blocking caveat when pin-media authority is complete");
+    expect(notes).toContain("unavailable supplemental viewport screenshot evidence is recorded as skipped and satisfied by pin media");
     expect(notes).toContain("pin-media-index.json remains Pinterest authority");
     expect(notes).toContain("media-analysis.json remains advisory");
     expect(notes).toContain("motion-evidence.json remains browser replay authority");