opendevbrowser 0.0.31 → 0.0.33

package/dist/{chunk-4BEJVZRK.js → chunk-FBKPDILE.js}

@@ -10,7 +10,7 @@ import {
   INSPIREDESIGN_HANDOFF_RECOMMENDED_SKILLS,
   buildInspiredesignFollowthroughSummary,
   buildInspiredesignNextStep
-} from "./chunk-KZ2IXVQT.js";
+} from "./chunk-IBIHDGTZ.js";
 import {
   applyPromptGuard,
   applyProviderIssueHint,
@@ -22,7 +22,7 @@ import {
   readProviderIssueHintFromRecord,
   redactSensitive,
   summarizePrimaryProviderIssue
-} from "./chunk-WHQZBUNY.js";
+} from "./chunk-3WLCWHIV.js";
 import {
   ProviderRuntimeError,
   createProviderError,
@@ -1968,7 +1968,7 @@ var executeStep = async (args) => {
       });
       await args.handle.pointerMove(args.sessionId, point.x, point.y, args.targetId, 12);
       await args.handle.pointerDown(args.sessionId, point.x, point.y, args.targetId, "left", 1);
-      await new Promise((resolve) => setTimeout(resolve, Math.max(250, args.step.holdMs ?? DEFAULT_HOLD_MS2)));
+      await new Promise((resolve2) => setTimeout(resolve2, Math.max(250, args.step.holdMs ?? DEFAULT_HOLD_MS2)));
       await args.handle.pointerUp(args.sessionId, point.x, point.y, args.targetId, "left", 1);
       return;
     }
@@ -3685,8 +3685,8 @@ var CrawlWorkerPool = class {
     }
     const taskId = this.nextTaskId;
     this.nextTaskId += 1;
-    return new Promise((resolve, reject) => {
-      this.queue.push({ id: taskId, input, resolve, reject });
+    return new Promise((resolve2, reject) => {
+      this.queue.push({ id: taskId, input, resolve: resolve2, reject });
       this.dispatch();
     });
   }
@@ -9086,7 +9086,10 @@ var isWorkflowResumeEnvelope = (value) => isJsonRecord(value) && isWorkflowKind(
 var isWorkflowResumePayload = (value) => isJsonRecord(value) && isWorkflowResumeEnvelope(value.workflow);
 
 // src/providers/workflows.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
+import { mkdtemp as mkdtemp2, readFile, rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join3, resolve } from "path";
 
 // src/providers/workflow-output-root.ts
 import { join as join2 } from "path";
@@ -9282,7 +9285,7 @@ var enrichResearchRecords = (records, timebox, now = /* @__PURE__ */ new Date())
 };
 
 // src/inspiredesign/contract.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 
 // skills/opendevbrowser-design-agent/assets/templates/canvas-generation-plan.design.v1.json
 var canvas_generation_plan_design_v1_default = {
@@ -11189,10 +11192,172 @@ var expandInspiredesignBrief = (brief, preferredFormatId) => {
   };
 };
 
+// src/guidance/recipes/pinterest.ts
+var pinterestGuidance = {
+  id: "inspiredesign.harvest.browser_native_site_search.pinterest",
+  recipeType: "site_navigation",
+  workflow: "inspiredesign",
+  severity: "warning",
+  readiness: "needs_recovery",
+  reasonCode: "pinterest_browser_native_recovery",
+  primaryAction: {
+    id: "pinterest_browser_native_discovery",
+    label: "Use Pinterest browser-native discovery",
+    summary: "Use a user-authorized signed-in Pinterest browser session when required, search Pinterest naturally, collect visual pins or boards, and reject full login walls, challenges, empty grids, and search-shell pages."
+  },
+  commands: [{
+    id: "pinterest-authenticated-harvest",
+    label: "Run an authenticated Pinterest harvest",
+    command: 'npx opendevbrowser inspiredesign harvest --brief "Digital photography studio landing page" --query "cinematic photography studio landing page inspiration" --provider social/pinterest --max-references 5 --visual-evidence required --browser-mode extension --use-cookies --cookie-policy required --challenge-automation-mode browser_with_helper --mode json --output-format json'
+  }],
+  paramsExamples: [{
+    id: "pinterest-harvest-input",
+    label: "Pinterest discovery input",
+    params: {
+      provider: "social/pinterest",
+      browserMode: "extension",
+      useCookies: true,
+      cookiePolicy: "required",
+      visualEvidence: "required"
+    }
+  }],
+  fieldExamples: [],
+  artifactInputs: [
+    { path: "ranked-references.json", purpose: "Confirm accepted URLs are pins, boards, or idea pages with actual visual grids.", required: true },
+    { path: "visual-evidence.json", purpose: "Reject login, challenge, empty-grid, and search-shell screenshots.", required: true }
+  ],
+  validationChecks: [
+    { id: "pinterest-hosts", description: "Accepted URLs stay on Pinterest hosts.", assertion: 'acceptedUrls.every(url => { const host = new URL(url).hostname; return host === "pinterest.com" || host.endsWith(".pinterest.com"); })' },
+    { id: "pinterest-visual-grid", description: "Screenshots show usable visual grids, pins, boards, or idea pages, not blocked UI." }
+  ],
+  fallbackPolicy: {
+    allowed: false,
+    requiresUserConfirmation: true,
+    reason: "Do not switch a Pinterest-scoped request to unrelated web providers without user confirmation."
+  },
+  doNotProceedIf: [
+    "Pinterest is logged out when cookies are required or protected by a challenge",
+    "The signed-in Pinterest session was not explicitly authorized by the user",
+    "Captured page is only a search shell, login wall, or empty grid",
+    "No ranked Pinterest references remain after scoring"
+  ]
+};
+var PINTEREST_PIN_ID_PATTERN = /^\d+$/;
+var RESERVED_PINTEREST_BOARD_PATHS = /* @__PURE__ */ new Set([
+  "about",
+  "board",
+  "business",
+  "create",
+  "explore",
+  "ideas",
+  "login",
+  "messages",
+  "notifications",
+  "pin",
+  "search",
+  "settings",
+  "shopping",
+  "today"
+]);
+var RESERVED_PINTEREST_IDEA_PATHS = /* @__PURE__ */ new Set(["create", "edit", "search"]);
+var RESERVED_PINTEREST_PROFILE_TABS = /* @__PURE__ */ new Set([
+  "activity",
+  "comments",
+  "created",
+  "followers",
+  "following",
+  "likes",
+  "pins",
+  "saved",
+  "tried"
+]);
+var isAllowedPinterestReferenceHost = (hostname) => hostname === "pinterest.com" || hostname === "www.pinterest.com" || /^[a-z]{2}\.pinterest\.com$/.test(hostname);
+var normalizePinterestReferenceUrl = (value) => {
+  const trimmed = value.trim();
+  const absolute = trimmed.startsWith("/") ? `https://www.pinterest.com${trimmed}` : trimmed;
+  try {
+    const url = new URL(absolute);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+    url.protocol = "https:";
+    const hostname = url.hostname.toLowerCase();
+    if (!isAllowedPinterestReferenceHost(hostname)) return null;
+    const pathSegments = url.pathname.split("/").filter(Boolean);
+    const isPin = pathSegments[0] === "pin" && pathSegments.length === 2 && PINTEREST_PIN_ID_PATTERN.test(pathSegments[1] ?? "");
+    const isIdea = pathSegments[0] === "ideas" && pathSegments.length >= 3 && !RESERVED_PINTEREST_IDEA_PATHS.has(pathSegments[1] ?? "") && PINTEREST_PIN_ID_PATTERN.test(pathSegments[pathSegments.length - 1] ?? "");
+    const isBoard = pathSegments.length === 2 && !RESERVED_PINTEREST_BOARD_PATHS.has(pathSegments[0] ?? "") && !RESERVED_PINTEREST_PROFILE_TABS.has(pathSegments[1] ?? "") && pathSegments.every((segment) => !segment.startsWith("_"));
+    if (!isPin && !isIdea && !isBoard) return null;
+    url.hash = "";
+    url.search = "";
+    return url.toString();
+  } catch {
+    return null;
+  }
+};
+var extractPinterestUrlsFromText = (value) => {
+  const candidates = value.match(/(?:https?:\/\/(?:(?:www|[a-z]{2})\.)?pinterest\.com\/(?:pin\/[a-zA-Z0-9_-]+|ideas\/[a-zA-Z0-9/_-]+|[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+)|(?<![A-Za-z0-9.])\/(?:pin\/[a-zA-Z0-9_-]+|ideas\/[a-zA-Z0-9/_-]+|[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+))\/?/g) ?? [];
+  return candidates.map(normalizePinterestReferenceUrl).filter((url) => url !== null);
+};
+var buildPinterestSearchUrl = (query) => {
+  const params = new URLSearchParams({ q: query });
+  return `https://www.pinterest.com/search/pins/?${params.toString()}`;
+};
+var extractPinterestReferenceUrls = (candidate) => {
+  return [
+    normalizePinterestReferenceUrl(candidate.url ?? ""),
+    ...(candidate.links ?? []).map(normalizePinterestReferenceUrl),
+    ...extractPinterestUrlsFromText(candidate.content ?? ""),
+    ...extractPinterestUrlsFromText(candidate.html ?? "")
+  ].filter((url) => url !== null);
+};
+var pinterestSiteRecipe = {
+  id: "social/pinterest",
+  providerIds: ["social/pinterest", "pinterest"],
+  hostnames: ["pinterest.com", "www.pinterest.com", "uk.pinterest.com"],
+  authMode: "authenticated_preferred",
+  navigationSteps: [
+    { id: "open", instruction: "Open Pinterest in the requested browser mode." },
+    { id: "verify-session", instruction: "Verify the page is logged in before searching when cookies are required." },
+    { id: "search", instruction: "Use the Pinterest search box with the brief-specific visual query." },
+    { id: "scroll", instruction: "Scroll enough to collect varied pins, boards, and idea pages." },
+    { id: "collect", instruction: "Collect candidate URLs only from visual result pages." }
+  ],
+  badStates: [
+    { id: "login", markers: ["log in", "sign up", "continue with"], reasonCode: "auth_required", recoveryAction: "Use extension mode with a user-authorized logged-in Pinterest session." },
+    { id: "challenge", markers: ["captcha", "verification", "challenge"], reasonCode: "challenge_detected", recoveryAction: "Resolve the browser challenge before rerunning harvest." },
+    { id: "search-shell", markers: ["pin card", "your profile", "when autocomplete results are available"], reasonCode: "env_limited", recoveryAction: "Open a concrete pin, board, or idea page before capture." }
+  ],
+  evidenceRequirements: [
+    { id: "visual-grid", description: "Candidate shows visual design material, not only Pinterest chrome.", validation: "Screenshot contains pins, boards, or idea page content." },
+    { id: "on-brief", description: "Candidate matches the design brief surface and style intent.", validation: "Reference signals overlap the brief target and are not generic marketplace chrome." }
+  ],
+  recoverySteps: [
+    { id: "authenticate", instruction: "Use extension mode and cookies only from a user-authorized signed-in Pinterest tab." },
+    { id: "explicit-url", instruction: "If search is blocked, provide explicit Pinterest pin, board, or idea page URLs." }
+  ],
+  browserNativeDiscovery: {
+    buildSearchUrl: buildPinterestSearchUrl,
+    extractReferenceUrls: extractPinterestReferenceUrls
+  },
+  guidance: pinterestGuidance
+};
+
 // src/inspiredesign/reference-pattern-board.ts
 var SIGNAL_LIMIT = 5;
 var SIGNAL_CLIP = 180;
 var PATTERN_LIMIT = 6;
+var SCORE_FETCH_CAPTURED = 20;
+var SCORE_CAPTURE_CAPTURED = 20;
+var SCORE_VISUAL_CAPTURED = 30;
+var SCORE_SNAPSHOT = 10;
+var SCORE_CLONE = 8;
+var SCORE_DOM = 8;
+var SCORE_PUBLIC_LANDING = 6;
+var SCORE_SIGNAL_CAP = 12;
+var SCORE_INTENT_MISMATCH_PENALTY = 55;
+var SCORE_PINTEREST_CHROME_METADATA_PENALTY = 35;
+var MAX_REFERENCE_SCORE = 100;
+var MIN_READY_REFERENCE_SCORE = 50;
+var MIN_READY_REFERENCE_CONFIDENCE = 0.5;
 var ADVANCED_MOTION_FIELDS = [
   "Advisory shader-style gradients: specify effect type, uniforms, static fallback, and reduced-motion replacement as design language only.",
   "Advisory WebGL-style depth cues: describe layered depth, camera-like parallax, and spatial hierarchy without requiring WebGL runtime.",
@@ -11211,7 +11376,7 @@ var textFromHtml = (html) => {
 var stripActionRefs = (value) => value.replace(/\[r\d+\]\s+(?:link|button|combobox|textbox|option)\s+/gi, "").replace(/\[r\d+\]\s+/gi, "").replace(/\bvalue=/gi, "");
 var isCodeOrCssPreview = (value) => {
   const lower = value.toLowerCase();
-  return lower.includes("dangerouslysetinnerhtml") || lower.includes("opendevbrowser-root") || lower.includes("align-content:") || lower.startsWith("import ") || /^[.#][a-z0-9_-]+\s*\{/.test(lower) || lower.includes("{") && /[a-z-]+:\s*[^;]+;/.test(lower);
+  return lower.includes("dangerouslysetinnerhtml") || lower.includes("opendevbrowser-root") || lower.includes("--gestalt-") || lower.includes("align-content:") || lower.startsWith(":root") || lower.startsWith("import ") || /^[.#][a-z0-9_-]+\s*\{/.test(lower) || lower.includes("{") && /[a-z-]+:\s*[^;]+;/.test(lower);
 };
 var cleanEvidenceText = (value) => {
   return trimText(stripActionRefs(value).replace(/[{};]/g, " "));
@@ -11223,6 +11388,15 @@ var DIAGNOSTIC_TEXT_MARKERS = [
   "challenge page",
   "access denied",
   "browser capture unavailable",
+  "404",
+  "page not found",
+  "not found",
+  "unavailable page",
+  "accept all cookies",
+  "cookie consent",
+  "cookie preferences",
+  "privacy settings",
+  "consent modal",
   "javascript required",
   "javascript is required",
   "captcha",
@@ -11232,6 +11406,48 @@ var DIAGNOSTIC_TEXT_MARKERS = [
   "complete the verification",
   "blocked reference"
 ];
+var SEARCH_OR_LISTING_SHELL_MARKERS = [
+  "search results for",
+  "related searches",
+  "sort by",
+  "filter by"
+];
+var MARKETPLACE_CHROME_MARKERS = [
+  "add to cart",
+  "marketplace",
+  "envato",
+  "etsy",
+  "template kits"
+];
+var HARD_DIAGNOSTIC_PAGE_MARKERS = [
+  "404",
+  "page not found",
+  "this page is unavailable",
+  "accept all cookies",
+  "manage cookies",
+  "cookie consent",
+  "sign in to continue",
+  "log in to continue",
+  "captcha",
+  "verification challenge"
+];
+var INTERFACE_CHROME_TEXT_MARKERS = [
+  "your profile",
+  "your boards",
+  "remove search input",
+  "settings & support",
+  "pin card",
+  "voice search",
+  "lens",
+  "back to home page",
+  "toggle mobile menu",
+  "facebook",
+  "instagram",
+  "updates",
+  "messages",
+  "when autocomplete results are available",
+  "touch device users"
+];
 var PUBLIC_LANDING_TEXT_MARKERS = [
   "church",
   "landing page",
@@ -11271,6 +11487,53 @@ var isDiagnosticText = (value) => {
   const lower = value.toLowerCase();
   return DIAGNOSTIC_TEXT_MARKERS.some((marker) => lower.includes(marker));
 };
+var diagnosticPageReasons = (value) => {
+  const lower = value.toLowerCase();
+  const reasons = [];
+  if (["404", "page not found", "this page is unavailable"].some((marker) => lower.includes(marker))) {
+    reasons.push("unavailable_page");
+  }
+  if (["accept all cookies", "manage cookies", "cookie consent", "privacy settings", "enable cookies"].some((marker) => lower.includes(marker))) {
+    reasons.push("cookie_or_consent_modal");
+  }
+  if ([
+    "sign in to continue",
+    "log in to continue",
+    "authentication required",
+    "access denied",
+    "captcha",
+    "verification challenge",
+    "complete the verification"
+  ].some((marker) => lower.includes(marker))) {
+    reasons.push("login_or_challenge_state");
+  }
+  const searchShellCount = SEARCH_OR_LISTING_SHELL_MARKERS.filter((marker) => lower.includes(marker)).length;
+  if (searchShellCount >= 2 || lower.includes("search results for") || lower.includes("related searches")) {
+    reasons.push("search_or_listing_shell");
+  }
+  const marketplaceChromeCount = MARKETPLACE_CHROME_MARKERS.filter((marker) => lower.includes(marker)).length;
+  if (marketplaceChromeCount >= 2 || (lower.includes("envato") || lower.includes("etsy")) && (lower.includes("template kits") || searchShellCount > 0)) {
+    reasons.push("marketplace_or_template_chrome");
+  }
+  if (isInterfaceChromeText(value)) {
+    reasons.push("interface_chrome_shell");
+  }
+  return [...new Set(reasons)];
+};
+var isDiagnosticPageText = (value) => {
+  const lower = value.toLowerCase();
+  return HARD_DIAGNOSTIC_PAGE_MARKERS.some((marker) => lower.includes(marker)) || diagnosticPageReasons(value).length > 0;
+};
+var isInterfaceChromeText = (value) => {
+  const lower = value.toLowerCase();
+  const actionRefCount = countActionRefs(value);
+  const markerCount = INTERFACE_CHROME_TEXT_MARKERS.filter((marker) => lower.includes(marker)).length;
+  if (lower === "your profile" || lower === "adobe, inc." || lower === "dribbble: the community for graphic design" || /^https?:\/\/\S+$/.test(lower) || lower.includes("when autocomplete results are available") && lower.includes("touch device users") || actionRefCount >= 3 && markerCount >= 2 || lower.includes("get 20%") && lower.includes("dribbble: the community for graphic design") || lower.includes("our free wordpress themes are downloaded") && lower.includes("get them now")) {
+    return true;
+  }
+  return markerCount >= 3 || lower.includes("pin card") && lower.includes("your profile");
+};
+var countActionRefs = (value) => (value.match(/\[r\d+\]\s+(?:link|button|combobox|textbox|option)\s+/gi) ?? []).length;
 var hasPublicLandingSignal = (value) => {
   const lower = value.toLowerCase();
   const strongCount = PUBLIC_LANDING_TEXT_MARKERS.filter((marker) => lower.includes(marker)).length;
@@ -11281,7 +11544,7 @@ var hasPublicLandingSignal = (value) => {
 var pushSignal = (signals, value) => {
   if (!value || isCodeOrCssPreview(value)) return;
   const text = cleanEvidenceText(value);
-  if (isCodeOrCssPreview(text) || isDiagnosticText(text)) return;
+  if (isCodeOrCssPreview(text) || isDiagnosticText(text) || isInterfaceChromeText(text)) return;
   if (text.length > 0 && !signals.includes(text)) {
     signals.push(text);
   }
@@ -11300,13 +11563,56 @@ var getInspiredesignReferenceSignals = (reference) => {
 var hasCleanSignal = (value) => {
   if (!value || isCodeOrCssPreview(value)) return false;
   const text = cleanEvidenceText(value);
-  return text.length > 0 && !isCodeOrCssPreview(text) && !isDiagnosticText(text);
+  return text.length > 0 && !isCodeOrCssPreview(text) && !isDiagnosticText(text) && !isDiagnosticPageText(text) && !isInterfaceChromeText(text);
 };
 var hasUsableCloneCreativeEvidence = (reference) => hasCleanSignal(reference.capture?.clone?.componentPreview);
+var hasUsableRecoveredCreativeEvidence = (reference) => hasUsableCloneCreativeEvidence(reference) || hasCleanSignal(textFromHtml(reference.capture?.dom?.outerHTML));
+var isPinterestVisualReferenceUrl = (value) => normalizePinterestReferenceUrl(value) !== null;
+var pinterestHostnameFromUrl = (value) => {
+  try {
+    return new URL(value).hostname.toLowerCase();
+  } catch {
+    return null;
+  }
+};
+var isPinterestOwnedReferenceUrl = (value) => {
+  const hostname = pinterestHostnameFromUrl(value);
+  return hostname !== null && (hostname === "pinterest.com" || hostname.endsWith(".pinterest.com"));
+};
+var isUnapprovedPinterestReferenceUrl = (value) => {
+  const hostname = pinterestHostnameFromUrl(value);
+  return hostname !== null && isPinterestOwnedReferenceUrl(value) && !isAllowedPinterestReferenceHost(hostname);
+};
+var hasCleanMetadataValue = (value) => typeof value === "string" && countActionRefs(value) < 3 && hasCleanSignal(value);
+var hasCleanMetadataSignal = (reference) => hasCleanMetadataValue(reference.title) || hasCleanMetadataValue(reference.excerpt) || hasCleanMetadataValue(reference.capture?.title);
+var hasOnlySoftPinterestChromeDiagnostics = (reasons) => reasons.every((reason) => reason === "interface_chrome_shell");
+var hasPinterestVisualMetadataEvidence = (reference, diagnosticReasons) => isPinterestVisualReferenceUrl(reference.url) && reference.captureStatus === "captured" && reference.capture?.visual?.status === "captured" && hasCleanMetadataSignal(reference) && hasOnlySoftPinterestChromeDiagnostics(diagnosticReasons);
 var hasUsableCaptureEvidence = (reference) => hasCleanSignal(reference.capture?.snapshot?.content) || hasUsableCloneCreativeEvidence(reference) || hasCleanSignal(textFromHtml(reference.capture?.dom?.outerHTML));
+var referenceDiagnosticReasons = (reference) => {
+  const text = [
+    reference.title,
+    reference.excerpt,
+    reference.capture?.title,
+    reference.capture?.snapshot?.content,
+    textFromHtml(reference.capture?.clone?.componentPreview),
+    reference.capture?.clone?.cssPreview,
+    textFromHtml(reference.capture?.dom?.outerHTML),
+    reference.capture?.visual?.failure,
+    ...reference.capture?.visual?.warnings ?? []
+  ].filter((value) => typeof value === "string" && value.trim().length > 0).join(" ");
+  return diagnosticPageReasons(text);
+};
+var hasBlockingDiagnosticReason = (reasons) => reasons.some((reason) => reason !== "login_or_challenge_state");
 var hasInspiredesignUsableReferenceEvidence = (reference) => {
+  if (isUnapprovedPinterestReferenceUrl(reference.url)) return false;
+  const diagnosticReasons = referenceDiagnosticReasons(reference);
+  if (hasPinterestVisualMetadataEvidence(reference, diagnosticReasons)) return true;
+  if (hasBlockingDiagnosticReason(diagnosticReasons)) return false;
+  if (diagnosticReasons.includes("login_or_challenge_state") && !hasUsableRecoveredCreativeEvidence(reference)) {
+    return false;
+  }
   if (reference.captureStatus === "captured" && hasUsableCaptureEvidence(reference)) return true;
-  return reference.fetchStatus === "captured" && (hasCleanSignal(reference.title) || hasCleanSignal(reference.excerpt));
+  return reference.fetchStatus === "captured" && diagnosticReasons.length === 0 && (hasCleanSignal(reference.title) || hasCleanSignal(reference.excerpt));
 };
 var firstSignal = (reference) => {
   const preferred = [
@@ -11316,9 +11622,16 @@ var firstSignal = (reference) => {
     textFromHtml(reference.capture?.dom?.outerHTML),
     reference.excerpt,
     reference.title
-  ].map((value) => value ? cleanEvidenceText(value) : "").find((value) => value.length > 0 && !isCodeOrCssPreview(value) && !isDiagnosticText(value));
+  ].map((value) => value ? cleanEvidenceText(value) : "").find((value) => value.length > 0 && !isCodeOrCssPreview(value) && !isDiagnosticText(value) && !isInterfaceChromeText(value));
   return preferred ? clipText(preferred, SIGNAL_CLIP) : reference.url;
 };
+var displayNameForReference = (reference, primarySignal) => {
+  const title = reference.title ? cleanEvidenceText(reference.title) : "";
+  if (title && !isDiagnosticText(title) && !isInterfaceChromeText(title)) {
+    return clipText(title, SIGNAL_CLIP);
+  }
+  return primarySignal !== reference.url ? primarySignal : reference.url;
+};
 var REFERENCE_PATTERN_RULES = [
   {
     summary: "location-first church discovery with regional pathways",
@@ -11370,14 +11683,64 @@ var appendSourceDetail = (patterns, primarySignal) => {
 };
 var deriveCapturedVia = (reference) => {
   const methods = [];
+  const diagnosticReasons = referenceDiagnosticReasons(reference);
+  const hasPinterestVisualMetadata = hasPinterestVisualMetadataEvidence(reference, diagnosticReasons);
   if (reference.fetchStatus === "captured") methods.push("fetch");
-  if (reference.capture?.snapshot?.content.trim()) methods.push("snapshot");
+  if (hasCleanSignal(reference.capture?.snapshot?.content)) methods.push("snapshot");
   if (hasUsableCloneCreativeEvidence(reference)) {
     methods.push("clone");
   }
-  if (reference.capture?.dom?.outerHTML.trim()) methods.push("dom");
+  if (hasCleanSignal(textFromHtml(reference.capture?.dom?.outerHTML))) methods.push("dom");
+  if (reference.capture?.visual?.status === "captured" && (hasUsableCaptureEvidence(reference) || hasPinterestVisualMetadata)) methods.push("visual");
   return methods;
 };
+var scoreReference = (reference, signals, isPublicLanding) => {
+  let score = 0;
+  const diagnosticReasons = referenceDiagnosticReasons(reference);
+  const hasPinterestVisualMetadata = hasPinterestVisualMetadataEvidence(reference, diagnosticReasons);
+  if (reference.fetchStatus === "captured") score += SCORE_FETCH_CAPTURED;
+  if (reference.captureStatus === "captured" && (hasUsableCaptureEvidence(reference) || hasPinterestVisualMetadata)) {
+    score += SCORE_CAPTURE_CAPTURED;
+  }
+  if (reference.capture?.visual?.status === "captured" && (hasUsableCaptureEvidence(reference) || hasPinterestVisualMetadata)) score += SCORE_VISUAL_CAPTURED;
+  if (hasCleanSignal(reference.capture?.snapshot?.content)) score += SCORE_SNAPSHOT;
+  if (hasUsableCloneCreativeEvidence(reference)) score += SCORE_CLONE;
+  if (hasCleanSignal(textFromHtml(reference.capture?.dom?.outerHTML))) score += SCORE_DOM;
+  if (isPublicLanding) score += SCORE_PUBLIC_LANDING;
+  score += Math.min(SCORE_SIGNAL_CAP, signals.length * 2);
+  if (hasPinterestVisualMetadata && diagnosticReasons.includes("interface_chrome_shell")) {
+    score -= SCORE_PINTEREST_CHROME_METADATA_PENALTY;
+  }
+  return Math.min(MAX_REFERENCE_SCORE, score);
+};
+var confidenceFromScore = (score) => Number((score / MAX_REFERENCE_SCORE).toFixed(2));
+var deriveVisualStrengths = (reference, patterns) => {
+  const strengths = [
+    ...reference.capture?.visual?.status === "captured" ? ["Screenshot artifact is available for direct visual inspection."] : [],
+    ...reference.capture?.snapshot?.content.trim() ? ["Snapshot text confirms visible hierarchy and interaction targets."] : [],
+    ...hasUsableCloneCreativeEvidence(reference) ? ["Clone preview exposes reusable component and styling cues."] : [],
+    ...patterns.slice(0, 2).map((pattern) => `Reusable visual cue: ${pattern}.`)
+  ];
+  return strengths.slice(0, PATTERN_LIMIT);
+};
+var deriveVisualRisks = (reference) => {
+  const risks = [
+    ...reference.capture?.visual?.status !== "captured" ? ["No finalized screenshot artifact, so visual claims must stay conservative."] : [],
+    ...reference.capture?.visual?.status === "failed" && reference.capture.visual.failure ? [`Screenshot failure: ${reference.capture.visual.failure}.`] : [],
+    ...(reference.capture?.visual?.warnings ?? []).map((warning) => `Screenshot warning: ${warning}.`),
+    ...reference.fetchStatus !== "captured" ? ["Fetch evidence failed or was skipped, so use browser capture cautiously."] : []
+  ];
+  return risks.length > 0 ? risks.slice(0, PATTERN_LIMIT) : ["No major visual evidence risk detected in the captured reference."];
+};
+var selectionReasonForScore = (score, capturedVia) => {
+  if (capturedVia.includes("visual")) {
+    return `Ranked for screenshot-backed visual evidence plus ${capturedVia.join(", ")} capture.`;
+  }
+  if (score >= 50) {
+    return `Ranked for strong text and structural evidence from ${capturedVia.join(", ") || "reference metadata"}.`;
+  }
+  return "Ranked for limited but usable reference cues.";
+};
 var deriveComponentFamilies = (format, patterns, isPublicLanding) => {
   const base = isPublicLanding ? "hero composition, proof bands, narrative pathways, service or story sections, conversion CTA, and footer" : format.componentGrammar;
   return [base, ...patterns.slice(0, 3)];
@@ -11400,17 +11763,80 @@ var boardEvidenceText = (board) => board.references.map((reference) => [
   ...reference.patternsToBorrow
 ].join(" ")).join(" ").toLowerCase();
 var hasEvidenceCue = (text, matches) => matches.some((match) => text.includes(match));
-var deriveReferenceEntry = (reference, format) => {
+var INTENT_STOP_WORDS = /* @__PURE__ */ new Set([
+  "and",
+  "cinematic",
+  "dark",
+  "digital",
+  "for",
+  "from",
+  "landing",
+  "light",
+  "microinteractions",
+  "motion",
+  "page",
+  "parallax",
+  "premium",
+  "reveal",
+  "site",
+  "scroll",
+  "theme",
+  "with",
+  "design",
+  "website"
+]);
+var tokenizeIntent = (value) => (value.toLowerCase().match(/[a-z0-9][a-z0-9-]{2,}/g) ?? []).filter((token) => !INTENT_STOP_WORDS.has(token));
+var formatIntentTokens = (format) => [
+  ...format.keywords,
+  ...format.businessFocus,
+  ...format.bestFor,
+  ...format.focusAreas ?? [],
+  format.archetype,
+  format.layoutArchetype,
+  format.surfaceTreatment,
+  format.motionGrammar,
+  format.paletteIntent
+].flatMap(tokenizeIntent);
+var intentTokenVariants = (token) => {
+  if (token === "photo" || token === "photos" || token === "photography" || token === "photographer" || token === "photographic") {
+    return ["photo", "photos", "photography", "photographer", "photographic"];
+  }
+  return [token];
+};
+var countMatchedIntentTokens = (signals, intentTokens) => {
+  const evidenceTokens = new Set(signals.flatMap(tokenizeIntent));
+  return intentTokens.filter((token) => intentTokenVariants(token).some((variant) => evidenceTokens.has(variant))).length;
+};
+var hasBriefIntentMatch = (signals, format, briefText) => {
+  const briefTokens = tokenizeIntent(briefText);
+  const hasBriefIntentTokens = briefTokens.length > 0;
+  const intentTokens = [...new Set(hasBriefIntentTokens ? briefTokens : formatIntentTokens(format))];
+  if (intentTokens.length === 0) return true;
+  const matchCount = countMatchedIntentTokens(signals, intentTokens);
+  if (!hasBriefIntentTokens) return matchCount > 0;
+  return matchCount >= Math.min(2, intentTokens.length);
+};
+var deriveReferenceEntry = (reference, format, briefText) => {
   const signals = getInspiredesignReferenceSignals(reference);
   const primarySignal = firstSignal(reference);
   const patterns = appendSourceDetail(derivePatternSummaries(signals, primarySignal), primarySignal);
   const isPublicLanding = signals.some(hasPublicLandingSignal);
+  const capturedVia = deriveCapturedVia(reference);
+  const intentMatched = hasBriefIntentMatch(signals, format, briefText);
+  const rawScore = scoreReference(reference, signals, isPublicLanding);
+  const score = intentMatched ? rawScore : Math.max(0, rawScore - SCORE_INTENT_MISMATCH_PENALTY);
   return {
     id: reference.id,
-    name: reference.title ?? reference.url,
+    score,
+    confidence: confidenceFromScore(score),
+    name: displayNameForReference(reference, primarySignal),
     url: reference.url,
     surfaceType: isPublicLanding ? "public landing page" : format.archetype,
-    capturedVia: deriveCapturedVia(reference),
+    capturedVia,
+    intentMatched,
+    selectionReason: intentMatched ? selectionReasonForScore(score, capturedVia) : `${selectionReasonForScore(score, capturedVia)} Intent overlap with the brief is weak, so the score was downgraded.`,
+    visualStrengths: deriveVisualStrengths(reference, patterns),
+    visualRisks: deriveVisualRisks(reference),
     layoutRecipe: patterns.join("; "),
     contentHierarchy: patterns.slice(0, 4),
     componentFamilies: deriveComponentFamilies(format, patterns, isPublicLanding),
@@ -11421,16 +11847,104 @@ var deriveReferenceEntry = (reference, format) => {
     whyItWorks: reference.captureStatus === "captured" ? "Captured reference evidence provides reusable hierarchy, rhythm, and component cues." : "Available reference text provides directional content and hierarchy cues."
   };
 };
-var buildInspiredesignReferencePatternBoard = (briefId, format, references) => {
-  const entries = references.filter(hasInspiredesignUsableReferenceEvidence).map((reference) => deriveReferenceEntry(reference, format));
-  const sharedStrengths = entries.flatMap((entry) => entry.patternsToBorrow).slice(0, 6);
-  const targetSurface = entries.some((entry) => entry.surfaceType === "public landing page") ? "reference-led public landing page" : format.layoutArchetype;
+var sortReferenceEntries = (entries) => entries.slice().sort((left, right) => right.score - left.score || left.id.localeCompare(right.id) || left.url.localeCompare(right.url)).map((entry, index) => ({
+  rank: index + 1,
+  ...entry
+}));
+var rejectionReasonForReference = (reference) => {
+  if (isUnapprovedPinterestReferenceUrl(reference.url)) {
+    return "Pinterest reference host is not approved for creative synthesis.";
+  }
+  const diagnosticReasons = referenceDiagnosticReasons(reference);
+  if (diagnosticReasons.length > 0) {
+    return `Reference evidence is diagnostic-only: ${diagnosticReasons.join(", ")}.`;
+  }
+  if (reference.fetchStatus === "failed" && reference.captureStatus === "failed") {
+    return "Fetch and capture did not produce usable creative evidence.";
+  }
+  if (reference.captureStatus === "failed") {
+    return "Capture did not produce usable creative evidence.";
+  }
+  if (reference.fetchStatus === "failed") {
+    return "Fetch did not produce usable creative evidence.";
+  }
+  return "Reference evidence was diagnostic, empty, or too weak for creative synthesis.";
+};
+var buildRejectedReferences = (references) => references.filter((reference) => !hasInspiredesignUsableReferenceEvidence(reference)).map((reference) => ({
+  id: reference.id,
+  url: reference.url,
+  reason: rejectionReasonForReference(reference),
+  fetchStatus: reference.fetchStatus,
+  captureStatus: reference.captureStatus
+}));
+var buildQualitySummary = (references, rankedEntries, rejectedReferences) => {
+  const diagnosticOnlyReasons = [...new Set(references.flatMap(referenceDiagnosticReasons))];
+  const rankedIds = new Set(rankedEntries.map((entry) => entry.id));
+  const rankedReferences = references.filter((reference) => rankedIds.has(reference.id));
+  const failedCaptureCount = rankedReferences.filter((reference) => reference.captureStatus === "failed").length;
+  const missingScreenshotCount = rankedReferences.filter((reference) => reference.capture?.visual?.status !== "captured").length;
+  const topReference = rankedEntries[0];
+  return {
+    rankedReferenceCount: rankedEntries.length,
+    rejectedReferenceCount: rejectedReferences.length,
+    failedCaptureCount,
+    missingScreenshotCount,
+    diagnosticOnlyReasons,
+    ...topReference ? {
+      topReferenceScore: topReference.score,
+      topReferenceConfidence: topReference.confidence,
+      topReferenceIntentMatched: topReference.intentMatched
+    } : {}
+  };
+};
+var summarizeInspiredesignReferenceQuality = (board) => ({ ...board.qualitySummary });
+var isInspiredesignReadyReference = (reference) => reference.intentMatched && reference.score >= MIN_READY_REFERENCE_SCORE && reference.confidence >= MIN_READY_REFERENCE_CONFIDENCE;
+var isInspiredesignDesignReference = (reference) => !isPinterestOwnedReferenceUrl(reference.url) || isPinterestVisualReferenceUrl(reference.url) && isInspiredesignReadyReference(reference);
+var buildInspiredesignDesignReferencePatternBoard = (board, designVectors) => {
+  const references = board.references.filter(isInspiredesignDesignReference);
+  const notReadyCount = board.references.length - references.length;
+  const topReference = references[0];
+  const missingScreenshotCount = references.filter((reference) => !reference.capturedVia.includes("visual")).length;
+  const qualitySummary = {
+    rankedReferenceCount: references.length,
+    rejectedReferenceCount: board.rejectedReferences.length + notReadyCount,
+    failedCaptureCount: 0,
+    missingScreenshotCount,
+    diagnosticOnlyReasons: [...board.qualitySummary.diagnosticOnlyReasons],
+    ...topReference ? {
+      topReferenceScore: topReference.score,
+      topReferenceConfidence: topReference.confidence,
+      topReferenceIntentMatched: topReference.intentMatched
+    } : {}
+  };
+  return {
+    ...board,
+    targetSurface: designVectors.surfaceIntent,
+    qualitySummary,
+    references,
+    rejectedReferences: [],
+    synthesis: {
+      dominantDirection: designVectors.directionLabel,
+      sharedStrengths: [...designVectors.patternsToBorrow],
+      sharedFailuresToAvoid: [...designVectors.patternsToReject],
+      contractDeltas: references.length > 0 ? [...board.synthesis.contractDeltas] : ["No ready reference evidence is available; keep implementation anchored to the source brief."]
+    }
+  };
+};
+var buildInspiredesignReferencePatternBoard = (briefId, format, references, briefText = "") => {
+  const entries = references.filter(hasInspiredesignUsableReferenceEvidence).map((reference) => deriveReferenceEntry(reference, format, briefText));
+  const rankedEntries = sortReferenceEntries(entries);
+  const rejectedReferences = buildRejectedReferences(references);
+  const sharedStrengths = rankedEntries.flatMap((entry) => entry.patternsToBorrow).slice(0, 6);
+  const targetSurface = rankedEntries.some((entry) => entry.surfaceType === "public landing page") ? "reference-led public landing page" : format.layoutArchetype;
   return {
     briefId,
     targetSurface,
-    references: entries,
+    qualitySummary: buildQualitySummary(references, rankedEntries, rejectedReferences),
+    references: rankedEntries,
+    rejectedReferences,
     synthesis: {
-      dominantDirection: entries[0]?.layoutRecipe ?? format.archetype,
+      dominantDirection: rankedEntries[0]?.layoutRecipe ?? format.archetype,
       sharedStrengths,
       sharedFailuresToAvoid: [...format.antiPatterns],
       contractDeltas: [
@@ -11534,13 +12048,16 @@ var buildSectionArchitecture = (format, board) => {
   ];
 };
 var buildInspiredesignDesignVectors = (format, board) => {
-  const influence = board.synthesis.sharedStrengths.length > 0 ? board.synthesis.sharedStrengths : [format.archetype];
-  const publicLandingEvidence = hasBoardPublicLandingEvidence(board);
+  const designReferences = board.references.filter(isInspiredesignDesignReference);
+  const designStrengths = designReferences.flatMap((entry) => entry.patternsToBorrow).slice(0, 6);
+  const influence = designStrengths.length > 0 ? designStrengths : [format.archetype];
+  const designBoard = { ...board, references: designReferences };
+  const publicLandingEvidence = hasBoardPublicLandingEvidence(designBoard);
   const surfaceIntent = publicLandingEvidence ? "reference-led public landing page" : format.archetype;
-  const compositionModel = publicLandingEvidence ? ["full-bleed hero with narrative section cadence", ...board.references.map((entry) => entry.layoutRecipe)] : [format.layoutArchetype, ...board.references.map((entry) => entry.layoutRecipe)];
+  const compositionModel = publicLandingEvidence ? ["full-bleed hero with narrative section cadence", ...designReferences.map((entry) => entry.layoutRecipe)] : [format.layoutArchetype, ...designReferences.map((entry) => entry.layoutRecipe)];
   return {
-    sourcePriority: board.references.length > 0 ? "reference-evidence-first" : "brief-only",
-    directionLabel: board.synthesis.dominantDirection,
+    sourcePriority: designReferences.length > 0 ? "reference-evidence-first" : "brief-only",
+    directionLabel: designReferences[0]?.layoutRecipe ?? format.archetype,
     surfaceIntent,
     compositionModel: compositionModel.slice(0, 5),
     premiumPosture: [
@@ -11554,21 +12071,198 @@ var buildInspiredesignDesignVectors = (format, board) => {
       "Respect reduced-motion preference with static hierarchy preserved.",
       format.motionGrammar
     ],
-    sectionArchitecture: buildSectionArchitecture(format, board),
+    sectionArchitecture: buildSectionArchitecture(format, designBoard),
     typographyPosture: [format.typographySystem],
-    imageryPosture: buildImageryPosture(format, board),
-    interactionDensity: buildInteractionDensity(format, board),
-    interactionMoments: buildInteractionMoments(format, board),
-    materialEffects: buildMaterialEffects(board),
+    imageryPosture: buildImageryPosture(format, designBoard),
+    interactionDensity: buildInteractionDensity(format, designBoard),
+    interactionMoments: buildInteractionMoments(format, designBoard),
+    materialEffects: buildMaterialEffects(designBoard),
     advancedMotionAdvisory: [...ADVANCED_MOTION_FIELDS],
     referenceInfluence: influence,
-    patternsToBorrow: board.references.flatMap((entry) => entry.patternsToBorrow).slice(0, 8),
-    patternsToReject: board.references.flatMap((entry) => entry.patternsToReject).slice(0, 8),
+    patternsToBorrow: designReferences.flatMap((entry) => entry.patternsToBorrow).slice(0, 8),
+    patternsToReject: designReferences.flatMap((entry) => entry.patternsToReject).slice(0, 8),
     guardrails: [...format.guardrails],
     antiPatterns: [...format.antiPatterns]
   };
 };
 
+// src/inspiredesign/meta-prompt.ts
+var formatList = (items) => items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : "- No evidence-backed item available.";
+var formatRankedReferences = (references) => {
+  if (references.length === 0) {
+    return "- No ready references were ranked. Work from the brief and note missing evidence.";
+  }
+  return references.map((reference) => [
+    `### Rank ${reference.rank}: ${reference.name}`,
+    `- URL: ${reference.url}`,
+    `- Score: ${reference.score}`,
+    `- Confidence: ${reference.confidence.toFixed(2)}`,
+    `- Selection reason: ${reference.selectionReason}`,
+    `- Borrow: ${reference.patternsToBorrow.join("; ")}`,
+    `- Reject: ${reference.patternsToReject.join("; ")}`,
+    `- Visual strengths: ${reference.visualStrengths.join("; ")}`,
+    `- Visual risks: ${reference.visualRisks.join("; ")}`
+  ].join("\n")).join("\n\n");
+};
+var formatRejectedReferences = (board, notReadyReferences) => {
+  const lines = [
+    ...board.rejectedReferences.length > 0 ? [`- ${board.rejectedReferences.length} reference(s) were rejected as diagnostic-only or unavailable.`] : [],
+    ...notReadyReferences.length > 0 ? [`- ${notReadyReferences.length} ranked reference(s) were not ready for creative synthesis due to score, confidence, or brief-intent mismatch.`] : []
+  ];
+  return lines.length > 0 ? lines.join("\n") : "- No references were rejected from the creative synthesis.";
+};
+var buildInspiredesignMetaPrompt = (input) => {
+  const designReferences = input.referencePatternBoard.references.filter(isInspiredesignDesignReference);
+  const notReadyReferences = input.referencePatternBoard.references.filter(
+    (reference) => !isInspiredesignDesignReference(reference)
+  );
+  return [
+    "# InspireDesign Meta Prompt",
+    "",
+    "Use this prompt to generate a fresh design direction from evidence without copying any reference brand, asset, layout, or proprietary expression.",
+    "",
+    "## Source Brief",
+    input.brief,
+    "",
+    "## Prompt Format",
+    `- Format: ${input.briefExpansion.format.label}`,
+    `- Target surface: ${input.designVectors.surfaceIntent}`,
+    `- Dominant direction: ${input.designVectors.directionLabel}`,
+    "",
+    "## Ranked References",
+    formatRankedReferences(designReferences),
+    "",
+    "## Rejected References",
+    formatRejectedReferences(input.referencePatternBoard, notReadyReferences),
+    "",
+    "## Borrow Guidance",
+    formatList(input.designVectors.patternsToBorrow),
+    "",
+    "## Reject Guidance",
+    formatList([
+      ...input.designVectors.patternsToReject,
+      "Do not copy logos, screenshots, protected brand assets, page structure, copy, or trade dress from references."
+    ]),
+    "",
+    "## Motion Posture",
+    formatList([
+      ...input.designVectors.motionPosture,
+      ...input.designVectors.interactionMoments,
+      ...input.designVectors.advancedMotionAdvisory
+    ]),
+    "",
+    "## Accessibility Constraints",
+    formatList([
+      "Keyboard navigation must reach every interactive element.",
+      "Focus states must be visible in every theme and viewport.",
+      "Respect prefers-reduced-motion with a static hierarchy-preserving alternative.",
+      "Validate contrast for text, controls, overlays, and disabled states."
+    ]),
+    "",
+    "## Validation Gates",
+    formatList([
+      "Read visual-evidence.json, screenshot-index.json, ranked-references.json, and evidence.json before implementation.",
+      "Confirm screenshot paths exist before making visual claims.",
+      "Verify desktop and mobile layouts with real browser screenshots.",
+      "Run reduced-motion, keyboard, focus, and contrast checks before shipping.",
+      "Keep production code generation outside the harvest output."
+    ])
+  ].join("\n");
+};
+
+// src/inspiredesign/visual-evidence.ts
+import { createHash as createHash3 } from "crypto";
+var INSPIREDESIGN_VISUAL_EVIDENCE_MODES = ["off", "auto", "required"];
+var INSPIREDESIGN_VISUAL_EVIDENCE_KINDS = ["viewport", "full_page"];
+var SAFE_REFERENCE_ID_PATTERN = /[^a-z0-9._-]+/gi;
+var MAX_VISUAL_REFERENCE_ID_LENGTH = 96;
+var MAX_VISUAL_WARNING_LENGTH = 160;
+var MAX_VISUAL_FAILURE_LENGTH = 240;
+var UNSAFE_VISUAL_TEXT_PATTERN = /(?:\/(?:Users|private|tmp|var|Volumes)\/|[A-Za-z]:\\|\\|data:image|;base64|base64,|[A-Za-z0-9+/]{80,}={0,2})/i;
+var DOT_ONLY_PATH_SEGMENT_PATTERN = /^\.+$/;
+var SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/i;
+var VISUAL_ARTIFACT_PATH_PATTERN = /^visual-evidence\/([A-Za-z0-9._-]+)\/(?:viewport|full_page)\.png$/;
+var FALLBACK_VISUAL_CAPTURED_AT = "1970-01-01T00:00:00.000Z";
+var isInspiredesignVisualEvidenceMode = (value) => typeof value === "string" && INSPIREDESIGN_VISUAL_EVIDENCE_MODES.includes(value);
+var isInspiredesignVisualEvidenceKind = (value) => typeof value === "string" && INSPIREDESIGN_VISUAL_EVIDENCE_KINDS.includes(value);
+var sanitizeInspiredesignVisualReferenceId = (referenceId) => {
+  const sanitized = referenceId.trim().replace(SAFE_REFERENCE_ID_PATTERN, "-").replace(/^-+|-+$/g, "");
+  if (!sanitized || DOT_ONLY_PATH_SEGMENT_PATTERN.test(sanitized)) return "reference";
+  const truncated = sanitized.slice(0, MAX_VISUAL_REFERENCE_ID_LENGTH);
+  return DOT_ONLY_PATH_SEGMENT_PATTERN.test(truncated) ? "reference" : truncated;
+};
+var buildVisualEvidenceArtifactPath = (referenceId, kind) => `visual-evidence/${sanitizeInspiredesignVisualReferenceId(referenceId)}/${kind}.png`;
+var hashVisualEvidenceBuffer = (buffer) => createHash3("sha256").update(buffer).digest("hex");
+var sanitizeVisualEvidenceText = (value, maxLength) => {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed || UNSAFE_VISUAL_TEXT_PATTERN.test(trimmed)) return void 0;
+  return trimmed.slice(0, maxLength);
+};
+var sanitizeVisualEvidencePath = (value) => {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  const match = VISUAL_ARTIFACT_PATH_PATTERN.exec(trimmed);
+  const referenceSegment = match?.[1];
+  if (!referenceSegment || DOT_ONLY_PATH_SEGMENT_PATTERN.test(referenceSegment)) return void 0;
+  return trimmed;
+};
+var sanitizeVisualEvidenceSha256 = (value) => {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return SHA256_HEX_PATTERN.test(trimmed) ? trimmed.toLowerCase() : void 0;
+};
+var sanitizeVisualEvidenceBytes = (value) => typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0 ? value : void 0;
+var sanitizeVisualEvidenceCapturedAt = (value) => {
+  if (typeof value !== "string") return FALLBACK_VISUAL_CAPTURED_AT;
+  const trimmed = value.trim();
+  if (!trimmed || UNSAFE_VISUAL_TEXT_PATTERN.test(trimmed)) return FALLBACK_VISUAL_CAPTURED_AT;
+  const timestamp = Date.parse(trimmed);
+  if (!Number.isFinite(timestamp)) return FALLBACK_VISUAL_CAPTURED_AT;
+  return new Date(timestamp).toISOString();
+};
+var normalizeVisualEvidenceViewport = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  const viewport = {};
+  if (typeof record.width === "number" && Number.isFinite(record.width)) {
+    viewport.width = record.width;
+  }
+  if (typeof record.height === "number" && Number.isFinite(record.height)) {
+    viewport.height = record.height;
+  }
+  if (typeof record.deviceScaleFactor === "number" && Number.isFinite(record.deviceScaleFactor)) {
+    viewport.deviceScaleFactor = record.deviceScaleFactor;
+  }
+  return Object.keys(viewport).length > 0 ? viewport : void 0;
+};
+var normalizeVisualEvidenceWarnings = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.map((warning) => sanitizeVisualEvidenceText(warning, MAX_VISUAL_WARNING_LENGTH)).filter((warning) => Boolean(warning));
+};
+var persistInspiredesignVisualEvidence = (metadata, options = {}) => {
+  const runtimeMetadata = metadata;
+  const persistedMetadata = metadata;
+  const path2 = metadata.status === "captured" ? sanitizeVisualEvidencePath(options.artifactPath) ?? sanitizeVisualEvidencePath(persistedMetadata.path) ?? sanitizeVisualEvidencePath(runtimeMetadata.artifactPath) : void 0;
+  const sha256 = sanitizeVisualEvidenceSha256(options.sha256) ?? sanitizeVisualEvidenceSha256(persistedMetadata.sha256);
+  const bytes = sanitizeVisualEvidenceBytes(options.bytes) ?? sanitizeVisualEvidenceBytes(persistedMetadata.bytes);
+  const capturedAt = sanitizeVisualEvidenceCapturedAt(metadata.capturedAt);
+  const viewport = normalizeVisualEvidenceViewport(metadata.viewport);
+  const failure = sanitizeVisualEvidenceText(metadata.failure, MAX_VISUAL_FAILURE_LENGTH);
+  return {
+    status: metadata.status,
+    kind: isInspiredesignVisualEvidenceKind(metadata.kind) ? metadata.kind : "viewport",
+    fullPage: metadata.fullPage === true,
+    capturedAt,
+    ...path2 ? { path: path2 } : {},
+    ...sha256 ? { sha256 } : {},
+    ...bytes !== void 0 ? { bytes } : {},
+    ...viewport ? { viewport } : {},
+    warnings: normalizeVisualEvidenceWarnings(metadata.warnings),
+    ...failure ? { failure } : {}
+  };
+};
+
 // src/inspiredesign/contract.ts
 var INSPIREDESIGN_CAPTURE_ATTEMPT_KEYS = ["snapshot", "clone", "dom"];
 var MALFORMED_CAPTURE_ATTEMPT_DETAIL = "Capture attempt metadata missing or malformed.";
@@ -11662,7 +12356,8 @@ var normalizeInspiredesignCaptureEvidence = (capture) => {
     ...capture.title ? { title: capture.title } : {},
     ...hasUsableInspiredesignSnapshot(capture) && capture.snapshot ? { snapshot: capture.snapshot } : {},
     ...hasUsableInspiredesignDom(capture) && capture.dom ? { dom: capture.dom } : {},
-    ...hasUsableInspiredesignClone(capture) && capture.clone ? { clone: capture.clone } : {}
+    ...hasUsableInspiredesignClone(capture) && capture.clone ? { clone: capture.clone } : {},
+    ...capture.visual ? { visual: persistInspiredesignVisualEvidence(capture.visual) } : {}
   };
   const attempts = reconcileInspiredesignCaptureAttempts(
     normalizedBase,
@@ -11920,13 +12615,16 @@ var buildReferenceSynthesis = (references) => {
   };
 };
 var renderReferenceFirstAdvancedBrief = (briefExpansion, board, vectors, references) => {
-  if (board.references.length === 0) {
+  if (board.references.length === 0 || vectors.sourcePriority !== "reference-evidence-first") {
     if (references.length > 0) {
       return [
         "Reference evidence unavailable:",
-        "URL references were attempted, but no usable creative evidence was captured. Treat this as a capture gap, not a design direction.",
+        "URL references were attempted, but no ready-quality creative evidence was captured. Treat this as a capture or intent gap, not a design direction.",
         "",
-        formatBulletList2(references.map((reference) => renderUnavailableReference(reference))),
+        formatBulletList2([
+          `${references.length} attempted reference(s) are retained in diagnostic artifacts only.`,
+          "Do not use rejected or not-ready reference URLs, names, screenshots, or metadata as creative direction."
+        ]),
         "",
         briefExpansion.advancedBrief
       ].join("\n");
@@ -12013,13 +12711,9 @@ var renderEvidenceDerivedAdvancedBrief = (briefExpansion, format) => [
   "Best fit use cases:",
   formatBulletList2(format.bestFor)
 ].join("\n");
-var renderUnavailableReference = (reference) => {
-  const reason = reference.fetchFailure ?? reference.captureFailure ?? "no usable creative evidence captured";
-  return `${reference.url}: fetch=${reference.fetchStatus}, capture=${reference.captureStatus}, reason=${clipText2(reason, 160)}`;
-};
 var cloneTemplate = (value) => structuredClone(value);
 var referenceFingerprint = (value) => {
-  return createHash3("sha256").update(value).digest("hex").slice(0, 12);
+  return createHash4("sha256").update(value).digest("hex").slice(0, 12);
 };
 var summarizeBrief = (brief) => {
   const normalized = trimText2(brief);
@@ -12543,6 +13237,10 @@ var buildBriefExpansionMetadata = (briefExpansion) => ({
 var buildRequiredReferenceArtifacts = (includePrototypeGuidance) => {
   const files = [
     INSPIREDESIGN_HANDOFF_FILES.evidence,
+    INSPIREDESIGN_HANDOFF_FILES.visualEvidence,
+    INSPIREDESIGN_HANDOFF_FILES.screenshotIndex,
+    INSPIREDESIGN_HANDOFF_FILES.rankedReferences,
+    INSPIREDESIGN_HANDOFF_FILES.metaPrompt,
     INSPIREDESIGN_HANDOFF_FILES.advancedBrief,
     INSPIREDESIGN_HANDOFF_FILES.designMarkdown,
     INSPIREDESIGN_HANDOFF_FILES.generationPlan,
@@ -12585,15 +13283,14 @@ var buildFollowthrough = ({
 });
 var buildDesignContract = ({
   brief,
-  urls,
-  references,
+  designReferences,
   plan,
   format
 }) => ({
-  intent: buildIntentBlock(brief, urls, references, format),
+  intent: buildIntentBlock(brief, designReferences.map((reference) => reference.url), designReferences, format),
   generationPlan: toCanvasGenerationPlan(plan),
   designLanguage: buildDesignLanguageBlock(plan.visualDirection.profile, format),
-  contentModel: buildContentModelBlock(brief, references.filter(hasInspiredesignUsableReferenceEvidence)),
+  contentModel: buildContentModelBlock(brief, designReferences),
   layoutSystem: buildLayoutSystemBlock(plan, format),
   typographySystem: buildTypographySystemBlock(format),
   colorSystem: buildColorSystemBlock(plan.visualDirection.profile, format),
@@ -12665,6 +13362,7 @@ var buildImplementationPlan = ({
   profile,
   format,
   references,
+  attemptedReferenceCount,
   synthesis,
   designVectors
 }) => ({
@@ -12702,7 +13400,7 @@ var buildImplementationPlan = ({
     "Avoid horizontal scrolling for primary content."
   ],
   risksAndAmbiguities: [
-    references.length === 0 ? "No live references were supplied, so visual cues are derived entirely from the written brief." : synthesis.lines.length > 0 ? "Live references were reduced into reusable patterns; unique brand assets should still be recreated, not copied." : "Reference URLs were attempted, but no usable creative evidence was captured; keep implementation anchored to the source brief and selected prompt format.",
+    attemptedReferenceCount === 0 ? "No live references were supplied, so visual cues are derived entirely from the written brief." : synthesis.lines.length > 0 ? "Live references were reduced into reusable patterns; unique brand assets should still be recreated, not copied." : "Reference URLs were attempted, but no usable creative evidence was captured; keep implementation anchored to the source brief and selected prompt format.",
     "Any missing interaction states must be validated during visual QA.",
     "Capture desktop and mobile browser proof before handoff, including reduced-motion behavior and primary CTA visibility."
   ],
@@ -12957,11 +13655,11 @@ var renderPrototypeGuidance = (profile, synthesis, designVectors, targetAnalysis
     "- first prototype should include vs omit: include shell, primary hero or decision section, CTA group, proof or detail sections, section patterns named in the design vectors, final CTA, and footer; omit analytics, app-shell widgets, empty card grids, and any section not supported by the brief or reference evidence."
   ].join("\n");
 };
-var renderDeliverablesSummary = (includePrototypeGuidance) => {
+var renderDeliverablesSummary = (includePrototypeGuidance, canvasContinuationReady) => {
   const deliverables = [
     "Structured `designContract` JSON aligned to canvas governance",
     "Valid `generationPlan` JSON aligned to the canvas generation plan contract",
-    "Ready-to-fill `canvasPlanRequest` JSON for `canvas.plan.set`",
+    canvasContinuationReady ? "Ready-to-fill `canvasPlanRequest` JSON for `canvas.plan.set`" : "Diagnostic `canvasPlanRequest` preview; do not submit to Canvas until next-step guidance is ready",
     "Design-agent handoff JSON with contract scope, skill nudges, and richer implementation context",
     "Human-readable `design.md` design specification",
     "Engineering implementation plan in JSON and Markdown"
@@ -12994,9 +13692,30 @@ var buildEvidencePayload = ({
   referenceCount: references.length,
   references: references.map((reference) => toReferenceEvidenceJson(reference)),
   referencePatternBoard,
+  rankedReferences: referencePatternBoard.references,
   designVectors,
-  targetAnalysis
+  targetAnalysis,
+  visualEvidence: buildVisualEvidencePayload(references),
+  screenshotIndex: buildScreenshotIndex(references)
 });
+var buildVisualEvidencePayload = (references) => references.flatMap((reference) => {
+  const visual = normalizeInspiredesignCaptureEvidence(reference.capture)?.visual;
+  return visual ? [{
+    referenceId: reference.id,
+    url: reference.url,
+    visual: persistInspiredesignVisualEvidence(visual)
+  }] : [];
+});
+var buildScreenshotIndex = (references) => buildVisualEvidencePayload(references).filter((entry) => entry.visual.status === "captured" && typeof entry.visual.path === "string" && typeof entry.visual.sha256 === "string" && typeof entry.visual.bytes === "number").map((entry) => ({
+  referenceId: entry.referenceId,
+  url: entry.url,
+  path: entry.visual.path,
+  sha256: entry.visual.sha256,
+  bytes: entry.visual.bytes,
+  kind: entry.visual.kind,
+  fullPage: entry.visual.fullPage,
+  capturedAt: entry.visual.capturedAt
+}));
 var toCaptureEvidenceJson = (reference) => {
   const normalized = normalizeInspiredesignCaptureEvidence(reference.capture);
   if (!normalized) return null;
@@ -13004,6 +13723,7 @@ var toCaptureEvidenceJson = (reference) => {
   return {
     ...normalized.title ? { title: normalized.title } : {},
     ...signals.length > 0 ? { signals } : {},
+    ...normalized.visual ? { visual: normalized.visual } : {},
     ...normalized.attempts ? { attempts: normalized.attempts } : {}
   };
 };
@@ -13028,19 +13748,25 @@ var buildInspiredesignPacket = (input) => {
     title: reference.title ? trimText2(reference.title) : void 0,
     excerpt: reference.excerpt ? trimText2(reference.excerpt) : void 0
   }));
-  const usableReferences = references.filter(hasInspiredesignUsableReferenceEvidence);
-  const synthesis = buildReferenceSynthesis(usableReferences);
+  const referenceEvidenceRequired = input.referenceEvidenceRequired ?? (urls.length > 0 || references.length > 0);
   const referencePatternBoard = buildInspiredesignReferencePatternBoard(
     referenceFingerprint(brief),
     selectedFormat,
-    references
+    references,
+    brief
   );
+  const readyReferenceIds = new Set(
+    referencePatternBoard.references.filter(isInspiredesignDesignReference).map((reference) => reference.id)
+  );
+  const usableReferences = references.filter(hasInspiredesignUsableReferenceEvidence).filter((reference) => readyReferenceIds.has(reference.id));
+  const synthesis = buildReferenceSynthesis(usableReferences);
   const designVectors = buildInspiredesignDesignVectors(selectedFormat, referencePatternBoard);
+  const designReferencePatternBoard = buildInspiredesignDesignReferencePatternBoard(referencePatternBoard, designVectors);
   const effectiveFormat = buildEvidenceDerivedFormat(selectedFormat, designVectors);
   const targetAnalysis = buildTargetAnalysis(
     brief,
     effectiveFormat,
-    references,
+    usableReferences,
     synthesis,
     designVectors
   );
@@ -13049,9 +13775,15 @@ var buildInspiredesignPacket = (input) => {
     advancedBrief: isReferenceFirstPublicLanding(designVectors) ? renderEvidenceDerivedAdvancedBrief(input.briefExpansion, effectiveFormat) : input.briefExpansion.advancedBrief,
     format: effectiveFormat
   };
+  const metaPromptMarkdown = buildInspiredesignMetaPrompt({
+    brief,
+    briefExpansion: effectiveBriefExpansion,
+    referencePatternBoard,
+    designVectors
+  });
   const advancedBriefMarkdown = renderReferenceFirstAdvancedBrief(
     effectiveBriefExpansion,
-    referencePatternBoard,
+    designReferencePatternBoard,
     designVectors,
     references
   );
@@ -13059,7 +13791,7 @@ var buildInspiredesignPacket = (input) => {
     brief,
     format: effectiveFormat,
     synthesis,
-    referencePatternBoard,
+    referencePatternBoard: designReferencePatternBoard,
     designVectors,
     targetAnalysis
   });
@@ -13067,8 +13799,7 @@ var buildInspiredesignPacket = (input) => {
   const canvasPlanRequest = buildCanvasPlanRequest(brief, generationPlan);
   const designContract = buildDesignContract({
     brief,
-    urls,
-    references,
+    designReferences: usableReferences,
     plan: generationPlan,
     format: effectiveFormat
   });
@@ -13077,14 +13808,15 @@ var buildInspiredesignPacket = (input) => {
     briefExpansion: effectiveBriefExpansion,
     synthesis,
     includePrototypeGuidance,
-    referencePatternBoard,
+    referencePatternBoard: designReferencePatternBoard,
     designVectors,
     targetAnalysis
   });
   const implementationPlan = buildImplementationPlan({
     profile,
     format: effectiveFormat,
-    references,
+    references: usableReferences,
+    attemptedReferenceCount: references.length,
     synthesis,
     designVectors
   });
@@ -13115,7 +13847,7 @@ var buildInspiredesignPacket = (input) => {
     "",
     "## 3.2 Reference Pattern Board",
     "",
-    formatBulletList2(referencePatternBoard.synthesis.sharedStrengths.length > 0 ? referencePatternBoard.synthesis.sharedStrengths : ["No live reference cues were captured."]),
+    formatBulletList2(designVectors.patternsToBorrow.length > 0 ? designVectors.patternsToBorrow : ["No live reference cues were captured."]),
     "",
     "## 3.3 Design Vectors",
     "",
@@ -13154,8 +13886,13 @@ var buildInspiredesignPacket = (input) => {
     "",
     "# 7. Deliverables Summary",
     "",
-    renderDeliverablesSummary(Boolean(input.includePrototypeGuidance))
+    renderDeliverablesSummary(
+      Boolean(input.includePrototypeGuidance),
+      !referenceEvidenceRequired || designReferencePatternBoard.references.length > 0
+    )
   ].join("\n");
+  const visualEvidence = buildVisualEvidencePayload(references);
+  const screenshotIndex = buildScreenshotIndex(references);
   return {
     advancedBriefMarkdown,
     designContract,
@@ -13166,89 +13903,1291 @@ var buildInspiredesignPacket = (input) => {
     implementationPlan,
     implementationPlanMarkdown,
     prototypeGuidanceMarkdown,
+    visualEvidence,
+    screenshotIndex,
+    rankedReferences: designReferencePatternBoard.references,
+    metaPromptMarkdown,
     evidence: buildEvidencePayload({
       brief,
       briefExpansion: effectiveBriefExpansion,
       advancedBriefMarkdown,
       urls,
       references,
-      referencePatternBoard,
+      referencePatternBoard: designReferencePatternBoard,
       designVectors,
       targetAnalysis
     })
   };
 };
 
-// src/providers/workflow-handoff.ts
-var PRODUCT_VIDEO_BRIEF_HELPER_PATH = "./skills/opendevbrowser-product-presentation-asset/scripts/render-video-brief.sh";
-var PRODUCT_VIDEO_BRIEF_HELPER_COMMAND = `${PRODUCT_VIDEO_BRIEF_HELPER_PATH} <pack>/manifest.json`;
-var createSuccessHandoff = (followthroughSummary, suggestedNextAction, suggestedSteps) => ({
-  followthroughSummary,
-  suggestedNextAction,
-  suggestedSteps
-});
-var cliExample = (command, args = "") => `npx opendevbrowser ${command}${args ? ` ${args}` : ""}`;
-var quoteCliValue = (value) => JSON.stringify(value);
-var GATED_PROVIDER_REASON_CODES = /* @__PURE__ */ new Set([
-  "auth_required",
-  "token_required",
-  "challenge_detected"
-]);
-var buildResearchRerunCommand = (input, options = {}) => {
-  const browserMode = options.browserMode ?? input.browserMode ?? "managed";
-  const useCookies = options.useCookies ? " --use-cookies" : "";
-  const challengeMode = options.challengeAutomationMode ? ` --challenge-automation-mode ${options.challengeAutomationMode}` : "";
-  return cliExample(
-    "research run",
-    `--topic ${quoteCliValue(input.topic)} --days 14 --sources web,community --browser-mode ${browserMode}${useCookies}${challengeMode} --mode json --output-format json`
-  );
+// src/guidance/renderers.ts
+var toJsonValue2 = (value) => {
+  return structuredClone(value);
 };
-var isJsonRecord3 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-var readFailureReasonCode = (failure) => {
-  return failure.error.reasonCode ?? normalizeProviderReasonCode({
-    code: failure.error.code,
-    message: failure.error.message,
-    details: failure.error.details
-  }) ?? null;
+var renderWorkflowGuidance = (guidance) => {
+  return toJsonValue2(guidance);
 };
-var readDiagnosticReasonCode = (diagnostic) => {
-  const reasonCode = diagnostic.reasonCode ?? diagnostic.browserFallbackReasonCode;
-  return isProviderReasonCode(reasonCode) && GATED_PROVIDER_REASON_CODES.has(reasonCode) ? reasonCode : null;
+var renderWorkflowCompatibility = (guidance, fallbackSummary) => {
+  const commandSteps = guidance.commands.map((entry) => ({
+    reason: entry.label,
+    command: entry.command
+  }));
+  const artifactSteps = guidance.artifactInputs.map((entry) => ({
+    reason: `${entry.required ? "Required" : "Optional"}: ${entry.path}. ${entry.purpose}`
+  }));
+  const validationSteps = guidance.validationChecks.map((entry) => ({
+    reason: entry.assertion ? `${entry.description} Assertion: ${entry.assertion}` : entry.description,
+    ...entry.command ? { command: entry.command } : {}
+  }));
+  return {
+    followthroughSummary: fallbackSummary ?? guidance.primaryAction.summary,
+    suggestedNextAction: guidance.primaryAction.summary,
+    suggestedSteps: [...commandSteps, ...artifactSteps, ...validationSteps]
+  };
 };
-var cookieDiagnosticShowsAvailableCookies = (diagnostic) => {
-  return diagnostic.available === true || typeof diagnostic.loaded === "number" && diagnostic.loaded > 0 || typeof diagnostic.injected === "number" && diagnostic.injected > 0 || typeof diagnostic.verifiedCount === "number" && diagnostic.verifiedCount > 0;
+
+// src/guidance/readiness.ts
+var MIN_READY_REFERENCE_SCORE2 = 50;
+var MIN_READY_REFERENCE_CONFIDENCE2 = 0.5;
+var hasProviderBlocker = (context) => {
+  if (context.providerUnavailable === true) return true;
+  return context.reasonCode === "provider_unavailable" || context.reasonCode === "auth_required";
+};
+var hasDiagnosticOnlyEvidence = (context) => {
+  const reasons = context.evidence?.diagnosticOnlyReasons ?? [];
+  if (reasons.length === 0) return false;
+  return (context.evidence?.rankedReferenceCount ?? 0) === 0;
+};
+var hasNoReferences = (context) => {
+  return context.evidence?.referenceEvidenceRequired !== false && (context.evidence?.referenceCount ?? 0) === 0;
+};
+var hasNoRankedReferences = (context) => {
+  const referenceCount = context.evidence?.referenceCount ?? 0;
+  if (referenceCount === 0) return false;
+  return (context.evidence?.rankedReferenceCount ?? 0) === 0;
+};
+var hasRequiredCaptureFailure = (context) => {
+  if (context.evidence?.visualEvidenceRequired !== true) return false;
+  return (context.evidence.failedCaptureCount ?? 0) > 0 || (context.evidence.missingScreenshotCount ?? 0) > 0;
+};
+var hasWeakTopReference = (context) => {
+  const rankedCount = context.evidence?.rankedReferenceCount ?? 0;
+  if (rankedCount === 0) return false;
+  const score = context.evidence?.topReferenceScore ?? 0;
+  const confidence = context.evidence?.topReferenceConfidence ?? 0;
+  return score < MIN_READY_REFERENCE_SCORE2 || confidence < MIN_READY_REFERENCE_CONFIDENCE2;
+};
+var hasOffBriefTopReference = (context) => {
+  const rankedCount = context.evidence?.rankedReferenceCount ?? 0;
+  return rankedCount > 0 && context.evidence?.topReferenceIntentMatched === false;
+};
+var classifyGuidanceReadiness = (context) => {
+  if (context.reasonCode === "missing_input" || context.reasonCode === "missing_params") return "needs_input";
+  if (context.reasonCode === "daemon_fingerprint_mismatch") return "blocked";
+  if (hasProviderBlocker(context)) return "blocked";
+  if (hasDiagnosticOnlyEvidence(context)) return "diagnostic_only";
+  if (hasNoReferences(context)) return "needs_recovery";
+  if (hasNoRankedReferences(context)) return "needs_recovery";
+  if (hasRequiredCaptureFailure(context)) return "needs_recovery";
+  if (hasOffBriefTopReference(context)) return "needs_recovery";
+  if (hasWeakTopReference(context)) return "needs_recovery";
+  return "ready";
 };
-var addProviderSignal = (signal, provider, reasonCode) => {
-  if (provider) signal.providers.push(provider);
-  if (reasonCode) signal.reasonCodes.push(reasonCode);
+
+// src/canvas/repair-examples.ts
+var EXAMPLE_MAX_INTERACTION_LATENCY_MS = 150;
+var MAX_ISSUE_FIELD_EXAMPLES = 8;
+var EXAMPLE_CANVAS_GENERATION_PLAN = {
+  targetOutcome: {
+    mode: "high-fi-live-edit",
+    summary: "Produce an evidence-backed, responsive landing page iteration."
+  },
+  visualDirection: {
+    profile: "cinematic-minimal",
+    themeStrategy: "single-theme"
+  },
+  layoutStrategy: {
+    approach: "hero-led composition with clear content sections",
+    navigationModel: "global-header"
+  },
+  contentStrategy: {
+    source: "design brief, harvested references, and current project content"
+  },
+  componentStrategy: {
+    mode: "reuse existing components before creating new primitives",
+    interactionStates: ["default", "hover", "focus", "disabled"]
+  },
+  motionPosture: {
+    level: "subtle",
+    reducedMotion: "respect-user-preference"
+  },
+  responsivePosture: {
+    primaryViewport: "desktop",
+    requiredViewports: ["desktop", "tablet", "mobile"]
+  },
+  accessibilityPosture: {
+    target: "WCAG_2_2_AA",
+    keyboardNavigation: "full"
+  },
+  validationTargets: {
+    blockOn: ["contrast-failure", "missing-intent", "missing-design-language"],
+    requiredThemes: ["light"],
+    browserValidation: "required",
+    maxInteractionLatencyMs: EXAMPLE_MAX_INTERACTION_LATENCY_MS
+  },
+  interactionMoments: ["primary CTA hover", "keyboard focus ring", "mobile navigation open"],
+  materialEffects: ["soft depth on primary surfaces"],
+  designVectors: {
+    density: "editorial",
+    imagery: "dominant first-viewport visual plane"
+  }
 };
-var readFailureCookieDiagnostics = (failure) => {
-  const candidate = failure.error.details?.cookieDiagnostics;
-  return isJsonRecord3(candidate) ? candidate : null;
+var exampleIds = {
+  canvasSessionId: "canvas-session-from-session-open",
+  leaseId: "lease-from-session-open",
+  documentId: "document-from-session-open"
 };
-var emptyResearchGatedProviderSignal = () => ({
-  providers: [],
-  reasonCodes: [],
-  useCookies: false
-});
-var normalizeResearchGatedProviderSignal = (signal) => {
-  return signal.providers.length > 0 || signal.reasonCodes.length > 0 ? {
-    providers: [...new Set(signal.providers)].sort(),
-    reasonCodes: [...new Set(signal.reasonCodes)].sort(),
-    useCookies: signal.useCookies
-  } : null;
+var stringifyReceived = (value) => {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
 };
-var mergeResearchGatedProviderSignals = (signals) => {
-  const merged = emptyResearchGatedProviderSignal();
-  for (const signal of signals) {
-    merged.providers.push(...signal.providers);
-    merged.reasonCodes.push(...signal.reasonCodes);
-    merged.useCookies = merged.useCookies || signal.useCookies;
+var toExpectedString = (value) => {
+  if (Array.isArray(value)) return value.join(" | ");
+  return value;
+};
+var commandForReason = (reasonCode, blockedCommand) => {
+  const retryCommand = blockedCommand && blockedCommand !== "canvas.session.attach" ? blockedCommand : "canvas.plan.set";
+  if (reasonCode === "missing_canvas_session_id") return ["canvas.session.open", retryCommand];
+  if (reasonCode === "missing_lease_id") return ["canvas.session.attach", retryCommand];
+  if (reasonCode === "missing_document_id") return ["canvas.document.load"];
+  if (reasonCode === "governance_missing") return ["canvas.document.patch", "canvas.preview.render", "canvas.document.save"];
+  return ["canvas.plan.set", "canvas.plan.get"];
+};
+var titleForReason = (reasonCode) => {
+  if (reasonCode === "missing_canvas_session_id") return "Open a Canvas session before running this command.";
+  if (reasonCode === "missing_lease_id") return "Attach to the Canvas session and include the active leaseId.";
+  if (reasonCode === "missing_document_id") return "Load a Canvas document by documentId or repoPath before continuing.";
+  if (reasonCode === "governance_missing") return "Patch missing governance blocks before mutation, preview, or save.";
+  if (reasonCode === "plan_required") return "Submit a valid generationPlan before mutating the Canvas document.";
+  return "Repair generationPlan and resubmit canvas.plan.set.";
+};
+var labelForCommand = (command) => {
+  switch (command) {
+    case "canvas.session.open":
+      return "Open a Canvas session";
+    case "canvas.session.attach":
+      return "Attach or reclaim a Canvas lease";
+    case "canvas.document.load":
+      return "Load the target Canvas document";
+    case "canvas.document.patch":
+      return "Patch missing governance";
+    case "canvas.plan.get":
+      return "Inspect the current plan status";
+    case "canvas.plan.set":
+      return "Submit a valid generationPlan";
+    default:
+      return command.startsWith("canvas.") ? `Retry ${command}` : "Submit a valid generationPlan";
   }
-  return merged;
 };
-var detectResearchFailureSignals = (failures) => {
-  const signal = emptyResearchGatedProviderSignal();
+var shellSingleQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+var inlineParamsFlag = (params) => ` --params ${shellSingleQuote(JSON.stringify(params))}`;
+var buildCanvasSessionParamsExample = () => ({
+  canvasSessionId: exampleIds.canvasSessionId,
+  leaseId: exampleIds.leaseId
+});
+var cliForCommand = (command) => {
+  switch (command) {
+    case "canvas.session.open":
+      return "npx opendevbrowser canvas --command canvas.session.open --output-format json";
+    case "canvas.session.attach":
+      return `npx opendevbrowser canvas --command canvas.session.attach${inlineParamsFlag(buildAttachParamsExample())} --output-format json`;
+    case "canvas.document.load":
+      return `npx opendevbrowser canvas --command canvas.document.load${inlineParamsFlag(buildDocumentLoadParamsExample())} --output-format json`;
+    case "canvas.document.patch":
+      return `npx opendevbrowser canvas --command canvas.document.patch${inlineParamsFlag(buildCanvasGovernancePatchParamsExample())} --output-format json`;
+    case "canvas.plan.get":
+      return `npx opendevbrowser canvas --command canvas.plan.get${inlineParamsFlag(buildCanvasSessionParamsExample())} --output-format json`;
+    case "canvas.plan.set":
+      return `npx opendevbrowser canvas --command canvas.plan.set${inlineParamsFlag(buildCanvasPlanSetParamsExample())} --output-format json`;
+    default:
+      if (command.startsWith("canvas.")) {
+        return `npx opendevbrowser canvas --command ${command}${inlineParamsFlag(buildCanvasSessionParamsExample())} --output-format json`;
+      }
+      return `npx opendevbrowser canvas --command canvas.plan.set${inlineParamsFlag(buildCanvasPlanSetParamsExample())} --output-format json`;
+  }
+};
+var commandExamples = (reasonCode, blockedCommand) => {
+  const commands = commandForReason(reasonCode, blockedCommand);
+  return commands.map((command) => ({
+    id: command.replaceAll(".", "-"),
+    label: labelForCommand(command),
+    command: cliForCommand(command)
+  }));
+};
+var buildCanvasPlanSetParamsExample = () => ({
+  canvasSessionId: exampleIds.canvasSessionId,
+  leaseId: exampleIds.leaseId,
+  generationPlan: EXAMPLE_CANVAS_GENERATION_PLAN
+});
+var buildCanvasGovernancePatchParamsExample = () => ({
+  canvasSessionId: exampleIds.canvasSessionId,
+  leaseId: exampleIds.leaseId,
+  baseRevision: 1,
+  patches: [{
+    op: "governance.update",
+    block: "intent",
+    changes: {
+      summary: "Create an evidence-backed landing page iteration for the current brief.",
+      audience: "Primary product or service buyers",
+      task: "Understand the offer and take the primary conversion action",
+      successCriteria: [
+        "Hero communicates the brand and offer without relying on navigation text",
+        "Primary CTA is visible and keyboard reachable",
+        "Desktop, tablet, and mobile layouts preserve content hierarchy"
+      ]
+    }
+  }]
+});
+var buildDocumentLoadParamsExample = () => ({
+  canvasSessionId: exampleIds.canvasSessionId,
+  leaseId: exampleIds.leaseId,
+  documentId: exampleIds.documentId
+});
+var buildAttachParamsExample = () => ({
+  canvasSessionId: exampleIds.canvasSessionId,
+  attachMode: "lease_reclaim"
+});
+var issuePriority = (issue) => {
+  if (issue.code === "invalid_value") return 0;
+  if (issue.code === "invalid_type") return 1;
+  return 2;
+};
+var issueFieldExamples = (issues) => {
+  const prioritizedIssues = [...issues].sort((left, right) => issuePriority(left) - issuePriority(right));
+  return prioritizedIssues.slice(0, MAX_ISSUE_FIELD_EXAMPLES).map((issue) => ({
+    path: `generationPlan.${issue.path}`,
+    description: issue.message,
+    example: readExampleForIssuePath(issue.path),
+    ...issue.expected ? { expected: toExpectedString(issue.expected) } : {},
+    ...typeof issue.received !== "undefined" ? { received: stringifyReceived(issue.received) } : {}
+  }));
+};
+var readExampleForIssuePath = (path2) => {
+  const segments = path2.split(".");
+  let current = EXAMPLE_CANVAS_GENERATION_PLAN;
+  for (const segment of segments) {
+    if (!current || typeof current !== "object" || Array.isArray(current)) return "<valid value>";
+    current = current[segment] ?? "<valid value>";
+  }
+  return current;
+};
+var normalizeGenerationPlanPath = (path2) => {
+  const trimmed = path2.trim();
+  return trimmed.startsWith("generationPlan.") ? trimmed.slice("generationPlan.".length) : trimmed;
+};
+var missingFieldExamples = (missingFields) => missingFields.map(normalizeGenerationPlanPath).filter((path2) => path2.length > 0).slice(0, MAX_ISSUE_FIELD_EXAMPLES).map((path2) => ({
+  path: `generationPlan.${path2}`,
+  description: `Provide generationPlan.${path2} before retrying canvas.plan.set.`,
+  example: readExampleForIssuePath(path2),
+  expected: "valid Canvas generation plan field"
+}));
+var baseFieldExamples = (reasonCode) => {
+  if (reasonCode === "missing_canvas_session_id") {
+    return [{
+      path: "canvasSessionId",
+      description: "Use the canvasSessionId returned by canvas.session.open.",
+      example: exampleIds.canvasSessionId,
+      expected: "non-empty string"
+    }];
+  }
+  if (reasonCode === "missing_lease_id") {
+    return [{
+      path: "leaseId",
+      description: "Use the active leaseId returned by canvas.session.open or canvas.session.attach.",
+      example: exampleIds.leaseId,
+      expected: "non-empty string"
+    }];
+  }
+  if (reasonCode === "missing_document_id") {
+    return [{
+      path: "documentId",
+      description: "Use documentId when loading a persisted Canvas document. Use repoPath instead when loading by file path.",
+      example: exampleIds.documentId,
+      expected: "non-empty string"
+    }];
+  }
+  return [{
+    path: "designGovernance.intent",
+    description: "Patch intent before save or downstream handoff when governance warnings report missing intent.",
+    example: {
+      summary: "Create an evidence-backed landing page iteration for the current brief.",
+      audience: "Primary product or service buyers",
+      task: "Understand the offer and take the primary conversion action"
+    }
+  }];
+};
+var chooseFieldExamples = (reasonCode, issues, missingFields) => {
+  const issueExamples = issueFieldExamples(issues);
+  if (issueExamples.length > 0) return issueExamples;
+  const missingExamples = missingFieldExamples(missingFields);
+  if (missingExamples.length > 0) return missingExamples;
+  return baseFieldExamples(reasonCode);
+};
+var paramsForCommand = (command) => {
+  switch (command) {
+    case "canvas.session.attach":
+      return buildAttachParamsExample();
+    case "canvas.document.load":
+      return buildDocumentLoadParamsExample();
+    case "canvas.document.patch":
+      return buildCanvasGovernancePatchParamsExample();
+    case "canvas.plan.get":
+      return buildCanvasSessionParamsExample();
+    case "canvas.plan.set":
+      return buildCanvasPlanSetParamsExample();
+    default:
+      return command.startsWith("canvas.") ? buildCanvasSessionParamsExample() : null;
+  }
+};
+var paramsExamples = (reasonCode, blockedCommand) => {
+  const examples = [];
+  if (reasonCode === "missing_lease_id") {
+    examples.push({
+      id: "canvas-attach-request",
+      label: "Attach or reclaim a session lease",
+      command: "canvas.session.attach",
+      params: buildAttachParamsExample()
+    });
+    const blockedParams = blockedCommand ? paramsForCommand(blockedCommand) : null;
+    if (blockedCommand && blockedCommand !== "canvas.session.attach" && blockedParams) {
+      examples.push({
+        id: `${blockedCommand.replaceAll(".", "-")}-request`,
+        label: `Valid ${blockedCommand} params after lease recovery`,
+        command: blockedCommand,
+        params: blockedParams
+      });
+      return examples;
+    }
+  }
+  if (reasonCode === "missing_document_id") {
+    examples.push({
+      id: "canvas-document-load-request",
+      label: "Load a document by id",
+      command: "canvas.document.load",
+      params: buildDocumentLoadParamsExample()
+    });
+    return examples;
+  }
+  examples.push({
+    id: "canvas-plan-set-request",
+    label: "Valid canvas.plan.set params",
+    command: "canvas.plan.set",
+    params: buildCanvasPlanSetParamsExample()
+  });
+  if (reasonCode === "governance_missing") {
+    examples.push({
+      id: "canvas-governance-intent-patch",
+      label: "Patch missing intent governance",
+      command: "canvas.document.patch",
+      params: buildCanvasGovernancePatchParamsExample()
+    });
+  }
+  return examples;
+};
+var validationChecks = (reasonCode) => {
+  const checks = [{
+    id: "session-opened",
+    description: "canvas.session.open or canvas.session.attach returns active ids before command retry.",
+    assertion: 'typeof canvasSessionId === "string" && typeof leaseId === "string"'
+  }];
+  if (reasonCode !== "missing_document_id") {
+    checks.push({
+      id: "plan-valid",
+      description: "generationPlan passes Canvas validation.",
+      assertion: "validateGenerationPlan(generationPlan).ok === true"
+    });
+  } else {
+    checks.push({
+      id: "document-target-selected",
+      description: "documentId or repoPath is present before loading a Canvas document.",
+      assertion: 'typeof documentId === "string" || typeof repoPath === "string"'
+    });
+  }
+  if (reasonCode === "governance_missing") {
+    checks.push({
+      id: "intent-present",
+      description: "intent governance block is present after canvas.document.patch.",
+      assertion: "designGovernance.intent is present"
+    });
+  }
+  return checks;
+};
+var doNotProceedIf = (reasonCode) => {
+  const blockers = [
+    "canvasSessionId is missing or stale",
+    "leaseId is missing or no longer active"
+  ];
+  if (reasonCode !== "missing_document_id") {
+    blockers.push("generationPlan validation still reports missing or invalid fields");
+  } else {
+    blockers.push("documentId and repoPath are both missing");
+  }
+  if (reasonCode === "governance_missing") {
+    blockers.push("intent or other required governance blocks are still missing");
+  }
+  return blockers;
+};
+var buildCanvasRepairGuidance = (input) => {
+  const fields = chooseFieldExamples(input.reasonCode, input.issues ?? [], input.missingFields ?? []);
+  const readiness = input.reasonCode === "governance_missing" ? "needs_recovery" : "needs_input";
+  const severity = input.reasonCode === "governance_missing" ? "warning" : "blocked";
+  return {
+    id: `canvas.${input.reasonCode}`,
+    recipeType: "schema_repair",
+    workflow: "canvas",
+    severity,
+    readiness,
+    reasonCode: input.reasonCode,
+    primaryAction: {
+      id: "repair_canvas_request",
+      label: "Repair Canvas command params",
+      summary: input.message ?? titleForReason(input.reasonCode)
+    },
+    commands: commandExamples(input.reasonCode, input.blockedCommand),
+    paramsExamples: paramsExamples(input.reasonCode, input.blockedCommand),
+    fieldExamples: fields,
+    artifactInputs: [],
+    validationChecks: validationChecks(input.reasonCode),
+    fallbackPolicy: {
+      allowed: false,
+      requiresUserConfirmation: true,
+      reason: "Do not skip Canvas validation or governance gates. Repair the typed command payload first."
+    },
+    doNotProceedIf: doNotProceedIf(input.reasonCode)
+  };
+};
+var buildCanvasRepairEnvelope = (input) => {
+  const guidance = buildCanvasRepairGuidance(input);
+  const recommendedNextCommands = commandForReason(input.reasonCode, input.blockedCommand);
+  const message = input.message ?? guidance.primaryAction.summary;
+  const guidancePayload = {
+    recommendedNextCommands,
+    reason: message,
+    nextStepGuidance: renderWorkflowGuidance(guidance),
+    paramsExamples: guidance.paramsExamples,
+    fieldExamples: guidance.fieldExamples,
+    validationChecks: guidance.validationChecks,
+    doNotProceedIf: guidance.doNotProceedIf
+  };
+  return {
+    code: input.reasonCode,
+    message,
+    recommendedNextCommands,
+    guidance: guidancePayload,
+    nextStepGuidance: guidancePayload.nextStepGuidance,
+    paramsExamples: guidancePayload.paramsExamples,
+    fieldExamples: guidancePayload.fieldExamples,
+    validationChecks: guidancePayload.validationChecks,
+    doNotProceedIf: guidancePayload.doNotProceedIf
+  };
+};
+var missingIdentifierReasonCode = (field) => {
+  if (field === "canvasSessionId") return "missing_canvas_session_id";
+  if (field === "leaseId") return "missing_lease_id";
+  return "missing_document_id";
+};
+var SESSION_REQUIRED_COMMANDS = /* @__PURE__ */ new Set([
+  "canvas.session.attach",
+  "canvas.session.status",
+  "canvas.session.close",
+  "canvas.capabilities.get",
+  "canvas.plan.set",
+  "canvas.plan.get",
+  "canvas.document.load",
+  "canvas.document.import",
+  "canvas.document.patch",
+  "canvas.history.undo",
+  "canvas.history.redo",
+  "canvas.document.save",
+  "canvas.document.export",
+  "canvas.inventory.list",
+  "canvas.inventory.insert",
+  "canvas.starter.apply",
+  "canvas.tab.open",
+  "canvas.tab.close",
+  "canvas.overlay.mount",
+  "canvas.overlay.unmount",
+  "canvas.overlay.select",
+  "canvas.preview.render",
+  "canvas.preview.refresh",
+  "canvas.feedback.poll",
+  "canvas.feedback.subscribe",
+  "canvas.feedback.next",
+  "canvas.feedback.unsubscribe",
+  "canvas.code.bind",
+  "canvas.code.unbind",
+  "canvas.code.pull",
+  "canvas.code.push",
+  "canvas.code.status",
+  "canvas.code.resolve"
+]);
+var requiresCanvasSessionId = (command) => SESSION_REQUIRED_COMMANDS.has(command);
+var LEASE_REQUIRED_COMMANDS = /* @__PURE__ */ new Set([
+  "canvas.session.close",
+  "canvas.plan.set",
+  "canvas.plan.get",
+  "canvas.document.load",
+  "canvas.document.import",
+  "canvas.document.patch",
+  "canvas.history.undo",
+  "canvas.history.redo",
+  "canvas.document.save",
+  "canvas.document.export",
+  "canvas.inventory.insert",
+  "canvas.starter.apply",
+  "canvas.tab.open",
+  "canvas.tab.close",
+  "canvas.overlay.mount",
+  "canvas.overlay.unmount",
+  "canvas.overlay.select",
+  "canvas.preview.render",
+  "canvas.preview.refresh",
+  "canvas.code.bind",
+  "canvas.code.unbind",
+  "canvas.code.pull",
+  "canvas.code.push",
+  "canvas.code.resolve"
+]);
+var requiresLeaseId = (command) => LEASE_REQUIRED_COMMANDS.has(command);
+var missingString = (params, field) => {
+  const value = params[field];
+  return typeof value !== "string" || value.trim().length === 0;
+};
+var buildCanvasCommandValidationEnvelope = (command, params) => {
+  if (requiresCanvasSessionId(command) && missingString(params, "canvasSessionId")) {
+    return buildCanvasMissingIdentifierEnvelope("canvasSessionId", command);
+  }
+  if (requiresLeaseId(command) && missingString(params, "leaseId")) {
+    return buildCanvasMissingIdentifierEnvelope("leaseId", command);
+  }
+  const repoPath = params.repoPath;
+  const hasRepoPath = typeof repoPath === "string" && repoPath.trim().length > 0;
+  if (command === "canvas.document.load" && missingString(params, "documentId") && !hasRepoPath) {
+    return buildCanvasMissingIdentifierEnvelope("documentId", command);
+  }
+  return null;
+};
+var buildCanvasMissingIdentifierEnvelope = (field, blockedCommand) => {
+  const reasonCode = missingIdentifierReasonCode(field);
+  return buildCanvasRepairEnvelope({
+    reasonCode,
+    ...blockedCommand ? { blockedCommand } : {},
+    message: `Missing ${field}. ${titleForReason(reasonCode)}`
+  });
+};
+
+// src/guidance/recipes/generic.ts
+var quote = (value) => JSON.stringify(value);
+var DAEMON_STATUS_PREFLIGHT_COMMAND = "opendevbrowser status --daemon --output-format json";
+var DAEMON_FINGERPRINT_CURRENT_ASSERTION = "data.fingerprintCurrent === true";
+var DEFAULT_INSPIREDESIGN_BRIEF = "Digital photography studio landing page";
+var DEFAULT_INSPIREDESIGN_QUERY = "cinematic photography studio landing page inspiration";
+var DEFAULT_RESEARCH_TOPIC = "browser automation provider recovery";
+var DEFAULT_PROVIDER = "provider diagnostics";
+var isCanvasGenerationPlanIssue = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record.path === "string" && typeof record.message === "string" && typeof record.code === "string";
+};
+var canvasGenerationPlanIssues = (value) => Array.isArray(value) ? value.filter(isCanvasGenerationPlanIssue) : [];
+var isPinterestProvider = (provider) => provider === "social/pinterest" || provider === "pinterest";
+var isPinterestOnlyContext = (context) => {
+  const providers = context.requestedProviders ?? [];
+  return providers.length === 0 || providers.every(isPinterestProvider);
+};
+var selectedInspiredesignProvider = (context) => {
+  const providers = context.requestedProviders ?? [];
+  const nonPinterestProvider = providers.find((provider) => !isPinterestProvider(provider));
+  if (!isPinterestOnlyContext(context) && nonPinterestProvider) return nonPinterestProvider;
+  return providers[0] ?? context.siteRecipeId ?? "web/default";
+};
+var selectedProviderIsPinterest = (context) => isPinterestProvider(selectedInspiredesignProvider(context));
+var isPinterestScopedRecovery = (context) => context.siteRecipeId === "social/pinterest" && isPinterestOnlyContext(context);
+var inspiredesignBrowserMode = (context) => selectedProviderIsPinterest(context) ? "extension" : context.browserMode ?? "managed";
+var inspiredesignCookieFlags = (context) => {
+  if (selectedProviderIsPinterest(context)) return " --use-cookies --cookie-policy required";
+  return context.useCookies === true ? " --use-cookies" : "";
+};
+var inspiredesignHarvestCommand = (context) => {
+  const brief = typeof context.details?.brief === "string" ? context.details.brief : DEFAULT_INSPIREDESIGN_BRIEF;
+  const query = context.query ?? DEFAULT_INSPIREDESIGN_QUERY;
+  const provider = selectedInspiredesignProvider(context);
+  const browserMode = inspiredesignBrowserMode(context);
+  const cookieFlags = inspiredesignCookieFlags(context);
+  return {
+    id: "inspiredesign-harvest-rerun",
+    label: "Rerun Inspired Design harvest with explicit evidence settings",
+    command: `npx opendevbrowser inspiredesign harvest --brief ${quote(brief)} --query ${quote(query)} --provider ${provider} --max-references 5 --visual-evidence required --browser-mode ${browserMode}${cookieFlags} --challenge-automation-mode browser_with_helper --mode json --output-format json`
+  };
+};
+var canvasSessionOpenCommand = {
+  id: "canvas-session-open",
+  label: "Open a Canvas session before submitting the plan",
+  command: "npx opendevbrowser canvas --command canvas.session.open --output-format json"
+};
+var canvasPlanSetCommand = {
+  id: "canvas-plan-set",
+  label: "Submit the generated Canvas plan request after filling ids",
+  command: "npx opendevbrowser canvas --command canvas.plan.set --params-file ./canvas-plan.request.json --output-format json"
+};
+var defaultFallbackPolicy = {
+  allowed: false,
+  requiresUserConfirmation: true,
+  reason: "Do not widen provider or source scope without user confirmation."
+};
+var inspiredesignArtifacts = [
+  { path: "advanced-brief.md", purpose: "Review the reference-first brief before design or implementation.", required: true },
+  { path: "ranked-references.json", purpose: "Verify ranked evidence quality and rejected diagnostics.", required: true },
+  { path: "visual-evidence.json", purpose: "Confirm screenshot metadata and warnings.", required: true },
+  { path: "screenshot-index.json", purpose: "Confirm screenshot artifact paths exist before visual claims.", required: true }
+];
+var requiresInspiredesignReferenceEvidence = (context) => context.evidence?.referenceEvidenceRequired !== false;
+var notReadyInspiredesignReasonCode = (context) => context.evidence?.topReferenceIntentMatched === false ? "off_brief_reference" : "weak_reference";
+var notReadyInspiredesignSummary = (reasonCode) => reasonCode === "off_brief_reference" ? "The workflow requested a design-ready handoff, but the top ranked reference is off brief for Canvas continuation." : "The workflow requested a design-ready handoff, but the evidence does not meet the ready threshold for Canvas continuation.";
+var buildReadyInspiredesignGuidance = (context, readiness) => {
+  if (readiness !== "ready") {
+    const reasonCode = notReadyInspiredesignReasonCode(context);
+    return buildEvidenceRecoveryGuidance(
+      context,
+      readiness,
+      reasonCode,
+      reasonCode === "off_brief_reference" ? "Replace off-brief reference evidence" : "Strengthen reference evidence before Canvas",
+      notReadyInspiredesignSummary(reasonCode)
+    );
+  }
+  const referenceEvidenceRequired = requiresInspiredesignReferenceEvidence(context);
+  const artifactInputs = referenceEvidenceRequired ? [...inspiredesignArtifacts, { path: "canvas-plan.request.json", purpose: "Runtime request body for canvas.plan.set.", required: true }] : [
+    { path: "advanced-brief.md", purpose: "Review the brief-expanded design direction before Canvas.", required: true },
+    { path: "design-contract.json", purpose: "Use the brief-derived Canvas governance contract.", required: true },
+    { path: "canvas-plan.request.json", purpose: "Runtime request body for canvas.plan.set.", required: true }
+  ];
+  const validationChecks2 = referenceEvidenceRequired ? [{
+    id: "plan-accepted",
+    description: "canvas.plan.set returns planStatus=accepted before document mutation.",
+    assertion: 'planStatus === "accepted"'
+  }] : [{
+    id: "brief-contract-accepted",
+    description: "canvas.plan.set accepts the generated brief-only generationPlan before document mutation.",
+    assertion: 'planStatus === "accepted"'
+  }];
+  const doNotProceedIf2 = referenceEvidenceRequired ? [
+    "rankedReferences is empty",
+    "screenshot paths are missing when visual evidence was required",
+    "planStatus is not accepted"
+  ] : [
+    "advanced-brief.md or design-contract.json is missing",
+    "planStatus is not accepted"
+  ];
+  return {
+    id: "inspiredesign.canvas_ready_handoff",
+    recipeType: "artifact_handoff",
+    workflow: "inspiredesign",
+    severity: "info",
+    readiness,
+    reasonCode: "design_ready",
+    primaryAction: {
+      id: "continue_in_canvas",
+      label: "Continue in Canvas",
+      summary: "Read the generated artifacts, open a Canvas session, fill canvas-plan.request.json ids, then submit canvas.plan.set."
+    },
+    commands: [canvasSessionOpenCommand, canvasPlanSetCommand],
+    paramsExamples: [{
+      id: "canvas-plan-request-ids",
+      label: "Canvas plan request id placeholders to fill",
+      command: "canvas.plan.set",
+      params: {
+        canvasSessionId: "<canvasSessionId from canvas.session.open>",
+        leaseId: "<leaseId from canvas.session.open>",
+        generationPlan: "<keep generated generationPlan object unchanged>"
+      }
+    }],
+    fieldExamples: [{
+      path: "intent",
+      description: "Patch emitted governance blocks from design-contract.json after plan acceptance.",
+      example: { audience: "Primary user", task: "Complete the design goal", successCriteria: ["Evidence-backed design direction is implemented"] }
+    }],
+    artifactInputs,
+    validationChecks: validationChecks2,
+    fallbackPolicy: {
+      allowed: true,
+      requiresUserConfirmation: false,
+      reason: referenceEvidenceRequired ? "Canvas continuation is allowed because ranked reference evidence is ready." : "Canvas continuation is allowed because this brief-only run did not require reference evidence."
+    },
+    doNotProceedIf: doNotProceedIf2
+  };
+};
+var buildDaemonFingerprintMismatchGuidance = (readiness) => ({
+  id: "daemon.fingerprint_mismatch",
+  recipeType: "workflow_entry",
+  workflow: "daemon",
+  severity: "blocked",
+  readiness,
+  reasonCode: "daemon_fingerprint_mismatch",
+  primaryAction: {
+    id: "verify_daemon_fingerprint",
+    label: "Verify daemon fingerprint",
+    summary: "Run the daemon status preflight and continue only when the running daemon matches the current opendevbrowser build."
+  },
+  commands: [{
+    id: "daemon-status-preflight",
+    label: "Check daemon fingerprint freshness",
+    command: DAEMON_STATUS_PREFLIGHT_COMMAND
+  }],
+  paramsExamples: [],
+  fieldExamples: [{
+    path: "data.fingerprintCurrent",
+    description: "The daemon status response must report the current build fingerprint.",
+    example: true,
+    expected: "true"
+  }],
+  artifactInputs: [],
+  validationChecks: [{
+    id: "fingerprint-current",
+    description: "Daemon status confirms the binary and daemon fingerprint match.",
+    assertion: DAEMON_FINGERPRINT_CURRENT_ASSERTION,
+    command: DAEMON_STATUS_PREFLIGHT_COMMAND
+  }],
+  fallbackPolicy: {
+    allowed: true,
+    requiresUserConfirmation: false,
+    reason: "Use the matching binary, restart the daemon from the current install, or isolate config, cache, daemon port, and relay port."
+  },
+  doNotProceedIf: [
+    "data.fingerprintCurrent is false or missing",
+    "the daemon is still running a different opendevbrowser build"
+  ]
+});
+var buildResearchGatedProviderGuidance = (context, readiness) => {
+  const topic = typeof context.details?.topic === "string" ? context.details.topic : DEFAULT_RESEARCH_TOPIC;
+  const browserMode = context.browserMode ?? "extension";
+  const cookieFlag = context.useCookies === true ? " --use-cookies" : "";
+  const providers = context.requestedProviders?.length ? context.requestedProviders.join(", ") : "gated providers";
+  return {
+    id: "research.gated_provider_recovery",
+    recipeType: "evidence_recovery",
+    workflow: "research",
+    severity: "warning",
+    readiness,
+    reasonCode: "gated_provider",
+    primaryAction: {
+      id: "recover_gated_provider_evidence",
+      label: "Recover gated provider evidence",
+      summary: `Inspect gated-provider diagnostics for ${providers}, then rerun research with a user-authorized signed-in browser session before publishing claims.`
+    },
+    commands: [{
+      id: "research-gated-provider-rerun",
+      label: "Rerun research with browser-scoped provider recovery",
+      command: `npx opendevbrowser research run --topic ${quote(topic)} --days 14 --sources web,community --browser-mode ${browserMode}${cookieFlag} --challenge-automation-mode browser_with_helper --mode json --output-format json`
+    }],
+    paramsExamples: [{
+      id: "research-gated-provider-input",
+      label: "Research gated-provider retry input",
+      params: {
+        topic,
+        browserMode,
+        useCookies: context.useCookies === true,
+        challengeAutomationMode: "browser_with_helper",
+        providers
+      }
+    }],
+    fieldExamples: [{
+      path: "meta.failures[].error.reasonCode",
+      description: "Gated provider failures should identify auth or challenge reason codes before retry.",
+      example: "auth_required"
+    }],
+    artifactInputs: [
+      { path: "records.json", purpose: "Confirm destination records support claims.", required: true },
+      { path: "context.json", purpose: "Inspect source and timebox context.", required: true },
+      { path: "meta.json", purpose: "Review failures, cookie diagnostics, and challenge orchestration metadata.", required: true },
+      { path: "report.md", purpose: "Publish only claims supported by accepted records.", required: true }
+    ],
+    validationChecks: [
+      { id: "signed-in-session", description: "Provider auth or challenge state has been resolved in the browser session." },
+      { id: "records-supported", description: "Final claims are supported by destination records, not SERP snippets." }
+    ],
+    fallbackPolicy: {
+      allowed: false,
+      requiresUserConfirmation: true,
+      reason: "Do not switch sources or publish unsupported claims without user approval."
+    },
+    doNotProceedIf: [
+      "gated provider failures remain unresolved",
+      "records.json lacks destination evidence for the claim",
+      "cookie or challenge recovery has not been user-authorized"
+    ]
+  };
+};
+var buildProviderWorkflowGuidance = (context, readiness) => {
+  const providers = context.requestedProviders?.join(", ") || DEFAULT_PROVIDER;
+  const reasonCode = context.reasonCode ?? "provider_recovery";
+  return {
+    id: `provider.${reasonCode}`,
+    recipeType: "evidence_recovery",
+    workflow: "provider",
+    severity: readiness === "blocked" ? "blocked" : "warning",
+    readiness,
+    reasonCode,
+    primaryAction: {
+      id: "inspect_provider_diagnostics",
+      label: "Inspect provider diagnostics",
+      summary: "Use the typed failure details to resolve auth, challenge, availability, or evidence-quality blockers before widening provider scope."
+    },
+    commands: [{
+      id: "provider-diagnostic-rerun",
+      label: "Show executable workflow help before rerunning",
+      command: "npx opendevbrowser help"
+    }],
+    paramsExamples: [{
+      id: "provider-recovery-input",
+      label: "Provider recovery input",
+      params: {
+        providers,
+        reasonCode,
+        browserMode: context.browserMode ?? "extension",
+        useCookies: context.useCookies === true
+      }
+    }],
+    fieldExamples: [{
+      path: "meta.failures[].error.reasonCode",
+      description: "Use the provider reason code to choose auth, challenge, availability, or evidence recovery.",
+      example: reasonCode
+    }],
+    artifactInputs: [
+      { path: "meta.json", purpose: "Inspect provider diagnostics and reason codes.", required: true },
+      { path: "records.json", purpose: "Confirm accepted destination records before using results.", required: true }
+    ],
+    validationChecks: [{
+      id: "provider-evidence-ready",
+      description: "At least one accepted record supports the workflow output before proceeding."
+    }],
+    fallbackPolicy: defaultFallbackPolicy,
+    doNotProceedIf: [
+      "provider failure reason codes remain unresolved",
+      "accepted records are empty",
+      "the requested provider scope would be widened without user confirmation"
+    ]
+  };
+};
+var buildCliValidationGuidance = (context, readiness) => {
+  const reasonCode = context.reasonCode ?? "validation_error";
+  return {
+    id: `cli.${reasonCode}`,
+    recipeType: "schema_repair",
+    workflow: "cli",
+    severity: "blocked",
+    readiness,
+    reasonCode,
+    primaryAction: {
+      id: "repair_cli_arguments",
+      label: "Repair CLI arguments",
+      summary: "Use the command help and typed error details to rerun with valid flags, params, and output mode."
+    },
+    commands: [{
+      id: "cli-help",
+      label: "Show command help",
+      command: "npx opendevbrowser help"
+    }],
+    paramsExamples: [{
+      id: "cli-validation-input",
+      label: "CLI validation retry",
+      params: {
+        reasonCode,
+        outputFormat: "json"
+      }
+    }],
+    fieldExamples: [{
+      path: "error.reasonCode",
+      description: "The reason code identifies which CLI argument or params field must be repaired.",
+      example: reasonCode
+    }],
+    artifactInputs: [],
+    validationChecks: [{
+      id: "json-output",
+      description: "Rerun the command with --output-format json and verify the response has no validation errors."
+    }],
+    fallbackPolicy: {
+      allowed: true,
+      requiresUserConfirmation: false,
+      reason: "Help output and typed examples are the supported recovery path for invalid CLI input."
+    },
+    doNotProceedIf: [
+      "the command still returns validation errors",
+      "required params are missing or empty"
+    ]
+  };
+};
+var buildEvidenceRecoveryGuidance = (context, readiness, reasonCode, actionLabel, actionSummary) => ({
+  id: `inspiredesign.harvest.${reasonCode}`,
+  recipeType: "evidence_recovery",
+  workflow: "inspiredesign",
+  severity: readiness === "blocked" ? "blocked" : "warning",
+  readiness,
+  reasonCode,
+  primaryAction: {
+    id: "recover_reference_evidence",
+    label: actionLabel,
+    summary: actionSummary
+  },
+  commands: [inspiredesignHarvestCommand(context)],
+  paramsExamples: [{
+    id: "explicit-reference-url-recovery",
+    label: "Use explicit high-quality visual references when provider discovery is blocked",
+    params: {
+      brief: typeof context.details?.brief === "string" ? context.details.brief : DEFAULT_INSPIREDESIGN_BRIEF,
+      urls: ["https://example.com/usable-reference"],
+      visualEvidence: "required",
+      browserMode: inspiredesignBrowserMode(context),
+      ...selectedProviderIsPinterest(context) ? { useCookies: true, cookiePolicy: "required" } : {}
+    }
+  }],
+  fieldExamples: [],
+  artifactInputs: inspiredesignArtifacts.map((artifact) => ({ ...artifact, required: false })),
+  validationChecks: [
+    { id: "ranked-reference-count", description: "At least one ranked reference is present.", assertion: "rankedReferences.length > 0" },
+    { id: "reference-score", description: "The top reference score meets the ready threshold.", assertion: "topReferenceScore >= 50" },
+    { id: "reference-intent", description: "The top ranked reference overlaps the requested brief intent.", assertion: "topReferenceIntentMatched === true" },
+    { id: "visual-artifact", description: "Required visual evidence has finalized screenshot paths.", assertion: "missingScreenshotCount === 0" }
+  ],
+  fallbackPolicy: defaultFallbackPolicy,
+  doNotProceedIf: [
+    "reference_count is 0",
+    "rankedReferences is empty",
+    "top ranked reference is diagnostic-only or off brief",
+    "required visual evidence is missing or failed"
+  ]
+});
+var genericGuidanceRecipes = [
+  {
+    id: "provider.generic_recovery",
+    recipeType: "evidence_recovery",
+    workflow: "provider",
+    priority: 130,
+    reasonCode: "provider_recovery",
+    matches: (context) => context.workflow === "provider",
+    build: buildProviderWorkflowGuidance
+  },
+  {
+    id: "cli.validation_recovery",
+    recipeType: "schema_repair",
+    workflow: "cli",
+    priority: 125,
+    reasonCode: "validation_error",
+    matches: (context) => context.workflow === "cli",
+    build: buildCliValidationGuidance
+  },
+  {
+    id: "daemon.fingerprint_mismatch",
+    recipeType: "workflow_entry",
+    workflow: "daemon",
+    priority: 120,
+    reasonCode: "daemon_fingerprint_mismatch",
+    matches: (context) => context.workflow === "daemon" && context.reasonCode === "daemon_fingerprint_mismatch",
+    build: (_context, readiness) => buildDaemonFingerprintMismatchGuidance(readiness)
+  },
+  {
+    id: "research.gated_provider",
+    recipeType: "evidence_recovery",
+    workflow: "research",
+    priority: 110,
+    reasonCode: "gated_provider",
+    matches: (context) => context.workflow === "research" && context.reasonCode === "gated_provider",
+    build: buildResearchGatedProviderGuidance
+  },
+  {
+    id: "canvas.generation_plan_invalid",
+    recipeType: "schema_repair",
+    workflow: "canvas",
+    priority: 100,
+    reasonCode: "generation_plan_invalid",
+    matches: (context) => context.workflow === "canvas" && context.reasonCode === "generation_plan_invalid",
+    build: (context) => buildCanvasRepairGuidance({
+      reasonCode: "generation_plan_invalid",
+      missingFields: Array.isArray(context.details?.missingFields) ? context.details.missingFields.filter((field) => typeof field === "string") : [],
+      issues: canvasGenerationPlanIssues(context.details?.issues)
+    })
+  },
+  {
+    id: "canvas.plan_required",
+    recipeType: "schema_repair",
+    workflow: "canvas",
+    priority: 90,
+    reasonCode: "plan_required",
+    matches: (context) => context.workflow === "canvas" && context.reasonCode === "plan_required",
+    build: () => buildCanvasRepairGuidance({ reasonCode: "plan_required" })
+  },
+  {
+    id: "canvas.governance_missing",
+    recipeType: "schema_repair",
+    workflow: "canvas",
+    priority: 80,
+    reasonCode: "governance_missing",
+    matches: (context) => context.workflow === "canvas" && context.reasonCode === "governance_missing",
+    build: () => buildCanvasRepairGuidance({ reasonCode: "governance_missing" })
+  },
+  {
+    id: "canvas.missing_canvas_session_id",
+    recipeType: "schema_repair",
+    workflow: "canvas",
+    priority: 70,
+    reasonCode: "missing_canvas_session_id",
+    matches: (context) => context.workflow === "canvas" && context.reasonCode === "missing_canvas_session_id",
+    build: () => buildCanvasRepairGuidance({ reasonCode: "missing_canvas_session_id" })
+  },
+  {
+    id: "canvas.missing_lease_id",
+    recipeType: "schema_repair",
+    workflow: "canvas",
+    priority: 60,
+    reasonCode: "missing_lease_id",
+    matches: (context) => context.workflow === "canvas" && context.reasonCode === "missing_lease_id",
+    build: () => buildCanvasRepairGuidance({ reasonCode: "missing_lease_id" })
+  },
+  {
+    id: "canvas.missing_document_id",
+    recipeType: "schema_repair",
+    workflow: "canvas",
+    priority: 50,
+    reasonCode: "missing_document_id",
+    matches: (context) => context.workflow === "canvas" && context.reasonCode === "missing_document_id",
+    build: () => buildCanvasRepairGuidance({ reasonCode: "missing_document_id" })
+  },
+  {
+    id: "inspiredesign.pinterest.browser_native_recovery",
+    recipeType: "site_navigation",
+    workflow: "inspiredesign",
+    priority: 100,
+    reasonCode: "pinterest_browser_native_recovery",
+    matches: (context) => context.workflow === "inspiredesign" && isPinterestScopedRecovery(context) && context.reasonCode !== "design_ready",
+    build: (context, readiness) => buildEvidenceRecoveryGuidance(
+      context,
+      readiness,
+      "pinterest_browser_native_recovery",
+      "Recover Pinterest evidence in an authenticated browser session",
+      "Use the Pinterest browser-native recipe to verify login, search the brief on Pinterest, collect usable pins or boards, and reject login, challenge, empty-grid, and search-shell pages before Canvas."
+    )
+  },
+  {
+    id: "inspiredesign.provider_unavailable",
+    recipeType: "evidence_recovery",
+    workflow: "inspiredesign",
+    priority: 90,
+    reasonCode: "provider_unavailable",
+    matches: (context) => context.workflow === "inspiredesign" && context.reasonCode === "provider_unavailable",
+    build: (context, readiness) => buildEvidenceRecoveryGuidance(
+      context,
+      readiness,
+      "provider_unavailable",
+      "Recover provider evidence",
+      "Resolve the requested provider lane or supply explicit usable reference URLs before continuing to Canvas."
+    )
+  },
+  {
+    id: "inspiredesign.diagnostic_only",
+    recipeType: "quality_gate",
+    workflow: "inspiredesign",
+    priority: 80,
+    reasonCode: "diagnostic_only",
+    matches: (context) => context.workflow === "inspiredesign" && context.reasonCode === "diagnostic_only",
+    build: (context, readiness) => buildEvidenceRecoveryGuidance(
+      context,
+      readiness,
+      "diagnostic_only",
+      "Replace diagnostic references",
+      "The harvest captured diagnostic or blocked pages. Replace them with usable creative references before Canvas."
+    )
+  },
+  {
+    id: "inspiredesign.zero_references",
+    recipeType: "evidence_recovery",
+    workflow: "inspiredesign",
+    priority: 70,
+    reasonCode: "zero_references",
+    matches: (context) => context.workflow === "inspiredesign" && context.reasonCode === "zero_references",
+    build: (context, readiness) => buildEvidenceRecoveryGuidance(
+      context,
+      readiness,
+      "zero_references",
+      "Collect reference evidence",
+      "The harvest produced no references. Run source-specific discovery or provide explicit URLs before Canvas."
+    )
+  },
+  {
+    id: "inspiredesign.failed_capture",
+    recipeType: "evidence_recovery",
+    workflow: "inspiredesign",
+    priority: 60,
+    reasonCode: "failed_capture",
+    matches: (context) => context.workflow === "inspiredesign" && context.reasonCode === "failed_capture",
+    build: (context, readiness) => buildEvidenceRecoveryGuidance(
+      context,
+      readiness,
+      "failed_capture",
+      "Retry capture with a usable browser session",
+      "Deep capture or required visual evidence failed. Restore session state or use explicit references with capturable pages."
+    )
+  },
+  {
+    id: "inspiredesign.zero_ranked_references",
+    recipeType: "evidence_recovery",
+    workflow: "inspiredesign",
+    priority: 55,
+    reasonCode: "zero_ranked_references",
+    matches: (context) => context.workflow === "inspiredesign" && context.reasonCode === "zero_ranked_references",
+    build: (context, readiness) => buildEvidenceRecoveryGuidance(
+      context,
+      readiness,
+      "zero_ranked_references",
+      "Replace rejected reference evidence",
+      "The harvest captured references, but none survived scoring. Replace rejected, off-brief, blocked, or diagnostic pages before Canvas."
+    )
+  },
+  {
+    id: "inspiredesign.off_brief_reference",
+    recipeType: "quality_gate",
+    workflow: "inspiredesign",
+    priority: 52,
+    reasonCode: "off_brief_reference",
+    matches: (context) => context.workflow === "inspiredesign" && context.reasonCode === "off_brief_reference",
+    build: (context, readiness) => buildEvidenceRecoveryGuidance(
+      context,
+      readiness,
+      "off_brief_reference",
+      "Replace off-brief reference evidence",
+      "The top ranked reference is captured, but its signals do not overlap the requested brief. Replace it with on-brief references before Canvas."
+    )
+  },
+  {
+    id: "inspiredesign.weak_reference",
+    recipeType: "quality_gate",
+    workflow: "inspiredesign",
+    priority: 50,
+    reasonCode: "weak_reference",
+    matches: (context) => context.workflow === "inspiredesign" && context.reasonCode === "weak_reference",
+    build: (context, readiness) => buildEvidenceRecoveryGuidance(
+      context,
+      readiness,
+      "weak_reference",
+      "Strengthen weak reference evidence",
+      "The harvest has ranked references, but their score or confidence is too weak for Canvas-first design handoff."
+    )
+  },
+  {
+    id: "inspiredesign.ready",
+    recipeType: "artifact_handoff",
+    workflow: "inspiredesign",
+    priority: 1,
+    reasonCode: "design_ready",
+    matches: (context) => context.workflow === "inspiredesign" && context.reasonCode === "design_ready",
+    build: buildReadyInspiredesignGuidance
+  }
+];
+
+// src/guidance/router.ts
+var byPriority = (left, right) => {
+  return right.priority - left.priority || left.id.localeCompare(right.id);
+};
+var GuidanceRouter = class {
+  recipes;
+  constructor(recipes = genericGuidanceRecipes) {
+    this.recipes = recipes.slice().sort(byPriority);
+  }
+  route(context) {
+    const readiness = classifyGuidanceReadiness(context);
+    const recipe = this.recipes.find((candidate) => candidate.matches(context));
+    if (!recipe) {
+      throw new Error(`No guidance recipe matched workflow ${context.workflow}.`);
+    }
+    return recipe.build(context, readiness);
+  }
+};
+var routeNextStepGuidance = (context) => {
+  return new GuidanceRouter().route(context);
+};
+
+// src/providers/workflow-handoff.ts
+var PRODUCT_VIDEO_BRIEF_HELPER_PATH = "./skills/opendevbrowser-product-presentation-asset/scripts/render-video-brief.sh";
+var PRODUCT_VIDEO_BRIEF_HELPER_COMMAND = `${PRODUCT_VIDEO_BRIEF_HELPER_PATH} <pack>/manifest.json`;
+var createSuccessHandoff = (followthroughSummary, suggestedNextAction, suggestedSteps) => ({
+  followthroughSummary,
+  suggestedNextAction,
+  suggestedSteps
+});
+var cliExample = (command, args) => `npx opendevbrowser ${command} ${args}`;
+var quoteCliValue = (value) => JSON.stringify(value);
+var GATED_PROVIDER_REASON_CODES = /* @__PURE__ */ new Set([
+  "auth_required",
+  "token_required",
+  "challenge_detected"
+]);
+var buildResearchRerunCommand = (input, options = {}) => {
+  const browserMode = options.browserMode ?? input.browserMode ?? "managed";
+  const useCookies = options.useCookies ? " --use-cookies" : "";
+  const challengeMode = options.challengeAutomationMode ? ` --challenge-automation-mode ${options.challengeAutomationMode}` : "";
+  return cliExample(
+    "research run",
+    `--topic ${quoteCliValue(input.topic)} --days 14 --sources web,community --browser-mode ${browserMode}${useCookies}${challengeMode} --mode json --output-format json`
+  );
+};
+var isJsonRecord3 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var readFailureReasonCode = (failure) => {
+  return failure.error.reasonCode ?? normalizeProviderReasonCode({
+    code: failure.error.code,
+    message: failure.error.message,
+    details: failure.error.details
+  }) ?? null;
+};
+var readDiagnosticReasonCode = (diagnostic) => {
+  const reasonCode = diagnostic.reasonCode ?? diagnostic.browserFallbackReasonCode;
+  return isProviderReasonCode(reasonCode) && GATED_PROVIDER_REASON_CODES.has(reasonCode) ? reasonCode : null;
+};
+var cookieDiagnosticShowsAvailableCookies = (diagnostic) => {
+  return diagnostic.available === true || typeof diagnostic.loaded === "number" && diagnostic.loaded > 0 || typeof diagnostic.injected === "number" && diagnostic.injected > 0 || typeof diagnostic.verifiedCount === "number" && diagnostic.verifiedCount > 0;
+};
+var addProviderSignal = (signal, provider, reasonCode) => {
+  if (provider) signal.providers.push(provider);
+  if (reasonCode) signal.reasonCodes.push(reasonCode);
+};
+var readFailureCookieDiagnostics = (failure) => {
+  const candidate = failure.error.details?.cookieDiagnostics;
+  return isJsonRecord3(candidate) ? candidate : null;
+};
+var emptyResearchGatedProviderSignal = () => ({
+  providers: [],
+  reasonCodes: [],
+  useCookies: false
+});
+var normalizeResearchGatedProviderSignal = (signal) => {
+  return signal.providers.length > 0 || signal.reasonCodes.length > 0 ? {
+    providers: [...new Set(signal.providers)].sort(),
+    reasonCodes: [...new Set(signal.reasonCodes)].sort(),
+    useCookies: signal.useCookies
+  } : null;
+};
+var mergeResearchGatedProviderSignals = (signals) => {
+  const merged = emptyResearchGatedProviderSignal();
+  for (const signal of signals) {
+    merged.providers.push(...signal.providers);
+    merged.reasonCodes.push(...signal.reasonCodes);
+    merged.useCookies = merged.useCookies || signal.useCookies;
+  }
+  return merged;
+};
+var detectResearchFailureSignals = (failures) => {
+  const signal = emptyResearchGatedProviderSignal();
   for (const failure of failures) {
     const reasonCode = readFailureReasonCode(failure);
     const isGatedFailure = Boolean(reasonCode && GATED_PROVIDER_REASON_CODES.has(reasonCode));
@@ -13317,6 +15256,10 @@ var buildProductVideoRerunCommand = (input = {}) => {
     `${target}${providerHint}${screenshots}${allImages}${includeCopy}${browserMode} --use-cookies --challenge-automation-mode browser_with_helper --output-format json`
   );
 };
+var extractPrimaryConstraintSentence = (summary) => {
+  const match = /^Primary constraint:\s+(.+?\.)\s/.exec(summary);
+  return match?.[1] ?? null;
+};
 var buildMacroResolveArgs = (input, options) => {
   const defaultProvider = input.defaultProvider ? ` --default-provider ${input.defaultProvider}` : "";
   const execute = options?.execute ? " --execute" : "";
@@ -13324,7 +15267,7 @@ var buildMacroResolveArgs = (input, options) => {
   const useCookies = options?.useCookies ? " --use-cookies" : "";
   const challenge = options?.challengeAutomationMode ? ` --challenge-automation-mode ${options.challengeAutomationMode}` : "";
   const cookiePolicy = options?.cookiePolicyOverride ? ` --cookie-policy ${options.cookiePolicyOverride}` : "";
-  const outputFormat = options?.includeOutputFormat === false ? "" : " --output-format json";
+  const outputFormat = " --output-format json";
   return `--expression ${quoteCliValue(input.expression)}${defaultProvider}${execute}${browserMode}${useCookies}${cookiePolicy}${challenge}${outputFormat}`;
 };
 var buildMacroPreviewCommand = (input) => cliExample("macro-resolve", buildMacroResolveArgs(input));
@@ -13338,7 +15281,7 @@ var buildResearchGatedSuccessHandoff = (input, signal) => {
   const recoveryCommand = buildResearchRecoveryRerunCommand(input, signal);
   const providers = signal.providers.length > 0 ? signal.providers.join(", ") : "gated providers";
   const cookieNote = signal.useCookies ? " The command includes --use-cookies because cookie diagnostics show available cookies." : " Add --use-cookies only when legitimate provider cookies are available.";
-  return createSuccessHandoff(
+  const handoff = createSuccessHandoff(
     `Review ranked records, artifact metadata, and gated-provider diagnostics for ${providers} before publishing claims.`,
     `Open the returned artifact path, inspect records.json, context.json, meta.json, and report.md, then rerun ${recoveryCommand} only with a user-authorized signed-in relay session.${cookieNote}`,
     [
@@ -13350,6 +15293,21 @@ var buildResearchGatedSuccessHandoff = (input, signal) => {
       { reason: "Keep SERPs discovery-only and publish only claims supported by destination records that passed review." }
     ]
   );
+  const guidance = routeNextStepGuidance({
+    workflow: "research",
+    reasonCode: "gated_provider",
+    requestedProviders: signal.providers,
+    browserMode: "extension",
+    useCookies: signal.useCookies,
+    details: {
+      topic: input.topic,
+      reasonCodes: signal.reasonCodes
+    }
+  });
+  return {
+    ...handoff,
+    nextStepGuidance: renderWorkflowGuidance(guidance)
+  };
 };
 var buildResearchDefaultSuccessHandoff = (input) => {
   const rerunCommand = buildResearchRerunCommand(input);
@@ -13438,26 +15396,43 @@ var buildMacroResolveSuccessHandoff = (input) => {
     ]
   );
 };
-var buildInspiredesignSuccessHandoff = (input) => createSuccessHandoff(
-  input.summary,
-  input.nextStep,
-  [
-    { reason: INSPIREDESIGN_HANDOFF_GUIDANCE.reviewAdvancedBrief },
-    {
-      reason: "Load the baseline workflow runbook before implementation.",
-      command: input.commandExamples.loadBestPractices
-    },
-    {
-      reason: "Load the Canvas contract lane before patching.",
-      command: input.commandExamples.loadDesignAgent
-    },
-    {
-      reason: INSPIREDESIGN_HANDOFF_GUIDANCE.prepareCanvasPlanRequest,
-      command: input.commandExamples.continueInCanvas
-    },
-    { reason: input.deepCaptureRecommendation }
-  ]
-);
+var buildInspiredesignSuccessHandoff = (input) => {
+  if (input.nextStepGuidance && input.nextStepGuidance.readiness !== "ready") {
+    const primaryConstraint = extractPrimaryConstraintSentence(input.summary);
+    const summary = primaryConstraint ? `Primary constraint: ${primaryConstraint} ${input.nextStepGuidance.primaryAction.summary}` : void 0;
+    const compatibility = renderWorkflowCompatibility(input.nextStepGuidance, summary);
+    return {
+      ...compatibility,
+      nextStepGuidance: renderWorkflowGuidance(input.nextStepGuidance)
+    };
+  }
+  const handoff = createSuccessHandoff(
+    input.summary,
+    input.nextStep,
+    [
+      { reason: INSPIREDESIGN_HANDOFF_GUIDANCE.reviewAdvancedBrief },
+      {
+        reason: "Load the baseline workflow runbook before implementation.",
+        command: input.commandExamples.loadBestPractices
+      },
+      {
+        reason: "Load the Canvas contract lane before patching.",
+        command: input.commandExamples.loadDesignAgent
+      },
+      {
+        reason: "Load the motion-design lane before translating visual evidence into animation, timing, or reduced-motion behavior.",
+        command: input.commandExamples.loadMotionDesign
+      },
+      { reason: INSPIREDESIGN_HANDOFF_GUIDANCE.visualArtifactRecommendation },
+      {
+        reason: INSPIREDESIGN_HANDOFF_GUIDANCE.prepareCanvasPlanRequest,
+        command: input.commandExamples.continueInCanvas
+      },
+      { reason: input.deepCaptureRecommendation }
+    ]
+  );
+  return input.nextStepGuidance ? { ...handoff, nextStepGuidance: renderWorkflowGuidance(input.nextStepGuidance) } : handoff;
+};
 
 // src/providers/renderer.ts
 var toCurrency = (value) => `$${value.toFixed(2)}`;
@@ -13562,6 +15537,33 @@ var researchFailureMessage = (content) => boundedInlineText({
   limit: RESEARCH_REPORT_LIMITS.failureMessageCharacters,
   target: "meta.json"
 });
+var CANVAS_CONTINUATION_BLOCKED_COMMAND = "Unavailable until nextStepGuidance.readiness is ready.";
+var canContinueInspiredesignInCanvas = (guidance) => guidance?.readiness === "ready";
+var blockInspiredesignCanvasArtifactGuide = (handoff, recoverySummary) => ({
+  ...handoff.artifactGuide,
+  [INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest]: {
+    ...handoff.artifactGuide[INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest],
+    purpose: "Diagnostic Canvas request preview only until nextStepGuidance.readiness is ready.",
+    howToUse: [
+      recoverySummary,
+      "Do not submit this payload to Canvas until usable ranked references pass the readiness checks."
+    ],
+    mustNot: [
+      "Do not submit canvas.plan.set while nextStepGuidance.readiness is not ready.",
+      "Do not treat rejected or not-ready references as Canvas design direction."
+    ]
+  }
+});
+var buildMissingInspiredesignGuidanceHandoff = () => {
+  const summary = "Canvas continuation unavailable until nextStepGuidance.readiness is ready.";
+  return {
+    followthroughSummary: summary,
+    suggestedNextAction: summary,
+    suggestedSteps: [{
+      reason: "Inspect the workflow output for nextStepGuidance before using Canvas artifacts."
+    }]
+  };
+};
 var limitedCount = (total, limit) => Math.min(total, limit);
 var omissionLine = (args) => {
   const omitted = args.total - limitedCount(args.total, args.limit);
@@ -13986,6 +15988,19 @@ var renderShopping = (args) => {
 var renderInspiredesign = (args) => {
   const captureAttemptReport = inspiredesignCaptureAttemptReportFromMeta(args.meta);
   const captureAttemptSummary = inspiredesignCaptureAttemptSummaryFromMeta(args.meta);
+  const visualEvidence = args.visualEvidence ?? [];
+  const screenshotIndex = args.screenshotIndex ?? [];
+  const rankedReferences = args.rankedReferences ?? [];
+  const rankedReferencesArtifact = args.referencePatternBoard ? {
+    qualitySummary: args.referencePatternBoard.qualitySummary,
+    references: args.referencePatternBoard.references,
+    rejectedReferences: args.referencePatternBoard.rejectedReferences,
+    synthesis: args.referencePatternBoard.synthesis
+  } : {
+    references: rankedReferences,
+    rejectedReferences: []
+  };
+  const metaPromptMarkdown = args.metaPromptMarkdown ?? "";
   const summary = buildInspiredesignSummary({
     brief: args.brief,
     referenceCount: args.urls.length,
@@ -13993,40 +16008,69 @@ var renderInspiredesign = (args) => {
     meta: args.meta
   });
   const followthroughSummary = prependPrimaryConstraint(args.designAgentHandoff.summary, args.meta);
+  const canContinueInCanvas = canContinueInspiredesignInCanvas(args.nextStepGuidance);
+  const prototypeGuidanceMarkdown = canContinueInCanvas ? args.prototypeGuidanceMarkdown : null;
+  const commandExamples2 = {
+    ...args.designAgentHandoff.commandExamples,
+    continueInCanvas: canContinueInCanvas ? args.designAgentHandoff.commandExamples.continueInCanvas : CANVAS_CONTINUATION_BLOCKED_COMMAND
+  };
+  const renderedWorkflowHandoff = buildInspiredesignSuccessHandoff({
+    summary: followthroughSummary,
+    nextStep: args.designAgentHandoff.nextStep,
+    commandExamples: commandExamples2,
+    deepCaptureRecommendation: args.designAgentHandoff.deepCaptureRecommendation,
+    ...args.nextStepGuidance ? { nextStepGuidance: args.nextStepGuidance } : {}
+  });
+  const handoff = args.nextStepGuidance ? renderedWorkflowHandoff : buildMissingInspiredesignGuidanceHandoff();
+  const blockedCanvasArtifactGuide = canContinueInCanvas ? args.designAgentHandoff.artifactGuide : blockInspiredesignCanvasArtifactGuide(args.designAgentHandoff, handoff.suggestedNextAction);
+  const renderedDesignAgentHandoff = {
+    ...args.designAgentHandoff,
+    ...handoff,
+    summary: handoff.followthroughSummary,
+    nextStep: handoff.suggestedNextAction,
+    artifactGuide: blockedCanvasArtifactGuide,
+    commandExamples: commandExamples2
+  };
   const contextPayload = {
     brief: args.brief,
     advancedBriefMarkdown: args.advancedBriefMarkdown,
     urls: args.urls,
     designContract: args.designContract,
     canvasPlanRequest: args.canvasPlanRequest,
-    designAgentHandoff: args.designAgentHandoff,
+    designAgentHandoff: renderedDesignAgentHandoff,
+    ...args.nextStepGuidance ? { nextStepGuidance: args.nextStepGuidance } : {},
     generationPlan: args.generationPlan,
     implementationPlan: args.implementationPlan,
     designMarkdown: args.designMarkdown,
     implementationPlanMarkdown: args.implementationPlanMarkdown,
-    prototypeGuidanceMarkdown: args.prototypeGuidanceMarkdown,
+    prototypeGuidanceMarkdown,
     evidence: args.evidence,
+    visualEvidence,
+    screenshotIndex,
+    rankedReferences,
+    metaPromptMarkdown,
     meta: args.meta
   };
-  const handoff = buildInspiredesignSuccessHandoff({
-    summary: followthroughSummary,
-    nextStep: args.designAgentHandoff.nextStep,
-    commandExamples: args.designAgentHandoff.commandExamples,
-    deepCaptureRecommendation: args.designAgentHandoff.deepCaptureRecommendation
-  });
   const files = [
     { path: INSPIREDESIGN_HANDOFF_FILES.designMarkdown, content: args.designMarkdown },
     { path: INSPIREDESIGN_HANDOFF_FILES.advancedBrief, content: args.advancedBriefMarkdown },
     { path: INSPIREDESIGN_HANDOFF_FILES.designContract, content: args.designContract },
     { path: INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest, content: args.canvasPlanRequest },
-    { path: INSPIREDESIGN_HANDOFF_FILES.designAgentHandoff, content: args.designAgentHandoff },
+    {
+      path: INSPIREDESIGN_HANDOFF_FILES.designAgentHandoff,
+      content: renderedDesignAgentHandoff
+    },
     { path: INSPIREDESIGN_HANDOFF_FILES.generationPlan, content: args.generationPlan },
     { path: INSPIREDESIGN_HANDOFF_FILES.implementationPlanMarkdown, content: args.implementationPlanMarkdown },
     { path: INSPIREDESIGN_HANDOFF_FILES.implementationPlan, content: args.implementationPlan },
-    { path: INSPIREDESIGN_HANDOFF_FILES.evidence, content: args.evidence }
+    { path: INSPIREDESIGN_HANDOFF_FILES.evidence, content: args.evidence },
+    { path: INSPIREDESIGN_HANDOFF_FILES.visualEvidence, content: { visualEvidence } },
+    { path: INSPIREDESIGN_HANDOFF_FILES.screenshotIndex, content: { screenshots: screenshotIndex } },
+    { path: INSPIREDESIGN_HANDOFF_FILES.rankedReferences, content: rankedReferencesArtifact },
+    { path: INSPIREDESIGN_HANDOFF_FILES.metaPrompt, content: metaPromptMarkdown }
   ];
-  if (args.prototypeGuidanceMarkdown) {
-    files.push({ path: INSPIREDESIGN_HANDOFF_FILES.prototypeGuidance, content: args.prototypeGuidanceMarkdown });
+  if (prototypeGuidanceMarkdown) {
+    files.push({ path: INSPIREDESIGN_HANDOFF_FILES.prototypeGuidance, content: prototypeGuidanceMarkdown });
   }
   const captureAttemptFields = {
     ...captureAttemptSummary ? { captureAttemptSummary } : {},
@@ -14052,12 +16096,17 @@ var renderInspiredesign = (args) => {
         advancedBriefMarkdown: args.advancedBriefMarkdown,
         urls: args.urls,
         canvasPlanRequest: args.canvasPlanRequest,
-        designAgentHandoff: args.designAgentHandoff,
+        designAgentHandoff: renderedDesignAgentHandoff,
+        ...args.nextStepGuidance ? { nextStepGuidance: args.nextStepGuidance } : {},
         designContract: args.designContract,
         generationPlan: args.generationPlan,
         implementationPlan: args.implementationPlan,
-        prototypeGuidanceMarkdown: args.prototypeGuidanceMarkdown,
+        prototypeGuidanceMarkdown,
         evidence: args.evidence,
+        visualEvidence,
+        screenshotIndex,
+        rankedReferences,
+        metaPromptMarkdown,
         ...handoff,
         ...captureAttemptFields,
         meta: args.meta
@@ -14071,7 +16120,7 @@ var renderInspiredesign = (args) => {
         mode: args.mode,
         markdown: args.designMarkdown,
         implementationPlanMarkdown: args.implementationPlanMarkdown,
-        prototypeGuidanceMarkdown: args.prototypeGuidanceMarkdown,
+        prototypeGuidanceMarkdown,
         ...handoff,
         ...captureAttemptFields,
         meta: args.meta
@@ -14102,6 +16151,271 @@ var renderInspiredesign = (args) => {
   };
 };
 
+// src/guidance/recipes/site-registry.ts
+var freezeRecipeValue = (value) => {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) {
+    freezeRecipeValue(child);
+  }
+  return Object.freeze(value);
+};
+var SITE_RECIPES = [freezeRecipeValue(pinterestSiteRecipe)];
+var normalizeHostname = (hostname) => hostname.toLowerCase().replace(/^www\./, "");
+var resolveSiteRecipeForProvider = (providerId) => {
+  return SITE_RECIPES.find((recipe) => recipe.providerIds.includes(providerId));
+};
+var resolveSiteRecipeForUrl = (url) => {
+  let hostname;
+  try {
+    hostname = new URL(url).hostname.toLowerCase();
+  } catch {
+    return void 0;
+  }
+  return SITE_RECIPES.find((recipe) => {
+    if (recipe.id === "social/pinterest") {
+      return isAllowedPinterestReferenceHost(hostname);
+    }
+    const normalizedHost = normalizeHostname(hostname);
+    return recipe.hostnames.some((candidate) => {
+      const normalized = normalizeHostname(candidate);
+      return normalizedHost === normalized || normalizedHost.endsWith(`.${normalized}`);
+    });
+  });
+};
+
+// src/guidance/context.ts
+var HARD_PROVIDER_FAILURE_REASON_CODES = /* @__PURE__ */ new Set([
+  "auth_required",
+  "challenge_detected",
+  "policy_blocked",
+  "rate_limited",
+  "token_required"
+]);
+var normalizeComparableUrl = (value) => {
+  try {
+    const url = new URL(value);
+    url.protocol = "https:";
+    url.hostname = url.hostname.toLowerCase().replace(/^www\./, "");
+    url.hash = "";
+    url.search = "";
+    return url.toString();
+  } catch {
+    return null;
+  }
+};
+var hasAcceptedUserSuppliedSiteRecipeReferenceUrl = (source) => {
+  if (source.metrics.referenceCount === 0 || source.quality.rankedReferenceCount === 0) return false;
+  const rankedReferenceUrls = new Set((source.quality.rankedReferenceUrls ?? []).map(normalizeComparableUrl).filter((url) => typeof url === "string"));
+  if (rankedReferenceUrls.size === 0) return false;
+  const requestedSiteRecipeIds = new Set(source.requestedProviders.map((providerId) => resolveSiteRecipeForProvider(providerId)?.id).filter((recipeId) => typeof recipeId === "string"));
+  return (source.urls ?? []).some((url) => {
+    const recipeId = resolveSiteRecipeForUrl(url)?.id;
+    if (!recipeId) return false;
+    if (requestedSiteRecipeIds.size > 0 && !requestedSiteRecipeIds.has(recipeId)) return false;
+    const normalizedUrl = normalizeComparableUrl(url);
+    return normalizedUrl !== null && rankedReferenceUrls.has(normalizedUrl);
+  });
+};
+var hasHardProviderFailureSignal = (source) => !hasAcceptedUserSuppliedSiteRecipeReferenceUrl(source) && (source.discovery.hardFailureReasonCodes ?? []).some((reasonCode) => HARD_PROVIDER_FAILURE_REASON_CODES.has(reasonCode)) || (source.primaryConstraint?.reasonCode ? HARD_PROVIDER_FAILURE_REASON_CODES.has(source.primaryConstraint.reasonCode) : false);
+var hasProviderUnavailableSignal = (source) => {
+  if (hasHardProviderFailureSignal(source)) return true;
+  if (source.metrics.referenceCount > 0 && source.quality.rankedReferenceCount > 0) return false;
+  if (source.discovery.requested && source.discovery.acceptedUrls.length === 0 && source.discovery.failures > 0) return true;
+  if (source.discovery.failure && source.discovery.acceptedUrls.length === 0) return true;
+  return source.primaryConstraint?.reasonCode === "auth_required";
+};
+var hasWeakTopReference2 = (source) => {
+  if (source.quality.rankedReferenceCount === 0) return false;
+  const score = source.quality.topReferenceScore ?? 0;
+  const confidence = source.quality.topReferenceConfidence ?? 0;
+  return score < 50 || confidence < 0.5;
+};
+var reasonCodeForInspiredesign = (source) => {
+  if (hasProviderUnavailableSignal(source)) return "provider_unavailable";
+  if (source.quality.diagnosticOnlyReasons.length > 0 && source.quality.rankedReferenceCount === 0) return "diagnostic_only";
+  if (source.metrics.referenceCount === 0 && source.metrics.referenceEvidenceRequired !== false) return "zero_references";
+  if (source.metrics.referenceCount > 0 && source.quality.rankedReferenceCount === 0) return "zero_ranked_references";
+  if (source.metrics.visualEvidenceRequired && (source.metrics.failedCaptureCount > 0 || source.quality.missingScreenshotCount > 0)) {
+    return "failed_capture";
+  }
+  if (source.quality.topReferenceIntentMatched === false) return "off_brief_reference";
+  if (hasWeakTopReference2(source)) return "weak_reference";
+  return "design_ready";
+};
+var resolveInspiredesignSiteRecipe = (source) => {
+  const providerRecipe = source.requestedProviders.map((providerId) => resolveSiteRecipeForProvider(providerId)).find((recipe) => recipe !== void 0);
+  if (providerRecipe) return providerRecipe.id;
+  const urlRecipe = (source.urls ?? []).map((url) => resolveSiteRecipeForUrl(url)).find((recipe) => recipe !== void 0);
+  return urlRecipe?.id;
+};
+var createInspiredesignGuidanceContext = (source) => {
+  const siteRecipeId = resolveInspiredesignSiteRecipe(source);
+  return {
+    workflow: "inspiredesign",
+    reasonCode: reasonCodeForInspiredesign(source),
+    requestedProviders: source.requestedProviders,
+    ...siteRecipeId ? { siteRecipeId } : {},
+    ...source.query ? { query: source.query } : {},
+    ...source.browserMode ? { browserMode: source.browserMode } : {},
+    ...source.cookiePolicy ? { cookiePolicy: source.cookiePolicy } : {},
+    ...typeof source.useCookies === "boolean" ? { useCookies: source.useCookies } : {},
+    providerUnavailable: hasProviderUnavailableSignal(source),
+    evidence: {
+      referenceCount: source.metrics.referenceCount,
+      referenceEvidenceRequired: source.metrics.referenceEvidenceRequired,
+      failedCaptureCount: source.metrics.failedCaptureCount,
+      visualEvidenceRequired: source.metrics.visualEvidenceRequired,
+      rankedReferenceCount: source.quality.rankedReferenceCount,
+      rejectedReferenceCount: source.quality.rejectedReferenceCount,
+      missingScreenshotCount: source.quality.missingScreenshotCount,
+      diagnosticOnlyReasons: source.quality.diagnosticOnlyReasons,
+      ...typeof source.quality.topReferenceScore === "number" ? { topReferenceScore: source.quality.topReferenceScore } : {},
+      ...typeof source.quality.topReferenceConfidence === "number" ? { topReferenceConfidence: source.quality.topReferenceConfidence } : {},
+      ...typeof source.quality.topReferenceIntentMatched === "boolean" ? { topReferenceIntentMatched: source.quality.topReferenceIntentMatched } : {}
+    },
+    details: {
+      brief: source.brief,
+      discoveryFailure: source.discovery.failure ?? "",
+      hardFailureReasonCodes: source.discovery.hardFailureReasonCodes ?? [],
+      primaryConstraintSummary: source.primaryConstraint?.summary ?? ""
+    }
+  };
+};
+
+// src/inspiredesign/reference-discovery.ts
+var normalizeHttpUrl = (value) => {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    url.hash = "";
+    if (url.pathname === "/" && !/^https?:\/\/[^/]+\/[^?#]/i.test(value)) {
+      return `${url.origin}${url.search}`;
+    }
+    return url.toString();
+  } catch (error) {
+    void error;
+    return null;
+  }
+};
+var extractInspiredesignDiscoveryUrl = (record) => {
+  if (typeof record.url !== "string") return null;
+  const trimmed = record.url.trim();
+  if (!trimmed) return null;
+  return normalizeHttpUrl(trimmed);
+};
+var normalizeInspiredesignDiscoveryRecords = (records) => {
+  const seen = /* @__PURE__ */ new Set();
+  const accepted = [];
+  const rejected = [];
+  records.forEach((record, index) => {
+    const rawUrl = typeof record.url === "string" ? record.url.trim() : void 0;
+    const url = extractInspiredesignDiscoveryUrl(record);
+    const base = {
+      ...record.title ? { title: record.title } : {},
+      source: record.source,
+      provider: record.provider,
+      rank: index + 1
+    };
+    if (!rawUrl) {
+      rejected.push({ ...base, status: "rejected", reason: "missing_url" });
+      return;
+    }
+    if (!url) {
+      rejected.push({ ...base, status: "rejected", reason: "invalid_url", rawUrl });
+      return;
+    }
+    if (seen.has(url)) {
+      rejected.push({ ...base, status: "rejected", reason: "duplicate_url", rawUrl });
+      return;
+    }
+    seen.add(url);
+    accepted.push({ ...base, status: "accepted", url });
+  });
+  return { accepted, rejected };
+};
+var mergeInspiredesignReferenceUrls = (explicitUrls, discoveredUrls, maxReferences) => {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const url of [...explicitUrls, ...discoveredUrls]) {
+    const normalized = normalizeHttpUrl(url.trim());
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    merged.push(normalized);
+    if (merged.length >= maxReferences) return merged;
+  }
+  return merged;
+};
+var normalizeInspiredesignProviders = (providers) => {
+  const normalized = (providers ?? []).map((provider) => provider.trim()).filter((provider) => provider.length > 0);
+  return [...new Set(normalized)];
+};
+
+// src/inspiredesign/visual-policy.ts
+var VISUAL_BLOCKER_REASONS = /* @__PURE__ */ new Set([
+  "policy_blocked",
+  "auth_required",
+  "challenge_detected",
+  "rate_limited"
+]);
+var toVisualPolicyReason = (reasonCode) => {
+  if (!VISUAL_BLOCKER_REASONS.has(reasonCode)) return null;
+  if (reasonCode === "policy_blocked" || reasonCode === "auth_required" || reasonCode === "challenge_detected" || reasonCode === "rate_limited") {
+    return reasonCode;
+  }
+  return null;
+};
+var blockerFromFailures = (failures) => {
+  for (const failure of failures ?? []) {
+    const reasonCode = failure.error.reasonCode;
+    if (!reasonCode) continue;
+    const blocker = toVisualPolicyReason(reasonCode);
+    if (blocker) return blocker;
+  }
+  return null;
+};
+var blockerFromTopLevelError = (error) => {
+  if (!error?.reasonCode) return null;
+  return toVisualPolicyReason(error.reasonCode);
+};
+var messageForBlocker = (reason) => {
+  switch (reason) {
+    case "policy_blocked":
+      return "Visual capture skipped because provider policy blocked the reference.";
+    case "auth_required":
+      return "Visual capture skipped because authenticated access is unresolved.";
+    case "challenge_detected":
+      return "Visual capture skipped because a challenge was detected.";
+    case "rate_limited":
+      return "Visual capture skipped because the provider is rate limited.";
+    case "visual_evidence_off":
+      return "Visual evidence is disabled for this run.";
+    case "visual_capture_allowed":
+      return "Visual capture is allowed for this reference.";
+  }
+};
+var decideInspiredesignVisualCapturePolicy = (input) => {
+  if (input.visualEvidence === "off") {
+    return {
+      status: "skipped",
+      reason: "visual_evidence_off",
+      message: messageForBlocker("visual_evidence_off")
+    };
+  }
+  const blocker = input.hasUsableRecords === true ? null : blockerFromFailures(input.failures) ?? blockerFromTopLevelError(input.topLevelError);
+  if (blocker) {
+    return {
+      status: "skipped",
+      reason: blocker,
+      message: messageForBlocker(blocker)
+    };
+  }
+  return {
+    status: "allowed",
+    reason: "visual_capture_allowed",
+    message: messageForBlocker("visual_capture_allowed")
+  };
+};
+
 // src/canvas/types.ts
 var CANVAS_SCHEMA_VERSION = "1.0.0";
 var CANVAS_SESSION_MODES = ["low-fi-wireframe", "high-fi-live-edit", "dual-track", "document-only"];
@@ -14230,7 +16544,7 @@ var CANVAS_VALIDATION_TARGET_BLOCK_ON_CODES = [
 var CANVAS_PUBLIC_WARNING_CLASSES = CANVAS_VALIDATION_TARGET_BLOCK_ON_CODES;
 
 // src/providers/shopping-postprocess.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var LOOKS_LIKE_URL_RE = /^https?:\/\/\S+$/i;
 var PRICE_TOKEN_RE = /((?:US\$|CA\$|C\$|USD|CAD|EUR|GBP|[$€£]))\s*([0-9]{1,4}(?:[.,][0-9]{3})*(?:[.,][0-9]{1,2})?)/gi;
 var CONTEXTUAL_PRICE_TOKEN_RE = /(?:connect to any carrier later|starting at|starts at|starting from|from|buy now for|buy for)\s*((?:US\$|CA\$|C\$|USD|CAD|EUR|GBP|[$€£]))\s*([0-9]{1,4}(?:[.,][0-9]{3})*(?:[.,][0-9]{1,2})?)/gi;
@@ -14316,7 +16630,7 @@ var REGION_CURRENCY_BY_REGION = {
   uk: "GBP",
   eu: "EUR"
 };
-var hash = (value) => createHash4("sha1").update(value).digest("hex").slice(0, 16);
+var hash = (value) => createHash5("sha1").update(value).digest("hex").slice(0, 16);
 var normalizePlainText = (value) => {
   if (!value) return "";
   return extractText(value).replace(/[\u0000-\u001F\u007F-\u009F]+/g, " ").replace(/\s+/g, " ").trim();
@@ -14681,7 +16995,7 @@ var withOfferFilterDiagnosticDetails = (details, offerFilterDiagnostic) => {
   };
 };
 var inferShoppingNoOfferFailure = (providerId, query, records, offerFilterDiagnostic) => {
-  const issuePriority = (issue) => ({
+  const issuePriority2 = (issue) => ({
     token_required: 3,
     auth_required: 3,
     challenge_detected: 2
@@ -14696,7 +17010,7 @@ var inferShoppingNoOfferFailure = (providerId, query, records, offerFilterDiagno
       ...title ? { title } : {},
       ...typeof record.attributes.providerShell === "string" && record.attributes.providerShell.trim().length > 0 ? { providerShell: record.attributes.providerShell.trim() } : {}
     }];
-  }).sort((left, right) => issuePriority(right.hint) - issuePriority(left.hint))[0] ?? null;
+  }).sort((left, right) => issuePriority2(right.hint) - issuePriority2(left.hint))[0] ?? null;
   if (primaryRecordIssue) {
     const reasonCode = primaryRecordIssue.hint.reasonCode;
     return {
@@ -14945,7 +17259,7 @@ var compileShoppingWorkflow = (input, options = {}) => {
 };
 
 // src/providers/shopping-compiler.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var DEFAULT_SHOPPING_SEARCH_LIMIT = 8;
 var SHOPPING_FETCH_RECOVERY_LIMIT = 2;
 var SEARCH_INDEX_RETRIEVAL_PATHS = /* @__PURE__ */ new Set(["shopping:search:index", "shopping:search:link"]);
@@ -14962,7 +17276,7 @@ var emptyCheckpointState = () => ({
   step_results_by_id: {}
 });
 var createShoppingSearchStepId = (providerId) => `search:${providerId}`;
-var createShoppingFetchStepId = (providerId, url) => `fetch:${providerId}:${createHash5("sha1").update(canonicalizeUrl(url)).digest("hex").slice(0, 16)}`;
+var createShoppingFetchStepId = (providerId, url) => `fetch:${providerId}:${createHash6("sha1").update(canonicalizeUrl(url)).digest("hex").slice(0, 16)}`;
 var serializeShoppingCheckpointState = (state) => ({
   completed_step_ids: [...state.completed_step_ids],
   step_results_by_id: state.step_results_by_id
@@ -15448,7 +17762,7 @@ var compileProductVideoExecutionPlan = (args) => {
 };
 
 // src/providers/research-compiler.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 var RESEARCH_AUTO_SOURCES = ["web", "community", "social"];
 var RESEARCH_ALL_SOURCES = [...RESEARCH_AUTO_SOURCES];
 var DEFAULT_RESEARCH_SEARCH_LIMIT = 10;
@@ -15474,7 +17788,7 @@ var toProviderSource = (providerId) => {
   return null;
 };
 var createResearchSearchStepId = (source) => `search:${source}`;
-var createResearchFetchStepId = (url) => `fetch:web:${createHash6("sha1").update(canonicalizeUrl(url)).digest("hex").slice(0, 16)}`;
+var createResearchFetchStepId = (url) => `fetch:web:${createHash7("sha1").update(canonicalizeUrl(url)).digest("hex").slice(0, 16)}`;
 var serializeResearchCheckpointState = (state) => ({
   completed_step_ids: [...state.completed_step_ids],
   step_results_by_id: state.step_results_by_id
@@ -15842,9 +18156,310 @@ var executeResearchWorkflowPlan = async (runtime, plan, options) => {
 var hasInspiredesignUrls = (urls) => {
   return Array.isArray(urls) && urls.some((url) => url.trim().length > 0);
 };
-function resolveInspiredesignCaptureMode(requested, urls) {
-  return hasInspiredesignUrls(urls) ? "deep" : requested ?? "off";
-}
+function resolveInspiredesignCaptureMode(requested, urls) {
+  return hasInspiredesignUrls(urls) ? "deep" : requested ?? "off";
+}
+
+// src/providers/browser-native-discovery.ts
+var HARD_FAILURE_REASON_CODES = /* @__PURE__ */ new Set([
+  "auth_required",
+  "challenge_detected",
+  "policy_blocked",
+  "rate_limited",
+  "token_required"
+]);
+var sourceForRecipe = (recipe) => {
+  return recipe.id.startsWith("social/") ? "social" : "web";
+};
+var needsAuthenticatedBrowser = (input) => {
+  if (input.recipe.authMode === "public") return false;
+  if (input.cookiePolicy === "required") return true;
+  return input.recipe.authMode === "authenticated";
+};
+var hasAuthenticatedBrowser = (input) => {
+  return input.browserMode === "extension" && input.useCookies === true;
+};
+var htmlFromRecord = (record) => {
+  const html = record.attributes.html;
+  return typeof html === "string" ? html : "";
+};
+var linksFromRecord = (record) => {
+  const links = record.attributes.links;
+  return Array.isArray(links) ? links.filter((link) => typeof link === "string") : [];
+};
+var badStateTextForRecord = (record) => {
+  return [
+    record.url ?? "",
+    record.title ?? "",
+    record.content ?? "",
+    htmlFromRecord(record)
+  ].join(" ").toLowerCase();
+};
+var normalizeBadStateReasonCode = (state) => {
+  return isProviderReasonCode(state.reasonCode) ? state.reasonCode : "env_limited";
+};
+var shouldMatchBadState = (state, mode) => {
+  if (mode === "hard_blocker") return state.id === "challenge";
+  return mode === "all" || state.id !== "search-shell";
+};
+var findBadState = (recipe, records, mode) => {
+  for (const record of records) {
+    const text = badStateTextForRecord(record);
+    const state = recipe.badStates.find((candidate) => shouldMatchBadState(candidate, mode) && candidate.markers.some((marker) => text.includes(marker.toLowerCase())));
+    if (state) {
+      return {
+        state,
+        reasonCode: normalizeBadStateReasonCode(state)
+      };
+    }
+  }
+  return void 0;
+};
+var findHardFailure = (failures) => failures.find((failure) => {
+  const reasonCode = failure.error.reasonCode ?? failure.error.details?.reasonCode;
+  return typeof reasonCode === "string" && isProviderReasonCode(reasonCode) && HARD_FAILURE_REASON_CODES.has(reasonCode);
+});
+var reasonCodeForFailure = (failure) => {
+  const reasonCode = failure.error.reasonCode ?? failure.error.details?.reasonCode;
+  return typeof reasonCode === "string" && isProviderReasonCode(reasonCode) ? reasonCode : void 0;
+};
+var buildBadStateResult = (input, source, searchUrl, fetchedRecordCount, badState) => ({
+  records: [],
+  failures: [{
+    provider: input.recipe.id,
+    source,
+    error: createProviderError(
+      providerErrorCodeFromReasonCode(badState.reasonCode),
+      badState.state.recoveryAction,
+      {
+        retryable: true,
+        reasonCode: badState.reasonCode,
+        provider: input.recipe.id,
+        source,
+        details: {
+          siteRecipeId: input.recipe.id,
+          query: input.query,
+          searchUrl,
+          badStateId: badState.state.id
+        }
+      }
+    )
+  }],
+  diagnostics: {
+    siteRecipeId: input.recipe.id,
+    attempted: true,
+    reason: badState.reasonCode,
+    searchUrl,
+    fetchedRecordCount,
+    badStateId: badState.state.id,
+    recoveryAction: badState.state.recoveryAction
+  }
+});
+var buildHardFailureResult = (input, source, searchUrl, fetchedRecordCount, failure) => ({
+  records: [],
+  failures: [failure],
+  diagnostics: {
+    siteRecipeId: input.recipe.id,
+    attempted: true,
+    reason: reasonCodeForFailure(failure) ?? "challenge_detected",
+    searchUrl,
+    fetchedRecordCount,
+    recoveryAction: failure.error.message
+  }
+});
+var extractRecipeReferenceUrls = (input, records, maxReferences) => {
+  const extractor = input.recipe.browserNativeDiscovery?.extractReferenceUrls;
+  if (!extractor) return [];
+  const urls = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushUrl = (url) => {
+    if (!url || seen.has(url)) return;
+    seen.add(url);
+    urls.push(url);
+  };
+  for (const record of records) {
+    extractor({
+      url: record.url ?? void 0,
+      content: record.content ?? void 0,
+      html: typeof record.attributes.html === "string" ? record.attributes.html : void 0,
+      links: linksFromRecord(record)
+    }).forEach(pushUrl);
+    if (urls.length >= maxReferences) break;
+  }
+  return urls.slice(0, maxReferences);
+};
+var buildRecipeReferenceRecord = (input, url, index) => {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: `${input.recipe.id}:reference:${index + 1}:${timestamp}`,
+    source: sourceForRecipe(input.recipe),
+    provider: input.recipe.id,
+    url,
+    title: `Site visual reference ${index + 1} for ${input.query}`,
+    content: input.recipe.navigationSteps.map((step) => step.instruction).join(" "),
+    timestamp,
+    confidence: 0.72,
+    attributes: {
+      siteRecipeId: input.recipe.id,
+      discoveryMode: "browser_native_extracted_reference",
+      authMode: input.recipe.authMode,
+      maxReferences: input.maxReferences,
+      validationChecks: input.recipe.evidenceRequirements.map((entry) => entry.validation)
+    }
+  };
+};
+var runBrowserNativeDiscovery = async (input) => {
+  const source = sourceForRecipe(input.recipe);
+  const searchUrl = input.recipe.browserNativeDiscovery?.buildSearchUrl(input.query);
+  if (!searchUrl) {
+    return {
+      records: [],
+      failures: [{
+        provider: input.recipe.id,
+        source,
+        error: createProviderError(
+          "unavailable",
+          `Site recipe ${input.recipe.id} does not define browser-native discovery.`,
+          {
+            retryable: false,
+            reasonCode: "env_limited",
+            provider: input.recipe.id,
+            source,
+            details: {
+              siteRecipeId: input.recipe.id,
+              query: input.query
+            }
+          }
+        )
+      }],
+      diagnostics: {
+        siteRecipeId: input.recipe.id,
+        attempted: false,
+        reason: "unsupported_site_recipe"
+      }
+    };
+  }
+  if (needsAuthenticatedBrowser(input) && !hasAuthenticatedBrowser(input)) {
+    return {
+      records: [],
+      failures: [{
+        provider: input.recipe.id,
+        source,
+        error: createProviderError(
+          "auth",
+          `${input.recipe.id} requires an authenticated browser session before search results are visible.`,
+          {
+            retryable: true,
+            reasonCode: "auth_required",
+            provider: input.recipe.id,
+            source,
+            details: {
+              siteRecipeId: input.recipe.id,
+              query: input.query,
+              requiredBrowserMode: "extension",
+              requiredCookies: true
+            }
+          }
+        )
+      }],
+      diagnostics: {
+        siteRecipeId: input.recipe.id,
+        attempted: false,
+        reason: "auth_required",
+        recoverySteps: input.recipe.recoverySteps.map((step) => step.instruction)
+      }
+    };
+  }
+  if (!input.fetchSearchPage) {
+    return {
+      records: [],
+      failures: [{
+        provider: input.recipe.id,
+        source,
+        error: createProviderError(
+          "unavailable",
+          `${input.recipe.id} browser-native discovery requires a browser-backed fetch executor for the search page.`,
+          {
+            retryable: true,
+            reasonCode: "env_limited",
+            provider: input.recipe.id,
+            source,
+            details: {
+              siteRecipeId: input.recipe.id,
+              query: input.query,
+              searchUrl
+            }
+          }
+        )
+      }],
+      diagnostics: {
+        siteRecipeId: input.recipe.id,
+        attempted: false,
+        reason: "fetch_executor_missing",
+        searchUrl
+      }
+    };
+  }
+  const fetched = await input.fetchSearchPage(searchUrl);
+  const hardFailure = findHardFailure(fetched.failures);
+  if (hardFailure) {
+    return buildHardFailureResult(input, source, searchUrl, fetched.records.length, hardFailure);
+  }
+  const preExtractionMode = needsAuthenticatedBrowser(input) ? "pre_extraction" : "hard_blocker";
+  const hardBlocker = findBadState(input.recipe, fetched.records, preExtractionMode);
+  if (hardBlocker) {
+    return buildBadStateResult(input, source, searchUrl, fetched.records.length, hardBlocker);
+  }
+  const extractedUrls = extractRecipeReferenceUrls(input, fetched.records, input.maxReferences);
+  if (extractedUrls.length === 0) {
+    const shellState = fetched.failures.length === 0 ? findBadState(input.recipe, fetched.records, "all") : void 0;
+    if (shellState) {
+      return buildBadStateResult(input, source, searchUrl, fetched.records.length, shellState);
+    }
+    return {
+      records: [],
+      failures: fetched.failures.length > 0 ? fetched.failures : [{
+        provider: input.recipe.id,
+        source,
+        error: createProviderError(
+          "unavailable",
+          fetched.errorMessage ?? `${input.recipe.id} search did not expose recipe-approved URLs that can be used as references.`,
+          {
+            retryable: true,
+            reasonCode: "env_limited",
+            provider: input.recipe.id,
+            source,
+            details: {
+              siteRecipeId: input.recipe.id,
+              query: input.query,
+              searchUrl
+            }
+          }
+        )
+      }],
+      diagnostics: {
+        siteRecipeId: input.recipe.id,
+        attempted: true,
+        reason: "no_reference_urls_extracted",
+        searchUrl,
+        fetchedRecordCount: fetched.records.length
+      }
+    };
+  }
+  return {
+    records: extractedUrls.map((url, index) => buildRecipeReferenceRecord(input, url, index)),
+    failures: [],
+    diagnostics: {
+      siteRecipeId: input.recipe.id,
+      attempted: true,
+      reason: "reference_urls_extracted",
+      searchUrl,
+      navigationSteps: input.recipe.navigationSteps.map((step) => step.instruction),
+      badStates: input.recipe.badStates.map((state) => state.id),
+      extractedUrlCount: extractedUrls.length
+    }
+  };
+};
 
 // src/providers/workflows.ts
 var SIGNAL_WINDOW = 50;
@@ -16105,7 +18720,15 @@ var withPrimaryConstraintMeta = (meta, failures) => {
 var withCamelCasePrimaryConstraintMeta = withPrimaryConstraintMeta;
 var readPrimaryConstraintGuidance = (constraint) => {
   const guidance = constraint.guidance;
-  return guidance && typeof guidance === "object" && !Array.isArray(guidance) ? guidance : void 0;
+  if (!guidance || typeof guidance !== "object" || Array.isArray(guidance)) return void 0;
+  const record = guidance;
+  if (typeof record.reason !== "string") return void 0;
+  if (!Array.isArray(record.recommendedNextCommands)) return void 0;
+  if (!record.recommendedNextCommands.every((command) => typeof command === "string")) return void 0;
+  return {
+    reason: record.reason,
+    recommendedNextCommands: record.recommendedNextCommands
+  };
 };
 var withPrimaryConstraintSummaryOverride = (meta, summary, guidance) => {
   const currentPrimaryConstraint = meta.primaryConstraint;
@@ -16396,6 +19019,9 @@ var workflowTestUtils = {
   redactRawCapture: (record) => redactRawCapture(record),
   toProviderSource: (providerId) => toProviderSource2(providerId),
   resolveShoppingProviderIdForUrl: (url) => resolveShoppingProviderIdForUrl(url),
+  resolveShoppingSourceForUrl: (url) => resolveShoppingSourceForUrl(url),
+  resolveProductCopy: (record, productUrl, refreshedDescription, featureList) => resolveProductCopy(record, productUrl, refreshedDescription, featureList),
+  getRequiredProductVideoExecutionStep: (steps, stepId) => getRequiredProductVideoExecutionStep(steps, stepId),
   normalizeProductVideoProviderHint: (productUrl, providerHint, fallbackProvider) => normalizeProductVideoProviderHint(productUrl, providerHint, fallbackProvider),
   hasTranscriptSuccess: (record) => hasTranscriptSuccess(record),
   sanitizeFeatureList: (values) => sanitizeFeatureList(values),
@@ -16407,7 +19033,15 @@ var workflowTestUtils = {
   fetchBinary: (url, timeoutMs) => fetchBinary(url, timeoutMs),
   rankResearchRecords: (records) => rankResearchRecords(records),
   isValidHttpUrl: (url) => isValidHttpUrl3(url),
-  buildWorkflowResumePayload: (kind, input) => buildWorkflowResumePayload(kind, input)
+  buildWorkflowResumePayload: (kind, input) => buildWorkflowResumePayload(kind, input),
+  withPrimaryConstraintSummaryOverride: (meta, summary, guidance) => withPrimaryConstraintSummaryOverride(meta, summary, guidance),
+  withReasonCodeDistributionMeta: (meta, reasonCodeDistribution) => withReasonCodeDistributionMeta(meta, reasonCodeDistribution),
+  incrementReasonCodeDistribution: (reasonCodeDistribution, reasonCode, count) => incrementReasonCodeDistribution(reasonCodeDistribution, reasonCode, count),
+  summarizeShoppingOfferFilterConstraint: (args) => summarizeShoppingOfferFilterConstraint(args),
+  parseInspiredesignEnvelopeInput: (input) => parseInspiredesignEnvelopeInput(input),
+  failureFromInspiredesignDiscoveryError: (workflowInput, error) => failureFromInspiredesignDiscoveryError(workflowInput, error),
+  failureFromInspiredesignFetchError: (result) => failureFromInspiredesignFetchError(result),
+  extractProductBrandFromTitle: (title, productUrl) => extractProductBrandFromTitle(title, productUrl)
 };
 var PRODUCT_ASSET_FETCH_TIMEOUT_MS = 15e3;
 var RESEARCH_PROVIDER_STEP_TIMEOUT_MS = 3e4;
@@ -16459,7 +19093,7 @@ var rankResearchRecords = (records) => {
     return left.id.localeCompare(right.id);
   });
 };
-var hash2 = (value) => createHash7("sha1").update(value).digest("hex").slice(0, 16);
+var hash2 = (value) => createHash8("sha1").update(value).digest("hex").slice(0, 16);
 var RESEARCH_ALWAYS_SANITIZED_PATHS = /* @__PURE__ */ new Set([
   "community:search:index",
   "community:search:url",
@@ -16655,8 +19289,17 @@ var INSPIREDESIGN_RENDER_MODES = /* @__PURE__ */ new Set(["compact", "json", "md
 var INSPIREDESIGN_CAPTURE_MODES = /* @__PURE__ */ new Set(["off", "deep"]);
 var INSPIREDESIGN_COOKIE_POLICIES = /* @__PURE__ */ new Set(["off", "auto", "required"]);
 var WORKFLOW_BROWSER_MODES = /* @__PURE__ */ new Set(["auto", "extension", "managed"]);
+var INSPIREDESIGN_DEFAULT_MAX_REFERENCES = 5;
+var INSPIREDESIGN_MAX_REFERENCES_LIMIT = 10;
 var isJsonRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var INSPIREDESIGN_CAPTURE_UNAVAILABLE_FAILURE = "Deep capture requested, but browser capture is unavailable in this execution lane.";
+var REQUIRED_VISUAL_EVIDENCE_MISSING_FAILURE = "Required visual evidence was not captured.";
+var INSPIREDESIGN_VISUAL_POLICY_BLOCKER_REASONS = /* @__PURE__ */ new Set([
+  "policy_blocked",
+  "auth_required",
+  "challenge_detected",
+  "rate_limited"
+]);
 var isCanvasVisualDirectionProfile = (value) => {
   return CANVAS_VISUAL_DIRECTION_PROFILES.includes(value);
 };
@@ -16670,6 +19313,11 @@ var serializeInspiredesignBriefExpansion = (expansion) => structuredClone(expans
 var serializeInspiredesignRunInput = (input) => ({
   brief: input.brief,
   briefExpansion: serializeInspiredesignBriefExpansion(input.briefExpansion),
+  ...input.harvest === true ? { harvest: true } : {},
+  ...input.query ? { query: input.query } : {},
+  ...input.providers.length > 0 ? { providers: input.providers } : {},
+  ...input.referenceLimit !== void 0 ? { maxReferences: input.maxReferences } : {},
+  visualEvidence: input.visualEvidence,
   urls: input.urls,
   captureMode: input.captureMode,
   mode: input.mode,
@@ -16745,6 +19393,11 @@ var parseInspiredesignEnvelopeInput = (input) => {
   return {
     brief: typeof input.brief === "string" ? input.brief : "",
     mode: typeof input.mode === "string" && INSPIREDESIGN_RENDER_MODES.has(input.mode) ? input.mode : "compact",
+    ...typeof input.harvest === "boolean" ? { harvest: input.harvest } : {},
+    ...typeof input.query === "string" && input.query.trim().length > 0 ? { query: input.query.trim() } : {},
+    ...Array.isArray(input.providers) ? { providers: input.providers.filter((provider) => typeof provider === "string") } : {},
+    ...typeof input.maxReferences === "number" ? { maxReferences: input.maxReferences } : {},
+    ...isInspiredesignVisualEvidenceMode(input.visualEvidence) ? { visualEvidence: input.visualEvidence } : {},
     ...briefExpansion ? { briefExpansion } : {},
     ...Array.isArray(input.urls) ? { urls: input.urls.filter((url) => typeof url === "string") } : {},
     ...typeof input.captureMode === "string" && INSPIREDESIGN_CAPTURE_MODES.has(input.captureMode) ? { captureMode: input.captureMode } : {},
@@ -16767,6 +19420,24 @@ var normalizeInspiredesignUrls = (urls) => {
   }
   return [...new Set(normalized.map((url) => canonicalizeUrl(url)))];
 };
+var normalizeInspiredesignMaxReferences = (value, fallbackCount) => {
+  if (typeof value === "undefined") {
+    return Math.max(1, Math.min(Math.max(fallbackCount, 1), INSPIREDESIGN_MAX_REFERENCES_LIMIT));
+  }
+  if (!Number.isInteger(value) || value < 1 || value > INSPIREDESIGN_MAX_REFERENCES_LIMIT) {
+    throw new Error("Inspiredesign workflow maxReferences must be an integer from 1 to 10.");
+  }
+  return value;
+};
+var normalizeInspiredesignVisualEvidenceMode = (value, harvest) => {
+  if (typeof value === "undefined") {
+    return harvest === true ? "required" : "off";
+  }
+  if (!isInspiredesignVisualEvidenceMode(value)) {
+    throw new Error("Inspiredesign workflow visualEvidence must be one of off, auto, or required.");
+  }
+  return value;
+};
 var hasValidInspiredesignBriefRoute = (route) => {
   return isCanvasVisualDirectionProfile(route.profile) && isCanvasThemeStrategy(route.themeStrategy) && isCanvasNavigationModel(route.navigationModel);
 };
@@ -16788,6 +19459,23 @@ var normalizeInspiredesignInput = (input) => {
     throw new Error("Inspiredesign workflow requires a non-empty brief.");
   }
   const urls = normalizeInspiredesignUrls(input.urls);
+  const query = typeof input.query === "string" && input.query.trim().length > 0 ? input.query.trim() : void 0;
+  const providers = normalizeInspiredesignProviders(input.providers);
+  const hasExplicitMaxReferences = typeof input.maxReferences !== "undefined";
+  if (query && input.harvest !== true) {
+    throw new Error("Inspiredesign workflow query is only supported when harvest is true.");
+  }
+  if (providers.length > 0 && !query) {
+    throw new Error("Inspiredesign workflow providers require query.");
+  }
+  if (input.harvest === true && !query && urls.length === 0) {
+    throw new Error("Inspiredesign harvest requires query or URL references.");
+  }
+  const visualEvidence = normalizeInspiredesignVisualEvidenceMode(
+    input.visualEvidence,
+    input.harvest
+  );
+  const maxReferencesFallback = query || input.harvest === true ? INSPIREDESIGN_DEFAULT_MAX_REFERENCES : urls.length;
   const normalizedBrief = normalizeInspiredesignBriefText(brief);
   const preferredFormatId = shouldReuseInspiredesignBriefExpansion(input.briefExpansion, normalizedBrief) ? input.briefExpansion.format.id : void 0;
   const briefExpansion = expandInspiredesignBrief(brief, preferredFormatId);
@@ -16795,9 +19483,14 @@ var normalizeInspiredesignInput = (input) => {
     ...input,
     brief,
     briefExpansion,
+    ...query ? { query } : {},
+    providers,
+    maxReferences: normalizeInspiredesignMaxReferences(input.maxReferences, maxReferencesFallback),
+    ...query || input.harvest === true || hasExplicitMaxReferences ? { referenceLimit: normalizeInspiredesignMaxReferences(input.maxReferences, maxReferencesFallback) } : {},
+    visualEvidence,
     urls,
     captureMode: resolveInspiredesignCaptureMode(input.captureMode, urls),
-    mode: input.mode ?? "compact"
+    mode: input.mode ?? (input.harvest === true ? "path" : "compact")
   };
 };
 var isInspiredesignWorkflowEnvelopeInput = (input) => {
@@ -16845,10 +19538,11 @@ var buildInspiredesignStepEnvelope = (workflowInput, trace, stepIndex, url) => b
     trace
   }
 );
-var buildInspiredesignFetchOptions = (workflowInput, envelope, timeoutMs) => withWorkflowResumeEnvelopeIntent(
+var buildInspiredesignFetchOptionsWithScope = (workflowInput, envelope, providerScope, timeoutMs) => withWorkflowResumeEnvelopeIntent(
   withBrowserModeOverride(
     withChallengeAutomationOverride(
       withCookieOverrides({
+        ...providerScope,
         ...typeof timeoutMs === "number" ? { timeoutMs } : {}
       }, workflowInput),
       workflowInput
@@ -16858,6 +19552,252 @@ var buildInspiredesignFetchOptions = (workflowInput, envelope, timeoutMs) => wit
   "workflow.inspiredesign",
   envelope
 );
+var buildInspiredesignFetchOptions = (workflowInput, envelope, timeoutMs) => {
+  const siteRecipeProviderIds = new Set(
+    workflowInput.providers.filter((providerId) => resolveSiteRecipeForProvider(providerId) !== void 0)
+  );
+  const standardProviderIds = workflowInput.providers.filter((providerId) => !siteRecipeProviderIds.has(providerId));
+  let providerScope = {};
+  if (workflowInput.providers.length > 0 && standardProviderIds.length === 0) {
+    providerScope = { source: "web" };
+  } else if (standardProviderIds.length > 0) {
+    providerScope = { providerIds: standardProviderIds };
+  }
+  return buildInspiredesignFetchOptionsWithScope(workflowInput, envelope, providerScope, timeoutMs);
+};
+var buildInspiredesignSiteRecipeFetchOptions = (workflowInput, envelope, timeoutMs) => buildInspiredesignFetchOptionsWithScope(
+  workflowInput,
+  envelope,
+  { source: "web" },
+  timeoutMs
+);
+var buildInspiredesignReferenceFetchOptions = (workflowInput, envelope, url, timeoutMs) => resolveSiteRecipeForUrl(url) ? buildInspiredesignSiteRecipeFetchOptions(workflowInput, envelope, timeoutMs) : buildInspiredesignFetchOptions(workflowInput, envelope, timeoutMs);
+var emptyInspiredesignDiscoveryDiagnostics = (workflowInput, searchAvailable, failure) => ({
+  requested: Boolean(workflowInput.query),
+  searchAvailable,
+  ...workflowInput.query ? { query: workflowInput.query } : {},
+  providers: workflowInput.providers,
+  acceptedUrls: [],
+  rejected: [],
+  failures: [],
+  ...failure ? { failure } : {}
+});
+var providerFromInspiredesignDiscoveryFailure = (workflowInput, error) => {
+  const provider = error.provider ?? workflowInput.providers[0];
+  const source = error.source ?? (provider ? toProviderSource2(provider) : null);
+  return provider && source ? { provider, source } : void 0;
+};
+var failureFromInspiredesignDiscoveryError = (workflowInput, error) => {
+  if (!error) return [];
+  const provider = providerFromInspiredesignDiscoveryFailure(workflowInput, error);
+  if (!provider) return [];
+  return [{
+    provider: provider.provider,
+    source: provider.source,
+    error
+  }];
+};
+var providerFromInspiredesignFetchFailure = (result) => {
+  const provider = result.error?.provider ?? result.providerOrder[0];
+  const source = result.error?.source ?? (provider ? toProviderSource2(provider) : null);
+  return provider && source ? { provider, source } : void 0;
+};
+var failureFromInspiredesignFetchError = (result) => {
+  if (!result.error || result.failures.length > 0) return [];
+  const provider = providerFromInspiredesignFetchFailure(result);
+  if (!provider) return [];
+  return [{
+    provider: provider.provider,
+    source: provider.source,
+    error: result.error
+  }];
+};
+var normalizeSiteRecipeFetchFailures = (siteRecipe, failures) => {
+  const source = toProviderSource2(siteRecipe.id) ?? "web";
+  return failures.map((failure) => ({
+    provider: siteRecipe.id,
+    source,
+    error: {
+      ...failure.error,
+      provider: siteRecipe.id,
+      source,
+      details: {
+        ...failure.error.details ?? {},
+        upstreamProvider: failure.provider,
+        upstreamSource: failure.source
+      }
+    }
+  }));
+};
+var appendNextUniqueDiscoveryCandidate = (queue, cursor, seen, accepted) => {
+  let nextCursor = cursor;
+  while (nextCursor < queue.length) {
+    const candidate = queue[nextCursor];
+    nextCursor += 1;
+    if (!candidate || seen.has(candidate.url)) continue;
+    seen.add(candidate.url);
+    accepted.push(candidate);
+    return nextCursor;
+  }
+  return nextCursor;
+};
+var capMixedInspiredesignDiscovery = (siteDiscovery, standardDiscovery, maxReferences) => {
+  const accepted = [];
+  const seen = /* @__PURE__ */ new Set();
+  let siteCursor = 0;
+  let standardCursor = 0;
+  while (accepted.length < maxReferences && (siteCursor < siteDiscovery.accepted.length || standardCursor < standardDiscovery.accepted.length)) {
+    siteCursor = appendNextUniqueDiscoveryCandidate(siteDiscovery.accepted, siteCursor, seen, accepted);
+    if (accepted.length >= maxReferences) break;
+    standardCursor = appendNextUniqueDiscoveryCandidate(standardDiscovery.accepted, standardCursor, seen, accepted);
+  }
+  return {
+    accepted,
+    rejected: [...siteDiscovery.rejected, ...standardDiscovery.rejected]
+  };
+};
+var discoverInspiredesignReferences = async (runtime, workflowInput, envelope, timeoutMs) => {
+  if (!workflowInput.query) {
+    return emptyInspiredesignDiscoveryDiagnostics(workflowInput, typeof runtime.search === "function");
+  }
+  const query = workflowInput.query;
+  const siteRecipe = workflowInput.providers.map((providerId) => resolveSiteRecipeForProvider(providerId)).find((recipe) => recipe !== void 0);
+  const siteRecipeProviderIds = new Set(
+    workflowInput.providers.filter((providerId) => resolveSiteRecipeForProvider(providerId) !== void 0)
+  );
+  const standardProviderIds = workflowInput.providers.filter((providerId) => !siteRecipeProviderIds.has(providerId));
+  if (siteRecipe) {
+    const runSiteRecipeDiscovery = async () => runBrowserNativeDiscovery({
+      recipe: siteRecipe,
+      query,
+      maxReferences: workflowInput.referenceLimit ?? workflowInput.maxReferences,
+      ...workflowInput.browserMode ? { browserMode: workflowInput.browserMode } : {},
+      ...typeof workflowInput.useCookies === "boolean" ? { useCookies: workflowInput.useCookies } : {},
+      ...workflowInput.cookiePolicyOverride ? { cookiePolicy: workflowInput.cookiePolicyOverride } : {},
+      fetchSearchPage: async (url) => {
+        const result = normalizeInspiredesignFetchResult(await runtime.fetch(
+          { url },
+          buildInspiredesignSiteRecipeFetchOptions(workflowInput, envelope, timeoutMs)
+        ));
+        const failures = result.failures.length > 0 ? result.failures : failureFromInspiredesignFetchError(result);
+        return {
+          records: result.records,
+          failures: normalizeSiteRecipeFetchFailures(siteRecipe, failures),
+          ...result.error?.message ? { errorMessage: result.error.message } : {}
+        };
+      }
+    });
+    if (standardProviderIds.length > 0 && typeof runtime.search === "function") {
+      try {
+        const searchResult2 = await runtime.search(
+          {
+            query,
+            limit: workflowInput.maxReferences
+          },
+          {
+            ...buildInspiredesignFetchOptions(workflowInput, envelope, timeoutMs),
+            providerIds: standardProviderIds
+          }
+        );
+        const searchFailures = searchResult2.failures.length > 0 ? searchResult2.failures : failureFromInspiredesignDiscoveryError({ ...workflowInput, providers: standardProviderIds }, searchResult2.error);
+        const discovery3 = normalizeInspiredesignDiscoveryRecords(searchResult2.records);
+        const siteResult2 = await runSiteRecipeDiscovery();
+        const siteDiscovery = normalizeInspiredesignDiscoveryRecords(siteResult2.records);
+        const combinedDiscovery = capMixedInspiredesignDiscovery(
+          siteDiscovery,
+          discovery3,
+          workflowInput.referenceLimit ?? workflowInput.maxReferences
+        );
+        const failures = [...searchFailures, ...siteResult2.failures];
+        return {
+          requested: true,
+          searchAvailable: true,
+          query,
+          providers: workflowInput.providers,
+          acceptedUrls: combinedDiscovery.accepted.map((candidate) => candidate.url),
+          rejected: combinedDiscovery.rejected,
+          failures,
+          ...failures[0]?.error.message ? { failure: failures[0].error.message } : {},
+          siteRecipeId: siteRecipe.id,
+          browserNativeDiagnostics: {
+            ...siteResult2.diagnostics,
+            standardAcceptedCount: discovery3.accepted.length,
+            standardRejectedCount: discovery3.rejected.length,
+            siteAcceptedCount: siteDiscovery.accepted.length,
+            cappedAcceptedCount: combinedDiscovery.accepted.length
+          }
+        };
+      } catch (error) {
+        const siteResult2 = await runSiteRecipeDiscovery();
+        const discovery3 = normalizeInspiredesignDiscoveryRecords(siteResult2.records);
+        return {
+          requested: true,
+          searchAvailable: true,
+          query,
+          providers: workflowInput.providers,
+          acceptedUrls: discovery3.accepted.map((candidate) => candidate.url),
+          rejected: discovery3.rejected,
+          failures: siteResult2.failures,
+          failure: error instanceof Error ? error.message : "Reference discovery failed.",
+          siteRecipeId: siteRecipe.id,
+          browserNativeDiagnostics: siteResult2.diagnostics
+        };
+      }
+    }
+    const siteResult = await runSiteRecipeDiscovery();
+    const discovery2 = normalizeInspiredesignDiscoveryRecords(siteResult.records);
+    return {
+      requested: true,
+      searchAvailable: true,
+      query,
+      providers: workflowInput.providers,
+      acceptedUrls: discovery2.accepted.map((candidate) => candidate.url),
+      rejected: discovery2.rejected,
+      failures: siteResult.failures,
+      ...siteResult.failures[0]?.error.message ? { failure: siteResult.failures[0].error.message } : {},
+      siteRecipeId: siteRecipe.id,
+      browserNativeDiagnostics: siteResult.diagnostics
+    };
+  }
+  if (typeof runtime.search !== "function") {
+    return emptyInspiredesignDiscoveryDiagnostics(
+      workflowInput,
+      false,
+      "Reference discovery requested, but provider search is unavailable in this execution lane."
+    );
+  }
+  let searchResult;
+  try {
+    searchResult = await runtime.search(
+      {
+        query: workflowInput.query,
+        limit: workflowInput.maxReferences
+      },
+      {
+        ...buildInspiredesignFetchOptions(workflowInput, envelope, timeoutMs),
+        ...workflowInput.providers.length > 0 ? { providerIds: workflowInput.providers } : {}
+      }
+    );
+  } catch (error) {
+    return emptyInspiredesignDiscoveryDiagnostics(
+      workflowInput,
+      true,
+      error instanceof Error ? error.message : "Reference discovery failed."
+    );
+  }
+  const discovery = normalizeInspiredesignDiscoveryRecords(searchResult.records);
+  const discoveryFailures = searchResult.failures.length > 0 ? searchResult.failures : failureFromInspiredesignDiscoveryError(workflowInput, searchResult.error);
+  return {
+    requested: true,
+    searchAvailable: true,
+    query: workflowInput.query,
+    providers: workflowInput.providers,
+    acceptedUrls: discovery.accepted.map((candidate) => candidate.url),
+    rejected: discovery.rejected,
+    failures: discoveryFailures,
+    ...searchResult.error?.message ? { failure: searchResult.error.message } : {}
+  };
+};
 var buildEmptyInspiredesignCaptureAttemptCounts = () => ({
   snapshot: { captured: 0, failed: 0, skipped: 0 },
   clone: { captured: 0, failed: 0, skipped: 0 },
@@ -16870,6 +19810,78 @@ var buildUnavailableInspiredesignCaptureEvidence = () => ({
     dom: { status: "skipped", detail: INSPIREDESIGN_CAPTURE_UNAVAILABLE_FAILURE }
   }
 });
+var getInspiredesignReferenceId = (url) => createHash8("sha256").update(url).digest("hex").slice(0, 12);
+var buildVisualPolicyMetadata = (decision) => {
+  if (decision.status === "allowed") return void 0;
+  return {
+    status: decision.status,
+    kind: "viewport",
+    fullPage: false,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    warnings: [`policy:${decision.reason}`],
+    failure: decision.message
+  };
+};
+var mergeCaptureVisualEvidence = (capture, visual) => {
+  if (!visual) return capture;
+  return {
+    ...capture ?? {},
+    visual
+  };
+};
+var isVisualPolicyBlockerDecision = (decision) => INSPIREDESIGN_VISUAL_POLICY_BLOCKER_REASONS.has(decision.reason);
+var buildMissingRequiredVisualEvidence = (failure, _visualPlan) => ({
+  status: "failed",
+  kind: "viewport",
+  fullPage: false,
+  capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  warnings: ["required_visual_evidence_missing"],
+  failure
+});
+var getRequiredVisualEvidenceFailure = (workflowInput, visualPlan, capture) => {
+  if (workflowInput.visualEvidence !== "required" || visualPlan.policy.status !== "allowed") return void 0;
+  const visual = normalizeInspiredesignCaptureEvidence(capture)?.visual;
+  if (!visual) return REQUIRED_VISUAL_EVIDENCE_MISSING_FAILURE;
+  if (visual.status === "captured") return void 0;
+  return visual.failure ?? REQUIRED_VISUAL_EVIDENCE_MISSING_FAILURE;
+};
+var addRequiredVisualEvidenceFailure = (capture, visualPlan, failure) => {
+  const visual = normalizeInspiredesignCaptureEvidence(capture)?.visual;
+  if (visual) return capture;
+  return mergeCaptureVisualEvidence(capture, buildMissingRequiredVisualEvidence(failure, visualPlan));
+};
+var VISUAL_TEMP_PATH_MISMATCH_FAILURE = "Visual evidence temp path did not match the workflow capture plan.";
+var VISUAL_KIND_MISMATCH_FAILURE = "Visual evidence kind did not match the workflow capture contract.";
+var hasTrustedVisualTempPath = (visual, visualPlan) => {
+  if (visual.status === "captured" && !visual.tempPath) return false;
+  if (!visual.tempPath) return true;
+  if (!visualPlan.tempPath) return false;
+  return resolve(visual.tempPath) === resolve(visualPlan.tempPath);
+};
+var hasTrustedVisualKind = (visual) => isInspiredesignVisualEvidenceKind(visual.kind);
+var readRuntimeVisualWarnings = (visual) => {
+  const warnings = visual.warnings;
+  return Array.isArray(warnings) ? warnings.filter((warning) => typeof warning === "string") : [];
+};
+var failMismatchedVisualTempPath = (visual, failure = VISUAL_TEMP_PATH_MISMATCH_FAILURE, warning = "visual_temp_path_mismatch") => ({
+  status: "failed",
+  kind: hasTrustedVisualKind(visual) ? visual.kind : "viewport",
+  fullPage: visual.fullPage,
+  capturedAt: visual.capturedAt,
+  warnings: [...readRuntimeVisualWarnings(visual), warning],
+  failure
+});
+var trustRuntimeVisualEvidence = (visual, visualPlan) => {
+  if (!visual) return void 0;
+  if (!hasTrustedVisualKind(visual)) {
+    return failMismatchedVisualTempPath(
+      visual,
+      VISUAL_KIND_MISMATCH_FAILURE,
+      "visual_kind_mismatch"
+    );
+  }
+  return hasTrustedVisualTempPath(visual, visualPlan) ? visual : failMismatchedVisualTempPath(visual);
+};
 var PRE_ARTIFACT_CAPTURE_SKIP_MESSAGE = "Skipped after deep capture failed before artifact capture started.";
 var buildFailedInspiredesignCaptureEvidence = (detail) => ({
   attempts: {
@@ -16904,41 +19916,74 @@ var summarizeInspiredesignCaptureAttempts = (references) => {
     summary: formatInspiredesignCaptureAttemptSummary({ worked, didNotWork })
   };
 };
-var captureInspiredesignReference = async (url, captureMode, workflowInput, captureReference, timeoutMs) => {
+var captureInspiredesignReference = async (url, captureMode, workflowInput, captureReference, visualPlan, timeoutMs) => {
+  const visualPolicyMetadata = buildVisualPolicyMetadata(visualPlan.policy);
   if (captureMode === "off") {
-    return { captureStatus: "off" };
+    return visualPolicyMetadata ? { captureStatus: "off", capture: { visual: visualPolicyMetadata } } : { captureStatus: "off" };
+  }
+  if (visualPolicyMetadata && isVisualPolicyBlockerDecision(visualPlan.policy)) {
+    const captureStatus = visualPlan.policy.status === "failed" ? "failed" : "off";
+    return {
+      captureStatus,
+      ...captureStatus === "failed" ? { captureFailure: visualPlan.policy.message } : {},
+      capture: { visual: visualPolicyMetadata }
+    };
   }
   if (!captureReference) {
+    const visualFailureMetadata = visualPolicyMetadata ?? (workflowInput.visualEvidence === "required" && visualPlan.policy.status === "allowed" ? buildMissingRequiredVisualEvidence(INSPIREDESIGN_CAPTURE_UNAVAILABLE_FAILURE, visualPlan) : void 0);
     return {
       captureStatus: "failed",
       captureFailure: INSPIREDESIGN_CAPTURE_UNAVAILABLE_FAILURE,
-      capture: buildUnavailableInspiredesignCaptureEvidence()
+      capture: mergeCaptureVisualEvidence(
+        buildUnavailableInspiredesignCaptureEvidence(),
+        visualFailureMetadata
+      )
     };
   }
   try {
-    const capture = normalizeInspiredesignCaptureEvidence(await captureReference(url, {
+    const rawCapture = await captureReference(url, {
       timeoutMs,
       useCookies: workflowInput.useCookies,
       challengeAutomationMode: workflowInput.challengeAutomationMode,
-      cookiePolicyOverride: workflowInput.cookiePolicyOverride
-    }));
+      cookiePolicyOverride: workflowInput.cookiePolicyOverride,
+      visualEvidence: visualPlan.policy.status === "allowed" ? workflowInput.visualEvidence : "off",
+      visualEvidencePath: visualPlan.policy.status === "allowed" ? visualPlan.tempPath : void 0
+    });
+    const capture = normalizeInspiredesignCaptureEvidence(rawCapture);
+    const runtimeVisual = rawCapture?.visual;
+    const trustedRuntimeVisual = trustRuntimeVisualEvidence(runtimeVisual, visualPlan);
+    const captureWithRuntimeVisual = trustedRuntimeVisual ? mergeCaptureVisualEvidence(capture, trustedRuntimeVisual) : capture;
+    const captureWithVisualPolicy = trustedRuntimeVisual ? captureWithRuntimeVisual : mergeCaptureVisualEvidence(captureWithRuntimeVisual, visualPolicyMetadata);
+    const requiredVisualFailure = getRequiredVisualEvidenceFailure(workflowInput, visualPlan, captureWithVisualPolicy);
+    const captureWithRequiredVisual = requiredVisualFailure ? addRequiredVisualEvidenceFailure(captureWithVisualPolicy, visualPlan, requiredVisualFailure) : captureWithVisualPolicy;
     if (!hasInspiredesignCaptureArtifacts(capture)) {
       return {
         captureStatus: "failed",
         captureFailure: "Deep capture did not return usable snapshot, DOM, or clone evidence.",
-        ...capture ? { capture } : {}
+        ...captureWithRequiredVisual ? { capture: captureWithRequiredVisual } : {}
+      };
+    }
+    if (requiredVisualFailure) {
+      return {
+        captureStatus: "failed",
+        captureFailure: requiredVisualFailure,
+        ...captureWithRequiredVisual ? { capture: captureWithRequiredVisual } : {}
       };
     }
     return {
       captureStatus: "captured",
-      ...capture ? { capture } : {}
+      ...captureWithRequiredVisual ? { capture: captureWithRequiredVisual } : {}
     };
   } catch (error) {
     const captureFailure = error instanceof Error && error.message.trim() ? error.message : "Deep capture failed.";
+    const visualFailureMetadata = visualPolicyMetadata ?? (workflowInput.visualEvidence === "required" && visualPlan.policy.status === "allowed" ? buildMissingRequiredVisualEvidence(captureFailure, visualPlan) : void 0);
     return {
       captureStatus: "failed",
       captureFailure,
-      capture: buildFailedInspiredesignCaptureEvidence(captureFailure)
+      capture: mergeCaptureVisualEvidence(
+        buildFailedInspiredesignCaptureEvidence(captureFailure),
+        visualFailureMetadata
+      )
     };
   }
 };
@@ -16983,7 +20028,11 @@ var toInspiredesignIssueFailure = (record, hint) => {
 };
 var normalizeInspiredesignFetchResult = (result) => {
   if (result.records.length === 0) {
-    return result;
+    const synthesizedFailures = failureFromInspiredesignFetchError(result);
+    return synthesizedFailures.length > 0 ? {
+      ...result,
+      failures: synthesizedFailures
+    } : result;
   }
   const usableRecords = [];
   const unusableRecords = [];
@@ -17043,12 +20092,14 @@ var summarizeInspiredesignRecoveredFetches = (references) => references.filter(i
 }));
 var buildInspiredesignReference = (url, result, capture) => {
   const primary = getInspiredesignPrimaryRecord(result, url);
-  const normalizedCapture = normalizeInspiredesignCaptureEvidence(capture.capture);
+  const baseCapture = normalizeInspiredesignCaptureEvidence(capture.capture);
+  const runtimeVisual = capture.capture?.visual;
+  const normalizedCapture = runtimeVisual?.tempPath ? mergeCaptureVisualEvidence(baseCapture, runtimeVisual) : baseCapture;
   const title = normalizePlainText(primary?.title) || titleFromInspiredesignCapture(normalizedCapture);
   const excerpt = excerptFromInspiredesignRecord(primary) ?? excerptFromInspiredesignCapture(normalizedCapture);
   const fetchStatus = result.records.length > 0 ? "captured" : "failed";
   return {
-    id: createHash7("sha256").update(url).digest("hex").slice(0, 12),
+    id: getInspiredesignReferenceId(url),
     url,
     ...title ? { title } : {},
     ...excerpt ? { excerpt } : {},
@@ -17059,6 +20110,102 @@ var buildInspiredesignReference = (url, result, capture) => {
     ...normalizedCapture ? { capture: normalizedCapture } : {}
   };
 };
+var failReferenceForRequiredVisualEvidence = (reference, failure, visualEvidence, shouldFail = true) => {
+  if (visualEvidence !== "required" || !shouldFail) return reference;
+  return {
+    ...reference,
+    captureStatus: "failed",
+    captureFailure: reference.captureFailure ?? failure
+  };
+};
+var isPolicySkippedVisualEvidence = (visual) => visual.status === "skipped" && visual.warnings.some((warning) => warning.startsWith("policy:"));
+var finalizeInspiredesignReferenceVisual = async (reference, visualEvidence) => {
+  const visual = reference.capture?.visual;
+  if (!visual) {
+    return { reference };
+  }
+  const runtimeVisual = visual;
+  if (visual.status !== "captured" || !runtimeVisual.tempPath) {
+    const persisted = persistInspiredesignVisualEvidence(visual);
+    const referenceWithPersistedVisual = {
+      ...reference,
+      capture: mergeCaptureVisualEvidence(reference.capture, persisted)
+    };
+    return {
+      reference: failReferenceForRequiredVisualEvidence(
+        referenceWithPersistedVisual,
+        persisted.failure ?? REQUIRED_VISUAL_EVIDENCE_MISSING_FAILURE,
+        visualEvidence,
+        !isPolicySkippedVisualEvidence(persisted)
+      )
+    };
+  }
+  const artifactPath = buildVisualEvidenceArtifactPath(reference.id, visual.kind);
+  try {
+    const buffer = await readFile(runtimeVisual.tempPath);
+    if (buffer.byteLength === 0) {
+      throw new Error("Visual evidence screenshot file was empty.");
+    }
+    const persisted = persistInspiredesignVisualEvidence(visual, {
+      artifactPath,
+      sha256: hashVisualEvidenceBuffer(buffer),
+      bytes: buffer.byteLength
+    });
+    return {
+      reference: {
+        ...reference,
+        capture: mergeCaptureVisualEvidence(reference.capture, persisted)
+      },
+      file: {
+        path: artifactPath,
+        content: buffer
+      }
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message.trim() : "";
+    const failure = errorMessage === "Visual evidence screenshot file was empty." ? errorMessage : "Visual evidence screenshot file was unavailable.";
+    const persisted = persistInspiredesignVisualEvidence({
+      ...visual,
+      status: "failed",
+      warnings: [...readRuntimeVisualWarnings(runtimeVisual), "finalize_failed"],
+      failure
+    });
+    const referenceWithPersistedVisual = {
+      ...reference,
+      capture: mergeCaptureVisualEvidence(reference.capture, persisted)
+    };
+    return {
+      reference: failReferenceForRequiredVisualEvidence(referenceWithPersistedVisual, failure, visualEvidence)
+    };
+  }
+};
+var finalizeInspiredesignVisualArtifacts = async (references, visualEvidence) => {
+  const finalized = await Promise.all(
+    references.map((reference) => finalizeInspiredesignReferenceVisual(reference, visualEvidence))
+  );
+  return {
+    references: finalized.map((entry) => entry.reference),
+    files: finalized.map((entry) => entry.file).filter((file) => Boolean(file))
+  };
+};
+var buildInspiredesignVisualCapturePlan = (url, workflowInput, result, visualEvidenceTempDir) => {
+  const referenceId = getInspiredesignReferenceId(url);
+  const policy = decideInspiredesignVisualCapturePolicy({
+    visualEvidence: workflowInput.visualEvidence,
+    failures: result.failures,
+    topLevelError: result.error,
+    cookiePolicy: workflowInput.cookiePolicyOverride,
+    hasUsableRecords: result.records.length > 0
+  });
+  if (policy.status !== "allowed" || !visualEvidenceTempDir) {
+    return { policy, referenceId };
+  }
+  return {
+    policy,
+    referenceId,
+    tempPath: join3(visualEvidenceTempDir, `${referenceId}-viewport.png`)
+  };
+};
 var summarizeInspiredesignCaptureConstraint = (references) => {
   const failedReferences = references.filter((reference) => reference.captureStatus === "failed");
   if (failedReferences.length === 0) {
@@ -17084,14 +20231,100 @@ var summarizeInspiredesignCaptureConstraint = (references) => {
 var summarizeInspiredesignFetchConstraint = (references) => {
   return references.find((reference) => reference.fetchStatus === "failed" && !isInspiredesignFetchRecovered(reference) && typeof reference.fetchFailure === "string" && reference.fetchFailure.trim().length > 0)?.fetchFailure;
 };
-var buildInspiredesignMeta = (runtime, workflowInput, references, failures, followthrough) => {
+var hasSurvivingInspiredesignReference = (references) => references.some((reference) => reference.fetchStatus === "captured" || reference.captureStatus === "captured");
+var INSPIREDESIGN_HARD_DISCOVERY_REASON_CODES = /* @__PURE__ */ new Set([
+  "auth_required",
+  "challenge_detected",
+  "policy_blocked",
+  "rate_limited",
+  "token_required"
+]);
+var readInspiredesignFailureReasonCode = (failure) => {
+  const reasonCode = failure.error.reasonCode ?? failure.error.details?.reasonCode;
+  return typeof reasonCode === "string" && INSPIREDESIGN_HARD_DISCOVERY_REASON_CODES.has(reasonCode) ? reasonCode : void 0;
+};
+var hardInspiredesignDiscoveryReasonCodes = (discovery) => {
+  const reasonCodes = discovery.failures.map(readInspiredesignFailureReasonCode).filter((reasonCode) => reasonCode !== void 0);
+  return [...new Set(reasonCodes)];
+};
+var hardInspiredesignMetaReasonCodes = (meta) => {
+  const distribution = meta.reasonCodeDistribution;
+  if (!distribution || typeof distribution !== "object" || Array.isArray(distribution)) return [];
+  return Object.keys(distribution).filter((reasonCode) => INSPIREDESIGN_HARD_DISCOVERY_REASON_CODES.has(reasonCode));
+};
+var hardInspiredesignGuidanceReasonCodes = (discovery, meta) => [
+  .../* @__PURE__ */ new Set([
+    ...hardInspiredesignDiscoveryReasonCodes(discovery),
+    ...hardInspiredesignMetaReasonCodes(meta)
+  ])
+];
+var selectInspiredesignPrimaryConstraintFailures = (failures, references, discovery) => {
+  if (!hasSurvivingInspiredesignReference(references)) return failures;
+  if (discovery.failures.length === 0) return failures;
+  return failures.slice(discovery.failures.length);
+};
+var readMetaPrimaryConstraint = (meta) => {
+  const value = meta.primaryConstraint;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const primaryConstraint = {
+    ...typeof record.reasonCode === "string" ? { reasonCode: record.reasonCode } : {},
+    ...typeof record.summary === "string" ? { summary: record.summary } : {}
+  };
+  return Object.keys(primaryConstraint).length > 0 ? primaryConstraint : void 0;
+};
+var isInspiredesignReferenceEvidenceRequired = (workflowInput) => workflowInput.harvest === true || workflowInput.urls.length > 0 || workflowInput.providers.length > 0 || typeof workflowInput.query === "string" || workflowInput.visualEvidence === "required";
+var buildInspiredesignGuidanceSource = (workflowInput, discovery, meta, referencePatternBoard) => {
+  const quality = summarizeInspiredesignReferenceQuality(referencePatternBoard);
+  const primaryConstraint = readMetaPrimaryConstraint(meta);
+  return {
+    brief: workflowInput.brief,
+    ...workflowInput.query ? { query: workflowInput.query } : {},
+    urls: workflowInput.urls,
+    requestedProviders: workflowInput.providers,
+    ...workflowInput.browserMode ? { browserMode: workflowInput.browserMode } : {},
+    ...workflowInput.cookiePolicyOverride ? { cookiePolicy: workflowInput.cookiePolicyOverride } : {},
+    ...typeof workflowInput.useCookies === "boolean" ? { useCookies: workflowInput.useCookies } : {},
+    discovery: {
+      requested: discovery.requested,
+      acceptedUrls: discovery.acceptedUrls,
+      failures: discovery.failures.length,
+      ...discovery.failure ? { failure: discovery.failure } : {},
+      hardFailureReasonCodes: hardInspiredesignGuidanceReasonCodes(discovery, meta)
+    },
+    metrics: {
+      referenceCount: quality.rankedReferenceCount + quality.rejectedReferenceCount,
+      referenceEvidenceRequired: isInspiredesignReferenceEvidenceRequired(workflowInput),
+      failedCaptureCount: quality.failedCaptureCount,
+      visualEvidenceRequired: workflowInput.visualEvidence === "required"
+    },
+    quality: {
+      rankedReferenceCount: quality.rankedReferenceCount,
+      rankedReferenceUrls: referencePatternBoard.references.map((reference) => reference.url),
+      rejectedReferenceCount: quality.rejectedReferenceCount,
+      missingScreenshotCount: quality.missingScreenshotCount,
+      diagnosticOnlyReasons: quality.diagnosticOnlyReasons,
+      ...typeof quality.topReferenceScore === "number" ? { topReferenceScore: quality.topReferenceScore } : {},
+      ...typeof quality.topReferenceConfidence === "number" ? { topReferenceConfidence: quality.topReferenceConfidence } : {},
+      ...typeof quality.topReferenceIntentMatched === "boolean" ? { topReferenceIntentMatched: quality.topReferenceIntentMatched } : {}
+    },
+    ...primaryConstraint ? { primaryConstraint } : {}
+  };
+};
+var buildInspiredesignMeta = (runtime, workflowInput, references, failures, followthrough, discovery) => {
   const failedCaptures = references.filter((reference) => reference.captureStatus === "failed");
   const captureAttemptReport = summarizeInspiredesignCaptureAttempts(references);
   const recoveredFetches = summarizeInspiredesignRecoveredFetches(references);
+  const hasSurvivingReference = hasSurvivingInspiredesignReference(references);
+  const primaryConstraintFailures = selectInspiredesignPrimaryConstraintFailures(failures, references, discovery);
   let reasonCodeDistribution = summarizeReasonCodeDistribution(failures);
   let meta = withCamelCasePrimaryConstraintMeta(withReasonCodeDistributionMeta({
     selection: {
       urls: workflowInput.urls,
+      ...workflowInput.query ? { query: workflowInput.query } : {},
+      ...workflowInput.providers.length > 0 ? { providers: workflowInput.providers } : {},
+      ...workflowInput.referenceLimit !== void 0 ? { max_references: workflowInput.referenceLimit } : {},
+      ...workflowInput.visualEvidence !== "off" ? { visual_evidence: workflowInput.visualEvidence } : {},
       capture_mode: workflowInput.captureMode,
       ...workflowInput.browserMode ? { requested_browser_mode: workflowInput.browserMode } : {},
       include_prototype_guidance: Boolean(workflowInput.includePrototypeGuidance)
@@ -17109,7 +20342,7 @@ var buildInspiredesignMeta = (runtime, workflowInput, references, failures, foll
       ...captureAttemptReport ? { capture_attempts: captureAttemptReport.counts } : {}
     },
     alerts: buildWorkflowAlerts(runtime, failures)
-  }, reasonCodeDistribution), failures);
+  }, reasonCodeDistribution), primaryConstraintFailures);
   if (!meta.primaryConstraint) {
     const fetchConstraint = summarizeInspiredesignFetchConstraint(references);
     if (fetchConstraint) {
@@ -17119,6 +20352,16 @@ var buildInspiredesignMeta = (runtime, workflowInput, references, failures, foll
       };
     }
   }
+  if (!hasSurvivingReference && !meta.primaryConstraint && !meta.primaryConstraintSummary) {
+    const discoveryConstraint = summarizeInspiredesignDiscoveryConstraint(discovery);
+    if (discoveryConstraint) {
+      meta = withPrimaryConstraintSummaryOverride(
+        meta,
+        discoveryConstraint.summary,
+        discoveryConstraint.guidance
+      );
+    }
+  }
   if (!meta.primaryConstraint && !meta.primaryConstraintSummary) {
     const captureConstraint = summarizeInspiredesignCaptureConstraint(references);
     if (captureConstraint) {
@@ -17143,9 +20386,31 @@ var buildInspiredesignMeta = (runtime, workflowInput, references, failures, foll
     } : {},
     recommendedSkills: followthrough.recommendedSkills,
     deepCaptureRecommendation: followthrough.deepCaptureRecommendation,
+    discovery,
     contractScope: followthrough.contractScope
   };
 };
+var buildInspiredesignDiscoveryGuidance = (discovery) => ({
+  reason: discovery.failure ?? "Reference discovery did not produce usable design references.",
+  recommendedNextCommands: [
+    "Rerun inspiredesign harvest with explicit --url references from usable inspiration pages.",
+    "Retry provider discovery in a lane with provider search support and any required authenticated browser session."
+  ]
+});
+var summarizeInspiredesignDiscoveryConstraint = (discovery) => {
+  if (!discovery.requested || discovery.acceptedUrls.length > 0) return void 0;
+  const queryDetail = discovery.query ? ` for query "${discovery.query}"` : "";
+  const summary = discovery.failure ?? `Reference discovery returned no usable references${queryDetail}.`;
+  return {
+    summary,
+    guidance: buildInspiredesignDiscoveryGuidance(discovery)
+  };
+};
+var buildInspiredesignGuidanceFollowthroughSummary = (_followthrough, meta, nextStepGuidance) => {
+  const primaryConstraintSummary = typeof meta.primaryConstraintSummary === "string" ? meta.primaryConstraintSummary.trim() : "";
+  const fallbackSummary = primaryConstraintSummary ? `Primary constraint: ${primaryConstraintSummary} ${nextStepGuidance.primaryAction.summary}` : void 0;
+  return renderWorkflowCompatibility(nextStepGuidance, fallbackSummary).followthroughSummary;
+};
 var inferBrandFromContent = (content, productUrl) => {
   const normalized = normalizePlainText(content);
   if (!normalized) return void 0;
@@ -17617,6 +20882,15 @@ var resolveShoppingSourceForUrl = (url) => {
     return "web";
   }
 };
+var getRequiredProductVideoExecutionStep = (steps, stepId) => {
+  const step = steps.find(
+    (candidate) => candidate.id === stepId
+  );
+  if (!step) {
+    throw new Error(`Product-video workflow plan is missing required step ${stepId}.`);
+  }
+  return step;
+};
 var RESEARCH_REJECTED_CANDIDATE_LIMIT = 25;
 var isResearchPrivacyPreferenceShell = (content) => {
   const matchIndex = content.slice(0, 400).search(RESEARCH_PRIVACY_PREFERENCE_SHELL_RE);
@@ -17909,8 +21183,9 @@ var runResearchWorkflow = async (runtime, input) => {
     challengeOrchestration
   });
   const responseMeta = withFollowthroughMeta(meta, handoff);
+  const renderMode = workflowInput.mode ?? "compact";
   const rendered = renderResearch({
-    mode: workflowInput.mode,
+    mode: renderMode,
     topic: plan.compiled.topic,
     records: ranked,
     meta: responseMeta
@@ -17921,7 +21196,7 @@ var runResearchWorkflow = async (runtime, input) => {
     ttlHours: workflowInput.ttlHours,
     files: rendered.files
   });
-  if (workflowInput.mode === "path") {
+  if (renderMode === "path") {
     return {
       ...rendered.response,
       ...handoff,
@@ -18135,102 +21410,169 @@ var runShoppingWorkflow = async (runtime, input) => {
 var runInspiredesignWorkflow = async (runtime, input, options = {}) => {
   const { envelope, workflowInput: rawWorkflowInput } = buildInspiredesignEnvelope(input);
   const artifactRoot = resolveWorkflowArtifactRoot(rawWorkflowInput.outputDir);
-  const workflowInput = { ...rawWorkflowInput, outputDir: artifactRoot };
+  let workflowInput = { ...rawWorkflowInput, outputDir: artifactRoot };
   const remainingTimeoutMs = createRemainingTimeoutResolver(workflowInput.timeoutMs);
-  let trace = appendWorkflowTrace(envelope.trace ?? [], "compile", "compile_started", {
-    kind: "inspiredesign"
-  });
-  trace = appendWorkflowTrace(trace, "compile", "compile_completed", {
-    kind: "inspiredesign",
-    urlCount: workflowInput.urls.length,
-    captureMode: workflowInput.captureMode
-  });
-  const references = [];
-  const failures = [];
-  for (const [index, url] of workflowInput.urls.entries()) {
-    const stepTrace = appendWorkflowTrace(trace, "execute", "reference_started", {
-      stepIndex: index,
-      url
+  const visualEvidenceTempDir = workflowInput.visualEvidence !== "off" ? await mkdtemp2(join3(tmpdir2(), "inspiredesign-visual-")) : void 0;
+  try {
+    const discovery = await discoverInspiredesignReferences(
+      runtime,
+      workflowInput,
+      envelope,
+      workflowInput.query ? remainingTimeoutMs() : void 0
+    );
+    workflowInput = {
+      ...workflowInput,
+      urls: mergeInspiredesignReferenceUrls(
+        workflowInput.urls,
+        discovery.acceptedUrls,
+        workflowInput.referenceLimit ?? workflowInput.urls.length + discovery.acceptedUrls.length
+      ),
+      captureMode: resolveInspiredesignCaptureMode(workflowInput.captureMode, [
+        ...workflowInput.urls,
+        ...discovery.acceptedUrls
+      ])
+    };
+    let trace = appendWorkflowTrace(envelope.trace ?? [], "compile", "compile_started", {
+      kind: "inspiredesign"
+    });
+    trace = appendWorkflowTrace(trace, "compile", "compile_completed", {
+      kind: "inspiredesign",
+      urlCount: workflowInput.urls.length,
+      captureMode: workflowInput.captureMode
     });
-    const fetchTimeoutMs = remainingTimeoutMs();
-    const fetchResult = await runtime.fetch(
-      { url },
-      buildInspiredesignFetchOptions(
+    const references = [];
+    const failures = [...discovery.failures];
+    for (const [index, url] of workflowInput.urls.entries()) {
+      const stepTrace = appendWorkflowTrace(trace, "execute", "reference_started", {
+        stepIndex: index,
+        url
+      });
+      const fetchTimeoutMs = remainingTimeoutMs();
+      const fetchResult = await runtime.fetch(
+        { url },
+        buildInspiredesignReferenceFetchOptions(
+          workflowInput,
+          buildInspiredesignStepEnvelope(workflowInput, stepTrace, index, url),
+          url,
+          fetchTimeoutMs
+        )
+      );
+      const result = normalizeInspiredesignFetchResult(fetchResult);
+      observeWorkflowSignals(runtime, result);
+      const captureTimeoutMs = remainingTimeoutMs();
+      const visualPlan = buildInspiredesignVisualCapturePlan(
+        url,
         workflowInput,
-        buildInspiredesignStepEnvelope(workflowInput, stepTrace, index, url),
-        fetchTimeoutMs
-      )
-    );
-    const result = normalizeInspiredesignFetchResult(fetchResult);
-    observeWorkflowSignals(runtime, result);
-    const captureTimeoutMs = remainingTimeoutMs();
-    const capture = await captureInspiredesignReference(
-      url,
-      workflowInput.captureMode,
+        result,
+        visualEvidenceTempDir
+      );
+      const capture = await captureInspiredesignReference(
+        url,
+        workflowInput.captureMode,
+        workflowInput,
+        options.captureReference,
+        visualPlan,
+        captureTimeoutMs
+      );
+      const reference = buildInspiredesignReference(url, result, capture);
+      references.push(reference);
+      if (reference.fetchStatus === "failed" && !isInspiredesignFetchRecovered(reference)) {
+        const fetchFailures = result.failures.length > 0 ? result.failures : failureFromInspiredesignFetchError(result);
+        const siteRecipe = resolveSiteRecipeForUrl(url);
+        failures.push(...siteRecipe ? normalizeSiteRecipeFetchFailures(siteRecipe, fetchFailures) : fetchFailures);
+      }
+      trace = appendWorkflowTrace(stepTrace, "execute", "reference_completed", {
+        stepIndex: index,
+        url,
+        fetchStatus: result.records.length > 0 ? "captured" : "failed",
+        captureStatus: capture.captureStatus
+      });
+    }
+    const visualCollation = await finalizeInspiredesignVisualArtifacts(references, workflowInput.visualEvidence);
+    const packet = buildInspiredesignPacket({
+      brief: workflowInput.brief,
+      briefExpansion: workflowInput.briefExpansion,
+      urls: workflowInput.urls,
+      references: visualCollation.references,
+      includePrototypeGuidance: workflowInput.includePrototypeGuidance,
+      referenceEvidenceRequired: isInspiredesignReferenceEvidenceRequired(workflowInput)
+    });
+    const meta = buildInspiredesignMeta(
+      runtime,
       workflowInput,
-      options.captureReference,
-      captureTimeoutMs
+      visualCollation.references,
+      failures,
+      packet.followthrough,
+      discovery
     );
-    const reference = buildInspiredesignReference(url, result, capture);
-    references.push(reference);
-    if (reference.fetchStatus === "failed" && !isInspiredesignFetchRecovered(reference)) {
-      failures.push(...result.failures);
-    }
-    trace = appendWorkflowTrace(stepTrace, "execute", "reference_completed", {
-      stepIndex: index,
-      url,
-      fetchStatus: result.records.length > 0 ? "captured" : "failed",
-      captureStatus: capture.captureStatus
+    const nextStepGuidance = routeNextStepGuidance(createInspiredesignGuidanceContext(
+      buildInspiredesignGuidanceSource(
+        workflowInput,
+        discovery,
+        meta,
+        packet.generationPlan.referencePatternBoard
+      )
+    ));
+    const metaWithGuidance = {
+      ...meta,
+      followthroughSummary: nextStepGuidance.readiness === "ready" ? meta.followthroughSummary : buildInspiredesignGuidanceFollowthroughSummary(
+        packet.followthrough,
+        meta,
+        nextStepGuidance
+      ),
+      nextStepGuidance
+    };
+    const rendered = renderInspiredesign({
+      mode: workflowInput.mode,
+      brief: workflowInput.brief,
+      advancedBriefMarkdown: packet.advancedBriefMarkdown,
+      urls: workflowInput.urls,
+      designContract: packet.designContract,
+      canvasPlanRequest: packet.canvasPlanRequest,
+      designAgentHandoff: packet.followthrough,
+      generationPlan: packet.generationPlan,
+      implementationPlan: packet.implementationPlan,
+      designMarkdown: packet.designMarkdown,
+      implementationPlanMarkdown: packet.implementationPlanMarkdown,
+      prototypeGuidanceMarkdown: packet.prototypeGuidanceMarkdown,
+      evidence: packet.evidence,
+      visualEvidence: packet.visualEvidence,
+      screenshotIndex: packet.screenshotIndex,
+      rankedReferences: packet.rankedReferences,
+      referencePatternBoard: packet.generationPlan.referencePatternBoard,
+      metaPromptMarkdown: packet.metaPromptMarkdown,
+      nextStepGuidance,
+      meta: metaWithGuidance
     });
-  }
-  const packet = buildInspiredesignPacket({
-    brief: workflowInput.brief,
-    briefExpansion: workflowInput.briefExpansion,
-    urls: workflowInput.urls,
-    references,
-    includePrototypeGuidance: workflowInput.includePrototypeGuidance
-  });
-  const meta = buildInspiredesignMeta(runtime, workflowInput, references, failures, packet.followthrough);
-  const rendered = renderInspiredesign({
-    mode: workflowInput.mode,
-    brief: workflowInput.brief,
-    advancedBriefMarkdown: packet.advancedBriefMarkdown,
-    urls: workflowInput.urls,
-    designContract: packet.designContract,
-    canvasPlanRequest: packet.canvasPlanRequest,
-    designAgentHandoff: packet.followthrough,
-    generationPlan: packet.generationPlan,
-    implementationPlan: packet.implementationPlan,
-    designMarkdown: packet.designMarkdown,
-    implementationPlanMarkdown: packet.implementationPlanMarkdown,
-    prototypeGuidanceMarkdown: packet.prototypeGuidanceMarkdown,
-    evidence: packet.evidence,
-    meta
-  });
-  const bundle = await createArtifactBundle({
-    namespace: "inspiredesign",
-    outputDir: artifactRoot,
-    ttlHours: workflowInput.ttlHours,
-    files: rendered.files
-  });
-  if (workflowInput.mode === "path") {
+    const bundle = await createArtifactBundle({
+      namespace: "inspiredesign",
+      outputDir: artifactRoot,
+      ttlHours: workflowInput.ttlHours,
+      files: [...rendered.files, ...visualCollation.files]
+    });
+    if (workflowInput.mode === "path") {
+      return {
+        ...rendered.response,
+        artifact_path: bundle.basePath,
+        meta: {
+          ...metaWithGuidance,
+          artifact_manifest: bundle.manifest
+        }
+      };
+    }
     return {
       ...rendered.response,
       artifact_path: bundle.basePath,
       meta: {
-        ...meta,
+        ...metaWithGuidance,
         artifact_manifest: bundle.manifest
       }
     };
-  }
-  return {
-    ...rendered.response,
-    artifact_path: bundle.basePath,
-    meta: {
-      ...meta,
-      artifact_manifest: bundle.manifest
+  } finally {
+    if (visualEvidenceTempDir) {
+      await rm2(visualEvidenceTempDir, { recursive: true, force: true }).catch(() => void 0);
     }
-  };
+  }
 };
 var runProductVideoWorkflow = async (runtime, input, options = {}) => {
   const envelope = isWorkflowResumeEnvelope(input) ? input : buildWorkflowResumeEnvelope("product_video", input);
@@ -18294,15 +21636,7 @@ var runProductVideoWorkflow = async (runtime, input, options = {}) => {
     ...updates,
     completed_step_ids: checkpointState2.completed_step_ids.includes(stepId) ? checkpointState2.completed_step_ids : [...checkpointState2.completed_step_ids, stepId]
   });
-  const getRequiredProductVideoStep = (stepId) => {
-    const step = plan.plan.steps.find(
-      (candidate) => candidate.id === stepId
-    );
-    if (!step) {
-      throw new Error(`Product-video workflow plan is missing required step ${stepId}.`);
-    }
-    return step;
-  };
+  const getRequiredProductVideoStep = (stepId) => getRequiredProductVideoExecutionStep(plan.plan.steps, stepId);
   let checkpointState = {
     ...plan.checkpointState,
     completed_step_ids: [...plan.checkpointState.completed_step_ids]
@@ -18732,10 +22066,10 @@ var Semaphore = class {
       this.active += 1;
       return;
     }
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       this.queue.push(() => {
         this.active += 1;
-        resolve();
+        resolve2();
       });
     });
   }
@@ -21036,6 +24370,8 @@ export {
   CANVAS_BROWSER_VALIDATION_MODES,
   CANVAS_VALIDATION_TARGET_BLOCK_ON_CODES,
   CANVAS_PUBLIC_WARNING_CLASSES,
+  buildCanvasRepairEnvelope,
+  buildCanvasCommandValidationEnvelope,
   createTraceContext,
   clampConfidence,
   createStableRecordId,
@@ -21085,4 +24421,4 @@ export {
   createProviderRuntime,
   createDefaultRuntime
 };
-//# sourceMappingURL=chunk-4BEJVZRK.js.map
+//# sourceMappingURL=chunk-FBKPDILE.js.map