opendevbrowser 0.0.32 → 0.0.34

package/dist/{chunk-RO3SMXF3.js → chunk-5FDXH4CS.js}

@@ -10,7 +10,7 @@ import {
   INSPIREDESIGN_HANDOFF_RECOMMENDED_SKILLS,
   buildInspiredesignFollowthroughSummary,
   buildInspiredesignNextStep
-} from "./chunk-2X4JFMKJ.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,
@@ -11192,6 +11192,162 @@ 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",
+  "ads",
+  "board",
+  "business",
+  "careers",
+  "contact",
+  "create",
+  "developers",
+  "explore",
+  "help",
+  "ideas",
+  "login",
+  "messages",
+  "notifications",
+  "pin",
+  "search",
+  "settings",
+  "shopping",
+  "terms",
+  "today"
+]);
+var RESERVED_PINTEREST_IDEA_PATHS = /* @__PURE__ */ new Set(["create", "edit", "search"]);
+var RESERVED_PINTEREST_PROFILE_TABS = /* @__PURE__ */ new Set([
+  "activity",
+  "boards",
+  "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;
@@ -11204,7 +11360,11 @@ 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.",
@@ -11235,6 +11395,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",
@@ -11244,6 +11413,31 @@ 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",
@@ -11300,14 +11494,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();
-  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") || 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")) {
+  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;
   }
-  const markerCount = INTERFACE_CHROME_TEXT_MARKERS.filter((marker) => lower.includes(marker)).length;
   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;
@@ -11337,13 +11570,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) && !isInterfaceChromeText(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 = [
@@ -11414,25 +11690,34 @@ 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 (reference.capture?.visual?.status === "captured") methods.push("visual");
+  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") score += SCORE_CAPTURE_CAPTURED;
-  if (reference.capture?.visual?.status === "captured") score += SCORE_VISUAL_CAPTURED;
-  if (reference.capture?.snapshot?.content.trim()) score += SCORE_SNAPSHOT;
+  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 (reference.capture?.dom?.outerHTML.trim()) score += SCORE_DOM;
+  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));
@@ -11485,13 +11770,68 @@ 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 score = scoreReference(reference, signals, isPublicLanding);
+  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,
     score,
@@ -11500,7 +11840,8 @@ var deriveReferenceEntry = (reference, format) => {
     url: reference.url,
     surfaceType: isPublicLanding ? "public landing page" : format.archetype,
     capturedVia,
-    selectionReason: selectionReasonForScore(score, 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("; "),
@@ -11518,6 +11859,13 @@ var sortReferenceEntries = (entries) => entries.slice().sort((left, right) => ri
   ...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.";
   }
@@ -11529,23 +11877,125 @@ var rejectionReasonForReference = (reference) => {
   }
   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 buildInspiredesignReferencePatternBoard = (briefId, format, references) => {
-  const entries = references.filter(hasInspiredesignUsableReferenceEvidence).map((reference) => deriveReferenceEntry(reference, format));
+var hasCapturedEvidence = (reference) => reference.captureStatus === "captured" || reference.capture?.visual?.status === "captured";
+var capturedButRejectedReason = (diagnosticReasons) => diagnosticReasons.length > 0 ? `Captured browser evidence was rejected because it only exposed diagnostic signals: ${diagnosticReasons.join(", ")}.` : "Captured browser evidence was rejected because it did not contain usable creative reference evidence.";
+var buildRejectedReferences = (references) => references.filter((reference) => !hasInspiredesignUsableReferenceEvidence(reference)).map((reference) => {
+  const diagnosticReasons = referenceDiagnosticReasons(reference);
+  const captured = hasCapturedEvidence(reference);
+  return {
+    id: reference.id,
+    url: reference.url,
+    reason: rejectionReasonForReference(reference),
+    fetchStatus: reference.fetchStatus,
+    captureStatus: reference.captureStatus,
+    ...captured ? { captured: true } : {},
+    ...diagnosticReasons.length > 0 ? { diagnosticReasons } : {},
+    ...captured ? {
+      capturedButRejectedReason: capturedButRejectedReason(diagnosticReasons),
+      evidenceGap: "Design-facing artifacts require creative layout evidence; diagnostic browser chrome is kept only as rejection metadata."
+    } : {}
+  };
+});
+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 buildNotReadyRejectedReference = (reference) => {
+  const captured = reference.capturedVia.length > 0;
+  return {
+    id: reference.id,
+    url: reference.url,
+    reason: reference.intentMatched ? "Reference evidence did not meet the design-ready ranking threshold." : "Reference evidence did not match the requested design intent.",
+    fetchStatus: reference.capturedVia.includes("fetch") ? "captured" : "skipped",
+    captureStatus: reference.capturedVia.some((method) => method !== "fetch") ? "captured" : "off",
+    ...captured ? {
+      captured: true,
+      capturedButRejectedReason: "Captured reference evidence did not satisfy design-ready ranking gates.",
+      evidenceGap: "Design-facing artifacts require design-ready creative evidence; non-ready captures are kept only as rejection metadata."
+    } : {}
+  };
+};
+var mergeRejectedReferences = (rejectedReferences) => {
+  const seen = /* @__PURE__ */ new Set();
+  return rejectedReferences.filter((reference) => {
+    if (seen.has(reference.id)) return false;
+    seen.add(reference.id);
+    return true;
+  });
+};
+var buildInspiredesignRankedArtifactPatternBoard = (designBoard, sourceBoard) => {
+  const designReferenceIds = new Set(designBoard.references.map((reference) => reference.id));
+  const notReadyReferences = sourceBoard.references.filter((reference) => !designReferenceIds.has(reference.id)).map(buildNotReadyRejectedReference);
+  return {
+    ...designBoard,
+    rejectedReferences: mergeRejectedReferences([
+      ...sourceBoard.rejectedReferences,
+      ...notReadyReferences
+    ])
+  };
+};
+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,
+    qualitySummary: buildQualitySummary(references, rankedEntries, rejectedReferences),
     references: rankedEntries,
-    rejectedReferences: buildRejectedReferences(references),
+    rejectedReferences,
     synthesis: {
       dominantDirection: rankedEntries[0]?.layoutRecipe ?? format.archetype,
       sharedStrengths,
@@ -11651,13 +12101,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: [
@@ -11671,16 +12124,16 @@ 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]
   };
@@ -11688,11 +12141,11 @@ var buildInspiredesignDesignVectors = (format, board) => {
 
 // src/inspiredesign/meta-prompt.ts
 var formatList = (items) => items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : "- No evidence-backed item available.";
-var formatRankedReferences = (board) => {
-  if (board.references.length === 0) {
-    return "- No usable references were ranked. Work from the brief and note missing evidence.";
+var formatRankedReferences = (references) => {
+  if (references.length === 0) {
+    return "- No ready references were ranked. Work from the brief and note missing evidence.";
   }
-  return board.references.map((reference) => [
+  return references.map((reference) => [
     `### Rank ${reference.rank}: ${reference.name}`,
     `- URL: ${reference.url}`,
     `- Score: ${reference.score}`,
@@ -11704,64 +12157,71 @@ var formatRankedReferences = (board) => {
     `- Visual risks: ${reference.visualRisks.join("; ")}`
   ].join("\n")).join("\n\n");
 };
-var formatRejectedReferences = (board) => {
-  if (board.rejectedReferences.length === 0) {
-    return "- No references were rejected from the creative synthesis.";
-  }
-  return board.rejectedReferences.map((reference) => `- ${reference.url}: ${reference.reason} (fetch=${reference.fetchStatus}, capture=${reference.captureStatus})`).join("\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");
 };
-var buildInspiredesignMetaPrompt = (input) => [
-  "# 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.referencePatternBoard.targetSurface}`,
-  `- Dominant direction: ${input.referencePatternBoard.synthesis.dominantDirection}`,
-  "",
-  "## Ranked References",
-  formatRankedReferences(input.referencePatternBoard),
-  "",
-  "## Rejected References",
-  formatRejectedReferences(input.referencePatternBoard),
-  "",
-  "## 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";
@@ -12208,13 +12668,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");
@@ -12301,10 +12764,6 @@ 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 createHash4("sha256").update(value).digest("hex").slice(0, 12);
@@ -12877,15 +13336,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),
@@ -12957,6 +13415,7 @@ var buildImplementationPlan = ({
   profile,
   format,
   references,
+  attemptedReferenceCount,
   synthesis,
   designVectors
 }) => ({
@@ -12994,7 +13453,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."
   ],
@@ -13249,11 +13708,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"
@@ -13342,19 +13801,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
   );
@@ -13371,7 +13836,7 @@ var buildInspiredesignPacket = (input) => {
   });
   const advancedBriefMarkdown = renderReferenceFirstAdvancedBrief(
     effectiveBriefExpansion,
-    referencePatternBoard,
+    designReferencePatternBoard,
     designVectors,
     references
   );
@@ -13379,7 +13844,7 @@ var buildInspiredesignPacket = (input) => {
     brief,
     format: effectiveFormat,
     synthesis,
-    referencePatternBoard,
+    referencePatternBoard: designReferencePatternBoard,
     designVectors,
     targetAnalysis
   });
@@ -13387,8 +13852,7 @@ var buildInspiredesignPacket = (input) => {
   const canvasPlanRequest = buildCanvasPlanRequest(brief, generationPlan);
   const designContract = buildDesignContract({
     brief,
-    urls,
-    references,
+    designReferences: usableReferences,
     plan: generationPlan,
     format: effectiveFormat
   });
@@ -13397,14 +13861,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
   });
@@ -13435,7 +13900,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",
     "",
@@ -13474,7 +13939,10 @@ 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);
@@ -13490,7 +13958,8 @@ var buildInspiredesignPacket = (input) => {
     prototypeGuidanceMarkdown,
     visualEvidence,
     screenshotIndex,
-    rankedReferences: referencePatternBoard.references,
+    rankedReferences: designReferencePatternBoard.references,
+    referencePatternBoard,
     metaPromptMarkdown,
     evidence: buildEvidencePayload({
       brief,
@@ -13498,13 +13967,1228 @@ var buildInspiredesignPacket = (input) => {
       advancedBriefMarkdown,
       urls,
       references,
-      referencePatternBoard,
+      referencePatternBoard: designReferencePatternBoard,
       designVectors,
       targetAnalysis
     })
   };
 };
 
+// src/guidance/renderers.ts
+var toJsonValue2 = (value) => {
+  return structuredClone(value);
+};
+var renderWorkflowGuidance = (guidance) => {
+  return toJsonValue2(guidance);
+};
+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]
+  };
+};
+
+// 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";
+};
+
+// 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 exampleIds = {
+  canvasSessionId: "canvas-session-from-session-open",
+  leaseId: "lease-from-session-open",
+  documentId: "document-from-session-open"
+};
+var stringifyReceived = (value) => {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+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";
+  }
+};
+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 DEFAULT_PINTEREST_REFERENCE_URL = "https://www.pinterest.com/pin/27654985208435505/";
+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 pinterestRecoveryUrls = (context) => {
+  if (!isPinterestScopedRecovery(context)) return [];
+  const urls = context.referenceUrls ?? [];
+  const canonicalUrls = urls.map(normalizePinterestReferenceUrl).filter((url) => url !== null);
+  return [...new Set(canonicalUrls)];
+};
+var inspiredesignRecoveryExampleUrls = (context) => selectedProviderIsPinterest(context) ? [DEFAULT_PINTEREST_REFERENCE_URL] : ["https://example.com/usable-reference"];
+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);
+  const urls = pinterestRecoveryUrls(context);
+  if (urls.length > 0) {
+    const urlFlags = urls.map((url) => `--url ${quote(url)}`).join(" ");
+    return {
+      id: "inspiredesign-harvest-url-recovery",
+      label: "Recover Inspired Design harvest with explicit Pinterest URLs",
+      command: `npx opendevbrowser inspiredesign harvest --brief ${quote(brief)} --provider social/pinterest ${urlFlags} --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`
+    };
+  }
+  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: inspiredesignRecoveryExampleUrls(context),
+      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`;
@@ -13513,7 +15197,7 @@ var createSuccessHandoff = (followthroughSummary, suggestedNextAction, suggested
   suggestedNextAction,
   suggestedSteps
 });
-var cliExample = (command, args = "") => `npx opendevbrowser ${command}${args ? ` ${args}` : ""}`;
+var cliExample = (command, args) => `npx opendevbrowser ${command} ${args}`;
 var quoteCliValue = (value) => JSON.stringify(value);
 var GATED_PROVIDER_REASON_CODES = /* @__PURE__ */ new Set([
   "auth_required",
@@ -13643,6 +15327,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" : "";
@@ -13650,7 +15338,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));
@@ -13664,7 +15352,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}`,
     [
@@ -13676,6 +15364,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);
@@ -13764,31 +15467,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: "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 }
-  ]
-);
+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)}`;
@@ -13893,6 +15608,86 @@ var researchFailureMessage = (content) => boundedInlineText({
   limit: RESEARCH_REPORT_LIMITS.failureMessageCharacters,
   target: "meta.json"
 });
+var CANVAS_CONTINUATION_BLOCKED_COMMAND = "Unavailable until nextStepGuidance.readiness is ready.";
+var CANVAS_PLAN_OMITTED_GUIDANCE = "Canvas plan request omitted until nextStepGuidance.readiness is ready.";
+var canContinueInspiredesignInCanvas = (guidance) => guidance?.readiness === "ready";
+var scrubCanvasPlanReference = (value) => value.includes(INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest) ? CANVAS_PLAN_OMITTED_GUIDANCE : value;
+var scrubGuideEntryCanvasReferences = (entry) => ({
+  ...entry,
+  expectedContents: entry.expectedContents.map(scrubCanvasPlanReference),
+  howToUse: entry.howToUse.map(scrubCanvasPlanReference),
+  mustNot: entry.mustNot.map(scrubCanvasPlanReference)
+});
+var scrubArtifactGuideCanvasReferences = (guide) => {
+  const scrubbed = {};
+  for (const [key, entry] of Object.entries(guide)) {
+    if (entry) {
+      scrubbed[key] = scrubGuideEntryCanvasReferences(entry);
+    }
+  }
+  return scrubbed;
+};
+var scrubContractSectionGuideCanvasReferences = (guide) => {
+  const scrubbed = {};
+  for (const [key, entry] of Object.entries(guide)) {
+    scrubbed[key] = scrubGuideEntryCanvasReferences(entry);
+  }
+  return scrubbed;
+};
+var blockInspiredesignCanvasArtifactGuide = (handoff) => {
+  const artifactGuide = { ...handoff.artifactGuide };
+  delete artifactGuide[INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest];
+  return artifactGuide;
+};
+var blockInspiredesignNotReadyArtifacts = (handoff) => {
+  const referenceSynthesis = plainObject(handoff.implementationContext.referenceSynthesis);
+  const blockedArtifacts = /* @__PURE__ */ new Set([
+    INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest,
+    INSPIREDESIGN_HANDOFF_FILES.prototypeGuidance
+  ]);
+  const requiredArtifacts = isStringArray(referenceSynthesis.requiredArtifacts) ? referenceSynthesis.requiredArtifacts.filter((artifact) => !blockedArtifacts.has(artifact)) : [];
+  const artifactGuide = { ...handoff.artifactGuide };
+  delete artifactGuide[INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest];
+  delete artifactGuide[INSPIREDESIGN_HANDOFF_FILES.prototypeGuidance];
+  return {
+    ...handoff,
+    artifactGuide: scrubArtifactGuideCanvasReferences(artifactGuide),
+    contractSectionGuide: scrubContractSectionGuideCanvasReferences(handoff.contractSectionGuide),
+    implementationContext: {
+      ...handoff.implementationContext,
+      referenceSynthesis: {
+        ...referenceSynthesis,
+        requiredArtifacts
+      }
+    }
+  };
+};
+var blockPrototypeGuidanceInDesignMarkdown = (markdown, prototypeGuidanceMarkdown) => {
+  const withoutCanvasDeliverable = markdown.replace(
+    /\n- Diagnostic `canvasPlanRequest` preview; do not submit to Canvas until next-step guidance is ready/g,
+    `
+- ${CANVAS_PLAN_OMITTED_GUIDANCE}`
+  );
+  const withoutPrototypeDeliverable = withoutCanvasDeliverable.replace(
+    /\n- Prototype guidance Markdown for the first HTML pass/g,
+    ""
+  );
+  if (!prototypeGuidanceMarkdown) return withoutPrototypeDeliverable;
+  return withoutPrototypeDeliverable.replace(
+    prototypeGuidanceMarkdown,
+    "# 6. Optional Prototype Plan\n\n- Prototype guidance omitted because next-step guidance is not ready."
+  );
+};
+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);
@@ -14321,6 +16116,7 @@ var renderInspiredesign = (args) => {
   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
@@ -14336,18 +16132,44 @@ 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 designMarkdown = canContinueInCanvas ? args.designMarkdown : blockPrototypeGuidanceInDesignMarkdown(args.designMarkdown, args.prototypeGuidanceMarkdown);
+  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);
+  const renderedDesignAgentHandoffBase = {
+    ...args.designAgentHandoff,
+    ...handoff,
+    summary: handoff.followthroughSummary,
+    nextStep: handoff.suggestedNextAction,
+    artifactGuide: blockedCanvasArtifactGuide,
+    commandExamples: commandExamples2
+  };
+  const renderedDesignAgentHandoff = canContinueInCanvas ? renderedDesignAgentHandoffBase : blockInspiredesignNotReadyArtifacts(renderedDesignAgentHandoffBase);
   const contextPayload = {
     brief: args.brief,
     advancedBriefMarkdown: args.advancedBriefMarkdown,
     urls: args.urls,
     designContract: args.designContract,
-    canvasPlanRequest: args.canvasPlanRequest,
-    designAgentHandoff: args.designAgentHandoff,
+    ...canContinueInCanvas ? { canvasPlanRequest: args.canvasPlanRequest } : {},
+    designAgentHandoff: renderedDesignAgentHandoff,
+    ...args.nextStepGuidance ? { nextStepGuidance: args.nextStepGuidance } : {},
     generationPlan: args.generationPlan,
     implementationPlan: args.implementationPlan,
-    designMarkdown: args.designMarkdown,
+    designMarkdown,
     implementationPlanMarkdown: args.implementationPlanMarkdown,
-    prototypeGuidanceMarkdown: args.prototypeGuidanceMarkdown,
+    prototypeGuidanceMarkdown,
     evidence: args.evidence,
     visualEvidence,
     screenshotIndex,
@@ -14355,18 +16177,14 @@ var renderInspiredesign = (args) => {
     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.designMarkdown, content: 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 },
@@ -14376,8 +16194,11 @@ var renderInspiredesign = (args) => {
     { 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 });
+  }
+  if (canContinueInCanvas) {
+    files.push({ path: INSPIREDESIGN_HANDOFF_FILES.canvasPlanRequest, content: args.canvasPlanRequest });
   }
   const captureAttemptFields = {
     ...captureAttemptSummary ? { captureAttemptSummary } : {},
@@ -14402,12 +16223,13 @@ var renderInspiredesign = (args) => {
         brief: args.brief,
         advancedBriefMarkdown: args.advancedBriefMarkdown,
         urls: args.urls,
-        canvasPlanRequest: args.canvasPlanRequest,
-        designAgentHandoff: args.designAgentHandoff,
+        ...canContinueInCanvas ? { canvasPlanRequest: args.canvasPlanRequest } : {},
+        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,
@@ -14424,9 +16246,9 @@ var renderInspiredesign = (args) => {
     return {
       response: {
         mode: args.mode,
-        markdown: args.designMarkdown,
+        markdown: designMarkdown,
         implementationPlanMarkdown: args.implementationPlanMarkdown,
-        prototypeGuidanceMarkdown: args.prototypeGuidanceMarkdown,
+        prototypeGuidanceMarkdown,
         ...handoff,
         ...captureAttemptFields,
         meta: args.meta
@@ -14457,6 +16279,247 @@ 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 dedupeInspiredesignReferenceUrls = (source) => {
+  const urls = [...source.urls ?? [], ...source.discovery.acceptedUrls].map((url) => url.trim()).filter((url) => url.length > 0);
+  return [...new Set(urls)];
+};
+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);
+  const referenceUrls = dedupeInspiredesignReferenceUrls(source);
+  return {
+    workflow: "inspiredesign",
+    reasonCode: reasonCodeForInspiredesign(source),
+    requestedProviders: source.requestedProviders,
+    ...siteRecipeId ? { siteRecipeId } : {},
+    ...source.query ? { query: source.query } : {},
+    ...referenceUrls.length > 0 ? { referenceUrls } : {},
+    ...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/guidance/recipes/site-recipe-validation.ts
+var normalizeNonBlank = (values) => values.map((value) => value.trim()).filter((value) => value.length > 0);
+var incompatible = (message) => ({ ok: false, message });
+var supportsBrowserNativeRecovery = (recipe) => typeof recipe?.browserNativeDiscovery?.buildSearchUrl === "function";
+var isCanonicalRecipeReferenceUrl = (recipe, url) => {
+  if (recipe.id === "social/pinterest") {
+    return normalizePinterestReferenceUrl(url) !== null;
+  }
+  return true;
+};
+var isPinterestLikeHostname = (value) => {
+  const hostname = value.toLowerCase();
+  return [
+    hostname === "pinterest.com",
+    hostname.endsWith(".pinterest.com"),
+    hostname.startsWith("pinterest."),
+    hostname.includes(".pinterest.")
+  ].some(Boolean);
+};
+var isPinterestLikeUrl = (value) => {
+  try {
+    return isPinterestLikeHostname(new URL(value).hostname);
+  } catch {
+    return false;
+  }
+};
+var isNonCanonicalPinterestLikeUrl = (url) => (resolveSiteRecipeForUrl(url)?.id === "social/pinterest" || isPinterestLikeUrl(url)) && normalizePinterestReferenceUrl(url) === null;
+var requiresProviderUrlSiteRecipeCompatibility = ({
+  providers,
+  urls,
+  query
+}) => {
+  const providerIds = normalizeNonBlank(providers);
+  if (providerIds.length === 0) return false;
+  if (!query?.trim()) return true;
+  return false;
+};
+var validateProviderScopedUrlCanonicality = ({
+  providers,
+  urls
+}) => {
+  const providerHasPinterest = normalizeNonBlank(providers).some((providerId) => resolveSiteRecipeForProvider(providerId)?.id === "social/pinterest");
+  if (!providerHasPinterest) return { ok: true };
+  const nonCanonicalPinterestUrl = normalizeNonBlank(urls).find((url) => normalizePinterestReferenceUrl(url) === null);
+  if (!nonCanonicalPinterestUrl) return { ok: true };
+  return incompatible(
+    `URL ${nonCanonicalPinterestUrl} is not a canonical social/pinterest reference URL for provider-scoped recovery.`
+  );
+};
+var validateProviderUrlSiteRecipeCompatibility = ({
+  providers,
+  urls
+}) => {
+  const providerIds = normalizeNonBlank(providers);
+  const referenceUrls = normalizeNonBlank(urls);
+  if (providerIds.length === 0) {
+    return incompatible("Provider-scoped URL recovery requires at least one provider.");
+  }
+  if (referenceUrls.length === 0) {
+    return incompatible("Provider-scoped URL recovery requires at least one URL.");
+  }
+  const providerRecipes = providerIds.map((providerId) => ({
+    providerId,
+    recipe: resolveSiteRecipeForProvider(providerId)
+  }));
+  const missingProviderRecipe = providerRecipes.find((entry) => entry.recipe === void 0);
+  if (missingProviderRecipe) {
+    return incompatible(`Provider ${missingProviderRecipe.providerId} does not support URL-only site recipe recovery.`);
+  }
+  const nonNativeProviderRecipe = providerRecipes.find((entry) => !supportsBrowserNativeRecovery(entry.recipe));
+  if (nonNativeProviderRecipe) {
+    return incompatible(`Provider ${nonNativeProviderRecipe.providerId} does not support browser-native URL-only site recipe recovery.`);
+  }
+  const urlRecipes = referenceUrls.map((url) => ({
+    url,
+    recipe: resolveSiteRecipeForUrl(url)
+  }));
+  const missingUrlRecipe = urlRecipes.find((entry) => entry.recipe === void 0);
+  if (missingUrlRecipe) {
+    return incompatible(`URL ${missingUrlRecipe.url} does not match a browser-native site recipe for provider-scoped recovery.`);
+  }
+  const nonNativeUrlRecipe = urlRecipes.find((entry) => !supportsBrowserNativeRecovery(entry.recipe));
+  if (nonNativeUrlRecipe) {
+    return incompatible(`URL ${nonNativeUrlRecipe.url} does not match a browser-native site recipe for provider-scoped recovery.`);
+  }
+  const recipeIds = /* @__PURE__ */ new Set([
+    ...providerRecipes.map((entry) => entry.recipe?.id),
+    ...urlRecipes.map((entry) => entry.recipe?.id)
+  ]);
+  if (recipeIds.size !== 1) {
+    return incompatible("Provider-scoped URL recovery requires every provider and URL to resolve to the same site recipe.");
+  }
+  const recipeId = providerRecipes[0]?.recipe?.id;
+  if (!recipeId) {
+    return incompatible("Provider-scoped URL recovery could not resolve a site recipe.");
+  }
+  const recipe = providerRecipes[0]?.recipe;
+  const nonReferenceUrl = recipe ? urlRecipes.find((entry) => !isCanonicalRecipeReferenceUrl(recipe, entry.url)) : void 0;
+  if (nonReferenceUrl) {
+    return incompatible(`URL ${nonReferenceUrl.url} is not a canonical ${recipeId} reference URL for provider-scoped recovery.`);
+  }
+  return { ok: true, recipeId };
+};
+
 // src/inspiredesign/reference-discovery.ts
 var normalizeHttpUrl = (value) => {
   try {
@@ -15170,7 +17233,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
@@ -15185,7 +17248,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 {
@@ -16335,6 +18398,307 @@ 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;
 var RECOVERY_WINDOWS_REQUIRED = 2;
@@ -16594,7 +18958,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;
@@ -17331,8 +19703,18 @@ var normalizeInspiredesignInput = (input) => {
   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.");
+  const canonicality = validateProviderScopedUrlCanonicality({ providers, urls });
+  if (!canonicality.ok) {
+    throw new Error(`Inspiredesign workflow ${canonicality.message}`);
+  }
+  if (requiresProviderUrlSiteRecipeCompatibility({ providers, urls, query })) {
+    if (input.harvest !== true) {
+      throw new Error("Inspiredesign workflow providers require query unless harvest uses compatible URL recovery.");
+    }
+    const compatibility = validateProviderUrlSiteRecipeCompatibility({ providers, urls });
+    if (!compatibility.ok) {
+      throw new Error(`Inspiredesign workflow ${compatibility.message}`);
+    }
   }
   if (input.harvest === true && !query && urls.length === 0) {
     throw new Error("Inspiredesign harvest requires query or URL references.");
@@ -17404,10 +19786,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
@@ -17417,6 +19800,26 @@ 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,
@@ -17457,10 +19860,177 @@ var failureFromInspiredesignFetchError = (result) => {
     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 filterStandardDiscoveryForSiteRecipe = (siteRecipe, discovery) => {
+  if (siteRecipe.id !== "social/pinterest") return discovery;
+  const accepted = [];
+  const rejected = [...discovery.rejected];
+  discovery.accepted.forEach((candidate) => {
+    if (!isNonCanonicalPinterestLikeUrl(candidate.url)) {
+      accepted.push(candidate);
+      return;
+    }
+    rejected.push({
+      status: "rejected",
+      reason: "invalid_url",
+      rawUrl: candidate.url,
+      ...candidate.title ? { title: candidate.title } : {},
+      source: candidate.source,
+      provider: candidate.provider,
+      rank: candidate.rank
+    });
+  });
+  return { accepted, 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 = filterStandardDiscoveryForSiteRecipe(
+          siteRecipe,
+          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,
@@ -17934,11 +20504,85 @@ var summarizeInspiredesignFetchConstraint = (references) => {
   return references.find((reference) => reference.fetchStatus === "failed" && !isInspiredesignFetchRecovered(reference) && typeof reference.fetchFailure === "string" && reference.fetchFailure.trim().length > 0)?.fetchFailure;
 };
 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);
@@ -18034,6 +20678,11 @@ var summarizeInspiredesignDiscoveryConstraint = (discovery) => {
     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;
@@ -19073,9 +21722,10 @@ var runInspiredesignWorkflow = async (runtime, input, options = {}) => {
       const fetchTimeoutMs = remainingTimeoutMs();
       const fetchResult = await runtime.fetch(
         { url },
-        buildInspiredesignFetchOptions(
+        buildInspiredesignReferenceFetchOptions(
           workflowInput,
           buildInspiredesignStepEnvelope(workflowInput, stepTrace, index, url),
+          url,
           fetchTimeoutMs
         )
       );
@@ -19099,7 +21749,9 @@ var runInspiredesignWorkflow = async (runtime, input, options = {}) => {
       const reference = buildInspiredesignReference(url, result, capture);
       references.push(reference);
       if (reference.fetchStatus === "failed" && !isInspiredesignFetchRecovered(reference)) {
-        failures.push(...result.failures);
+        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,
@@ -19114,7 +21766,8 @@ var runInspiredesignWorkflow = async (runtime, input, options = {}) => {
       briefExpansion: workflowInput.briefExpansion,
       urls: workflowInput.urls,
       references: visualCollation.references,
-      includePrototypeGuidance: workflowInput.includePrototypeGuidance
+      includePrototypeGuidance: workflowInput.includePrototypeGuidance,
+      referenceEvidenceRequired: isInspiredesignReferenceEvidenceRequired(workflowInput)
     });
     const meta = buildInspiredesignMeta(
       runtime,
@@ -19124,6 +21777,23 @@ var runInspiredesignWorkflow = async (runtime, input, options = {}) => {
       packet.followthrough,
       discovery
     );
+    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,
@@ -19141,9 +21811,13 @@ var runInspiredesignWorkflow = async (runtime, input, options = {}) => {
       visualEvidence: packet.visualEvidence,
       screenshotIndex: packet.screenshotIndex,
       rankedReferences: packet.rankedReferences,
-      referencePatternBoard: packet.generationPlan.referencePatternBoard,
+      referencePatternBoard: buildInspiredesignRankedArtifactPatternBoard(
+        packet.generationPlan.referencePatternBoard,
+        packet.referencePatternBoard
+      ),
       metaPromptMarkdown: packet.metaPromptMarkdown,
-      meta
+      nextStepGuidance,
+      meta: metaWithGuidance
     });
     const bundle = await createArtifactBundle({
       namespace: "inspiredesign",
@@ -19156,7 +21830,7 @@ var runInspiredesignWorkflow = async (runtime, input, options = {}) => {
         ...rendered.response,
         artifact_path: bundle.basePath,
         meta: {
-          ...meta,
+          ...metaWithGuidance,
           artifact_manifest: bundle.manifest
         }
       };
@@ -19165,7 +21839,7 @@ var runInspiredesignWorkflow = async (runtime, input, options = {}) => {
       ...rendered.response,
       artifact_path: bundle.basePath,
       meta: {
-        ...meta,
+        ...metaWithGuidance,
         artifact_manifest: bundle.manifest
       }
     };
@@ -21947,6 +24621,8 @@ var mergeBudgets = (base, partial) => {
 };
 
 export {
+  WORKFLOW_ARTIFACT_DIRECTORY,
+  resolveWorkflowArtifactRoot,
   CHALLENGE_AUTOMATION_MODES,
   isChallengeAutomationMode,
   resolveChallengeAutomationPolicy,
@@ -21971,6 +24647,8 @@ export {
   CANVAS_BROWSER_VALIDATION_MODES,
   CANVAS_VALIDATION_TARGET_BLOCK_ON_CODES,
   CANVAS_PUBLIC_WARNING_CLASSES,
+  buildCanvasRepairEnvelope,
+  buildCanvasCommandValidationEnvelope,
   createTraceContext,
   clampConfidence,
   createStableRecordId,
@@ -21998,8 +24676,6 @@ export {
   createShoppingProviders,
   createShoppingProviderById,
   createWebProvider,
-  WORKFLOW_ARTIFACT_DIRECTORY,
-  resolveWorkflowArtifactRoot,
   resolveTimebox,
   isWithinTimebox,
   filterByTimebox,
@@ -22009,6 +24685,9 @@ export {
   renderResearch,
   renderShopping,
   renderInspiredesign,
+  requiresProviderUrlSiteRecipeCompatibility,
+  validateProviderScopedUrlCanonicality,
+  validateProviderUrlSiteRecipeCompatibility,
   resolveInspiredesignCaptureMode,
   workflowTestUtils,
   runResearchWorkflow,
@@ -22020,4 +24699,4 @@ export {
   createProviderRuntime,
   createDefaultRuntime
 };
-//# sourceMappingURL=chunk-RO3SMXF3.js.map
+//# sourceMappingURL=chunk-5FDXH4CS.js.map