unbrowse 2.1.3 → 2.1.4

package/dist/index.js

@@ -6863,7 +6863,7 @@ function classifyRows(rows, intent) {
     return matching.length >= 1 ? { verdict: "pass", reason: "channel_rows" } : { verdict: "fail", reason: "wrong_entity_type" };
   }
   if (/\b(search|find|lookup)\b/.test(lower)) {
-    const matching = objects.filter((row) => hasAnyPath(row, ["name", "title", "songName", "resource_name"]) && hasAnyPath(row, ["id", "url", "link", "href", "resource_id"]) && hasAnyPath(row, ["description", "summary", "metadata", "stats", "author", "uploader", "createdAt", "updatedAt"]));
+    const matching = objects.filter((row) => hasAnyPath(row, ["name", "title", "songName", "resource_name"]) && hasAnyPath(row, ["id", "url", "link", "href", "resource_id", "citation", "case_number"]) && hasAnyPath(row, ["description", "summary", "metadata", "stats", "author", "uploader", "createdAt", "updatedAt", "court", "decision_date", "coram", "catchword"]));
     return matching.length >= 1 ? { verdict: "pass", reason: "search_rows" } : { verdict: "fail", reason: "wrong_entity_type" };
   }
   return { verdict: "skip", reason: "unclassified_array" };
@@ -7282,6 +7282,14 @@ function normalizeStructureForIntent(structure, intent) {
   const objectRows = structure.data.filter((row) => !!row && typeof row === "object" && !Array.isArray(row));
   if (objectRows.length === 0)
     return structure;
+  const normalizedLawNet = normalizeLawNetSearchRows(objectRows);
+  if (normalizedLawNet.length >= 1) {
+    return {
+      ...structure,
+      data: normalizedLawNet,
+      element_count: normalizedLawNet.length
+    };
+  }
   const pruned = pruneRowsForIntent(objectRows, intent);
   if (pruned.length >= 1 && pruned.length < objectRows.length) {
     return {
@@ -7292,6 +7300,87 @@ function normalizeStructureForIntent(structure, intent) {
   }
   return structure;
 }
+function parseLawNetCitation(title) {
+  const match = title.match(/^(.*?)\s*-\s*(\[[^\]]+\].+)$/);
+  if (!match)
+    return {};
+  const case_name = cleanText(match[1] ?? "");
+  const citation = cleanText(match[2] ?? "");
+  return {
+    ...case_name ? { case_name } : {},
+    ...citation ? { citation } : {}
+  };
+}
+function parseLawNetLabeledField(text, label) {
+  const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = text.match(new RegExp(`${escaped}\\s*:\\s*([\\s\\S]*?)(?=\\s+(?:Court|Corams?|Decision Date|Case Number|Catchword)\\s*:|$)`, "i"));
+  const value = cleanText(match?.[1] ?? "");
+  return value || undefined;
+}
+function isLikelyLawNetSearchShell(rows) {
+  return rows.some((row) => {
+    if (row.title === "Search Results")
+      return true;
+    const keys = Object.keys(row);
+    if (!keys.some((key) => /^heading_\d+$/.test(key)))
+      return false;
+    return Object.values(row).some((value) => typeof value === "string" && (/Results returned:/i.test(value) || /\bCourt\s*:/.test(value) || /\[\d{4}\]/.test(value)));
+  });
+}
+function parseLawNetCaseRow(text) {
+  const cleaned = cleanText(text.replace(/\u00a0/g, " "));
+  if (!cleaned)
+    return null;
+  if (cleaned === "Search Results" || /^Results returned:/i.test(cleaned) || /^(Catchword|Category|Courts|Coram|Jurisdiction|Years|Title \[A to Z\]|Title \[Z to A\]|Date \[latest first\])$/i.test(cleaned) || /^Please enter the no\. of words before and after\./i.test(cleaned)) {
+    return null;
+  }
+  if (!/\[\d{4}\]/.test(cleaned))
+    return null;
+  const marker = cleaned.search(/\s+(?:Court|Corams?|Decision Date|Case Number|Catchword)\s*:/i);
+  const title = cleanText(marker >= 0 ? cleaned.slice(0, marker) : cleaned);
+  if (!title || !/\[\d{4}\]/.test(title) || title.length < 12)
+    return null;
+  const row = {
+    title,
+    ...parseLawNetCitation(title)
+  };
+  const court = parseLawNetLabeledField(cleaned, "Court");
+  const coram = parseLawNetLabeledField(cleaned, "Corams") ?? parseLawNetLabeledField(cleaned, "Coram");
+  const decision_date = parseLawNetLabeledField(cleaned, "Decision Date");
+  const case_number = parseLawNetLabeledField(cleaned, "Case Number");
+  const catchword = parseLawNetLabeledField(cleaned, "Catchword");
+  if (court)
+    row.court = court;
+  if (coram)
+    row.coram = coram;
+  if (decision_date)
+    row.decision_date = decision_date;
+  if (case_number)
+    row.case_number = case_number;
+  if (catchword)
+    row.catchword = catchword;
+  row.raw_text = cleaned;
+  return row;
+}
+function normalizeLawNetSearchRows(rows) {
+  if (rows.length === 0 || !isLikelyLawNetSearchShell(rows))
+    return [];
+  const bestByTitle = new Map;
+  for (const row of rows) {
+    for (const value of Object.values(row)) {
+      if (typeof value !== "string")
+        continue;
+      const parsed = parseLawNetCaseRow(value);
+      if (!parsed)
+        continue;
+      const existing = bestByTitle.get(parsed.title);
+      if (!existing || Object.keys(parsed).length > Object.keys(existing).length) {
+        bestByTitle.set(parsed.title, parsed);
+      }
+    }
+  }
+  return [...bestByTitle.values()];
+}
 function normalizeGitHubPath(href) {
   if (!href)
     return null;
@@ -8090,6 +8179,31 @@ function scoreFieldRichness(structure) {
     return 8;
   return 0;
 }
+function scoreCaseRowElements(structure) {
+  if (structure.type !== "repeated-elements" || !Array.isArray(structure.data))
+    return 0;
+  const items = structure.data;
+  if (items.length < 2)
+    return 0;
+  const caseLike = items.filter((item) => typeof item.title === "string" && (typeof item.case_name === "string" || typeof item.citation === "string" || typeof item.case_number === "string" || typeof item.court === "string")).length;
+  if (caseLike >= Math.min(3, items.length))
+    return 220;
+  if (caseLike >= 2)
+    return 140;
+  return 0;
+}
+function scoreSearchShellNoise(structure) {
+  if (structure.type !== "key-value" || !structure.data || typeof structure.data !== "object")
+    return 0;
+  const record = structure.data;
+  const title = typeof record.title === "string" ? record.title : "";
+  const description = typeof record.description === "string" ? record.description : "";
+  const headingCount = Object.keys(record).filter((key) => /^heading_\d+$/.test(key)).length;
+  if (/^search results$/i.test(title) && /results returned:/i.test(description) && headingCount >= 6) {
+    return -260;
+  }
+  return 0;
+}
 function buildReplaySelector($el) {
   const tag = $el.get(0)?.tagName;
   if (!tag)
@@ -8173,7 +8287,7 @@ function extractFromDOM(html, intent) {
   const intentWords = intent.toLowerCase().split(/\s+/).filter(Boolean);
   const scored = structures.map((s) => ({
     structure: s,
-    score: scoreRelevance(s, intentWords) + scoreSemanticFit(s, intent) + scoreSparseLinkList(s) + scoreFieldRichness(s)
+    score: scoreRelevance(s, intentWords) + scoreSemanticFit(s, intent) + scoreSparseLinkList(s) + scoreFieldRichness(s) + scoreCaseRowElements(s) + scoreSearchShellNoise(s)
   }));
   scored.sort((a, b) => b.score - a.score);
   const passing = scored.filter((candidate) => assessIntentResult(candidate.structure.data, intent).verdict === "pass");
@@ -10645,6 +10759,12 @@ function stampTrace(trace) {
   trace.trace_version = TRACE_VERSION;
   return trace;
 }
+function canUseTriggerIntercept(endpoint) {
+  return !!endpoint.trigger_url && (endpoint.method === "GET" || endpoint.idempotency === "safe");
+}
+function resolveTriggerInterceptTargetUrl(url, structuredReplayUrl, hasStructuredReplay) {
+  return hasStructuredReplay ? structuredReplayUrl : url;
+}
 function mapHeaders(headers) {
   return Object.entries(headers ?? {}).map(([name, value]) => ({ name, value: String(value) }));
 }
@@ -12717,6 +12837,31 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
       }
     } catch {}
   }
+  const reloadAuthMaterial = async () => {
+    cookies.length = 0;
+    for (const key of Object.keys(authHeaders))
+      delete authHeaders[key];
+    authSourceMeta = null;
+    try {
+      const epBundle = await getStoredAuthBundle(epDomain);
+      if (epBundle) {
+        cookies.push(...epBundle.cookies);
+        Object.assign(authHeaders, epBundle.headers);
+        authSourceMeta = epBundle.source_meta ?? authSourceMeta;
+      }
+    } catch {}
+    if (registrableDomain && registrableDomain !== epDomain) {
+      try {
+        const regBundle = await getStoredAuthBundle(registrableDomain);
+        if (regBundle) {
+          cookies.push(...regBundle.cookies.filter((cookie) => !cookies.some((existing) => existing.name === cookie.name && existing.domain === cookie.domain)));
+          if (Object.keys(authHeaders).length === 0)
+            Object.assign(authHeaders, regBundle.headers);
+          authSourceMeta = regBundle.source_meta ?? authSourceMeta;
+        }
+      } catch {}
+    }
+  };
   log("exec", `endpoint ${endpoint.endpoint_id}: cookies=${cookies.length} authHeaders=${Object.keys(authHeaders).length} hasAuth=${cookies.length > 0 || Object.keys(authHeaders).length > 0}`);
   let mergedParams = mergeContextTemplateParams(params, endpoint.url_template, options?.contextUrl);
   if (endpoint.path_params && typeof endpoint.path_params === "object") {
@@ -12821,6 +12966,7 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
   }
   const structuredReplayUrl = isSafe ? deriveStructuredDataReplayUrl(url) : url;
   const hasStructuredReplay = structuredReplayUrl !== url;
+  const triggerInterceptTargetUrl = resolveTriggerInterceptTargetUrl(url, structuredReplayUrl, hasStructuredReplay);
   const serverFetch = async () => {
     const defaultAccept = !endpoint.dom_extraction && !endpoint.headers_template?.["accept"] ? { accept: "application/json" } : {};
     const headers = {
@@ -12906,6 +13052,17 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
     }
     return { data: last.data, status: last.status, trace_id: nanoid5(), network_events: networkEvents.length > 0 ? networkEvents : [last.event] };
   };
+  const serverFetchWithAuthRefresh = async () => {
+    let current = await serverFetch();
+    if (current.status !== 401 && current.status !== 403)
+      return current;
+    const refreshedEndpoint = await refreshAuthFromBrowser(epDomain).catch(() => false);
+    const refreshedRegistrable = !refreshedEndpoint && registrableDomain && registrableDomain !== epDomain ? await refreshAuthFromBrowser(registrableDomain).catch(() => false) : false;
+    if (!refreshedEndpoint && !refreshedRegistrable)
+      return current;
+    await reloadAuthMaterial();
+    return serverFetch();
+  };
   const browserCall = () => executeInBrowser(url, endpoint.method, endpoint.headers_template ?? {}, body, authHeaders, cookies);
   let result;
   const hasAuth = cookies.length > 0 || Object.keys(authHeaders).length > 0;
@@ -12922,11 +13079,11 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
     let strategy;
     const endpointStrategy = endpoint.exec_strategy;
     if (hasStructuredReplay) {
-      result = await serverFetch();
+      result = await serverFetchWithAuthRefresh();
       if (result.status >= 200 && result.status < 400 && !shouldFallbackToBrowserReplay(result.data, endpoint, options?.intent ?? skill.intent_signature, options?.contextUrl)) {
         strategy = "server";
-      } else if (endpoint.trigger_url && isSafe) {
-        result = await triggerAndIntercept(endpoint.trigger_url, endpoint.url_template, cookies, authHeaders, {
+      } else if (canUseTriggerIntercept(endpoint)) {
+        result = await triggerAndIntercept(endpoint.trigger_url, triggerInterceptTargetUrl, cookies, authHeaders, {
           authSource: authSourceMeta
         });
         strategy = "trigger-intercept";
@@ -12935,16 +13092,33 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
         strategy = "browser";
       }
     } else if (endpointStrategy === "server") {
-      result = await serverFetch();
-      if (shouldFallbackToBrowserReplay(result.data, endpoint, options?.intent ?? skill.intent_signature, options?.contextUrl)) {
+      result = await serverFetchWithAuthRefresh();
+      if (result.status >= 200 && result.status < 400) {
+        if (shouldFallbackToBrowserReplay(result.data, endpoint, options?.intent ?? skill.intent_signature, options?.contextUrl)) {
+          if (canUseTriggerIntercept(endpoint)) {
+            result = await triggerAndIntercept(endpoint.trigger_url, triggerInterceptTargetUrl, cookies, authHeaders, {
+              authSource: authSourceMeta
+            });
+            strategy = "trigger-intercept";
+          } else {
+            result = await withRetry(browserCall, (r) => isRetryableStatus(r.status));
+            strategy = "browser";
+          }
+        } else {
+          strategy = "server";
+        }
+      } else if (canUseTriggerIntercept(endpoint)) {
+        result = await triggerAndIntercept(endpoint.trigger_url, triggerInterceptTargetUrl, cookies, authHeaders, {
+          authSource: authSourceMeta
+        });
+        strategy = "trigger-intercept";
+      } else {
         result = await withRetry(browserCall, (r) => isRetryableStatus(r.status));
         strategy = "browser";
-      } else {
-        strategy = "server";
       }
-    } else if (endpointStrategy === "trigger-intercept" && endpoint.trigger_url && isSafe) {
+    } else if (endpointStrategy === "trigger-intercept" && canUseTriggerIntercept(endpoint)) {
       log("exec", `using learned strategy trigger-intercept via ${endpoint.trigger_url}`);
-      result = await triggerAndIntercept(endpoint.trigger_url, endpoint.url_template, cookies, authHeaders, {
+      result = await triggerAndIntercept(endpoint.trigger_url, triggerInterceptTargetUrl, cookies, authHeaders, {
         authSource: authSourceMeta
       });
       strategy = "trigger-intercept";
@@ -12965,7 +13139,7 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
       }
     } else {
       try {
-        result = await serverFetch();
+        result = await serverFetchWithAuthRefresh();
         if (result.status >= 200 && result.status < 400) {
           if (shouldFallbackToBrowserReplay(result.data, endpoint, options?.intent ?? skill.intent_signature, options?.contextUrl)) {
             result = await withRetry(browserCall, (r) => isRetryableStatus(r.status));
@@ -12975,8 +13149,8 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
           }
         } else {
           log("exec", `server fetch returned ${result.status}, falling back`);
-          if (endpoint.trigger_url && isSafe) {
-            result = await triggerAndIntercept(endpoint.trigger_url, endpoint.url_template, cookies, authHeaders, {
+          if (canUseTriggerIntercept(endpoint)) {
+            result = await triggerAndIntercept(endpoint.trigger_url, triggerInterceptTargetUrl, cookies, authHeaders, {
               authSource: authSourceMeta
             });
             strategy = "trigger-intercept";
@@ -13956,7 +14130,7 @@ function queuePassiveSkillPublish(skill, options = {}) {
 
 // ../../src/orchestrator/index.ts
 import { nanoid as nanoid6 } from "nanoid";
-import { existsSync as existsSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync6 } from "node:fs";
+import { existsSync as existsSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "node:fs";
 import { dirname as dirname2, join as join8 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 var CONFIDENCE_THRESHOLD = 0.3;
@@ -14058,15 +14232,109 @@ function writeSkillSnapshot(cacheKey, skill) {
     return;
   }
 }
+function hasSearchBindings(endpoint) {
+  const haystack = JSON.stringify({
+    url: endpoint.url_template,
+    query: endpoint.query ?? {},
+    body_params: endpoint.body_params ?? {},
+    body: endpoint.body ?? {},
+    semantic: endpoint.semantic ?? {}
+  }).toLowerCase();
+  return /(basicsearchkey|query|keyword|search|lookup|find|term)/.test(haystack);
+}
+function scoreSkillSnapshot(skill) {
+  let score = 0;
+  for (const endpoint of skill.endpoints) {
+    const active = endpoint.verification_status !== "disabled";
+    if (active)
+      score += 20;
+    if (endpoint.dom_extraction || endpoint.response_schema)
+      score += 10;
+    if (hasSearchBindings(endpoint))
+      score += 40;
+    if (endpoint.method === "POST")
+      score += 6;
+    if (/\/result-page\b/i.test(endpoint.url_template))
+      score += 12;
+    if (/captured page artifact/i.test(endpoint.description ?? ""))
+      score -= 18;
+  }
+  return score + skill.endpoints.length;
+}
+function pickPreferredSkillSnapshot(primary, candidates) {
+  let best = primary;
+  let bestScore = scoreSkillSnapshot(primary);
+  for (const candidate of candidates) {
+    if (candidate.skill_id !== primary.skill_id)
+      continue;
+    const candidateScore = scoreSkillSnapshot(candidate);
+    if (candidateScore > bestScore) {
+      best = candidate;
+      bestScore = candidateScore;
+    }
+  }
+  return best;
+}
 function readSkillSnapshot(path4) {
   if (!path4 || !existsSync8(path4))
     return;
   try {
-    return JSON.parse(readFileSync5(path4, "utf-8"));
+    const primary = JSON.parse(readFileSync5(path4, "utf-8"));
+    if (!existsSync8(SKILL_SNAPSHOT_DIR))
+      return primary;
+    const siblingSnapshots = [];
+    for (const entry of readdirSync4(SKILL_SNAPSHOT_DIR)) {
+      if (!entry.endsWith(".json"))
+        continue;
+      const candidatePath = join8(SKILL_SNAPSHOT_DIR, entry);
+      if (candidatePath === path4)
+        continue;
+      try {
+        const candidate = JSON.parse(readFileSync5(candidatePath, "utf-8"));
+        if (candidate.skill_id === primary.skill_id)
+          siblingSnapshots.push(candidate);
+      } catch {}
+    }
+    return pickPreferredSkillSnapshot(primary, siblingSnapshots);
   } catch {
     return;
   }
 }
+function findBestLocalDomainSnapshot(requestedDomain, intent, contextUrl) {
+  if (!existsSync8(SKILL_SNAPSHOT_DIR))
+    return;
+  const targetDomain = getRegistrableDomain(requestedDomain);
+  const bestBySkill = new Map;
+  for (const entry of readdirSync4(SKILL_SNAPSHOT_DIR)) {
+    if (!entry.endsWith(".json"))
+      continue;
+    try {
+      const candidate = JSON.parse(readFileSync5(join8(SKILL_SNAPSHOT_DIR, entry), "utf-8"));
+      if (getRegistrableDomain(candidate.domain) !== targetDomain)
+        continue;
+      const existing = bestBySkill.get(candidate.skill_id);
+      bestBySkill.set(candidate.skill_id, existing ? pickPreferredSkillSnapshot(existing, [candidate]) : candidate);
+    } catch {}
+  }
+  let best;
+  let bestScore = Number.NEGATIVE_INFINITY;
+  for (const candidate of bestBySkill.values()) {
+    if (!hasUsableEndpoints(candidate))
+      continue;
+    if (!isCachedSkillRelevantForIntent(candidate, intent, contextUrl))
+      continue;
+    if (!marketplaceSkillMatchesContext(candidate, intent, contextUrl))
+      continue;
+    const ranked = rankEndpoints(candidate.endpoints, intent, candidate.domain, contextUrl);
+    const topScore = ranked[0]?.score ?? Number.NEGATIVE_INFINITY;
+    const composite = topScore + scoreSkillSnapshot(candidate);
+    if (composite > bestScore) {
+      best = candidate;
+      bestScore = composite;
+    }
+  }
+  return best;
+}
 function isIpv4Hostname(hostname2) {
   return /^\d{1,3}(?:\.\d{1,3}){3}$/.test(hostname2);
 }
@@ -14272,6 +14540,11 @@ function isCachedSkillRelevantForIntent(skill, intent, contextUrl) {
   if (top && isEducationCatalogIntent(intent) && isRootContextUrl(contextUrl) && /captured page artifact/i.test(top.endpoint.description ?? "") && top.endpoint.url_template === contextUrl) {
     return false;
   }
+  if (isSearchIntent) {
+    const hasStructuredSearchEndpoint = resolvedSkill.endpoints.some((endpoint) => endpointHasSearchBindings(endpoint) && (!!endpoint.dom_extraction || !!endpoint.response_schema) && endpointMatchesContextOrigin(endpoint, contextUrl));
+    if (hasStructuredSearchEndpoint)
+      return true;
+  }
   return (top?.score ?? Number.NEGATIVE_INFINITY) >= 0;
 }
 function assessLocalExecutionResult(endpoint, result, intent, trace) {
@@ -14280,7 +14553,26 @@ function assessLocalExecutionResult(endpoint, result, intent, trace) {
     return semanticAssessment;
   if (endpoint.response_schema?.type !== "array")
     return semanticAssessment;
-  if (Array.isArray(result) || result == null || typeof result !== "object")
+  if (Array.isArray(result)) {
+    if (result.length === 0)
+      return { verdict: "fail", reason: "search_empty_results" };
+    const rows = result.filter((row) => !!row && typeof row === "object");
+    if (rows.length === 0)
+      return semanticAssessment;
+    const authBounce = rows.some((row) => {
+      const title2 = String(row.title ?? row.name ?? "").trim().toLowerCase();
+      const description2 = String(row.description ?? row.summary ?? "").trim().toLowerCase();
+      const link2 = String(row.link ?? row.url ?? "").trim().toLowerCase();
+      return /^(about|home|welcome)\b/.test(title2) || /\b(login|log in|sign in|password)\b/.test(`${title2} ${description2}`) || /\/(?:about|home|login)\b/.test(link2);
+    });
+    if (authBounce)
+      return { verdict: "fail", reason: "search_auth_or_homepage_bounce" };
+    const hasStructuredRows = rows.some((row) => typeof row.title === "string" || typeof row.name === "string" || typeof row.case_name === "string" || typeof row.citation === "string");
+    if (hasStructuredRows)
+      return { verdict: "pass", reason: "search_result_rows" };
+    return semanticAssessment;
+  }
+  if (result == null || typeof result !== "object")
     return semanticAssessment;
   const record = result;
   const title = String(record.title ?? "").trim().toLowerCase();
@@ -14516,9 +14808,216 @@ function inferDefaultParam(paramName, intent) {
   }
   return;
 }
+var SEARCH_INTENT_STOPWORDS = new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "at",
+  "be",
+  "boss",
+  "but",
+  "by",
+  "do",
+  "doing",
+  "fact",
+  "for",
+  "from",
+  "get",
+  "going",
+  "had",
+  "has",
+  "have",
+  "i",
+  "if",
+  "im",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "just",
+  "let",
+  "like",
+  "me",
+  "my",
+  "now",
+  "of",
+  "on",
+  "or",
+  "our",
+  "s",
+  "says",
+  "search",
+  "should",
+  "show",
+  "so",
+  "take",
+  "taking",
+  "tell",
+  "that",
+  "the",
+  "their",
+  "them",
+  "there",
+  "these",
+  "they",
+  "this",
+  "thoroughly",
+  "to",
+  "up",
+  "us",
+  "was",
+  "we",
+  "were",
+  "what",
+  "where",
+  "which",
+  "who",
+  "why",
+  "with",
+  "would",
+  "you",
+  "your"
+]);
+var SEARCH_DIRECTIVE_PREFIX = /^(search\s+for|search|find\s+me|find|look\s+for|looking\s+for|show\s+me|show|get\s+me|get|browse|discover|shop\s+for|buy)\s+/i;
+var SEARCH_TRAILING_SITE_HINT = /\s+(on|at|from|in|via)\s+\S+$/i;
+var SEARCH_INSTRUCTION_NOISE = /\b(do not|don't|dont|tell me|let me know|extremely thoroughly|thoroughly|random cases|for the sake of it|if there is no such|if none exists|if no such)\b/i;
+function isLikelySearchParam(urlTemplate, param) {
+  const lowerParam = param.toLowerCase();
+  if (/(^q$|^k$|basicsearchkey|basic_search_key|query|keyword|keywords|search|lookup|find|term|phrase|querystr|query_string)/.test(lowerParam)) {
+    return true;
+  }
+  try {
+    const parsed = new URL(urlTemplate.replace(/\{[^}]+\}/g, "x"));
+    for (const [key, value] of parsed.searchParams.entries()) {
+      if (key === param || value === "x") {
+        if (/(^q$|^k$|query|keyword|keywords|search|lookup|find|term|phrase|querystr|query_string)/.test(key.toLowerCase())) {
+          return true;
+        }
+      }
+    }
+  } catch {}
+  return false;
+}
+function collectSearchBindingKeys(endpoint) {
+  const keys = new Set;
+  for (const key of Object.keys(endpoint.body_params ?? {})) {
+    if (isLikelySearchParam(endpoint.url_template, key))
+      keys.add(key);
+  }
+  for (const key of Object.keys(endpoint.query ?? {})) {
+    if (isLikelySearchParam(endpoint.url_template, key))
+      keys.add(key);
+  }
+  for (const [rawKey, bindingKey] of Object.entries(extractTemplateQueryBindings(endpoint.url_template))) {
+    if (isLikelySearchParam(endpoint.url_template, rawKey) || isLikelySearchParam(endpoint.url_template, bindingKey)) {
+      keys.add(bindingKey);
+    }
+  }
+  for (const match of endpoint.url_template.matchAll(/\{([^}]+)\}/g)) {
+    const key = match[1];
+    if (isLikelySearchParam(endpoint.url_template, key))
+      keys.add(key);
+  }
+  return [...keys];
+}
+function stripSearchIntentBoilerplate(intent) {
+  return intent.trim().replace(SEARCH_DIRECTIVE_PREFIX, "").replace(SEARCH_TRAILING_SITE_HINT, "").replace(/\s+/g, " ").trim();
+}
+function extractLiteralSearchTermsFromIntent(intent) {
+  const stripped = stripSearchIntentBoilerplate(intent);
+  if (!stripped)
+    return null;
+  const clauses = stripped.split(/(?<=[.!?])\s+|\n+/).map((clause) => clause.trim()).filter(Boolean);
+  if (clauses.length <= 1)
+    return stripped;
+  const scored = clauses.map((clause, index) => {
+    const tokens = clause.toLowerCase().replace(/[^a-z0-9\-/]+/g, " ").split(/\s+/).filter((token) => token.length >= 3 && !SEARCH_INTENT_STOPWORDS.has(token));
+    let score = Math.min(tokens.length, 12);
+    if (/["“”']/.test(clause))
+      score += 4;
+    if (/[()]/.test(clause))
+      score += 2;
+    if (/\d/.test(clause))
+      score += 2;
+    if (SEARCH_INSTRUCTION_NOISE.test(clause))
+      score -= 8;
+    return { clause, index, score };
+  });
+  const selected = scored.filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.index - b.index).slice(0, 2).sort((a, b) => a.index - b.index).map((entry) => entry.clause.replace(/\s+/g, " ").trim());
+  const joined = (selected.length > 0 ? selected.join(" ") : stripped).trim();
+  return joined || null;
+}
+function inferSearchParamOverrides(endpoint, intent, explicitParams = {}) {
+  if (!/\b(search|find|lookup|browse|discover)\b/i.test(intent))
+    return {};
+  const keys = collectSearchBindingKeys(endpoint);
+  if (keys.length === 0)
+    return {};
+  const selectedTerms = selectSearchTermsForExecution(intent);
+  if (!selectedTerms)
+    return {};
+  const overrides = {};
+  for (const key of keys) {
+    if (explicitParams[key] != null && explicitParams[key] !== "")
+      continue;
+    overrides[key] = selectedTerms;
+  }
+  return overrides;
+}
+function selectSearchTermsForExecution(intent) {
+  const literal = extractLiteralSearchTermsFromIntent(intent);
+  const condensed = extractSearchTermsFromIntent(intent);
+  if (!literal)
+    return condensed;
+  if (!condensed || condensed === literal)
+    return literal;
+  const wordCount = literal.split(/\s+/).filter(Boolean).length;
+  const hasQuotedPhrase = /["“”]/.test(literal);
+  const hasSentencePunctuation = /[.!?]/.test(literal);
+  const tooLongForSingleField = literal.length > 180 || wordCount > 24;
+  if (hasQuotedPhrase && !tooLongForSingleField)
+    return literal;
+  if (!hasSentencePunctuation && !tooLongForSingleField)
+    return literal;
+  return condensed;
+}
+function condenseSearchIntent(intent) {
+  const wantsSearchAction = /\b(search|find|lookup|look\s+for|browse|discover)\b/i.test(intent);
+  const priorityPattern = /\b(high|court|appeal|leave|adduce|evidence|assessment|damages?|tranche|tranches|started|late|stage|hearing|trial|mediation|case|cases)\b/;
+  const tokens = intent.toLowerCase().replace(/[^a-z0-9\][\-/]+/g, " ").split(/\s+/).map((token) => token.trim()).filter((token) => token.length >= 3 && !SEARCH_INTENT_STOPWORDS.has(token));
+  const scored = new Map;
+  tokens.forEach((token, index) => {
+    let score = 0;
+    if (priorityPattern.test(token))
+      score += 10;
+    if (token.length >= 8)
+      score += 2;
+    if (index < 12)
+      score += 1;
+    const existing = scored.get(token);
+    if (!existing || score > existing.score) {
+      scored.set(token, { token, index, score });
+    }
+  });
+  const budget = wantsSearchAction ? 13 : 14;
+  const selected = Array.from(scored.values()).sort((a, b) => b.score - a.score || a.index - b.index).slice(0, budget).sort((a, b) => a.index - b.index).map((entry) => entry.token);
+  if (selected.length === 0)
+    return null;
+  if (wantsSearchAction && selected[0] !== "search") {
+    selected.unshift("search");
+  }
+  return selected.join(" ");
+}
 function extractSearchTermsFromIntent(intent) {
-  let terms = intent.trim().toLowerCase();
-  terms = terms.replace(/^(search\s+for|find\s+me|find|look\s+for|looking\s+for|show\s+me|get\s+me|get|browse|shop\s+for|buy)\s+/i, "").replace(/\s+(on|at|from|in|via)\s+\S+$/i, "").trim();
+  let terms = stripSearchIntentBoilerplate(intent).toLowerCase();
+  if (!terms)
+    return null;
+  const words = terms.split(/\s+/).filter(Boolean);
+  if (terms.length > 160 || words.length > 20 || /[.!?]/.test(terms)) {
+    return condenseSearchIntent(terms);
+  }
   if (/\b(from|to|between|before|after|near|in\s+\w+,?\s+\w+|under\s+\$|over\s+\$|cheaper\s+than|more\s+than)\b/i.test(terms)) {
     return null;
   }
@@ -14529,9 +15028,11 @@ async function inferParamsFromIntent(urlTemplate, intent, unboundParams, endpoin
     return {};
   if (unboundParams.length === 1) {
     const param = unboundParams[0];
-    const searchTerms = extractSearchTermsFromIntent(intent);
-    if (searchTerms) {
-      return { [param]: searchTerms };
+    if (isLikelySearchParam(urlTemplate, param, endpointDescription)) {
+      const searchTerms = selectSearchTermsForExecution(intent);
+      if (searchTerms) {
+        return { [param]: searchTerms };
+      }
     }
   }
   const system = `You extract URL query/path parameter values from a user's natural-language intent.
@@ -14954,6 +15455,9 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
     search_candidates: [],
     autoexec_attempts: []
   };
+  const queryIntent = extractSearchTermsFromIntent(intent) ?? intent;
+  if (queryIntent !== intent)
+    decisionTrace.query_intent = queryIntent;
   const DEFAULT_CAPTURE_MS = 22000;
   const DEFAULT_CAPTURE_TOKENS = 30000;
   const CHARS_PER_TOKEN = 4;
@@ -15000,7 +15504,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
     return timing;
   }
   async function buildDeferralWithAutoExec(skill, source, extraFields) {
-    if (intent && intent.trim().length > 0) {
+    if (queryIntent && queryIntent.trim().length > 0) {
       try {
         const autoResult = await tryAutoExecute(skill, source);
         if (autoResult) {
@@ -15021,13 +15525,13 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
     };
   }
   function buildDeferral(skill, source, extraFields) {
-    const resolvedSkill = withContextReplayEndpoint(skill, intent, context?.url);
+    const resolvedSkill = withContextReplayEndpoint(skill, queryIntent, context?.url);
     const chunk = getSkillChunk(resolvedSkill, {
-      intent,
+      intent: queryIntent,
       known_bindings: knownBindingsFromInputs(params, context?.url),
       max_operations: 8
     });
-    const epRanked = rankEndpoints(resolvedSkill.endpoints, intent, resolvedSkill.domain, context?.url);
+    const epRanked = rankEndpoints(resolvedSkill.endpoints, queryIntent, resolvedSkill.domain, context?.url);
     const deferTrace = {
       trace_id: nanoid6(),
       skill_id: resolvedSkill.skill_id,
@@ -15093,9 +15597,9 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
   function canAutoExecuteEndpoint(endpoint) {
     const endpointParams = resolveEndpointTemplateBindings(endpoint, resolvedParams, context?.url);
     const missing = missingTemplateParams(endpoint, endpointParams);
-    const unresolvedBySync = missing.filter((name) => inferDefaultParam(name, intent) === undefined);
+    const unresolvedBySync = missing.filter((name) => inferDefaultParam(name, queryIntent) === undefined);
     if (unresolvedBySync.length > 0) {
-      if (!intent || intent.trim().length === 0)
+      if (!queryIntent || queryIntent.trim().length === 0)
         return false;
       if (unresolvedBySync.length > 4)
         return false;
@@ -15118,10 +15622,10 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
     return merged;
   })();
   async function tryAutoExecute(skill, source) {
-    let epRanked = rankEndpoints(skill.endpoints, intent, skill.domain, context?.url);
+    let epRanked = rankEndpoints(skill.endpoints, queryIntent, skill.domain, context?.url);
     const originalRanked = epRanked;
     const chunk = getSkillChunk(skill, {
-      intent,
+      intent: queryIntent,
       known_bindings: knownBindingsFromInputs(resolvedParams, context?.url),
       max_operations: 8
     });
@@ -15144,8 +15648,8 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
       url: ranked.endpoint.url_template,
       dom_extraction: !!ranked.endpoint.dom_extraction
     }));
-    if (epRanked.length >= 2 && intent) {
-      const intentTokens = new Set(intent.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((w) => w.length > 2));
+    if (epRanked.length >= 2 && queryIntent) {
+      const intentTokens = new Set(queryIntent.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter((w) => w.length > 2));
       epRanked = epRanked.map((r) => {
         let schemaBonus = 0;
         const schema = r.endpoint.response_schema;
@@ -15186,11 +15690,11 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
       if (missing.length === 0)
         readinessBonus += 40;
       else {
-        const syncSatisfiable = missing.filter((name) => inferDefaultParam(name, intent) !== undefined);
+        const syncSatisfiable = missing.filter((name) => inferDefaultParam(name, queryIntent) !== undefined);
         const remaining = missing.length - syncSatisfiable.length;
         if (remaining === 0) {
           readinessBonus += 8;
-        } else if (intent && remaining <= 4) {
+        } else if (queryIntent && remaining <= 4) {
           readinessBonus += 4 - remaining * 5;
         } else {
           readinessBonus -= missing.length * 25;
@@ -15219,12 +15723,12 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
       return { ...r, score: r.score + readinessBonus };
     });
     epRanked.sort((a, b) => b.score - a.score);
-    epRanked = prioritizeIntentMatchedApis(epRanked, intent, context?.url);
+    epRanked = prioritizeIntentMatchedApis(epRanked, queryIntent, context?.url);
     const ready = epRanked.filter((r) => canAutoExecuteEndpoint(r.endpoint));
     const tryList = ready.length > 0 ? [...ready, ...epRanked.filter((r) => !canAutoExecuteEndpoint(r.endpoint))] : epRanked;
     const MAX_TRIES = Math.min(tryList.length, 5);
-    const deterministicStructuredSearchLeader = /\b(search|find|lookup|browse|discover)\b/i.test(intent) && !!epRanked[0] && endpointHasSearchBindings(epRanked[0].endpoint) && (!!epRanked[0].endpoint.dom_extraction || !!epRanked[0].endpoint.response_schema);
-    const agentOrder = !agentChoseEndpoint && tryList.length > 1 && !deterministicStructuredSearchLeader ? await agentSelectEndpoint(intent, skill, tryList.slice(0, MAX_TRIES), context?.url) : null;
+    const deterministicStructuredSearchLeader = /\b(search|find|lookup|browse|discover)\b/i.test(queryIntent) && !!epRanked[0] && endpointHasSearchBindings(epRanked[0].endpoint) && (!!epRanked[0].endpoint.dom_extraction || !!epRanked[0].endpoint.response_schema);
+    const agentOrder = !agentChoseEndpoint && tryList.length > 1 && !deterministicStructuredSearchLeader ? await agentSelectEndpoint(queryIntent, skill, tryList.slice(0, MAX_TRIES), context?.url) : null;
     const orderedTryList = agentOrder ? [
       ...agentOrder.map((endpointId) => tryList.find((r) => r.endpoint.endpoint_id === endpointId)).filter((r) => !!r),
       ...tryList.filter((r) => !agentOrder.includes(r.endpoint.endpoint_id))
@@ -15236,28 +15740,42 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
       console.log(`[auto-exec] trying #${i + 1}: ${candidate.endpoint.endpoint_id} score=${candidate.score.toFixed(1)}`);
       try {
         const endpointParams = mergeContextTemplateParams(resolvedParams, candidate.endpoint.url_template, context?.url);
+        const templateDefaults = {
+          ...candidate.endpoint.path_params ?? {},
+          ...candidate.endpoint.body_params ?? {}
+        };
+        const searchOverrides = inferSearchParamOverrides(candidate.endpoint, intent, params);
         const inferredOptionalParams = {};
-        const inferredType = inferDefaultParam("type", intent);
+        const inferredType = inferDefaultParam("type", queryIntent);
         if (inferredType !== undefined && endpointParams.type == null && /\/(search|lookup|find)\b/i.test(candidate.endpoint.url_template)) {
           inferredOptionalParams.type = inferredType;
         }
-        const syncInferred = Object.fromEntries([...candidate.endpoint.url_template.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]).filter((name) => endpointParams[name] == null || endpointParams[name] === "").map((name) => [name, inferDefaultParam(name, intent)]).filter((entry) => entry[1] !== undefined));
-        const allBound = { ...endpointParams, ...syncInferred, ...inferredOptionalParams };
+        const syncInferred = Object.fromEntries([...candidate.endpoint.url_template.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]).filter((name) => endpointParams[name] == null || endpointParams[name] === "").map((name) => [name, inferDefaultParam(name, queryIntent)]).filter((entry) => entry[1] !== undefined));
+        const allBound = {
+          ...templateDefaults,
+          ...endpointParams,
+          ...syncInferred,
+          ...searchOverrides,
+          ...inferredOptionalParams
+        };
         const stillUnbound = [...candidate.endpoint.url_template.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]).filter((name) => allBound[name] == null || allBound[name] === "");
         let llmInferred = {};
-        if (stillUnbound.length > 0 && intent) {
-          llmInferred = await inferParamsFromIntent(candidate.endpoint.url_template, intent, stillUnbound, candidate.endpoint.description);
+        if (stillUnbound.length > 0 && queryIntent) {
+          llmInferred = await inferParamsFromIntent(candidate.endpoint.url_template, queryIntent, stillUnbound, candidate.endpoint.description);
         }
         const execOut = await executeSkill(skill, {
+          ...templateDefaults,
           ...endpointParams,
           ...syncInferred,
+          ...searchOverrides,
           ...llmInferred,
           ...inferredOptionalParams,
-          endpoint_id: candidate.endpoint.endpoint_id
-        }, projection, { ...options, intent, contextUrl: context?.url });
+          endpoint_id: candidate.endpoint.endpoint_id,
+          ...queryIntent !== intent ? { intent: queryIntent } : {}
+        }, projection, { ...options, intent: queryIntent, contextUrl: context?.url });
         timing.execute_ms = Date.now() - te02;
         if (execOut.trace.success) {
-          const localAssessment = assessLocalExecutionResult(candidate.endpoint, execOut.result, intent, execOut.trace);
+          const localAssessment = assessLocalExecutionResult(candidate.endpoint, execOut.result, queryIntent, execOut.trace);
           if (localAssessment.verdict === "fail") {
             decisionTrace.autoexec_attempts.push({
               endpoint_id: candidate.endpoint.endpoint_id,
@@ -15352,7 +15870,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
   if (!forceCapture && !agentChoseEndpoint) {
     const cachedResult = routeResultCache.get(cacheKey);
     if (cachedResult) {
-      if (!shouldReuseRouteResultSnapshot(cachedResult, intent, context?.url)) {
+      if (!shouldReuseRouteResultSnapshot(cachedResult, queryIntent, context?.url)) {
         routeResultCache.delete(cacheKey);
       } else {
         timing.cache_hit = true;
@@ -15379,7 +15897,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
         continue;
       }
       const skill = readSkillSnapshot(cached.localSkillPath) ?? await getSkillWithTimeout(cached.skillId, clientScope);
-      if (!skill || !isCachedSkillRelevantForIntent(skill, intent, context?.url)) {
+      if (!skill || !isCachedSkillRelevantForIntent(skill, queryIntent, context?.url)) {
         skillRouteCache.delete(scopedKey);
         persistRouteCache();
         continue;
@@ -15391,7 +15909,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
         skill
       });
     }
-    const bestCached = chooseBestRouteCacheCandidate(routeCacheCandidates, intent, context?.url);
+    const bestCached = chooseBestRouteCacheCandidate(routeCacheCandidates, queryIntent, context?.url);
     if (bestCached) {
       if (bestCached.scopedKey !== cacheKey) {
         promoteLearnedSkill(clientScope, resolveCacheKey, bestCached.skill, bestCached.entry.endpointId, context?.url);
@@ -15412,7 +15930,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
     const domainCached = domainKey ? domainSkillCache.get(domainKey) : null;
     if (domainCached && Date.now() - domainCached.ts < 7 * 24 * 60 * 60000) {
       const skill = readSkillSnapshot(domainCached.localSkillPath) ?? await getSkill2(domainCached.skillId, clientScope);
-      if (skill && isCachedSkillRelevantForIntent(skill, intent, context?.url)) {
+      if (skill && isCachedSkillRelevantForIntent(skill, queryIntent, context?.url)) {
         console.log(`[domain-cache] hit for ${domainKey} → skill ${skill.skill_id.slice(0, 15)}`);
         const result2 = await buildDeferralWithAutoExec(skill, "marketplace");
         if (shouldFallbackToLiveCaptureAfterAutoexecFailure(result2.autoexecFailedAll, context?.url)) {
@@ -15424,9 +15942,22 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
           return result2.orchestratorResult;
         }
       } else if (skill) {
-        const ranked = rankEndpoints(skill.endpoints, intent, skill.domain, context?.url);
+        const ranked = rankEndpoints(skill.endpoints, queryIntent, skill.domain, context?.url);
         const top = ranked[0];
-        console.log(`[domain-cache] skip ${domainKey}: no relevant endpoint for "${intent}"` + (top ? ` (${top.endpoint.endpoint_id} score=${top.score.toFixed(1)})` : ""));
+        console.log(`[domain-cache] skip ${domainKey}: no relevant endpoint for "${queryIntent}"` + (top ? ` (${top.endpoint.endpoint_id} score=${top.score.toFixed(1)})` : ""));
+      }
+    }
+    const localDomainSkill = findBestLocalDomainSnapshot(requestedDomain, queryIntent, context?.url);
+    if (localDomainSkill) {
+      console.log(`[local-snapshot] hit for ${requestedDomain} → skill ${localDomainSkill.skill_id.slice(0, 15)}`);
+      const result2 = await buildDeferralWithAutoExec(localDomainSkill, "marketplace");
+      if (shouldFallbackToLiveCaptureAfterAutoexecFailure(result2.autoexecFailedAll, context?.url)) {
+        console.log(`[local-snapshot] stale skill for ${requestedDomain}; retrying via live capture`);
+      } else {
+        timing.cache_hit = true;
+        result2.orchestratorResult.timing.cache_hit = true;
+        promoteLearnedSkill(clientScope, cacheKey, localDomainSkill, result2.orchestratorResult.trace.endpoint_id, context?.url);
+        return result2.orchestratorResult;
       }
     }
   }
@@ -15451,7 +15982,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
         skill
       });
     }
-    const cached = chooseBestRouteCacheCandidate(routeCacheCandidates, intent, context?.url);
+    const cached = chooseBestRouteCacheCandidate(routeCacheCandidates, queryIntent, context?.url);
     if (cached) {
       if (cached.scopedKey !== cacheKey) {
         promoteLearnedSkill(clientScope, resolveCacheKey, cached.skill, cached.entry.endpointId, context?.url);
@@ -15460,9 +15991,9 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
       if (skill) {
         const te02 = Date.now();
         try {
-          const execOut = await executeSkill(skill, { ...params, endpoint_id: params.endpoint_id ?? cached.entry.endpointId }, projection, { ...options, intent, contextUrl: context?.url });
+          const execOut = await executeSkill(skill, { ...params, endpoint_id: params.endpoint_id ?? cached.entry.endpointId, ...queryIntent !== intent ? { intent: queryIntent } : {} }, projection, { ...options, intent: queryIntent, contextUrl: context?.url });
           timing.execute_ms = Date.now() - te02;
-          if (execOut.trace.success && isAcceptableIntentResult(execOut.result, intent)) {
+          if (execOut.trace.success && isAcceptableIntentResult(execOut.result, queryIntent)) {
             timing.cache_hit = true;
             promoteResultSnapshot(cacheKey, skill, params.endpoint_id ?? cached.entry.endpointId, execOut.result, execOut.trace, execOut.response_schema, execOut.extraction_hints);
             return {
@@ -15484,7 +16015,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
   }
   if (!forceCapture) {
     const ts0 = Date.now();
-    const { domain_results: domainResults, global_results: globalResults } = await searchIntentResolve(intent, requestedDomain ?? undefined, MARKETPLACE_DOMAIN_SEARCH_K, MARKETPLACE_GLOBAL_SEARCH_K).catch(() => ({
+    const { domain_results: domainResults, global_results: globalResults } = await searchIntentResolve(queryIntent, requestedDomain ?? undefined, MARKETPLACE_DOMAIN_SEARCH_K, MARKETPLACE_GLOBAL_SEARCH_K).catch(() => ({
       domain_results: [],
       global_results: [],
       skipped_global: false
@@ -15523,9 +16054,9 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
         continue;
       if (!hasUsableEndpoints(skill))
         continue;
-      if (!isCachedSkillRelevantForIntent(skill, intent, context?.url))
+      if (!isCachedSkillRelevantForIntent(skill, queryIntent, context?.url))
         continue;
-      if (!marketplaceSkillMatchesContext(skill, intent, context?.url))
+      if (!marketplaceSkillMatchesContext(skill, queryIntent, context?.url))
         continue;
       if (targetRegDomain && getRegistrableDomain(skill.domain) !== targetRegDomain)
         continue;
@@ -15548,7 +16079,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
           const winner = await Promise.any(viable.map((candidate, i) => Promise.race([
             executeSkill(candidate.skill, params, projection, {
               ...options,
-              intent,
+              intent: queryIntent,
               contextUrl: context?.url
             }).then((execOut) => {
               if (!execOut.trace.success) {
@@ -15597,12 +16128,12 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
   const captureDomain = new URL(context.url).hostname;
   const domainHit = !forceCapture ? capturedDomainCache.get(cacheKey) : undefined;
   if (domainHit && Date.now() < domainHit.expires) {
-    if (!isCachedSkillRelevantForIntent(domainHit.skill, intent, context?.url)) {
+    if (!isCachedSkillRelevantForIntent(domainHit.skill, queryIntent, context?.url)) {
       capturedDomainCache.delete(cacheKey);
     } else {
       if (agentChoseEndpoint) {
-        const execOut = await executeSkill(domainHit.skill, { ...params, endpoint_id: params.endpoint_id ?? domainHit.endpointId }, projection, { ...options, intent, contextUrl: context?.url });
-        if (execOut.trace.success && isAcceptableIntentResult(execOut.result, intent)) {
+        const execOut = await executeSkill(domainHit.skill, { ...params, endpoint_id: params.endpoint_id ?? domainHit.endpointId, ...queryIntent !== intent ? { intent: queryIntent } : {} }, projection, { ...options, intent: queryIntent, contextUrl: context?.url });
+        if (execOut.trace.success && isAcceptableIntentResult(execOut.result, queryIntent)) {
           promoteResultSnapshot(cacheKey, domainHit.skill, params.endpoint_id ?? domainHit.endpointId, execOut.result, execOut.trace, execOut.response_schema, execOut.extraction_hints);
           return {
             result: execOut.result,
@@ -15723,18 +16254,18 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
     if (!directDomCaptureResult)
       learned_skill = undefined;
   }
-  if (learned_skill && learnedSkillUsable && !isCachedSkillRelevantForIntent(learned_skill, intent, context?.url)) {
-    const resolvedSkill = withContextReplayEndpoint(learned_skill, intent, context?.url);
-    const ranked = rankEndpoints(resolvedSkill.endpoints, intent, resolvedSkill.domain, context?.url);
+  if (learned_skill && learnedSkillUsable && !isCachedSkillRelevantForIntent(learned_skill, queryIntent, context?.url)) {
+    const resolvedSkill = withContextReplayEndpoint(learned_skill, queryIntent, context?.url);
+    const ranked = rankEndpoints(resolvedSkill.endpoints, queryIntent, resolvedSkill.domain, context?.url);
     const rejectedTrace = {
       ...trace,
       success: false,
-      error: `No relevant endpoint discovered for "${intent}"`
+      error: `No relevant endpoint discovered for "${queryIntent}"`
     };
-    console.warn(`[capture] dropping learned skill with no relevant endpoints for "${intent}"`);
+    console.warn(`[capture] dropping learned skill with no relevant endpoints for "${queryIntent}"`);
     return {
       result: {
-        error: `No relevant endpoint discovered for "${intent}"`,
+        error: `No relevant endpoint discovered for "${queryIntent}"`,
         discovered_endpoints: ranked.slice(0, 3).map((candidate) => ({
           endpoint_id: candidate.endpoint.endpoint_id,
           score: Math.round(candidate.score * 10) / 10,
@@ -15787,7 +16318,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
     };
   }
   const hasNonDomApiEndpoints = !!learned_skill?.endpoints?.some((ep) => !ep.dom_extraction && ep.method !== "WS");
-  const hasBetterStructuredSearchEndpoint = learned_skill ? skillHasBetterStructuredSearchEndpoint(learned_skill, trace.endpoint_id, intent, context?.url) : false;
+  const hasBetterStructuredSearchEndpoint = learned_skill ? skillHasBetterStructuredSearchEndpoint(learned_skill, trace.endpoint_id, queryIntent, context?.url) : false;
   const isDirectDomResult = directDomCaptureResult;
   const directExtractionSource = isDirectDomResult && result && typeof result === "object" ? result._extraction?.source : undefined;
   if (isDirectDomResult && (directExtractionSource === "html-embedded" && !hasBetterStructuredSearchEndpoint || !hasNonDomApiEndpoints)) {
@@ -15823,13 +16354,13 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
     const te1 = Date.now();
     const execOut = await executeSkill(learned_skill, params, projection, {
       ...options,
-      intent,
+      intent: queryIntent,
       contextUrl: context?.url
     });
     timing.execute_ms += Date.now() - te1;
     if (execOut.trace.success)
       promoteLearnedSkill(clientScope, cacheKey, learned_skill, execOut.trace.endpoint_id, context?.url);
-    if (execOut.trace.success && isAcceptableIntentResult(execOut.result, intent)) {
+    if (execOut.trace.success && isAcceptableIntentResult(execOut.result, queryIntent)) {
       queuePassivePublishIfExecuted(learned_skill, {
         result: execOut.result,
         trace: execOut.trace,
@@ -15840,7 +16371,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
         extraction_hints: execOut.extraction_hints
       }, parityBaseline);
     }
-    if (execOut.trace.success && isAcceptableIntentResult(execOut.result, intent)) {
+    if (execOut.trace.success && isAcceptableIntentResult(execOut.result, queryIntent)) {
       promoteResultSnapshot(cacheKey, learned_skill, execOut.trace.endpoint_id, execOut.result, execOut.trace, execOut.response_schema, execOut.extraction_hints);
     }
     return {
@@ -16007,7 +16538,7 @@ var ROUTE_LIMITS = {
 
 // ../../src/session-logs.ts
 init_domain();
-import { existsSync as existsSync9, readFileSync as readFileSync6, readdirSync as readdirSync4, statSync } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6, readdirSync as readdirSync5, statSync } from "node:fs";
 import { join as join9 } from "node:path";
 function normalizeDomainVariants(domain) {
   const trimmed = domain.trim().toLowerCase();
@@ -16086,7 +16617,7 @@ function listRecentSessionsForDomain(tracesDir, domain, limit = 10) {
   if (variants.length === 0)
     return [];
   const entries = [];
-  for (const name of readdirSync4(tracesDir)) {
+  for (const name of readdirSync5(tracesDir)) {
     if (!name.endsWith(".json"))
       continue;
     const filePath = join9(tracesDir, name);